2015-09-25 06:19:17 -04:00
|
|
|
package daemon
|
|
|
|
|
|
|
|
import (
|
|
|
|
"errors"
|
2015-10-09 14:21:48 -04:00
|
|
|
"fmt"
|
|
|
|
"net"
|
2015-09-25 06:19:17 -04:00
|
|
|
"strings"
|
|
|
|
|
2015-10-09 14:21:48 -04:00
|
|
|
"github.com/docker/docker/daemon/network"
|
2015-09-25 06:19:17 -04:00
|
|
|
"github.com/docker/libnetwork"
|
|
|
|
)
|
|
|
|
|
|
|
|
const (
|
|
|
|
// NetworkByID represents a constant to find a network by its ID
|
|
|
|
NetworkByID = iota + 1
|
|
|
|
// NetworkByName represents a constant to find a network by its Name
|
|
|
|
NetworkByName
|
|
|
|
)
|
|
|
|
|
2015-10-16 18:45:54 -04:00
|
|
|
// NetworkControllerEnabled checks if the networking stack is enabled.
|
|
|
|
// This feature depends on OS primitives and it's dissabled in systems like Windows.
|
|
|
|
func (daemon *Daemon) NetworkControllerEnabled() bool {
|
|
|
|
return daemon.netController != nil
|
|
|
|
}
|
|
|
|
|
2015-09-25 06:19:17 -04:00
|
|
|
// FindNetwork function finds a network for a given string that can represent network name or id
|
|
|
|
func (daemon *Daemon) FindNetwork(idName string) (libnetwork.Network, error) {
|
|
|
|
// Find by Name
|
|
|
|
n, err := daemon.GetNetwork(idName, NetworkByName)
|
|
|
|
if _, ok := err.(libnetwork.ErrNoSuchNetwork); err != nil && !ok {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
if n != nil {
|
|
|
|
return n, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// Find by id
|
|
|
|
n, err = daemon.GetNetwork(idName, NetworkByID)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
return n, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// GetNetwork function returns a network for a given string that represents the network and
|
|
|
|
// a hint to indicate if the string is an Id or Name of the network
|
|
|
|
func (daemon *Daemon) GetNetwork(idName string, by int) (libnetwork.Network, error) {
|
|
|
|
c := daemon.netController
|
|
|
|
switch by {
|
|
|
|
case NetworkByID:
|
|
|
|
list := daemon.GetNetworksByID(idName)
|
|
|
|
|
|
|
|
if len(list) == 0 {
|
|
|
|
return nil, libnetwork.ErrNoSuchNetwork(idName)
|
|
|
|
}
|
|
|
|
|
|
|
|
if len(list) > 1 {
|
|
|
|
return nil, libnetwork.ErrInvalidID(idName)
|
|
|
|
}
|
|
|
|
|
|
|
|
return list[0], nil
|
|
|
|
case NetworkByName:
|
|
|
|
if idName == "" {
|
|
|
|
idName = c.Config().Daemon.DefaultNetwork
|
|
|
|
}
|
|
|
|
return c.NetworkByName(idName)
|
|
|
|
}
|
|
|
|
return nil, errors.New("unexpected selector for GetNetwork")
|
|
|
|
}
|
|
|
|
|
|
|
|
// GetNetworksByID returns a list of networks whose ID partially matches zero or more networks
|
|
|
|
func (daemon *Daemon) GetNetworksByID(partialID string) []libnetwork.Network {
|
|
|
|
c := daemon.netController
|
|
|
|
list := []libnetwork.Network{}
|
|
|
|
l := func(nw libnetwork.Network) bool {
|
|
|
|
if strings.HasPrefix(nw.ID(), partialID) {
|
|
|
|
list = append(list, nw)
|
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
c.WalkNetworks(l)
|
|
|
|
|
|
|
|
return list
|
|
|
|
}
|
|
|
|
|
|
|
|
// CreateNetwork creates a network with the given name, driver and other optional parameters
|
2015-10-14 21:49:27 -04:00
|
|
|
func (daemon *Daemon) CreateNetwork(name, driver string, ipam network.IPAM, options map[string]string) (libnetwork.Network, error) {
|
2015-09-25 06:19:17 -04:00
|
|
|
c := daemon.netController
|
|
|
|
if driver == "" {
|
|
|
|
driver = c.Config().Daemon.DefaultDriver
|
|
|
|
}
|
|
|
|
|
2015-10-09 14:21:48 -04:00
|
|
|
nwOptions := []libnetwork.NetworkOption{}
|
|
|
|
|
|
|
|
v4Conf, v6Conf, err := getIpamConfig(ipam.Config)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
2015-10-19 19:17:05 -04:00
|
|
|
nwOptions = append(nwOptions, libnetwork.NetworkOptionIpam(ipam.Driver, "", v4Conf, v6Conf))
|
2015-10-14 21:49:27 -04:00
|
|
|
nwOptions = append(nwOptions, libnetwork.NetworkOptionDriverOpts(options))
|
2015-10-09 14:21:48 -04:00
|
|
|
return c.NewNetwork(driver, name, nwOptions...)
|
|
|
|
}
|
|
|
|
|
|
|
|
func getIpamConfig(data []network.IPAMConfig) ([]*libnetwork.IpamConf, []*libnetwork.IpamConf, error) {
|
|
|
|
ipamV4Cfg := []*libnetwork.IpamConf{}
|
|
|
|
ipamV6Cfg := []*libnetwork.IpamConf{}
|
|
|
|
for _, d := range data {
|
|
|
|
iCfg := libnetwork.IpamConf{}
|
|
|
|
iCfg.PreferredPool = d.Subnet
|
|
|
|
iCfg.SubPool = d.IPRange
|
|
|
|
iCfg.Gateway = d.Gateway
|
|
|
|
iCfg.AuxAddresses = d.AuxAddress
|
|
|
|
ip, _, err := net.ParseCIDR(d.Subnet)
|
|
|
|
if err != nil {
|
|
|
|
return nil, nil, fmt.Errorf("Invalid subnet %s : %v", d.Subnet, err)
|
|
|
|
}
|
|
|
|
if ip.To4() != nil {
|
|
|
|
ipamV4Cfg = append(ipamV4Cfg, &iCfg)
|
|
|
|
} else {
|
|
|
|
ipamV6Cfg = append(ipamV6Cfg, &iCfg)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return ipamV4Cfg, ipamV6Cfg, nil
|
2015-09-25 06:19:17 -04:00
|
|
|
}
|
2015-10-13 18:44:23 -04:00
|
|
|
|
|
|
|
// ConnectContainerToNetwork connects the given container to the given
|
|
|
|
// network. If either cannot be found, an err is returned. If the
|
|
|
|
// network cannot be set up, an err is returned.
|
|
|
|
func (daemon *Daemon) ConnectContainerToNetwork(containerName, networkName string) error {
|
|
|
|
container, err := daemon.Get(containerName)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
return container.ConnectToNetwork(networkName)
|
|
|
|
}
|
|
|
|
|
|
|
|
// DisconnectContainerFromNetwork disconnects the given container from
|
|
|
|
// the given network. If either cannot be found, an err is returned.
|
|
|
|
func (daemon *Daemon) DisconnectContainerFromNetwork(containerName string, network libnetwork.Network) error {
|
|
|
|
container, err := daemon.Get(containerName)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
return container.DisconnectFromNetwork(network)
|
|
|
|
}
|