2014-07-31 20:36:42 +00:00
|
|
|
package daemon
|
|
|
|
|
|
|
|
import (
|
2015-07-02 10:24:35 +00:00
|
|
|
"github.com/Sirupsen/logrus"
|
2015-11-12 19:55:17 +00:00
|
|
|
"github.com/docker/docker/container"
|
2015-09-17 18:54:14 +00:00
|
|
|
derr "github.com/docker/docker/errors"
|
2015-07-20 17:57:15 +00:00
|
|
|
"github.com/docker/docker/image"
|
2015-12-16 22:13:50 +00:00
|
|
|
"github.com/docker/docker/layer"
|
2015-11-18 22:20:54 +00:00
|
|
|
"github.com/docker/docker/pkg/idtools"
|
2015-06-12 13:25:32 +00:00
|
|
|
"github.com/docker/docker/pkg/stringid"
|
2015-09-23 20:29:14 +00:00
|
|
|
volumestore "github.com/docker/docker/volume/store"
|
2016-01-05 00:05:26 +00:00
|
|
|
"github.com/docker/engine-api/types"
|
|
|
|
containertypes "github.com/docker/engine-api/types/container"
|
2016-01-08 00:18:34 +00:00
|
|
|
networktypes "github.com/docker/engine-api/types/network"
|
2015-07-16 23:00:55 +00:00
|
|
|
"github.com/opencontainers/runc/libcontainer/label"
|
2014-07-31 20:36:42 +00:00
|
|
|
)
|
|
|
|
|
2015-12-16 16:56:49 +00:00
|
|
|
// ContainerCreate creates a container.
|
|
|
|
func (daemon *Daemon) ContainerCreate(params types.ContainerCreateConfig) (types.ContainerCreateResponse, error) {
|
2015-09-10 02:23:06 +00:00
|
|
|
if params.Config == nil {
|
2015-09-23 01:06:09 +00:00
|
|
|
return types.ContainerCreateResponse{}, derr.ErrorCodeEmptyConfig
|
2015-06-06 16:41:42 +00:00
|
|
|
}
|
|
|
|
|
2015-09-10 02:23:06 +00:00
|
|
|
warnings, err := daemon.verifyContainerSettings(params.HostConfig, params.Config)
|
2015-04-16 06:31:52 +00:00
|
|
|
if err != nil {
|
2015-12-16 16:56:49 +00:00
|
|
|
return types.ContainerCreateResponse{Warnings: warnings}, err
|
2015-01-23 03:29:21 +00:00
|
|
|
}
|
2014-09-25 21:23:59 +00:00
|
|
|
|
2016-01-21 22:24:35 +00:00
|
|
|
err = daemon.verifyNetworkingConfig(params.NetworkingConfig)
|
|
|
|
if err != nil {
|
|
|
|
return types.ContainerCreateResponse{}, err
|
|
|
|
}
|
|
|
|
|
2015-11-30 05:10:18 +00:00
|
|
|
if params.HostConfig == nil {
|
2015-12-18 18:36:17 +00:00
|
|
|
params.HostConfig = &containertypes.HostConfig{}
|
2015-11-30 05:10:18 +00:00
|
|
|
}
|
|
|
|
err = daemon.adaptContainerSettings(params.HostConfig, params.AdjustCPUShares)
|
|
|
|
if err != nil {
|
2015-12-16 16:56:49 +00:00
|
|
|
return types.ContainerCreateResponse{Warnings: warnings}, err
|
2015-11-30 05:10:18 +00:00
|
|
|
}
|
2015-09-07 03:07:12 +00:00
|
|
|
|
2015-09-10 02:23:06 +00:00
|
|
|
container, err := daemon.create(params)
|
2014-07-31 20:36:42 +00:00
|
|
|
if err != nil {
|
2015-12-16 16:56:49 +00:00
|
|
|
return types.ContainerCreateResponse{Warnings: warnings}, daemon.imageNotExistToErrcode(err)
|
2014-07-31 20:36:42 +00:00
|
|
|
}
|
2014-12-01 16:44:13 +00:00
|
|
|
|
2015-11-02 16:28:34 +00:00
|
|
|
return types.ContainerCreateResponse{ID: container.ID, Warnings: warnings}, nil
|
2014-07-31 20:36:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Create creates a new container from the given configuration with a given name.
|
2015-12-22 00:13:02 +00:00
|
|
|
func (daemon *Daemon) create(params types.ContainerCreateConfig) (retC *container.Container, retErr error) {
|
2014-07-31 20:36:42 +00:00
|
|
|
var (
|
2015-11-12 19:55:17 +00:00
|
|
|
container *container.Container
|
2015-07-20 17:57:15 +00:00
|
|
|
img *image.Image
|
2015-11-18 22:20:54 +00:00
|
|
|
imgID image.ID
|
2014-10-28 21:06:23 +00:00
|
|
|
err error
|
2014-07-31 20:36:42 +00:00
|
|
|
)
|
|
|
|
|
2015-09-10 02:23:06 +00:00
|
|
|
if params.Config.Image != "" {
|
2015-11-18 22:20:54 +00:00
|
|
|
img, err = daemon.GetImage(params.Config.Image)
|
2014-10-28 21:06:23 +00:00
|
|
|
if err != nil {
|
2015-09-06 17:26:40 +00:00
|
|
|
return nil, err
|
2014-10-28 21:06:23 +00:00
|
|
|
}
|
2015-11-18 22:20:54 +00:00
|
|
|
imgID = img.ID()
|
2014-07-31 20:36:42 +00:00
|
|
|
}
|
2014-10-28 21:06:23 +00:00
|
|
|
|
2015-09-10 02:23:06 +00:00
|
|
|
if err := daemon.mergeAndVerifyConfig(params.Config, img); err != nil {
|
2015-09-06 17:26:40 +00:00
|
|
|
return nil, err
|
2014-07-31 20:36:42 +00:00
|
|
|
}
|
2015-08-12 02:27:33 +00:00
|
|
|
|
2015-09-10 02:23:06 +00:00
|
|
|
if container, err = daemon.newContainer(params.Name, params.Config, imgID); err != nil {
|
2015-09-06 17:26:40 +00:00
|
|
|
return nil, err
|
2014-07-31 20:36:42 +00:00
|
|
|
}
|
2015-08-11 14:21:52 +00:00
|
|
|
defer func() {
|
|
|
|
if retErr != nil {
|
2015-12-04 20:34:43 +00:00
|
|
|
if err := daemon.ContainerRm(container.ID, &types.ContainerRmConfig{ForceRemove: true}); err != nil {
|
2015-08-11 14:21:52 +00:00
|
|
|
logrus.Errorf("Clean up Error! Cannot destroy container %s: %v", container.ID, err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
|
2015-12-21 19:23:20 +00:00
|
|
|
if err := daemon.setSecurityOptions(container, params.HostConfig); err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
// Set RWLayer for container after mount labels have been set
|
|
|
|
if err := daemon.setRWLayer(container); err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
2015-09-29 17:51:40 +00:00
|
|
|
if err := daemon.Register(container); err != nil {
|
2015-09-06 17:26:40 +00:00
|
|
|
return nil, err
|
2014-09-30 00:06:26 +00:00
|
|
|
}
|
2015-11-18 22:20:54 +00:00
|
|
|
rootUID, rootGID, err := idtools.GetRootUIDGID(daemon.uidMaps, daemon.gidMaps)
|
|
|
|
if err != nil {
|
2015-10-28 13:19:51 +00:00
|
|
|
return nil, err
|
|
|
|
}
|
2015-11-12 19:55:17 +00:00
|
|
|
if err := idtools.MkdirAs(container.Root, 0700, rootUID, rootGID); err != nil {
|
2015-09-06 17:26:40 +00:00
|
|
|
return nil, err
|
2014-07-31 20:36:42 +00:00
|
|
|
}
|
2015-11-18 22:20:54 +00:00
|
|
|
|
2015-09-10 02:23:06 +00:00
|
|
|
if err := daemon.setHostConfig(container, params.HostConfig); err != nil {
|
2015-09-06 17:26:40 +00:00
|
|
|
return nil, err
|
2014-09-25 21:23:59 +00:00
|
|
|
}
|
2015-09-14 17:21:17 +00:00
|
|
|
defer func() {
|
|
|
|
if retErr != nil {
|
2015-11-03 16:42:08 +00:00
|
|
|
if err := daemon.removeMountPoints(container, true); err != nil {
|
2015-09-14 17:21:17 +00:00
|
|
|
logrus.Error(err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}()
|
2015-05-19 20:05:25 +00:00
|
|
|
|
2016-01-08 18:19:25 +00:00
|
|
|
if err := daemon.createContainerPlatformSpecificSettings(container, params.Config, params.HostConfig); err != nil {
|
2015-09-06 17:26:40 +00:00
|
|
|
return nil, err
|
2014-11-11 16:17:33 +00:00
|
|
|
}
|
2015-07-16 21:14:58 +00:00
|
|
|
|
2016-01-08 00:18:34 +00:00
|
|
|
var endpointsConfigs map[string]*networktypes.EndpointSettings
|
|
|
|
if params.NetworkingConfig != nil {
|
|
|
|
endpointsConfigs = params.NetworkingConfig.EndpointsConfig
|
|
|
|
}
|
|
|
|
|
|
|
|
if err := daemon.updateContainerNetworkSettings(container, endpointsConfigs); err != nil {
|
2015-12-13 07:33:18 +00:00
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
2015-11-12 19:55:17 +00:00
|
|
|
if err := container.ToDiskLocking(); err != nil {
|
2015-07-02 10:24:35 +00:00
|
|
|
logrus.Errorf("Error saving new container to disk: %v", err)
|
2015-09-06 17:26:40 +00:00
|
|
|
return nil, err
|
2014-07-31 20:36:42 +00:00
|
|
|
}
|
2015-11-03 17:33:13 +00:00
|
|
|
daemon.LogContainerEvent(container, "create")
|
2015-09-06 17:26:40 +00:00
|
|
|
return container, nil
|
2014-07-31 20:36:42 +00:00
|
|
|
}
|
2014-12-01 16:44:13 +00:00
|
|
|
|
2015-12-18 18:36:17 +00:00
|
|
|
func (daemon *Daemon) generateSecurityOpt(ipcMode containertypes.IpcMode, pidMode containertypes.PidMode) ([]string, error) {
|
2014-11-25 20:10:53 +00:00
|
|
|
if ipcMode.IsHost() || pidMode.IsHost() {
|
2014-11-10 21:14:17 +00:00
|
|
|
return label.DisableSecOpt(), nil
|
|
|
|
}
|
|
|
|
if ipcContainer := ipcMode.Container(); ipcContainer != "" {
|
2015-12-11 17:39:28 +00:00
|
|
|
c, err := daemon.GetContainer(ipcContainer)
|
2014-12-16 23:06:35 +00:00
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
2014-11-10 21:14:17 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return label.DupSecOpt(c.ProcessLabel), nil
|
|
|
|
}
|
|
|
|
return nil, nil
|
|
|
|
}
|
2015-06-12 13:25:32 +00:00
|
|
|
|
2015-12-16 22:13:50 +00:00
|
|
|
func (daemon *Daemon) setRWLayer(container *container.Container) error {
|
|
|
|
var layerID layer.ChainID
|
|
|
|
if container.ImageID != "" {
|
|
|
|
img, err := daemon.imageStore.Get(container.ImageID)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
layerID = img.RootFS.ChainID()
|
|
|
|
}
|
|
|
|
rwLayer, err := daemon.layerStore.CreateRWLayer(container.ID, layerID, container.MountLabel, daemon.setupInitLayer)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
container.RWLayer = rwLayer
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2015-06-12 13:25:32 +00:00
|
|
|
// VolumeCreate creates a volume with the specified name, driver, and opts
|
|
|
|
// This is called directly from the remote API
|
2015-09-29 17:51:40 +00:00
|
|
|
func (daemon *Daemon) VolumeCreate(name, driverName string, opts map[string]string) (*types.Volume, error) {
|
2015-06-12 13:25:32 +00:00
|
|
|
if name == "" {
|
|
|
|
name = stringid.GenerateNonCryptoID()
|
|
|
|
}
|
|
|
|
|
|
|
|
v, err := daemon.volumes.Create(name, driverName, opts)
|
|
|
|
if err != nil {
|
2015-09-23 20:29:14 +00:00
|
|
|
if volumestore.IsNameConflict(err) {
|
|
|
|
return nil, derr.ErrorVolumeNameTaken.WithArgs(name)
|
|
|
|
}
|
2015-06-12 13:25:32 +00:00
|
|
|
return nil, err
|
|
|
|
}
|
2015-10-04 12:09:51 +00:00
|
|
|
|
2015-09-23 20:29:14 +00:00
|
|
|
daemon.LogVolumeEvent(v.Name(), "create", map[string]string{"driver": v.DriverName()})
|
2015-06-12 13:25:32 +00:00
|
|
|
return volumeToAPIType(v), nil
|
|
|
|
}
|