// modifyHostNetworkOptionForSandbox applies NetworkMode/UTSMode to sandbox's dockercontainer.HostConfig.
func modifyHostNetworkOptionForSandbox(hostNetwork bool, hc *dockercontainer.HostConfig) {
if hostNetwork {
hc.NetworkMode = namespaceModeHost
} else {
// Assume kubelet uses either the cni or the kubenet plugin.
// TODO: support docker networking.
hc.NetworkMode = "none"
}
}
// SetDefaultNetModeIfBlank changes the NetworkMode in a HostConfig structure
// to default if it is not populated. This ensures backwards compatibility after
// the validation of the network mode was moved from the docker CLI to the
// docker daemon.
func SetDefaultNetModeIfBlank(hc *container.HostConfig) *container.HostConfig {
if hc != nil {
if hc.NetworkMode == container.NetworkMode("") {
hc.NetworkMode = container.NetworkMode("default")
}
}
return hc
}
// modifyHostNetworkOptionForContainer applies NetworkMode/UTSMode to container's dockercontainer.HostConfig.
func modifyHostNetworkOptionForContainer(hostNetwork bool, sandboxID string, hc *dockercontainer.HostConfig) {
sandboxNSMode := fmt.Sprintf("container:%v", sandboxID)
hc.NetworkMode = dockercontainer.NetworkMode(sandboxNSMode)
hc.IpcMode = dockercontainer.IpcMode(sandboxNSMode)
hc.UTSMode = ""
hc.PidMode = ""
if hostNetwork {
hc.UTSMode = namespaceModeHost
}
}
// modifyHostNetworkOptionForSandbox applies NetworkMode/UTSMode to sandbox's dockercontainer.HostConfig.
func modifyHostNetworkOptionForSandbox(hostNetwork bool, networkPlugin network.NetworkPlugin, hc *dockercontainer.HostConfig) {
if hostNetwork {
hc.NetworkMode = namespaceModeHost
return
}
if networkPlugin == nil {
hc.NetworkMode = "default"
return
}
switch networkPlugin.Name() {
case "cni":
fallthrough
case "kubenet":
hc.NetworkMode = "none"
default:
hc.NetworkMode = "default"
}
}
func (c *Container) addNetNs(config *container.HostConfig, service project.Service, containers []project.Container) (*container.HostConfig, error) {
if len(containers) == 0 {
return nil, fmt.Errorf("Failed to find container for networks ns %v", c.service.Config().Net)
}
id, err := containers[0].ID()
if err != nil {
return nil, err
}
config.NetworkMode = container.NetworkMode("container:" + id)
return config, nil
}
func addNetNs(config *containertypes.HostConfig, service project.Service, containers []project.Container, networkMode string) (*containertypes.HostConfig, error) {
if len(containers) == 0 {
return nil, fmt.Errorf("Failed to find container for networks ns %v", networkMode)
}
id, err := containers[0].ID()
if err != nil {
return nil, err
}
config.NetworkMode = containertypes.NetworkMode("container:" + id)
return config, nil
}
// createContainer creates a new container using the specified
// options. Per the docker API, the created container is not running
// and must be started explicitly. Note that the passed-in hostConfig
// will be augmented with the necessary settings to use the network
// defined by l.createNetwork().
func createContainer(l *LocalCluster, containerConfig container.Config, hostConfig container.HostConfig, containerName string) (*Container, error) {
hostConfig.NetworkMode = container.NetworkMode(l.networkID)
// Disable DNS search under the host machine's domain. This can
// catch upstream wildcard DNS matching and result in odd behavior.
hostConfig.DNSSearch = []string{"."}
resp, err := l.client.ContainerCreate(&containerConfig, &hostConfig, nil, containerName)
if err != nil {
return nil, err
}
return &Container{
id: resp.ID,
name: containerName,
cluster: l,
}, nil
}
func (c *Container) containerStart(name string, hostConfig *containertypes.HostConfig, bind bool) error {
var err error
// Get an API client to the portlayer
client := c.containerProxy.Client()
// Look up the container name in the metadata cache to get long ID
vc := cache.ContainerCache().GetContainer(name)
if vc == nil {
return NotFoundError(name)
}
id := vc.ContainerID
// handle legacy hostConfig
if hostConfig != nil {
// hostConfig exist for backwards compatibility. TODO: Figure out which parameters we
// need to look at in hostConfig
} else if vc != nil {
hostConfig = vc.HostConfig
}
if vc != nil && hostConfig.NetworkMode.NetworkName() == "" {
hostConfig.NetworkMode = vc.HostConfig.NetworkMode
}
// get a handle to the container
handle, err := c.Handle(id, name)
if err != nil {
return err
}
var endpoints []*models.EndpointConfig
// bind network
if bind {
var bindRes *scopes.BindContainerOK
bindRes, err = client.Scopes.BindContainer(scopes.NewBindContainerParamsWithContext(ctx).WithHandle(handle))
if err != nil {
switch err := err.(type) {
case *scopes.BindContainerNotFound:
cache.ContainerCache().DeleteContainer(id)
return NotFoundError(name)
case *scopes.BindContainerInternalServerError:
return InternalServerError(err.Payload.Message)
default:
return InternalServerError(err.Error())
}
}
handle = bindRes.Payload.Handle
endpoints = bindRes.Payload.Endpoints
// unbind in case we fail later
defer func() {
if err != nil {
client.Scopes.UnbindContainer(scopes.NewUnbindContainerParamsWithContext(ctx).WithHandle(handle))
}
}()
// unmap ports that vc needs if they're not being used by previously mapped container
err = c.cleanupPortBindings(vc)
if err != nil {
return err
}
}
// change the state of the container
// TODO: We need a resolved ID from the name
var stateChangeRes *containers.StateChangeOK
stateChangeRes, err = client.Containers.StateChange(containers.NewStateChangeParamsWithContext(ctx).WithHandle(handle).WithState("RUNNING"))
if err != nil {
switch err := err.(type) {
case *containers.StateChangeNotFound:
cache.ContainerCache().DeleteContainer(id)
return NotFoundError(name)
case *containers.StateChangeDefault:
return InternalServerError(err.Payload.Message)
default:
return InternalServerError(err.Error())
}
}
handle = stateChangeRes.Payload
// map ports
if bind {
e := c.findPortBoundNetworkEndpoint(hostConfig, endpoints)
if err = MapPorts(hostConfig, e, id); err != nil {
return InternalServerError(fmt.Sprintf("error mapping ports: %s", err))
}
defer func() {
if err != nil {
UnmapPorts(hostConfig)
}
}()
}
// commit the handle; this will reconfigure and start the vm
_, err = client.Containers.Commit(containers.NewCommitParamsWithContext(ctx).WithHandle(handle))
if err != nil {
switch err := err.(type) {
case *containers.CommitNotFound:
cache.ContainerCache().DeleteContainer(id)
return NotFoundError(name)
case *containers.CommitConflict:
return ConflictError(err.Error())
case *containers.CommitDefault:
return InternalServerError(err.Payload.Message)
default:
return InternalServerError(err.Error())
}
}
return nil
}
