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

 	"os"

 	"path/filepath"

-	"github.com/docker/docker/daemon/execdriver"

 	"github.com/docker/docker/volume"

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

 )

@@ -23,6 +22,12 @@ type Container struct {

 	// Fields below here are platform specific.

 }

+// ExitStatus provides exit reasons for a container.

+type ExitStatus struct {

+	// The exit code with which the container exited.

+	ExitCode int

+}

+

 // CreateDaemonEnvironment creates a new environment variable slice for this container.

 func (container *Container) CreateDaemonEnvironment(linkedEnv []string) []string {

 	// On Windows, nothing to link. Just return the container environment.

@@ -35,7 +40,7 @@ func (container *Container) UnmountIpcMounts(unmount func(pth string) error) {

 }

 // IpcMounts returns the list of Ipc related mounts.

-func (container *Container) IpcMounts() []execdriver.Mount {

+func (container *Container) IpcMounts() []Mount {

 	return nil

 }

@@ -45,7 +50,7 @@ func (container *Container) UnmountVolumes(forceSyscall bool, volumeEventLog fun

 }

 // TmpfsMounts returns the list of tmpfs mounts

-func (container *Container) TmpfsMounts() []execdriver.Mount {

+func (container *Container) TmpfsMounts() []Mount {

 	return nil

 }

new file mode 100644

@@ -0,0 +1,8 @@

+package container

+

+// Mount contains information for a mount operation.

+type Mount struct {

+	Source      string `json:"source"`

+	Destination string `json:"destination"`

+	Writable    bool   `json:"writable"`

+}

@@ -1,9 +1,7 @@

 package container

-import "github.com/docker/docker/daemon/execdriver"

-

 // setFromExitStatus is a platform specific helper function to set the state

 // based on the ExitStatus structure.

-func (s *State) setFromExitStatus(exitStatus *execdriver.ExitStatus) {

+func (s *State) setFromExitStatus(exitStatus *ExitStatus) {

 	s.ExitCode = exitStatus.ExitCode

 }

@@ -7,8 +7,9 @@ import (

 )

 var (

-	defaultPidFile = os.Getenv("programdata") + string(os.PathSeparator) + "docker.pid"

-	defaultGraph   = os.Getenv("programdata") + string(os.PathSeparator) + "docker"

+	defaultPidFile  = os.Getenv("programdata") + string(os.PathSeparator) + "docker.pid"

+	defaultGraph    = os.Getenv("programdata") + string(os.PathSeparator) + "docker"

+	defaultExecRoot = defaultGraph

 )

 // bridgeConfig stores all the bridge driver specific

@@ -4,14 +4,9 @@ package daemon

 import (

 	"fmt"

-	"strings"

-

-	networktypes "github.com/docker/engine-api/types/network"

 	"github.com/docker/docker/container"

-	"github.com/docker/docker/daemon/execdriver"

-	"github.com/docker/docker/daemon/execdriver/windows"

-	"github.com/docker/docker/layer"

+	networktypes "github.com/docker/engine-api/types/network"

 	"github.com/docker/libnetwork"

 )

@@ -29,135 +24,6 @@ func (daemon *Daemon) DisconnectFromNetwork(container *container.Container, n li

 	return fmt.Errorf("Windows does not support disconnecting a running container from a network")

 }

-func (daemon *Daemon) populateCommand(c *container.Container, env []string) error {

-	en := &execdriver.Network{

-		Interface: nil,

-	}

-

-	var epList []string

-

-	// Connect all the libnetwork allocated networks to the container

-	if c.NetworkSettings != nil {

-		for n := range c.NetworkSettings.Networks {

-			sn, err := daemon.FindNetwork(n)

-			if err != nil {

-				continue

-			}

-

-			ep, err := c.GetEndpointInNetwork(sn)

-			if err != nil {

-				continue

-			}

-

-			data, err := ep.DriverInfo()

-			if err != nil {

-				continue

-			}

-			if data["hnsid"] != nil {

-				epList = append(epList, data["hnsid"].(string))

-			}

-		}

-	}

-

-	if daemon.netController == nil {

-		parts := strings.SplitN(string(c.HostConfig.NetworkMode), ":", 2)

-		switch parts[0] {

-		case "none":

-		case "default", "": // empty string to support existing containers

-			if !c.Config.NetworkDisabled {

-				en.Interface = &execdriver.NetworkInterface{

-					MacAddress:   c.Config.MacAddress,

-					Bridge:       daemon.configStore.bridgeConfig.Iface,

-					PortBindings: c.HostConfig.PortBindings,

-

-					// TODO Windows. Include IPAddress. There already is a

-					// property IPAddress on execDrive.CommonNetworkInterface,

-					// but there is no CLI option in docker to pass through

-					// an IPAddress on docker run.

-				}

-			}

-		default:

-			return fmt.Errorf("invalid network mode: %s", c.HostConfig.NetworkMode)

-		}

-	}

-

-	// TODO Windows. More resource controls to be implemented later.

-	resources := &execdriver.Resources{

-		CommonResources: execdriver.CommonResources{

-			CPUShares: c.HostConfig.CPUShares,

-		},

-	}

-

-	processConfig := execdriver.ProcessConfig{

-		CommonProcessConfig: execdriver.CommonProcessConfig{

-			Entrypoint: c.Path,

-			Arguments:  c.Args,

-			Tty:        c.Config.Tty,

-		},

-		ConsoleSize: c.HostConfig.ConsoleSize,

-	}

-

-	processConfig.Env = env

-

-	var layerPaths []string

-	img, err := daemon.imageStore.Get(c.ImageID)

-	if err != nil {

-		return fmt.Errorf("Failed to graph.Get on ImageID %s - %s", c.ImageID, err)

-	}

-

-	if img.RootFS != nil && img.RootFS.Type == "layers+base" {

-		max := len(img.RootFS.DiffIDs)

-		for i := 0; i <= max; i++ {

-			img.RootFS.DiffIDs = img.RootFS.DiffIDs[:i]

-			path, err := layer.GetLayerPath(daemon.layerStore, img.RootFS.ChainID())

-			if err != nil {

-				return fmt.Errorf("Failed to get layer path from graphdriver %s for ImageID %s - %s", daemon.layerStore, img.RootFS.ChainID(), err)

-			}

-			// Reverse order, expecting parent most first

-			layerPaths = append([]string{path}, layerPaths...)

-		}

-	}

-

-	m, err := c.RWLayer.Metadata()

-	if err != nil {

-		return fmt.Errorf("Failed to get layer metadata - %s", err)

-	}

-	layerFolder := m["dir"]

-

-	var hvPartition bool

-	// Work out the isolation (whether it is a hypervisor partition)

-	if c.HostConfig.Isolation.IsDefault() {

-		// Not specified by caller. Take daemon default

-		hvPartition = windows.DefaultIsolation.IsHyperV()

-	} else {

-		// Take value specified by caller

-		hvPartition = c.HostConfig.Isolation.IsHyperV()

-	}

-

-	c.Command = &execdriver.Command{

-		CommonCommand: execdriver.CommonCommand{

-			ID:            c.ID,

-			Rootfs:        c.BaseFS,

-			WorkingDir:    c.Config.WorkingDir,

-			Network:       en,

-			MountLabel:    c.GetMountLabel(),

-			Resources:     resources,

-			ProcessConfig: processConfig,

-			ProcessLabel:  c.GetProcessLabel(),

-		},

-		FirstStart:  !c.HasBeenStartedBefore,

-		LayerFolder: layerFolder,

-		LayerPaths:  layerPaths,

-		Hostname:    c.Config.Hostname,

-		Isolation:   string(c.HostConfig.Isolation),

-		ArgsEscaped: c.Config.ArgsEscaped,

-		HvPartition: hvPartition,

-		EpList:      epList,

-	}

-

-	return nil

-}

-

 // getSize returns real size & virtual size

 func (daemon *Daemon) getSize(container *container.Container) (int64, int64) {

 	// TODO Windows

@@ -18,11 +18,13 @@ import (

 	"github.com/docker/docker/layer"

 	"github.com/docker/docker/reference"

 	"github.com/docker/docker/runconfig"

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

 	// register the windows graph driver

 	"github.com/docker/docker/daemon/graphdriver/windows"

 	"github.com/docker/docker/pkg/idtools"

+	"github.com/docker/docker/pkg/parsers"

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

+	"github.com/docker/engine-api/types"

+	containertypes "github.com/docker/engine-api/types/container"

 	"github.com/docker/libnetwork"

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

 	winlibnetwork "github.com/docker/libnetwork/drivers/windows"

@@ -39,7 +41,7 @@ const (

 	windowsMaxCPUShares  = 10000

 )

-func getBlkioWeightDevices(config *containertypes.HostConfig) ([]*blkiodev.WeightDevice, error) {

+func getBlkioWeightDevices(config *containertypes.HostConfig) ([]blkiodev.WeightDevice, error) {

 	return nil, nil

 }

@@ -47,19 +49,19 @@ func parseSecurityOpt(container *container.Container, config *containertypes.Hos

 	return nil

 }

-func getBlkioReadIOpsDevices(config *containertypes.HostConfig) ([]*blkiodev.ThrottleDevice, error) {

+func getBlkioReadIOpsDevices(config *containertypes.HostConfig) ([]blkiodev.ThrottleDevice, error) {

 	return nil, nil

 }

-func getBlkioWriteIOpsDevices(config *containertypes.HostConfig) ([]*blkiodev.ThrottleDevice, error) {

+func getBlkioWriteIOpsDevices(config *containertypes.HostConfig) ([]blkiodev.ThrottleDevice, error) {

 	return nil, nil

 }

-func getBlkioReadBpsDevices(config *containertypes.HostConfig) ([]*blkiodev.ThrottleDevice, error) {

+func getBlkioReadBpsDevices(config *containertypes.HostConfig) ([]blkiodev.ThrottleDevice, error) {

 	return nil, nil

 }

-func getBlkioWriteBpsDevices(config *containertypes.HostConfig) ([]*blkiodev.ThrottleDevice, error) {

+func getBlkioWriteBpsDevices(config *containertypes.HostConfig) ([]blkiodev.ThrottleDevice, error) {

 	return nil, nil

 }

@@ -287,6 +289,10 @@ func (daemon *Daemon) registerLinks(container *container.Container, hostConfig *

 	return nil

 }

+func (daemon *Daemon) cleanupMountsByID(in string) error {

+	return nil

+}

+

 func (daemon *Daemon) cleanupMounts() error {

 	return nil

 }

@@ -307,8 +313,19 @@ func setupDaemonRoot(config *Config, rootDir string, rootUID, rootGID int) error

 // conditionalMountOnStart is a platform specific helper function during the

 // container start to call mount.

 func (daemon *Daemon) conditionalMountOnStart(container *container.Container) error {

+

+	// Are we going to run as a Hyper-V container?

+	hv := false

+	if container.HostConfig.Isolation.IsDefault() {

+		// Container is set to use the default, so take the default from the daemon configuration

+		hv = daemon.defaultIsolation.IsHyperV()

+	} else {

+		// Container is requesting an isolation mode. Honour it.

+		hv = container.HostConfig.Isolation.IsHyperV()

+	}

+

 	// We do not mount if a Hyper-V container

-	if !container.HostConfig.Isolation.IsHyperV() {

+	if !hv {

 		if err := daemon.Mount(container); err != nil {

 			return err

 		}

@@ -318,11 +335,12 @@ func (daemon *Daemon) conditionalMountOnStart(container *container.Container) er

 // conditionalUnmountOnCleanup is a platform specific helper function called

 // during the cleanup of a container to unmount.

-func (daemon *Daemon) conditionalUnmountOnCleanup(container *container.Container) {

+func (daemon *Daemon) conditionalUnmountOnCleanup(container *container.Container) error {

 	// We do not unmount if a Hyper-V container

 	if !container.HostConfig.Isolation.IsHyperV() {

-		daemon.Unmount(container)

+		return daemon.Unmount(container)

 	}

+	return nil

 }

 func restoreCustomImage(is image.Store, ls layer.Store, rs reference.Store) error {

@@ -404,3 +422,35 @@ func restoreCustomImage(is image.Store, ls layer.Store, rs reference.Store) erro

 func driverOptions(config *Config) []nwconfig.Option {

 	return []nwconfig.Option{}

 }

+

+func (daemon *Daemon) stats(c *container.Container) (*types.StatsJSON, error) {

+	return nil, nil

+}

+

+// setDefaultIsolation determine the default isolation mode for the

+// daemon to run in. This is only applicable on Windows

+func (daemon *Daemon) setDefaultIsolation() error {

+	daemon.defaultIsolation = containertypes.Isolation("process")

+	for _, option := range daemon.configStore.ExecOptions {

+		key, val, err := parsers.ParseKeyValueOpt(option)

+		if err != nil {

+			return err

+		}

+		key = strings.ToLower(key)

+		switch key {

+

+		case "isolation":

+			if !containertypes.Isolation(val).IsValid() {

+				return fmt.Errorf("Invalid exec-opt value for 'isolation':'%s'", val)

+			}

+			if containertypes.Isolation(val).IsHyperV() {

+				daemon.defaultIsolation = containertypes.Isolation("hyperv")

+			}

+		default:

+			return fmt.Errorf("Unrecognised exec-opt '%s'\n", key)

+		}

+	}

+

+	logrus.Infof("Windows default isolation mode: %s", daemon.defaultIsolation)

+	return nil

+}

@@ -2,11 +2,13 @@ package daemon

 import (

 	"github.com/docker/docker/container"

-	"github.com/docker/docker/daemon/execdriver"

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

+	"github.com/docker/docker/daemon/exec"

+	"github.com/docker/docker/libcontainerd"

 )

-// setPlatformSpecificExecProcessConfig sets platform-specific fields in the

-// ProcessConfig structure. This is a no-op on Windows

-func setPlatformSpecificExecProcessConfig(config *types.ExecConfig, container *container.Container, pc *execdriver.ProcessConfig) {

+func execSetPlatformOpt(c *container.Container, ec *exec.Config, p *libcontainerd.Process) error {

+	// Process arguments need to be escaped before sending to OCI.

+	// TODO (jstarks): escape the entrypoint too once the tests are fixed to not rely on this behavior

+	p.Args = append([]string{p.Args[0]}, escapeArgs(p.Args[1:])...)

+	return nil

 }

@@ -33,8 +33,8 @@ func (daemon *Daemon) containerInspectPre120(name string) (*types.ContainerJSON,

 func inspectExecProcessConfig(e *exec.Config) *backend.ExecProcessConfig {

 	return &backend.ExecProcessConfig{

-		Tty:        e.ProcessConfig.Tty,

-		Entrypoint: e.ProcessConfig.Entrypoint,

-		Arguments:  e.ProcessConfig.Arguments,

+		Tty:        e.Tty,

+		Entrypoint: e.Entrypoint,

+		Arguments:  e.Args,

 	}

 }

new file mode 100644

@@ -0,0 +1,13 @@

+package daemon

+

+import (

+	"github.com/docker/docker/container"

+	"github.com/docker/docker/libcontainerd"

+)

+

+// platformConstructExitStatus returns a platform specific exit status structure

+func platformConstructExitStatus(e libcontainerd.StateInfo) *container.ExitStatus {

+	return &container.ExitStatus{

+		ExitCode: int(e.ExitCode),

+	}

+}

new file mode 100644

@@ -0,0 +1,204 @@

+package daemon

+

+import (

+	"fmt"

+	"strings"

+	"syscall"

+

+	"github.com/docker/docker/container"

+	"github.com/docker/docker/layer"

+	"github.com/docker/docker/libcontainerd"

+	"github.com/docker/docker/libcontainerd/windowsoci"

+	"github.com/docker/docker/oci"

+)

+

+func (daemon *Daemon) createSpec(c *container.Container) (*libcontainerd.Spec, error) {

+	s := oci.DefaultSpec()

+

+	linkedEnv, err := daemon.setupLinkedContainers(c)

+	if err != nil {

+		return nil, err

+	}

+

+	// TODO Windows - this can be removed. Not used (UID/GID)

+	rootUID, rootGID := daemon.GetRemappedUIDGID()

+	if err := c.SetupWorkingDirectory(rootUID, rootGID); err != nil {

+		return nil, err

+	}

+

+	img, err := daemon.imageStore.Get(c.ImageID)

+	if err != nil {

+		return nil, fmt.Errorf("Failed to graph.Get on ImageID %s - %s", c.ImageID, err)

+	}

+

+	// In base spec

+	s.Hostname = c.FullHostname()

+

+	// In s.Mounts

+	mounts, err := daemon.setupMounts(c)

+	if err != nil {

+		return nil, err

+	}

+	for _, mount := range mounts {

+		s.Mounts = append(s.Mounts, windowsoci.Mount{

+			Source:      mount.Source,

+			Destination: mount.Destination,

+			Readonly:    !mount.Writable,

+		})

+	}

+

+	// Are we going to run as a Hyper-V container?

+	hv := false

+	if c.HostConfig.Isolation.IsDefault() {

+		// Container is set to use the default, so take the default from the daemon configuration

+		hv = daemon.defaultIsolation.IsHyperV()

+	} else {

+		// Container is requesting an isolation mode. Honour it.

+		hv = c.HostConfig.Isolation.IsHyperV()

+	}

+	if hv {

+		// TODO We don't yet have the ImagePath hooked up. But set to

+		// something non-nil to pickup in libcontainerd.

+		s.Windows.HvRuntime = &windowsoci.HvRuntime{}

+	}

+

+	// In s.Process

+	if c.Config.ArgsEscaped {

+		s.Process.Args = append([]string{c.Path}, c.Args...)

+	} else {

+		// TODO (jstarks): escape the entrypoint too once the tests are fixed to not rely on this behavior

+		s.Process.Args = append([]string{c.Path}, escapeArgs(c.Args)...)

+	}

+	s.Process.Cwd = c.Config.WorkingDir

+	s.Process.Env = c.CreateDaemonEnvironment(linkedEnv)

+	s.Process.InitialConsoleSize = c.HostConfig.ConsoleSize

+	s.Process.Terminal = c.Config.Tty

+	s.Process.User.User = c.Config.User

+

+	// In spec.Root

+	s.Root.Path = c.BaseFS

+	s.Root.Readonly = c.HostConfig.ReadonlyRootfs

+

+	// In s.Windows

+	s.Windows.FirstStart = !c.HasBeenStartedBefore

+

+	// s.Windows.LayerFolder.

+	m, err := c.RWLayer.Metadata()

+	if err != nil {

+		return nil, fmt.Errorf("Failed to get layer metadata - %s", err)

+	}

+	s.Windows.LayerFolder = m["dir"]

+

+	// s.Windows.LayerPaths

+	var layerPaths []string

+	if img.RootFS != nil && img.RootFS.Type == "layers+base" {

+		max := len(img.RootFS.DiffIDs)

+		for i := 0; i <= max; i++ {

+			img.RootFS.DiffIDs = img.RootFS.DiffIDs[:i]

+			path, err := layer.GetLayerPath(daemon.layerStore, img.RootFS.ChainID())

+			if err != nil {

+				return nil, fmt.Errorf("Failed to get layer path from graphdriver %s for ImageID %s - %s", daemon.layerStore, img.RootFS.ChainID(), err)

+			}

+			// Reverse order, expecting parent most first

+			layerPaths = append([]string{path}, layerPaths...)

+		}

+	}

+	s.Windows.LayerPaths = layerPaths

+

+	// In s.Windows.Networking (TP5+ libnetwork way of doing things)

+	// Connect all the libnetwork allocated networks to the container

+	var epList []string

+	if c.NetworkSettings != nil {

+		for n := range c.NetworkSettings.Networks {

+			sn, err := daemon.FindNetwork(n)

+			if err != nil {

+				continue

+			}

+

+			ep, err := c.GetEndpointInNetwork(sn)

+			if err != nil {

+				continue

+			}

+

+			data, err := ep.DriverInfo()

+			if err != nil {

+				continue

+			}

+			if data["hnsid"] != nil {

+				epList = append(epList, data["hnsid"].(string))

+			}

+		}

+	}

+	s.Windows.Networking = &windowsoci.Networking{

+		EndpointList: epList,

+	}

+

+	// In s.Windows.Networking (TP4 back compat)

+	// TODO Windows: Post TP4 - Remove this along with definitions from spec

+	// and changes to libcontainerd to not read these fields.

+	if daemon.netController == nil {

+		parts := strings.SplitN(string(c.HostConfig.NetworkMode), ":", 2)

+		switch parts[0] {

+		case "none":

+		case "default", "": // empty string to support existing containers

+			if !c.Config.NetworkDisabled {

+				s.Windows.Networking = &windowsoci.Networking{

+					MacAddress:   c.Config.MacAddress,

+					Bridge:       daemon.configStore.bridgeConfig.Iface,

+					PortBindings: c.HostConfig.PortBindings,

+				}

+			}

+		default:

+			return nil, fmt.Errorf("invalid network mode: %s", c.HostConfig.NetworkMode)

+		}

+	}

+

+	// In s.Windows.Resources

+	// @darrenstahlmsft implement these resources

+	cpuShares := uint64(c.HostConfig.CPUShares)

+	s.Windows.Resources = &windowsoci.Resources{

+		CPU: &windowsoci.CPU{

+			//TODO Count: ...,

+			//TODO Percent: ...,

+			Shares: &cpuShares,

+		},

+		Memory: &windowsoci.Memory{

+		//TODO Limit: ...,

+		//TODO Reservation: ...,

+		},

+		Network: &windowsoci.Network{

+		//TODO Bandwidth: ...,

+		},

+		Storage: &windowsoci.Storage{

+		//TODO Bps: ...,

+		//TODO Iops: ...,

+		//TODO SandboxSize: ...,

+		},

+	}

+

+	// BUGBUG - Next problem. This was an exec opt. Where do we now get these?

+	// Come back to this when add Xenon support.

+	//	var hvPartition bool

+	//	// Work out the isolation (whether it is a hypervisor partition)

+	//	if c.HostConfig.Isolation.IsDefault() {

+	//		// Not specified by caller. Take daemon default

+	//		hvPartition = windows.DefaultIsolation.IsHyperV()

+	//	} else {

+	//		// Take value specified by caller

+	//		hvPartition = c.HostConfig.Isolation.IsHyperV()

+	//	}

+

+	//		Isolation:   string(c.HostConfig.Isolation),

+	//		HvPartition: hvPartition,

+	//	}

+

+	return (*libcontainerd.Spec)(&s), nil

+}

+

+func escapeArgs(args []string) []string {

+	escapedArgs := make([]string, len(args))

+	for i, a := range args {

+		escapedArgs[i] = syscall.EscapeArg(a)

+	}

+	return escapedArgs

+}

new file mode 100644

@@ -0,0 +1,13 @@

+// +build windows

+

+package daemon

+

+import (

+	"github.com/docker/docker/libcontainerd"

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

+)

+

+func toContainerdResources(resources container.Resources) libcontainerd.Resources {

+	var r libcontainerd.Resources

+	return r

+}

@@ -7,18 +7,22 @@ import (

 	"sort"

 	"github.com/docker/docker/container"

-	"github.com/docker/docker/daemon/execdriver"

 	"github.com/docker/docker/volume"

 )

 // setupMounts configures the mount points for a container by appending each

-// of the configured mounts on the container to the execdriver mount structure

+// of the configured mounts on the container to the oci mount structure

 // which will ultimately be passed into the exec driver during container creation.

 // It also ensures each of the mounts are lexographically sorted.

-func (daemon *Daemon) setupMounts(container *container.Container) ([]execdriver.Mount, error) {

-	var mnts []execdriver.Mount

-	for _, mount := range container.MountPoints { // type is volume.MountPoint

-		if err := daemon.lazyInitializeVolume(container.ID, mount); err != nil {

+

+// BUGBUG TODO Windows containerd. This would be much better if it returned

+// an array of windowsoci mounts, not container mounts. Then no need to

+// do multiple transitions.

+

+func (daemon *Daemon) setupMounts(c *container.Container) ([]container.Mount, error) {

+	var mnts []container.Mount

+	for _, mount := range c.MountPoints { // type is volume.MountPoint

+		if err := daemon.lazyInitializeVolume(c.ID, mount); err != nil {

 			return nil, err

 		}

 		// If there is no source, take it from the volume path

@@ -29,7 +33,7 @@ func (daemon *Daemon) setupMounts(container *container.Container) ([]execdriver.

 		if s == "" {

 			return nil, fmt.Errorf("No source for mount name '%s' driver %q destination '%s'", mount.Name, mount.Driver, mount.Destination)

 		}

-		mnts = append(mnts, execdriver.Mount{

+		mnts = append(mnts, container.Mount{

 			Source:      s,

 			Destination: mount.Destination,

 			Writable:    mount.RW,

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

 	"github.com/Sirupsen/logrus"

 	apiserver "github.com/docker/docker/api/server"

 	"github.com/docker/docker/daemon"

+	"github.com/docker/docker/libcontainerd"

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

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

 )

@@ -57,3 +58,7 @@ func setupConfigReloadTrap(configFile string, flags *mflag.FlagSet, reload func(

 		}

 	}()

 }

+

+func (cli *DaemonCli) getPlatformRemoteOptions() []libcontainerd.RemoteOption {

+	return nil

+}

new file mode 100644

@@ -0,0 +1,579 @@

+package libcontainerd

+

+import (

+	"encoding/json"

+	"errors"

+	"fmt"

+	"io"

+	"path/filepath"

+	"strconv"

+	"strings"

+

+	"syscall"

+	"time"

+

+	"github.com/Microsoft/hcsshim"

+	"github.com/Sirupsen/logrus"

+)

+

+type client struct {

+	clientCommon

+

+	// Platform specific properties below here (none presently on Windows)

+}

+

+// defaultContainerNAT is the default name of the container NAT device that is

+// preconfigured on the server. TODO Windows - Remove for TP5 support as not needed.

+const defaultContainerNAT = "ContainerNAT"

+

+// Win32 error codes that are used for various workarounds

+// These really should be ALL_CAPS to match golangs syscall library and standard

+// Win32 error conventions, but golint insists on CamelCase.

+const (

+	CoEClassstring     = syscall.Errno(0x800401F3) // Invalid class string

+	ErrorNoNetwork     = syscall.Errno(1222)       // The network is not present or not started

+	ErrorBadPathname   = syscall.Errno(161)        // The specified path is invalid

+	ErrorInvalidObject = syscall.Errno(0x800710D8) // The object identifier does not represent a valid object

+)

+

+type layer struct {

+	ID   string

+	Path string

+}

+

+type defConfig struct {

+	DefFile string

+}

+

+type portBinding struct {

+	Protocol     string

+	InternalPort int

+	ExternalPort int

+}

+

+type natSettings struct {

+	Name         string

+	PortBindings []portBinding

+}

+

+type networkConnection struct {

+	NetworkName string

+	//EnableNat bool

+	Nat natSettings

+}

+type networkSettings struct {

+	MacAddress string

+}

+

+type device struct {

+	DeviceType string

+	Connection interface{}

+	Settings   interface{}

+}

+

+type mappedDir struct {

+	HostPath      string

+	ContainerPath string

+	ReadOnly      bool

+}

+

+// TODO Windows RTM: @darrenstahlmsft Add ProcessorCount

+type containerInit struct {

+	SystemType              string      // HCS requires this to be hard-coded to "Container"

+	Name                    string      // Name of the container. We use the docker ID.

+	Owner                   string      // The management platform that created this container

+	IsDummy                 bool        // Used for development purposes.

+	VolumePath              string      // Windows volume path for scratch space

+	Devices                 []device    // Devices used by the container

+	IgnoreFlushesDuringBoot bool        // Optimization hint for container startup in Windows

+	LayerFolderPath         string      // Where the layer folders are located

+	Layers                  []layer     // List of storage layers

+	ProcessorWeight         uint64      `json:",omitempty"` // CPU Shares 0..10000 on Windows; where 0 will be omitted and HCS will default.

+	ProcessorMaximum        int64       `json:",omitempty"` // CPU maximum usage percent 1..100

+	StorageIOPSMaximum      uint64      `json:",omitempty"` // Maximum Storage IOPS

+	StorageBandwidthMaximum uint64      `json:",omitempty"` // Maximum Storage Bandwidth in bytes per second

+	StorageSandboxSize      uint64      `json:",omitempty"` // Size in bytes that the container system drive should be expanded to if smaller

+	MemoryMaximumInMB       int64       `json:",omitempty"` // Maximum memory available to the container in Megabytes

+	HostName                string      // Hostname

+	MappedDirectories       []mappedDir // List of mapped directories (volumes/mounts)

+	SandboxPath             string      // Location of unmounted sandbox (used for Hyper-V containers)

+	HvPartition             bool        // True if it a Hyper-V Container

+	EndpointList            []string    // List of networking endpoints to be attached to container

+}

+

+// defaultOwner is a tag passed to HCS to allow it to differentiate between

+// container creator management stacks. We hard code "docker" in the case

+// of docker.

+const defaultOwner = "docker"

+

+// Create is the entrypoint to create a container from a spec, and if successfully

+// created, start it too.

+func (clnt *client) Create(containerID string, spec Spec, options ...CreateOption) error {

+	logrus.Debugln("LCD client.Create() with spec", spec)

+

+	cu := &containerInit{

+		SystemType: "Container",

+		Name:       containerID,

+		Owner:      defaultOwner,

+

+		VolumePath:              spec.Root.Path,

+		IgnoreFlushesDuringBoot: spec.Windows.FirstStart,

+		LayerFolderPath:         spec.Windows.LayerFolder,

+		HostName:                spec.Hostname,

+	}

+

+	if spec.Windows.Networking != nil {

+		cu.EndpointList = spec.Windows.Networking.EndpointList

+	}

+

+	if spec.Windows.Resources != nil {

+		if spec.Windows.Resources.CPU != nil {

+			if spec.Windows.Resources.CPU.Shares != nil {

+				cu.ProcessorWeight = *spec.Windows.Resources.CPU.Shares

+			}

+			if spec.Windows.Resources.CPU.Percent != nil {

+				cu.ProcessorMaximum = *spec.Windows.Resources.CPU.Percent * 100 // ProcessorMaximum is a value between 1 and 10000

+			}

+		}

+		if spec.Windows.Resources.Memory != nil {

+			if spec.Windows.Resources.Memory.Limit != nil {

+				cu.MemoryMaximumInMB = *spec.Windows.Resources.Memory.Limit / 1024 / 1024

+			}

+		}

+		if spec.Windows.Resources.Storage != nil {

+			if spec.Windows.Resources.Storage.Bps != nil {

+				cu.StorageBandwidthMaximum = *spec.Windows.Resources.Storage.Bps

+			}

+			if spec.Windows.Resources.Storage.Iops != nil {

+				cu.StorageIOPSMaximum = *spec.Windows.Resources.Storage.Iops

+			}

+			if spec.Windows.Resources.Storage.SandboxSize != nil {

+				cu.StorageSandboxSize = *spec.Windows.Resources.Storage.SandboxSize

+			}

+		}

+	}

+

+	// TODO Ultimately need to set the path from HvRuntime.ImagePath

+	cu.HvPartition = (spec.Windows.HvRuntime != nil)

+	//	if spec.Windows.HvRuntime != nil {

+	//		cu.HvPartition = len(spec.Windows.HvRuntime.ImagePath) > 0

+	//	}

+

+	if cu.HvPartition {

+		cu.SandboxPath = filepath.Dir(spec.Windows.LayerFolder)

+	} else {

+		cu.VolumePath = spec.Root.Path

+		cu.LayerFolderPath = spec.Windows.LayerFolder

+	}

+

+	for _, layerPath := range spec.Windows.LayerPaths {

+		_, filename := filepath.Split(layerPath)

+		g, err := hcsshim.NameToGuid(filename)

+		if err != nil {

+			return err

+		}

+		cu.Layers = append(cu.Layers, layer{

+			ID:   g.ToString(),

+			Path: layerPath,

+		})

+	}

+

+	// Add the mounts (volumes, bind mounts etc) to the structure

+	mds := make([]mappedDir, len(spec.Mounts))

+	for i, mount := range spec.Mounts {

+		mds[i] = mappedDir{

+			HostPath:      mount.Source,

+			ContainerPath: mount.Destination,

+			ReadOnly:      mount.Readonly}