2015-09-25 10:19:17 +00:00
|
|
|
package network
|
|
|
|
|
|
|
|
import (
|
|
|
|
"encoding/json"
|
|
|
|
"net/http"
|
|
|
|
|
|
|
|
"golang.org/x/net/context"
|
|
|
|
|
|
|
|
"github.com/docker/docker/api/server/httputils"
|
2016-09-06 18:46:37 +00:00
|
|
|
"github.com/docker/docker/api/types"
|
|
|
|
"github.com/docker/docker/api/types/filters"
|
|
|
|
"github.com/docker/docker/api/types/network"
|
2015-09-25 10:19:17 +00:00
|
|
|
"github.com/docker/libnetwork"
|
2016-11-04 19:27:36 +00:00
|
|
|
"github.com/docker/libnetwork/networkdb"
|
2015-09-25 10:19:17 +00:00
|
|
|
)
|
|
|
|
|
2016-12-29 08:10:40 +00:00
|
|
|
var (
|
|
|
|
// acceptedNetworkFilters is a list of acceptable filters
|
|
|
|
acceptedNetworkFilters = map[string]bool{
|
|
|
|
"driver": true,
|
|
|
|
"type": true,
|
|
|
|
"name": true,
|
|
|
|
"id": true,
|
|
|
|
"label": true,
|
|
|
|
}
|
|
|
|
)
|
|
|
|
|
2015-09-25 10:19:17 +00:00
|
|
|
func (n *networkRouter) getNetworksList(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
|
|
|
|
if err := httputils.ParseForm(r); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
filter := r.Form.Get("filters")
|
|
|
|
netFilters, err := filters.FromParam(filter)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2016-12-29 08:10:40 +00:00
|
|
|
if err := netFilters.Validate(acceptedNetworkFilters); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2016-06-14 02:52:49 +00:00
|
|
|
list := []types.NetworkResource{}
|
2015-09-25 10:19:17 +00:00
|
|
|
|
2016-12-26 12:53:13 +00:00
|
|
|
if nr, err := n.cluster.GetNetworks(); err == nil {
|
2016-10-13 16:34:19 +00:00
|
|
|
list = append(list, nr...)
|
2015-09-25 10:19:17 +00:00
|
|
|
}
|
2015-11-10 08:57:06 +00:00
|
|
|
|
2016-06-14 02:52:49 +00:00
|
|
|
// Combine the network list returned by Docker daemon if it is not already
|
|
|
|
// returned by the cluster manager
|
|
|
|
SKIP:
|
|
|
|
for _, nw := range n.backend.GetNetworks() {
|
|
|
|
for _, nl := range list {
|
|
|
|
if nl.ID == nw.ID() {
|
|
|
|
continue SKIP
|
|
|
|
}
|
|
|
|
}
|
|
|
|
list = append(list, *n.buildNetworkResource(nw))
|
2015-11-10 08:57:06 +00:00
|
|
|
}
|
|
|
|
|
2016-06-14 02:52:49 +00:00
|
|
|
list, err = filterNetworks(list, netFilters)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2015-09-25 10:19:17 +00:00
|
|
|
return httputils.WriteJSON(w, http.StatusOK, list)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (n *networkRouter) getNetwork(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
|
|
|
|
if err := httputils.ParseForm(r); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2015-10-26 21:47:48 +00:00
|
|
|
nw, err := n.backend.FindNetwork(vars["id"])
|
2015-09-25 10:19:17 +00:00
|
|
|
if err != nil {
|
2016-12-26 12:53:13 +00:00
|
|
|
if nr, err := n.cluster.GetNetwork(vars["id"]); err == nil {
|
2016-06-14 02:52:49 +00:00
|
|
|
return httputils.WriteJSON(w, http.StatusOK, nr)
|
|
|
|
}
|
2015-09-25 10:19:17 +00:00
|
|
|
return err
|
|
|
|
}
|
2016-06-14 02:52:49 +00:00
|
|
|
return httputils.WriteJSON(w, http.StatusOK, n.buildNetworkResource(nw))
|
2015-09-25 10:19:17 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
func (n *networkRouter) postNetworkCreate(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
|
2016-04-13 08:33:46 +00:00
|
|
|
var create types.NetworkCreateRequest
|
2015-09-25 10:19:17 +00:00
|
|
|
|
|
|
|
if err := httputils.ParseForm(r); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
if err := httputils.CheckForJSON(r); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
if err := json.NewDecoder(r.Body).Decode(&create); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2016-12-26 12:53:13 +00:00
|
|
|
if nws, err := n.cluster.GetNetworksByName(create.Name); err == nil && len(nws) > 0 {
|
2016-06-30 01:08:55 +00:00
|
|
|
return libnetwork.NetworkNameError(create.Name)
|
|
|
|
}
|
|
|
|
|
2016-03-28 17:41:06 +00:00
|
|
|
nw, err := n.backend.CreateNetwork(create)
|
2015-09-25 10:19:17 +00:00
|
|
|
if err != nil {
|
2016-06-14 02:52:49 +00:00
|
|
|
if _, ok := err.(libnetwork.ManagerRedirectError); !ok {
|
|
|
|
return err
|
|
|
|
}
|
2016-12-26 12:53:13 +00:00
|
|
|
id, err := n.cluster.CreateNetwork(create)
|
2016-06-14 02:52:49 +00:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
nw = &types.NetworkCreateResponse{ID: id}
|
2015-09-25 10:19:17 +00:00
|
|
|
}
|
|
|
|
|
2016-03-28 17:41:06 +00:00
|
|
|
return httputils.WriteJSON(w, http.StatusCreated, nw)
|
2015-09-25 10:19:17 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
func (n *networkRouter) postNetworkConnect(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
|
|
|
|
var connect types.NetworkConnect
|
|
|
|
if err := httputils.ParseForm(r); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
if err := httputils.CheckForJSON(r); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
if err := json.NewDecoder(r.Body).Decode(&connect); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2016-08-23 23:50:15 +00:00
|
|
|
return n.backend.ConnectContainerToNetwork(connect.Container, vars["id"], connect.EndpointConfig)
|
2015-09-25 10:19:17 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
func (n *networkRouter) postNetworkDisconnect(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
|
|
|
|
var disconnect types.NetworkDisconnect
|
|
|
|
if err := httputils.ParseForm(r); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
if err := httputils.CheckForJSON(r); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
if err := json.NewDecoder(r.Body).Decode(&disconnect); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2016-08-26 20:08:28 +00:00
|
|
|
return n.backend.DisconnectContainerFromNetwork(disconnect.Container, vars["id"], disconnect.Force)
|
2015-09-25 10:19:17 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
func (n *networkRouter) deleteNetwork(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
|
2016-03-05 16:41:51 +00:00
|
|
|
if err := httputils.ParseForm(r); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2016-12-26 12:53:13 +00:00
|
|
|
if _, err := n.cluster.GetNetwork(vars["id"]); err == nil {
|
|
|
|
if err = n.cluster.RemoveNetwork(vars["id"]); err != nil {
|
2016-09-27 18:04:36 +00:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
w.WriteHeader(http.StatusNoContent)
|
|
|
|
return nil
|
2016-06-14 02:52:49 +00:00
|
|
|
}
|
2016-03-05 16:41:51 +00:00
|
|
|
if err := n.backend.DeleteNetwork(vars["id"]); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
w.WriteHeader(http.StatusNoContent)
|
|
|
|
return nil
|
2015-09-25 10:19:17 +00:00
|
|
|
}
|
|
|
|
|
2016-06-14 02:52:49 +00:00
|
|
|
func (n *networkRouter) buildNetworkResource(nw libnetwork.Network) *types.NetworkResource {
|
2015-09-25 10:19:17 +00:00
|
|
|
r := &types.NetworkResource{}
|
|
|
|
if nw == nil {
|
|
|
|
return r
|
|
|
|
}
|
|
|
|
|
2016-03-16 21:52:34 +00:00
|
|
|
info := nw.Info()
|
2015-09-25 10:19:17 +00:00
|
|
|
r.Name = nw.Name()
|
|
|
|
r.ID = nw.ID()
|
2016-08-30 04:53:16 +00:00
|
|
|
r.Created = info.Created()
|
2016-03-16 21:52:34 +00:00
|
|
|
r.Scope = info.Scope()
|
2016-12-26 12:53:13 +00:00
|
|
|
if n.cluster.IsManager() {
|
|
|
|
if _, err := n.cluster.GetNetwork(nw.Name()); err == nil {
|
2016-06-14 02:52:49 +00:00
|
|
|
r.Scope = "swarm"
|
|
|
|
}
|
|
|
|
} else if info.Dynamic() {
|
|
|
|
r.Scope = "swarm"
|
|
|
|
}
|
2015-09-25 10:19:17 +00:00
|
|
|
r.Driver = nw.Type()
|
2016-03-16 21:52:34 +00:00
|
|
|
r.EnableIPv6 = info.IPv6Enabled()
|
|
|
|
r.Internal = info.Internal()
|
2016-11-22 19:33:00 +00:00
|
|
|
r.Attachable = info.Attachable()
|
2016-03-16 21:52:34 +00:00
|
|
|
r.Options = info.DriverOptions()
|
2015-09-25 10:19:17 +00:00
|
|
|
r.Containers = make(map[string]types.EndpointResource)
|
2016-03-16 21:52:34 +00:00
|
|
|
buildIpamResources(r, info)
|
|
|
|
r.Labels = info.Labels()
|
2015-10-09 18:21:48 +00:00
|
|
|
|
2016-11-04 19:27:36 +00:00
|
|
|
peers := info.Peers()
|
|
|
|
if len(peers) != 0 {
|
|
|
|
r.Peers = buildPeerInfoResources(peers)
|
|
|
|
}
|
|
|
|
|
2015-09-25 10:19:17 +00:00
|
|
|
epl := nw.Endpoints()
|
|
|
|
for _, e := range epl {
|
2015-11-03 22:15:34 +00:00
|
|
|
ei := e.Info()
|
|
|
|
if ei == nil {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
sb := ei.Sandbox()
|
2016-07-06 09:54:46 +00:00
|
|
|
tmpID := e.ID()
|
|
|
|
key := "ep-" + tmpID
|
2016-03-12 21:29:25 +00:00
|
|
|
if sb != nil {
|
|
|
|
key = sb.ContainerID()
|
2015-09-25 10:19:17 +00:00
|
|
|
}
|
|
|
|
|
2016-07-06 09:54:46 +00:00
|
|
|
r.Containers[key] = buildEndpointResource(tmpID, e.Name(), ei)
|
2015-09-25 10:19:17 +00:00
|
|
|
}
|
|
|
|
return r
|
|
|
|
}
|
|
|
|
|
2016-11-04 19:27:36 +00:00
|
|
|
func buildPeerInfoResources(peers []networkdb.PeerInfo) []network.PeerInfo {
|
|
|
|
peerInfo := make([]network.PeerInfo, 0, len(peers))
|
|
|
|
for _, peer := range peers {
|
|
|
|
peerInfo = append(peerInfo, network.PeerInfo{
|
|
|
|
Name: peer.Name,
|
|
|
|
IP: peer.IP,
|
|
|
|
})
|
|
|
|
}
|
|
|
|
return peerInfo
|
|
|
|
}
|
|
|
|
|
2016-03-16 21:52:34 +00:00
|
|
|
func buildIpamResources(r *types.NetworkResource, nwInfo libnetwork.NetworkInfo) {
|
|
|
|
id, opts, ipv4conf, ipv6conf := nwInfo.IpamConfig()
|
2015-10-09 18:21:48 +00:00
|
|
|
|
2016-03-16 21:52:34 +00:00
|
|
|
ipv4Info, ipv6Info := nwInfo.IpamInfo()
|
2015-12-28 04:56:57 +00:00
|
|
|
|
2015-10-09 18:21:48 +00:00
|
|
|
r.IPAM.Driver = id
|
|
|
|
|
2015-10-23 19:28:39 +00:00
|
|
|
r.IPAM.Options = opts
|
|
|
|
|
2015-10-09 18:21:48 +00:00
|
|
|
r.IPAM.Config = []network.IPAMConfig{}
|
|
|
|
for _, ip4 := range ipv4conf {
|
2015-12-28 04:56:57 +00:00
|
|
|
if ip4.PreferredPool == "" {
|
|
|
|
continue
|
|
|
|
}
|
2015-10-09 18:21:48 +00:00
|
|
|
iData := network.IPAMConfig{}
|
|
|
|
iData.Subnet = ip4.PreferredPool
|
|
|
|
iData.IPRange = ip4.SubPool
|
|
|
|
iData.Gateway = ip4.Gateway
|
|
|
|
iData.AuxAddress = ip4.AuxAddresses
|
|
|
|
r.IPAM.Config = append(r.IPAM.Config, iData)
|
|
|
|
}
|
|
|
|
|
2015-12-28 04:56:57 +00:00
|
|
|
if len(r.IPAM.Config) == 0 {
|
|
|
|
for _, ip4Info := range ipv4Info {
|
|
|
|
iData := network.IPAMConfig{}
|
|
|
|
iData.Subnet = ip4Info.IPAMData.Pool.String()
|
2016-08-12 01:08:54 +00:00
|
|
|
iData.Gateway = ip4Info.IPAMData.Gateway.IP.String()
|
2015-12-28 04:56:57 +00:00
|
|
|
r.IPAM.Config = append(r.IPAM.Config, iData)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
hasIpv6Conf := false
|
2015-10-09 18:21:48 +00:00
|
|
|
for _, ip6 := range ipv6conf {
|
2015-12-28 04:56:57 +00:00
|
|
|
if ip6.PreferredPool == "" {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
hasIpv6Conf = true
|
2015-10-09 18:21:48 +00:00
|
|
|
iData := network.IPAMConfig{}
|
|
|
|
iData.Subnet = ip6.PreferredPool
|
|
|
|
iData.IPRange = ip6.SubPool
|
|
|
|
iData.Gateway = ip6.Gateway
|
|
|
|
iData.AuxAddress = ip6.AuxAddresses
|
|
|
|
r.IPAM.Config = append(r.IPAM.Config, iData)
|
|
|
|
}
|
2015-12-28 04:56:57 +00:00
|
|
|
|
|
|
|
if !hasIpv6Conf {
|
|
|
|
for _, ip6Info := range ipv6Info {
|
|
|
|
iData := network.IPAMConfig{}
|
|
|
|
iData.Subnet = ip6Info.IPAMData.Pool.String()
|
|
|
|
iData.Gateway = ip6Info.IPAMData.Gateway.String()
|
|
|
|
r.IPAM.Config = append(r.IPAM.Config, iData)
|
|
|
|
}
|
|
|
|
}
|
2015-10-09 18:21:48 +00:00
|
|
|
}
|
|
|
|
|
2016-07-06 09:54:46 +00:00
|
|
|
func buildEndpointResource(id string, name string, info libnetwork.EndpointInfo) types.EndpointResource {
|
2015-09-25 10:19:17 +00:00
|
|
|
er := types.EndpointResource{}
|
|
|
|
|
2016-07-06 09:54:46 +00:00
|
|
|
er.EndpointID = id
|
|
|
|
er.Name = name
|
|
|
|
ei := info
|
2015-11-03 22:15:34 +00:00
|
|
|
if ei == nil {
|
|
|
|
return er
|
|
|
|
}
|
|
|
|
|
|
|
|
if iface := ei.Iface(); iface != nil {
|
2015-09-25 10:19:17 +00:00
|
|
|
if mac := iface.MacAddress(); mac != nil {
|
|
|
|
er.MacAddress = mac.String()
|
|
|
|
}
|
2015-10-10 16:43:03 +00:00
|
|
|
if ip := iface.Address(); ip != nil && len(ip.IP) > 0 {
|
|
|
|
er.IPv4Address = ip.String()
|
2015-09-25 10:19:17 +00:00
|
|
|
}
|
|
|
|
|
2015-10-10 16:43:03 +00:00
|
|
|
if ipv6 := iface.AddressIPv6(); ipv6 != nil && len(ipv6.IP) > 0 {
|
|
|
|
er.IPv6Address = ipv6.String()
|
2015-09-25 10:19:17 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return er
|
|
|
|
}
|
2016-10-18 04:36:52 +00:00
|
|
|
|
|
|
|
func (n *networkRouter) postNetworksPrune(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
|
|
|
|
if err := httputils.ParseForm(r); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2016-12-07 22:02:13 +00:00
|
|
|
pruneFilters, err := filters.FromParam(r.Form.Get("filters"))
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
pruneReport, err := n.backend.NetworksPrune(pruneFilters)
|
2016-10-18 04:36:52 +00:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
return httputils.WriteJSON(w, http.StatusOK, pruneReport)
|
|
|
|
}
|