github.com/uppal0016/docker_new@v0.0.0-20240123060250-1c98be13ac2c/api/server/router/network/network_routes.go (about)

     1  package network
     2  
     3  import (
     4  	"encoding/json"
     5  	"net/http"
     6  
     7  	"golang.org/x/net/context"
     8  
     9  	"github.com/docker/docker/api/server/httputils"
    10  	"github.com/docker/engine-api/types"
    11  	"github.com/docker/engine-api/types/filters"
    12  	"github.com/docker/engine-api/types/network"
    13  	"github.com/docker/libnetwork"
    14  )
    15  
    16  func (n *networkRouter) getNetworksList(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
    17  	if err := httputils.ParseForm(r); err != nil {
    18  		return err
    19  	}
    20  
    21  	filter := r.Form.Get("filters")
    22  	netFilters, err := filters.FromParam(filter)
    23  	if err != nil {
    24  		return err
    25  	}
    26  
    27  	list := []*types.NetworkResource{}
    28  
    29  	nwList, err := n.backend.FilterNetworks(netFilters)
    30  	if err != nil {
    31  		return err
    32  	}
    33  
    34  	for _, nw := range nwList {
    35  		list = append(list, buildNetworkResource(nw))
    36  	}
    37  
    38  	return httputils.WriteJSON(w, http.StatusOK, list)
    39  }
    40  
    41  func (n *networkRouter) getNetwork(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
    42  	if err := httputils.ParseForm(r); err != nil {
    43  		return err
    44  	}
    45  
    46  	nw, err := n.backend.FindNetwork(vars["id"])
    47  	if err != nil {
    48  		return err
    49  	}
    50  	return httputils.WriteJSON(w, http.StatusOK, buildNetworkResource(nw))
    51  }
    52  
    53  func (n *networkRouter) postNetworkCreate(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
    54  	var create types.NetworkCreate
    55  
    56  	if err := httputils.ParseForm(r); err != nil {
    57  		return err
    58  	}
    59  
    60  	if err := httputils.CheckForJSON(r); err != nil {
    61  		return err
    62  	}
    63  
    64  	if err := json.NewDecoder(r.Body).Decode(&create); err != nil {
    65  		return err
    66  	}
    67  
    68  	nw, err := n.backend.CreateNetwork(create)
    69  	if err != nil {
    70  		return err
    71  	}
    72  
    73  	return httputils.WriteJSON(w, http.StatusCreated, nw)
    74  }
    75  
    76  func (n *networkRouter) postNetworkConnect(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
    77  	var connect types.NetworkConnect
    78  	if err := httputils.ParseForm(r); err != nil {
    79  		return err
    80  	}
    81  
    82  	if err := httputils.CheckForJSON(r); err != nil {
    83  		return err
    84  	}
    85  
    86  	if err := json.NewDecoder(r.Body).Decode(&connect); err != nil {
    87  		return err
    88  	}
    89  
    90  	nw, err := n.backend.FindNetwork(vars["id"])
    91  	if err != nil {
    92  		return err
    93  	}
    94  
    95  	return n.backend.ConnectContainerToNetwork(connect.Container, nw.Name(), connect.EndpointConfig)
    96  }
    97  
    98  func (n *networkRouter) postNetworkDisconnect(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
    99  	var disconnect types.NetworkDisconnect
   100  	if err := httputils.ParseForm(r); err != nil {
   101  		return err
   102  	}
   103  
   104  	if err := httputils.CheckForJSON(r); err != nil {
   105  		return err
   106  	}
   107  
   108  	if err := json.NewDecoder(r.Body).Decode(&disconnect); err != nil {
   109  		return err
   110  	}
   111  
   112  	nw, err := n.backend.FindNetwork(vars["id"])
   113  	if err != nil {
   114  		return err
   115  	}
   116  
   117  	return n.backend.DisconnectContainerFromNetwork(disconnect.Container, nw, disconnect.Force)
   118  }
   119  
   120  func (n *networkRouter) deleteNetwork(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
   121  	if err := httputils.ParseForm(r); err != nil {
   122  		return err
   123  	}
   124  	if err := n.backend.DeleteNetwork(vars["id"]); err != nil {
   125  		return err
   126  	}
   127  	w.WriteHeader(http.StatusNoContent)
   128  	return nil
   129  }
   130  
   131  func buildNetworkResource(nw libnetwork.Network) *types.NetworkResource {
   132  	r := &types.NetworkResource{}
   133  	if nw == nil {
   134  		return r
   135  	}
   136  
   137  	info := nw.Info()
   138  	r.Name = nw.Name()
   139  	r.ID = nw.ID()
   140  	r.Scope = info.Scope()
   141  	r.Driver = nw.Type()
   142  	r.EnableIPv6 = info.IPv6Enabled()
   143  	r.Internal = info.Internal()
   144  	r.Options = info.DriverOptions()
   145  	r.Containers = make(map[string]types.EndpointResource)
   146  	buildIpamResources(r, info)
   147  	r.Internal = info.Internal()
   148  	r.Labels = info.Labels()
   149  
   150  	epl := nw.Endpoints()
   151  	for _, e := range epl {
   152  		ei := e.Info()
   153  		if ei == nil {
   154  			continue
   155  		}
   156  		sb := ei.Sandbox()
   157  		key := "ep-" + e.ID()
   158  		if sb != nil {
   159  			key = sb.ContainerID()
   160  		}
   161  
   162  		r.Containers[key] = buildEndpointResource(e)
   163  	}
   164  	return r
   165  }
   166  
   167  func buildIpamResources(r *types.NetworkResource, nwInfo libnetwork.NetworkInfo) {
   168  	id, opts, ipv4conf, ipv6conf := nwInfo.IpamConfig()
   169  
   170  	ipv4Info, ipv6Info := nwInfo.IpamInfo()
   171  
   172  	r.IPAM.Driver = id
   173  
   174  	r.IPAM.Options = opts
   175  
   176  	r.IPAM.Config = []network.IPAMConfig{}
   177  	for _, ip4 := range ipv4conf {
   178  		if ip4.PreferredPool == "" {
   179  			continue
   180  		}
   181  		iData := network.IPAMConfig{}
   182  		iData.Subnet = ip4.PreferredPool
   183  		iData.IPRange = ip4.SubPool
   184  		iData.Gateway = ip4.Gateway
   185  		iData.AuxAddress = ip4.AuxAddresses
   186  		r.IPAM.Config = append(r.IPAM.Config, iData)
   187  	}
   188  
   189  	if len(r.IPAM.Config) == 0 {
   190  		for _, ip4Info := range ipv4Info {
   191  			iData := network.IPAMConfig{}
   192  			iData.Subnet = ip4Info.IPAMData.Pool.String()
   193  			iData.Gateway = ip4Info.IPAMData.Gateway.String()
   194  			r.IPAM.Config = append(r.IPAM.Config, iData)
   195  		}
   196  	}
   197  
   198  	hasIpv6Conf := false
   199  	for _, ip6 := range ipv6conf {
   200  		if ip6.PreferredPool == "" {
   201  			continue
   202  		}
   203  		hasIpv6Conf = true
   204  		iData := network.IPAMConfig{}
   205  		iData.Subnet = ip6.PreferredPool
   206  		iData.IPRange = ip6.SubPool
   207  		iData.Gateway = ip6.Gateway
   208  		iData.AuxAddress = ip6.AuxAddresses
   209  		r.IPAM.Config = append(r.IPAM.Config, iData)
   210  	}
   211  
   212  	if !hasIpv6Conf {
   213  		for _, ip6Info := range ipv6Info {
   214  			iData := network.IPAMConfig{}
   215  			iData.Subnet = ip6Info.IPAMData.Pool.String()
   216  			iData.Gateway = ip6Info.IPAMData.Gateway.String()
   217  			r.IPAM.Config = append(r.IPAM.Config, iData)
   218  		}
   219  	}
   220  }
   221  
   222  func buildEndpointResource(e libnetwork.Endpoint) types.EndpointResource {
   223  	er := types.EndpointResource{}
   224  	if e == nil {
   225  		return er
   226  	}
   227  
   228  	er.EndpointID = e.ID()
   229  	er.Name = e.Name()
   230  	ei := e.Info()
   231  	if ei == nil {
   232  		return er
   233  	}
   234  
   235  	if iface := ei.Iface(); iface != nil {
   236  		if mac := iface.MacAddress(); mac != nil {
   237  			er.MacAddress = mac.String()
   238  		}
   239  		if ip := iface.Address(); ip != nil && len(ip.IP) > 0 {
   240  			er.IPv4Address = ip.String()
   241  		}
   242  
   243  		if ipv6 := iface.AddressIPv6(); ipv6 != nil && len(ipv6.IP) > 0 {
   244  			er.IPv6Address = ipv6.String()
   245  		}
   246  	}
   247  	return er
   248  }