@@ -12,7 +12,7 @@ import (

 	"github.com/docker/docker/pkg/jsonmessage"

 	"github.com/docker/docker/reference"

 	"github.com/docker/docker/registry"

-	"github.com/docker/docker/runconfig"

+	runconfigopts "github.com/docker/docker/runconfig/opts"

 )

 func (cli *DockerCli) pullImage(image string) error {

@@ -156,7 +156,7 @@ func (cli *DockerCli) CmdCreate(args ...string) error {

 		flName = cmd.String([]string{"-name"}, "", "Assign a name to the container")

 	)

-	config, hostConfig, cmd, err := runconfig.Parse(cmd, args)

+	config, hostConfig, cmd, err := runconfigopts.Parse(cmd, args)

 	if err != nil {

 		cmd.ReportError(err.Error(), true)

 		os.Exit(1)

@@ -14,7 +14,7 @@ import (

 	"github.com/docker/docker/opts"

 	"github.com/docker/docker/pkg/promise"

 	"github.com/docker/docker/pkg/signal"

-	"github.com/docker/docker/runconfig"

+	runconfigopts "github.com/docker/docker/runconfig/opts"

 	"github.com/docker/libnetwork/resolvconf/dns"

 )

@@ -82,7 +82,7 @@ func (cli *DockerCli) CmdRun(args ...string) error {

 		ErrConflictDetachAutoRemove           = fmt.Errorf("Conflicting options: --rm and -d")

 	)

-	config, hostConfig, cmd, err := runconfig.Parse(cmd, args)

+	config, hostConfig, cmd, err := runconfigopts.Parse(cmd, args)

 	// just in case the Parse does not exit

 	if err != nil {

 		cmd.ReportError(err.Error(), true)

@@ -25,6 +25,7 @@ import (

 	"github.com/docker/docker/pkg/signal"

 	"github.com/docker/docker/pkg/system"

 	"github.com/docker/docker/runconfig"

+	runconfigopts "github.com/docker/docker/runconfig/opts"

 	"github.com/docker/go-connections/nat"

 )

@@ -337,7 +338,7 @@ func run(b *Builder, args []string, attributes map[string]bool, original string)

 	// of RUN, without leaking it to the final image. It also aids cache

 	// lookup for same image built with same build time environment.

 	cmdBuildEnv := []string{}

-	configEnv := runconfig.ConvertKVStringsToMap(b.runConfig.Env)

+	configEnv := runconfigopts.ConvertKVStringsToMap(b.runConfig.Env)

 	for key, val := range b.BuildArgs {

 		if !b.isBuildArgAllowed(key) {

 			// skip build-args that are not in allowed list, meaning they have

@@ -23,6 +23,7 @@ import (

 	"github.com/docker/docker/pkg/sysinfo"

 	"github.com/docker/docker/reference"

 	"github.com/docker/docker/runconfig"

+	runconfigopts "github.com/docker/docker/runconfig/opts"

 	"github.com/docker/libnetwork"

 	nwconfig "github.com/docker/libnetwork/config"

 	"github.com/docker/libnetwork/drivers/bridge"

@@ -681,7 +682,7 @@ func (daemon *Daemon) registerLinks(container *container.Container, hostConfig *

 	}

 	for _, l := range hostConfig.Links {

-		name, alias, err := runconfig.ParseLink(l)

+		name, alias, err := runconfigopts.ParseLink(l)

 		if err != nil {

 			return err

 		}

deleted file mode 100644

@@ -1,651 +0,0 @@

-package runconfig

-

-import (

-	"fmt"

-	"path"

-	"strconv"

-	"strings"

-

-	"github.com/docker/docker/api/types/container"

-	"github.com/docker/docker/api/types/strslice"

-	"github.com/docker/docker/opts"

-	flag "github.com/docker/docker/pkg/mflag"

-	"github.com/docker/docker/pkg/mount"

-	"github.com/docker/docker/pkg/signal"

-	runconfigopts "github.com/docker/docker/runconfig/opts"

-	"github.com/docker/docker/volume"

-	"github.com/docker/go-connections/nat"

-	"github.com/docker/go-units"

-)

-

-var (

-	// ErrConflictContainerNetworkAndLinks conflict between --net=container and links

-	ErrConflictContainerNetworkAndLinks = fmt.Errorf("Conflicting options: container type network can't be used with links. This would result in undefined behavior")

-	// ErrConflictUserDefinedNetworkAndLinks conflict between --net=<NETWORK> and links

-	ErrConflictUserDefinedNetworkAndLinks = fmt.Errorf("Conflicting options: networking can't be used with links. This would result in undefined behavior")

-	// ErrConflictSharedNetwork conflict between private and other networks

-	ErrConflictSharedNetwork = fmt.Errorf("Container sharing network namespace with another container or host cannot be connected to any other network")

-	// ErrConflictHostNetwork conflict from being disconnected from host network or connected to host network.

-	ErrConflictHostNetwork = fmt.Errorf("Container cannot be disconnected from host network or connected to host network")

-	// ErrConflictNoNetwork conflict between private and other networks

-	ErrConflictNoNetwork = fmt.Errorf("Container cannot be connected to multiple networks with one of the networks in private (none) mode")

-	// ErrConflictNetworkAndDNS conflict between --dns and the network mode

-	ErrConflictNetworkAndDNS = fmt.Errorf("Conflicting options: dns and the network mode")

-	// ErrConflictNetworkHostname conflict between the hostname and the network mode

-	ErrConflictNetworkHostname = fmt.Errorf("Conflicting options: hostname and the network mode")

-	// ErrConflictHostNetworkAndLinks conflict between --net=host and links

-	ErrConflictHostNetworkAndLinks = fmt.Errorf("Conflicting options: host type networking can't be used with links. This would result in undefined behavior")

-	// ErrConflictContainerNetworkAndMac conflict between the mac address and the network mode

-	ErrConflictContainerNetworkAndMac = fmt.Errorf("Conflicting options: mac-address and the network mode")

-	// ErrConflictNetworkHosts conflict between add-host and the network mode

-	ErrConflictNetworkHosts = fmt.Errorf("Conflicting options: custom host-to-IP mapping and the network mode")

-	// ErrConflictNetworkPublishPorts conflict between the publish options and the network mode

-	ErrConflictNetworkPublishPorts = fmt.Errorf("Conflicting options: port publishing and the container type network mode")

-	// ErrConflictNetworkExposePorts conflict between the expose option and the network mode

-	ErrConflictNetworkExposePorts = fmt.Errorf("Conflicting options: port exposing and the container type network mode")

-)

-

-// Parse parses the specified args for the specified command and generates a Config,

-// a HostConfig and returns them with the specified command.

-// If the specified args are not valid, it will return an error.

-func Parse(cmd *flag.FlagSet, args []string) (*container.Config, *container.HostConfig, *flag.FlagSet, error) {

-	var (

-		// FIXME: use utils.ListOpts for attach and volumes?

-		flAttach            = opts.NewListOpts(opts.ValidateAttach)

-		flVolumes           = opts.NewListOpts(nil)

-		flTmpfs             = opts.NewListOpts(nil)

-		flBlkioWeightDevice = runconfigopts.NewWeightdeviceOpt(runconfigopts.ValidateWeightDevice)

-		flDeviceReadBps     = runconfigopts.NewThrottledeviceOpt(runconfigopts.ValidateThrottleBpsDevice)

-		flDeviceWriteBps    = runconfigopts.NewThrottledeviceOpt(runconfigopts.ValidateThrottleBpsDevice)

-		flLinks             = opts.NewListOpts(ValidateLink)

-		flDeviceReadIOps    = runconfigopts.NewThrottledeviceOpt(runconfigopts.ValidateThrottleIOpsDevice)

-		flDeviceWriteIOps   = runconfigopts.NewThrottledeviceOpt(runconfigopts.ValidateThrottleIOpsDevice)

-		flEnv               = opts.NewListOpts(opts.ValidateEnv)

-		flLabels            = opts.NewListOpts(opts.ValidateEnv)

-		flDevices           = opts.NewListOpts(ValidateDevice)

-

-		flUlimits = runconfigopts.NewUlimitOpt(nil)

-

-		flPublish           = opts.NewListOpts(nil)

-		flExpose            = opts.NewListOpts(nil)

-		flDNS               = opts.NewListOpts(opts.ValidateIPAddress)

-		flDNSSearch         = opts.NewListOpts(opts.ValidateDNSSearch)

-		flDNSOptions        = opts.NewListOpts(nil)

-		flExtraHosts        = opts.NewListOpts(opts.ValidateExtraHost)

-		flVolumesFrom       = opts.NewListOpts(nil)

-		flEnvFile           = opts.NewListOpts(nil)

-		flCapAdd            = opts.NewListOpts(nil)

-		flCapDrop           = opts.NewListOpts(nil)

-		flGroupAdd          = opts.NewListOpts(nil)

-		flSecurityOpt       = opts.NewListOpts(nil)

-		flLabelsFile        = opts.NewListOpts(nil)

-		flLoggingOpts       = opts.NewListOpts(nil)

-		flPrivileged        = cmd.Bool([]string{"-privileged"}, false, "Give extended privileges to this container")

-		flPidMode           = cmd.String([]string{"-pid"}, "", "PID namespace to use")

-		flUTSMode           = cmd.String([]string{"-uts"}, "", "UTS namespace to use")

-		flPublishAll        = cmd.Bool([]string{"P", "-publish-all"}, false, "Publish all exposed ports to random ports")

-		flStdin             = cmd.Bool([]string{"i", "-interactive"}, false, "Keep STDIN open even if not attached")

-		flTty               = cmd.Bool([]string{"t", "-tty"}, false, "Allocate a pseudo-TTY")

-		flOomKillDisable    = cmd.Bool([]string{"-oom-kill-disable"}, false, "Disable OOM Killer")

-		flOomScoreAdj       = cmd.Int([]string{"-oom-score-adj"}, 0, "Tune host's OOM preferences (-1000 to 1000)")

-		flContainerIDFile   = cmd.String([]string{"-cidfile"}, "", "Write the container ID to the file")

-		flEntrypoint        = cmd.String([]string{"-entrypoint"}, "", "Overwrite the default ENTRYPOINT of the image")

-		flHostname          = cmd.String([]string{"h", "-hostname"}, "", "Container host name")

-		flMemoryString      = cmd.String([]string{"m", "-memory"}, "", "Memory limit")

-		flMemoryReservation = cmd.String([]string{"-memory-reservation"}, "", "Memory soft limit")

-		flMemorySwap        = cmd.String([]string{"-memory-swap"}, "", "Swap limit equal to memory plus swap: '-1' to enable unlimited swap")

-		flKernelMemory      = cmd.String([]string{"-kernel-memory"}, "", "Kernel memory limit")

-		flUser              = cmd.String([]string{"u", "-user"}, "", "Username or UID (format: <name|uid>[:<group|gid>])")

-		flWorkingDir        = cmd.String([]string{"w", "-workdir"}, "", "Working directory inside the container")

-		flCPUShares         = cmd.Int64([]string{"#c", "-cpu-shares"}, 0, "CPU shares (relative weight)")

-		flCPUPeriod         = cmd.Int64([]string{"-cpu-period"}, 0, "Limit CPU CFS (Completely Fair Scheduler) period")

-		flCPUQuota          = cmd.Int64([]string{"-cpu-quota"}, 0, "Limit CPU CFS (Completely Fair Scheduler) quota")

-		flCpusetCpus        = cmd.String([]string{"-cpuset-cpus"}, "", "CPUs in which to allow execution (0-3, 0,1)")

-		flCpusetMems        = cmd.String([]string{"-cpuset-mems"}, "", "MEMs in which to allow execution (0-3, 0,1)")

-		flBlkioWeight       = cmd.Uint16([]string{"-blkio-weight"}, 0, "Block IO (relative weight), between 10 and 1000")

-		flSwappiness        = cmd.Int64([]string{"-memory-swappiness"}, -1, "Tune container memory swappiness (0 to 100)")

-		flNetMode           = cmd.String([]string{"-net"}, "default", "Connect a container to a network")

-		flMacAddress        = cmd.String([]string{"-mac-address"}, "", "Container MAC address (e.g. 92:d0:c6:0a:29:33)")

-		flIpcMode           = cmd.String([]string{"-ipc"}, "", "IPC namespace to use")

-		flRestartPolicy     = cmd.String([]string{"-restart"}, "no", "Restart policy to apply when a container exits")

-		flReadonlyRootfs    = cmd.Bool([]string{"-read-only"}, false, "Mount the container's root filesystem as read only")

-		flLoggingDriver     = cmd.String([]string{"-log-driver"}, "", "Logging driver for container")

-		flCgroupParent      = cmd.String([]string{"-cgroup-parent"}, "", "Optional parent cgroup for the container")

-		flVolumeDriver      = cmd.String([]string{"-volume-driver"}, "", "Optional volume driver for the container")

-		flStopSignal        = cmd.String([]string{"-stop-signal"}, signal.DefaultStopSignal, fmt.Sprintf("Signal to stop a container, %v by default", signal.DefaultStopSignal))

-		flIsolation         = cmd.String([]string{"-isolation"}, "", "Container isolation level")

-		flShmSize           = cmd.String([]string{"-shm-size"}, "", "Size of /dev/shm, default value is 64MB")

-	)

-

-	cmd.Var(&flAttach, []string{"a", "-attach"}, "Attach to STDIN, STDOUT or STDERR")

-	cmd.Var(&flBlkioWeightDevice, []string{"-blkio-weight-device"}, "Block IO weight (relative device weight)")

-	cmd.Var(&flDeviceReadBps, []string{"-device-read-bps"}, "Limit read rate (bytes per second) from a device")

-	cmd.Var(&flDeviceWriteBps, []string{"-device-write-bps"}, "Limit write rate (bytes per second) to a device")

-	cmd.Var(&flDeviceReadIOps, []string{"-device-read-iops"}, "Limit read rate (IO per second) from a device")

-	cmd.Var(&flDeviceWriteIOps, []string{"-device-write-iops"}, "Limit write rate (IO per second) to a device")

-	cmd.Var(&flVolumes, []string{"v", "-volume"}, "Bind mount a volume")

-	cmd.Var(&flTmpfs, []string{"-tmpfs"}, "Mount a tmpfs directory")

-	cmd.Var(&flLinks, []string{"-link"}, "Add link to another container")

-	cmd.Var(&flDevices, []string{"-device"}, "Add a host device to the container")

-	cmd.Var(&flLabels, []string{"l", "-label"}, "Set meta data on a container")

-	cmd.Var(&flLabelsFile, []string{"-label-file"}, "Read in a line delimited file of labels")

-	cmd.Var(&flEnv, []string{"e", "-env"}, "Set environment variables")

-	cmd.Var(&flEnvFile, []string{"-env-file"}, "Read in a file of environment variables")

-	cmd.Var(&flPublish, []string{"p", "-publish"}, "Publish a container's port(s) to the host")

-	cmd.Var(&flExpose, []string{"-expose"}, "Expose a port or a range of ports")

-	cmd.Var(&flDNS, []string{"-dns"}, "Set custom DNS servers")

-	cmd.Var(&flDNSSearch, []string{"-dns-search"}, "Set custom DNS search domains")

-	cmd.Var(&flDNSOptions, []string{"-dns-opt"}, "Set DNS options")

-	cmd.Var(&flExtraHosts, []string{"-add-host"}, "Add a custom host-to-IP mapping (host:ip)")

-	cmd.Var(&flVolumesFrom, []string{"-volumes-from"}, "Mount volumes from the specified container(s)")

-	cmd.Var(&flCapAdd, []string{"-cap-add"}, "Add Linux capabilities")

-	cmd.Var(&flCapDrop, []string{"-cap-drop"}, "Drop Linux capabilities")

-	cmd.Var(&flGroupAdd, []string{"-group-add"}, "Add additional groups to join")

-	cmd.Var(&flSecurityOpt, []string{"-security-opt"}, "Security Options")

-	cmd.Var(flUlimits, []string{"-ulimit"}, "Ulimit options")

-	cmd.Var(&flLoggingOpts, []string{"-log-opt"}, "Log driver options")

-

-	cmd.Require(flag.Min, 1)

-

-	if err := cmd.ParseFlags(args, true); err != nil {

-		return nil, nil, cmd, err

-	}

-

-	var (

-		attachStdin  = flAttach.Get("stdin")

-		attachStdout = flAttach.Get("stdout")

-		attachStderr = flAttach.Get("stderr")

-	)

-

-	// Validate the input mac address

-	if *flMacAddress != "" {

-		if _, err := opts.ValidateMACAddress(*flMacAddress); err != nil {

-			return nil, nil, cmd, fmt.Errorf("%s is not a valid mac address", *flMacAddress)

-		}

-	}

-	if *flStdin {

-		attachStdin = true

-	}

-	// If -a is not set attach to the output stdio

-	if flAttach.Len() == 0 {

-		attachStdout = true

-		attachStderr = true

-	}

-

-	var err error

-

-	var flMemory int64

-	if *flMemoryString != "" {

-		flMemory, err = units.RAMInBytes(*flMemoryString)

-		if err != nil {

-			return nil, nil, cmd, err

-		}

-	}

-

-	var MemoryReservation int64

-	if *flMemoryReservation != "" {

-		MemoryReservation, err = units.RAMInBytes(*flMemoryReservation)

-		if err != nil {

-			return nil, nil, cmd, err

-		}

-	}

-

-	var memorySwap int64

-	if *flMemorySwap != "" {

-		if *flMemorySwap == "-1" {

-			memorySwap = -1

-		} else {

-			memorySwap, err = units.RAMInBytes(*flMemorySwap)

-			if err != nil {

-				return nil, nil, cmd, err

-			}

-		}

-	}

-

-	var KernelMemory int64

-	if *flKernelMemory != "" {

-		KernelMemory, err = units.RAMInBytes(*flKernelMemory)

-		if err != nil {

-			return nil, nil, cmd, err

-		}

-	}

-

-	swappiness := *flSwappiness

-	if swappiness != -1 && (swappiness < 0 || swappiness > 100) {

-		return nil, nil, cmd, fmt.Errorf("Invalid value: %d. Valid memory swappiness range is 0-100", swappiness)

-	}

-

-	var parsedShm *int64

-	if *flShmSize != "" {

-		shmSize, err := units.RAMInBytes(*flShmSize)

-		if err != nil {

-			return nil, nil, cmd, err

-		}

-		parsedShm = &shmSize

-	}

-

-	var binds []string

-	// add any bind targets to the list of container volumes

-	for bind := range flVolumes.GetMap() {

-		if arr := volume.SplitN(bind, 2); len(arr) > 1 {

-			// after creating the bind mount we want to delete it from the flVolumes values because

-			// we do not want bind mounts being committed to image configs

-			binds = append(binds, bind)

-			flVolumes.Delete(bind)

-		}

-	}

-

-	// Can't evaluate options passed into --tmpfs until we actually mount

-	tmpfs := make(map[string]string)

-	for _, t := range flTmpfs.GetAll() {

-		if arr := strings.SplitN(t, ":", 2); len(arr) > 1 {

-			if _, _, err := mount.ParseTmpfsOptions(arr[1]); err != nil {

-				return nil, nil, cmd, err

-			}

-			tmpfs[arr[0]] = arr[1]

-		} else {

-			tmpfs[arr[0]] = ""

-		}

-	}

-

-	var (

-		parsedArgs = cmd.Args()

-		runCmd     *strslice.StrSlice

-		entrypoint *strslice.StrSlice

-		image      = cmd.Arg(0)

-	)

-	if len(parsedArgs) > 1 {

-		runCmd = strslice.New(parsedArgs[1:]...)

-	}

-	if *flEntrypoint != "" {

-		entrypoint = strslice.New(*flEntrypoint)

-	}

-

-	var (

-		domainname string

-		hostname   = *flHostname

-		parts      = strings.SplitN(hostname, ".", 2)

-	)

-	if len(parts) > 1 {

-		hostname = parts[0]

-		domainname = parts[1]

-	}

-

-	ports, portBindings, err := nat.ParsePortSpecs(flPublish.GetAll())

-	if err != nil {

-		return nil, nil, cmd, err

-	}

-

-	// Merge in exposed ports to the map of published ports

-	for _, e := range flExpose.GetAll() {

-		if strings.Contains(e, ":") {

-			return nil, nil, cmd, fmt.Errorf("Invalid port format for --expose: %s", e)

-		}

-		//support two formats for expose, original format <portnum>/[<proto>] or <startport-endport>/[<proto>]

-		proto, port := nat.SplitProtoPort(e)

-		//parse the start and end port and create a sequence of ports to expose

-		//if expose a port, the start and end port are the same

-		start, end, err := nat.ParsePortRange(port)

-		if err != nil {

-			return nil, nil, cmd, fmt.Errorf("Invalid range format for --expose: %s, error: %s", e, err)

-		}

-		for i := start; i <= end; i++ {

-			p, err := nat.NewPort(proto, strconv.FormatUint(i, 10))

-			if err != nil {

-				return nil, nil, cmd, err

-			}

-			if _, exists := ports[p]; !exists {

-				ports[p] = struct{}{}

-			}

-		}

-	}

-

-	// parse device mappings

-	deviceMappings := []container.DeviceMapping{}

-	for _, device := range flDevices.GetAll() {

-		deviceMapping, err := ParseDevice(device)

-		if err != nil {

-			return nil, nil, cmd, err

-		}

-		deviceMappings = append(deviceMappings, deviceMapping)

-	}

-

-	// collect all the environment variables for the container

-	envVariables, err := readKVStrings(flEnvFile.GetAll(), flEnv.GetAll())

-	if err != nil {

-		return nil, nil, cmd, err

-	}

-

-	// collect all the labels for the container

-	labels, err := readKVStrings(flLabelsFile.GetAll(), flLabels.GetAll())

-	if err != nil {

-		return nil, nil, cmd, err

-	}

-

-	ipcMode := container.IpcMode(*flIpcMode)

-	if !ipcMode.Valid() {

-		return nil, nil, cmd, fmt.Errorf("--ipc: invalid IPC mode")

-	}

-

-	pidMode := container.PidMode(*flPidMode)

-	if !pidMode.Valid() {

-		return nil, nil, cmd, fmt.Errorf("--pid: invalid PID mode")

-	}

-

-	utsMode := container.UTSMode(*flUTSMode)

-	if !utsMode.Valid() {

-		return nil, nil, cmd, fmt.Errorf("--uts: invalid UTS mode")

-	}

-

-	restartPolicy, err := ParseRestartPolicy(*flRestartPolicy)

-	if err != nil {

-		return nil, nil, cmd, err

-	}

-

-	loggingOpts, err := parseLoggingOpts(*flLoggingDriver, flLoggingOpts.GetAll())

-	if err != nil {

-		return nil, nil, cmd, err

-	}

-

-	resources := container.Resources{

-		CgroupParent:         *flCgroupParent,

-		Memory:               flMemory,

-		MemoryReservation:    MemoryReservation,

-		MemorySwap:           memorySwap,

-		MemorySwappiness:     flSwappiness,

-		KernelMemory:         KernelMemory,

-		OomKillDisable:       *flOomKillDisable,

-		CPUShares:            *flCPUShares,

-		CPUPeriod:            *flCPUPeriod,

-		CpusetCpus:           *flCpusetCpus,

-		CpusetMems:           *flCpusetMems,

-		CPUQuota:             *flCPUQuota,

-		BlkioWeight:          *flBlkioWeight,

-		BlkioWeightDevice:    flBlkioWeightDevice.GetList(),

-		BlkioDeviceReadBps:   flDeviceReadBps.GetList(),

-		BlkioDeviceWriteBps:  flDeviceWriteBps.GetList(),

-		BlkioDeviceReadIOps:  flDeviceReadIOps.GetList(),

-		BlkioDeviceWriteIOps: flDeviceWriteIOps.GetList(),

-		Ulimits:              flUlimits.GetList(),

-		Devices:              deviceMappings,

-	}

-

-	config := &container.Config{

-		Hostname:     hostname,

-		Domainname:   domainname,

-		ExposedPorts: ports,

-		User:         *flUser,

-		Tty:          *flTty,

-		// TODO: deprecated, it comes from -n, --networking

-		// it's still needed internally to set the network to disabled

-		// if e.g. bridge is none in daemon opts, and in inspect

-		NetworkDisabled: false,

-		OpenStdin:       *flStdin,

-		AttachStdin:     attachStdin,

-		AttachStdout:    attachStdout,

-		AttachStderr:    attachStderr,

-		Env:             envVariables,

-		Cmd:             runCmd,

-		Image:           image,

-		Volumes:         flVolumes.GetMap(),

-		MacAddress:      *flMacAddress,

-		Entrypoint:      entrypoint,

-		WorkingDir:      *flWorkingDir,

-		Labels:          ConvertKVStringsToMap(labels),

-		StopSignal:      *flStopSignal,

-	}

-

-	hostConfig := &container.HostConfig{

-		Binds:           binds,

-		ContainerIDFile: *flContainerIDFile,

-		OomScoreAdj:     *flOomScoreAdj,

-		Privileged:      *flPrivileged,

-		PortBindings:    portBindings,

-		Links:           flLinks.GetAll(),

-		PublishAllPorts: *flPublishAll,

-		// Make sure the dns fields are never nil.

-		// New containers don't ever have those fields nil,

-		// but pre created containers can still have those nil values.

-		// See https://github.com/docker/docker/pull/17779

-		// for a more detailed explanation on why we don't want that.

-		DNS:            flDNS.GetAllOrEmpty(),

-		DNSSearch:      flDNSSearch.GetAllOrEmpty(),

-		DNSOptions:     flDNSOptions.GetAllOrEmpty(),

-		ExtraHosts:     flExtraHosts.GetAll(),

-		VolumesFrom:    flVolumesFrom.GetAll(),

-		NetworkMode:    container.NetworkMode(*flNetMode),

-		IpcMode:        ipcMode,

-		PidMode:        pidMode,

-		UTSMode:        utsMode,

-		CapAdd:         strslice.New(flCapAdd.GetAll()...),

-		CapDrop:        strslice.New(flCapDrop.GetAll()...),

-		GroupAdd:       flGroupAdd.GetAll(),

-		RestartPolicy:  restartPolicy,

-		SecurityOpt:    flSecurityOpt.GetAll(),

-		ReadonlyRootfs: *flReadonlyRootfs,

-		LogConfig:      container.LogConfig{Type: *flLoggingDriver, Config: loggingOpts},

-		VolumeDriver:   *flVolumeDriver,

-		Isolation:      container.IsolationLevel(*flIsolation),

-		ShmSize:        parsedShm,

-		Resources:      resources,

-		Tmpfs:          tmpfs,

-	}

-

-	// When allocating stdin in attached mode, close stdin at client disconnect

-	if config.OpenStdin && config.AttachStdin {

-		config.StdinOnce = true

-	}

-	return config, hostConfig, cmd, nil

-}

-

-// reads a file of line terminated key=value pairs and override that with override parameter

-func readKVStrings(files []string, override []string) ([]string, error) {

-	envVariables := []string{}

-	for _, ef := range files {

-		parsedVars, err := opts.ParseEnvFile(ef)

-		if err != nil {

-			return nil, err

-		}

-		envVariables = append(envVariables, parsedVars...)

-	}

-	// parse the '-e' and '--env' after, to allow override

-	envVariables = append(envVariables, override...)

-

-	return envVariables, nil

-}

-

-// ConvertKVStringsToMap converts ["key=value"] to {"key":"value"}

-func ConvertKVStringsToMap(values []string) map[string]string {

-	result := make(map[string]string, len(values))

-	for _, value := range values {

-		kv := strings.SplitN(value, "=", 2)

-		if len(kv) == 1 {

-			result[kv[0]] = ""

-		} else {

-			result[kv[0]] = kv[1]

-		}

-	}

-

-	return result

-}

-

-func parseLoggingOpts(loggingDriver string, loggingOpts []string) (map[string]string, error) {

-	loggingOptsMap := ConvertKVStringsToMap(loggingOpts)

-	if loggingDriver == "none" && len(loggingOpts) > 0 {

-		return map[string]string{}, fmt.Errorf("Invalid logging opts for driver %s", loggingDriver)

-	}

-	return loggingOptsMap, nil

-}

-

-// ParseRestartPolicy returns the parsed policy or an error indicating what is incorrect

-func ParseRestartPolicy(policy string) (container.RestartPolicy, error) {

-	p := container.RestartPolicy{}

-

-	if policy == "" {

-		return p, nil

-	}

-

-	var (

-		parts = strings.Split(policy, ":")

-		name  = parts[0]

-	)

-

-	p.Name = name

-	switch name {

-	case "always", "unless-stopped":

-		if len(parts) > 1 {

-			return p, fmt.Errorf("maximum restart count not valid with restart policy of \"%s\"", name)

-		}

-	case "no":

-		// do nothing

-	case "on-failure":

-		if len(parts) > 2 {

-			return p, fmt.Errorf("restart count format is not valid, usage: 'on-failure:N' or 'on-failure'")

-		}

-		if len(parts) == 2 {

-			count, err := strconv.Atoi(parts[1])

-			if err != nil {

-				return p, err

-			}

-

-			p.MaximumRetryCount = count

-		}

-	default:

-		return p, fmt.Errorf("invalid restart policy %s", name)

-	}

-

-	return p, nil

-}

-

-// ParseDevice parses a device mapping string to a container.DeviceMapping struct

-func ParseDevice(device string) (container.DeviceMapping, error) {

-	src := ""

-	dst := ""

-	permissions := "rwm"

-	arr := strings.Split(device, ":")

-	switch len(arr) {

-	case 3:

-		permissions = arr[2]

-		fallthrough

-	case 2:

-		if ValidDeviceMode(arr[1]) {

-			permissions = arr[1]

-		} else {

-			dst = arr[1]

-		}

-		fallthrough

-	case 1:

-		src = arr[0]

-	default:

-		return container.DeviceMapping{}, fmt.Errorf("Invalid device specification: %s", device)

-	}

-

-	if dst == "" {

-		dst = src

-	}

-

-	deviceMapping := container.DeviceMapping{

-		PathOnHost:        src,

-		PathInContainer:   dst,

-		CgroupPermissions: permissions,

-	}

-	return deviceMapping, nil

-}

-

-// ParseLink parses and validates the specified string as a link format (name:alias)

-func ParseLink(val string) (string, string, error) {

-	if val == "" {

-		return "", "", fmt.Errorf("empty string specified for links")

-	}

-	arr := strings.Split(val, ":")

-	if len(arr) > 2 {

-		return "", "", fmt.Errorf("bad format for links: %s", val)

-	}

-	if len(arr) == 1 {

-		return val, val, nil

-	}

-	// This is kept because we can actually get an HostConfig with links

-	// from an already created container and the format is not `foo:bar`

-	// but `/foo:/c1/bar`

-	if strings.HasPrefix(arr[0], "/") {

-		_, alias := path.Split(arr[1])

-		return arr[0][1:], alias, nil

-	}

-	return arr[0], arr[1], nil

-}

-

-// ValidateLink validates that the specified string has a valid link format (containerName:alias).

-func ValidateLink(val string) (string, error) {

-	if _, _, err := ParseLink(val); err != nil {

-		return val, err

-	}

-	return val, nil

-}

-

-// ValidDeviceMode checks if the mode for device is valid or not.

-// Valid mode is a composition of r (read), w (write), and m (mknod).

-func ValidDeviceMode(mode string) bool {

-	var legalDeviceMode = map[rune]bool{

-		'r': true,

-		'w': true,

-		'm': true,

-	}

-	if mode == "" {

-		return false

-	}

-	for _, c := range mode {

-		if !legalDeviceMode[c] {

-			return false

-		}

-		legalDeviceMode[c] = false

-	}

-	return true

-}

-

-// ValidateDevice validates a path for devices

-// It will make sure 'val' is in the form:

-//    [host-dir:]container-path[:mode]

-// It also validates the device mode.

-func ValidateDevice(val string) (string, error) {

-	return validatePath(val, ValidDeviceMode)

-}

-

-func validatePath(val string, validator func(string) bool) (string, error) {

-	var containerPath string

-	var mode string

-

-	if strings.Count(val, ":") > 2 {

-		return val, fmt.Errorf("bad format for path: %s", val)

-	}

-

-	split := strings.SplitN(val, ":", 3)

-	if split[0] == "" {

-		return val, fmt.Errorf("bad format for path: %s", val)

-	}

-	switch len(split) {

-	case 1:

-		containerPath = split[0]

-		val = path.Clean(containerPath)

-	case 2:

-		if isValid := validator(split[1]); isValid {

-			containerPath = split[0]

-			mode = split[1]

-			val = fmt.Sprintf("%s:%s", path.Clean(containerPath), mode)

-		} else {

-			containerPath = split[1]

-			val = fmt.Sprintf("%s:%s", split[0], path.Clean(containerPath))

-		}

-	case 3:

-		containerPath = split[1]

-		mode = split[2]

-		if isValid := validator(split[2]); !isValid {

-			return val, fmt.Errorf("bad mode specified: %s", mode)

-		}

-		val = fmt.Sprintf("%s:%s:%s", split[0], containerPath, mode)

-	}

-

-	if !path.IsAbs(containerPath) {

-		return val, fmt.Errorf("%s is not an absolute path", containerPath)

-	}

-	return val, nil

-}

deleted file mode 100644

@@ -1,764 +0,0 @@

-package runconfig

-

-import (

-	"bytes"

-	"encoding/json"

-	"fmt"

-	"io/ioutil"

-	"os"

-	"runtime"

-	"strings"

-	"testing"

-

-	"github.com/docker/docker/api/types/container"

-	flag "github.com/docker/docker/pkg/mflag"

-	"github.com/docker/go-connections/nat"

-)

-

-func parseRun(args []string) (*container.Config, *container.HostConfig, *flag.FlagSet, error) {

-	cmd := flag.NewFlagSet("run", flag.ContinueOnError)

-	cmd.SetOutput(ioutil.Discard)

-	cmd.Usage = nil

-	return Parse(cmd, args)

-}

-

-func parse(t *testing.T, args string) (*container.Config, *container.HostConfig, error) {

-	config, hostConfig, _, err := parseRun(strings.Split(args+" ubuntu bash", " "))

-	return config, hostConfig, err

-}

-

-func mustParse(t *testing.T, args string) (*container.Config, *container.HostConfig) {

-	config, hostConfig, err := parse(t, args)

-	if err != nil {

-		t.Fatal(err)

-	}

-	return config, hostConfig

-}

-

-func TestParseRunLinks(t *testing.T) {

-	if _, hostConfig := mustParse(t, "--link a:b"); len(hostConfig.Links) == 0 || hostConfig.Links[0] != "a:b" {

-		t.Fatalf("Error parsing links. Expected []string{\"a:b\"}, received: %v", hostConfig.Links)

-	}

-	if _, hostConfig := mustParse(t, "--link a:b --link c:d"); len(hostConfig.Links) < 2 || hostConfig.Links[0] != "a:b" || hostConfig.Links[1] != "c:d" {

-		t.Fatalf("Error parsing links. Expected []string{\"a:b\", \"c:d\"}, received: %v", hostConfig.Links)

-	}

-	if _, hostConfig := mustParse(t, ""); len(hostConfig.Links) != 0 {

-		t.Fatalf("Error parsing links. No link expected, received: %v", hostConfig.Links)

-	}

-}

-

-func TestParseRunAttach(t *testing.T) {

-	if config, _ := mustParse(t, "-a stdin"); !config.AttachStdin || config.AttachStdout || config.AttachStderr {

-		t.Fatalf("Error parsing attach flags. Expect only Stdin enabled. Received: in: %v, out: %v, err: %v", config.AttachStdin, config.AttachStdout, config.AttachStderr)

-	}

-	if config, _ := mustParse(t, "-a stdin -a stdout"); !config.AttachStdin || !config.AttachStdout || config.AttachStderr {

-		t.Fatalf("Error parsing attach flags. Expect only Stdin and Stdout enabled. Received: in: %v, out: %v, err: %v", config.AttachStdin, config.AttachStdout, config.AttachStderr)

-	}

-	if config, _ := mustParse(t, "-a stdin -a stdout -a stderr"); !config.AttachStdin || !config.AttachStdout || !config.AttachStderr {

-		t.Fatalf("Error parsing attach flags. Expect all attach enabled. Received: in: %v, out: %v, err: %v", config.AttachStdin, config.AttachStdout, config.AttachStderr)

-	}

-	if config, _ := mustParse(t, ""); config.AttachStdin || !config.AttachStdout || !config.AttachStderr {

-		t.Fatalf("Error parsing attach flags. Expect Stdin disabled. Received: in: %v, out: %v, err: %v", config.AttachStdin, config.AttachStdout, config.AttachStderr)

-	}

-	if config, _ := mustParse(t, "-i"); !config.AttachStdin || !config.AttachStdout || !config.AttachStderr {

-		t.Fatalf("Error parsing attach flags. Expect Stdin enabled. Received: in: %v, out: %v, err: %v", config.AttachStdin, config.AttachStdout, config.AttachStderr)

-	}

-

-	if _, _, err := parse(t, "-a"); err == nil {

-		t.Fatalf("Error parsing attach flags, `-a` should be an error but is not")

-	}

-	if _, _, err := parse(t, "-a invalid"); err == nil {

-		t.Fatalf("Error parsing attach flags, `-a invalid` should be an error but is not")

-	}

-	if _, _, err := parse(t, "-a invalid -a stdout"); err == nil {

-		t.Fatalf("Error parsing attach flags, `-a stdout -a invalid` should be an error but is not")

-	}

-	if _, _, err := parse(t, "-a stdout -a stderr -d"); err == nil {

-		t.Fatalf("Error parsing attach flags, `-a stdout -a stderr -d` should be an error but is not")

-	}

-	if _, _, err := parse(t, "-a stdin -d"); err == nil {

-		t.Fatalf("Error parsing attach flags, `-a stdin -d` should be an error but is not")

-	}

-	if _, _, err := parse(t, "-a stdout -d"); err == nil {

-		t.Fatalf("Error parsing attach flags, `-a stdout -d` should be an error but is not")

-	}

-	if _, _, err := parse(t, "-a stderr -d"); err == nil {

-		t.Fatalf("Error parsing attach flags, `-a stderr -d` should be an error but is not")

-	}

-	if _, _, err := parse(t, "-d --rm"); err == nil {

-		t.Fatalf("Error parsing attach flags, `-d --rm` should be an error but is not")

-	}

-}

-

-func TestParseRunVolumes(t *testing.T) {

-

-	// A single volume

-	arr, tryit := setupPlatformVolume([]string{`/tmp`}, []string{`c:\tmp`})

-	if config, hostConfig := mustParse(t, tryit); hostConfig.Binds != nil {

-		t.Fatalf("Error parsing volume flags, %q should not mount-bind anything. Received %v", tryit, hostConfig.Binds)

-	} else if _, exists := config.Volumes[arr[0]]; !exists {

-		t.Fatalf("Error parsing volume flags, %q is missing from volumes. Received %v", tryit, config.Volumes)

-	}

-

-	// Two volumes

-	arr, tryit = setupPlatformVolume([]string{`/tmp`, `/var`}, []string{`c:\tmp`, `c:\var`})

-	if config, hostConfig := mustParse(t, tryit); hostConfig.Binds != nil {

-		t.Fatalf("Error parsing volume flags, %q should not mount-bind anything. Received %v", tryit, hostConfig.Binds)

-	} else if _, exists := config.Volumes[arr[0]]; !exists {

-		t.Fatalf("Error parsing volume flags, %s is missing from volumes. Received %v", arr[0], config.Volumes)

-	} else if _, exists := config.Volumes[arr[1]]; !exists {

-		t.Fatalf("Error parsing volume flags, %s is missing from volumes. Received %v", arr[1], config.Volumes)

-	}

-

-	// A single bind-mount

-	arr, tryit = setupPlatformVolume([]string{`/hostTmp:/containerTmp`}, []string{os.Getenv("TEMP") + `:c:\containerTmp`})

-	if config, hostConfig := mustParse(t, tryit); hostConfig.Binds == nil || hostConfig.Binds[0] != arr[0] {

-		t.Fatalf("Error parsing volume flags, %q should mount-bind the path before the colon into the path after the colon. Received %v %v", arr[0], hostConfig.Binds, config.Volumes)

-	}

-

-	// Two bind-mounts.

-	arr, tryit = setupPlatformVolume([]string{`/hostTmp:/containerTmp`, `/hostVar:/containerVar`}, []string{os.Getenv("ProgramData") + `:c:\ContainerPD`, os.Getenv("TEMP") + `:c:\containerTmp`})

-	if _, hostConfig := mustParse(t, tryit); hostConfig.Binds == nil || compareRandomizedStrings(hostConfig.Binds[0], hostConfig.Binds[1], arr[0], arr[1]) != nil {

-		t.Fatalf("Error parsing volume flags, `%s and %s` did not mount-bind correctly. Received %v", arr[0], arr[1], hostConfig.Binds)

-	}

-

-	// Two bind-mounts, first read-only, second read-write.

-	// TODO Windows: The Windows version uses read-write as that's the only mode it supports. Can change this post TP4

-	arr, tryit = setupPlatformVolume([]string{`/hostTmp:/containerTmp:ro`, `/hostVar:/containerVar:rw`}, []string{os.Getenv("TEMP") + `:c:\containerTmp:rw`, os.Getenv("ProgramData") + `:c:\ContainerPD:rw`})

-	if _, hostConfig := mustParse(t, tryit); hostConfig.Binds == nil || compareRandomizedStrings(hostConfig.Binds[0], hostConfig.Binds[1], arr[0], arr[1]) != nil {

-		t.Fatalf("Error parsing volume flags, `%s and %s` did not mount-bind correctly. Received %v", arr[0], arr[1], hostConfig.Binds)

-	}

-

-	// Similar to previous test but with alternate modes which are only supported by Linux

-	if runtime.GOOS != "windows" {

-		arr, tryit = setupPlatformVolume([]string{`/hostTmp:/containerTmp:ro,Z`, `/hostVar:/containerVar:rw,Z`}, []string{})

-		if _, hostConfig := mustParse(t, tryit); hostConfig.Binds == nil || compareRandomizedStrings(hostConfig.Binds[0], hostConfig.Binds[1], arr[0], arr[1]) != nil {

-			t.Fatalf("Error parsing volume flags, `%s and %s` did not mount-bind correctly. Received %v", arr[0], arr[1], hostConfig.Binds)

-		}

-

-		arr, tryit = setupPlatformVolume([]string{`/hostTmp:/containerTmp:Z`, `/hostVar:/containerVar:z`}, []string{})

-		if _, hostConfig := mustParse(t, tryit); hostConfig.Binds == nil || compareRandomizedStrings(hostConfig.Binds[0], hostConfig.Binds[1], arr[0], arr[1]) != nil {

-			t.Fatalf("Error parsing volume flags, `%s and %s` did not mount-bind correctly. Received %v", arr[0], arr[1], hostConfig.Binds)

-		}

-	}

-

-	// One bind mount and one volume

-	arr, tryit = setupPlatformVolume([]string{`/hostTmp:/containerTmp`, `/containerVar`}, []string{os.Getenv("TEMP") + `:c:\containerTmp`, `c:\containerTmp`})

-	if config, hostConfig := mustParse(t, tryit); hostConfig.Binds == nil || len(hostConfig.Binds) > 1 || hostConfig.Binds[0] != arr[0] {

-		t.Fatalf("Error parsing volume flags, %s and %s should only one and only one bind mount %s. Received %s", arr[0], arr[1], arr[0], hostConfig.Binds)

-	} else if _, exists := config.Volumes[arr[1]]; !exists {