package daemon // import "github.com/docker/docker/daemon"

 import (

 	"fmt"
 	"io/ioutil"
 	"os"
 

 	"github.com/docker/docker/container"

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

 	"github.com/docker/libnetwork"

 	"github.com/pkg/errors"

 	"github.com/sirupsen/logrus"

 )

 func (daemon *Daemon) setupLinkedContainers(container *container.Container) ([]string, error) {

 	return nil, nil
 }
 

 func (daemon *Daemon) setupConfigDir(c *container.Container) (setupErr error) {
 	if len(c.ConfigReferences) == 0 {
 		return nil
 	}
 

 	localPath := c.ConfigsDirPath()

 	logrus.Debugf("configs: setting up config dir: %s", localPath)
 
 	// create local config root

 	if err := system.MkdirAllWithACL(localPath, 0, system.SddlAdministratorsLocalSystem); err != nil {

 		return errors.Wrap(err, "error creating config dir")
 	}
 
 	defer func() {
 		if setupErr != nil {
 			if err := os.RemoveAll(localPath); err != nil {
 				logrus.Errorf("error cleaning up config dir: %s", err)
 			}
 		}
 	}()
 
 	if c.DependencyStore == nil {
 		return fmt.Errorf("config store is not initialized")
 	}
 
 	for _, configRef := range c.ConfigReferences {
 		// TODO (ehazlett): use type switch when more are supported
 		if configRef.File == nil {

 			// Runtime configs are not mounted into the container, but they're
 			// a valid type of config so we should not error when we encounter
 			// one.
 			if configRef.Runtime == nil {
 				logrus.Error("config target type is not a file or runtime target")
 			}
 			// However, in any case, this isn't a file config, so we have no
 			// further work to do

 			continue
 		}
 

 		fPath := c.ConfigFilePath(*configRef)

 		log := logrus.WithFields(logrus.Fields{"name": configRef.File.Name, "path": fPath})
 
 		log.Debug("injecting config")

 		config, err := c.DependencyStore.Configs().Get(configRef.ConfigID)
 		if err != nil {
 			return errors.Wrap(err, "unable to get config from config store")

 		}
 		if err := ioutil.WriteFile(fPath, config.Spec.Data, configRef.File.Mode); err != nil {
 			return errors.Wrap(err, "error injecting config")
 		}
 	}
 
 	return nil
 }
 

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

 	return nil
 }
 

 // TODO Windows: Fix Post-TP5. This is a hack to allow docker cp to work

 // against containers which have volumes. You will still be able to cp
 // to somewhere on the container drive, but not to any mounted volumes
 // inside the container. Without this fix, docker cp is broken to any
 // container which has a volume, regardless of where the file is inside the
 // container.
 func (daemon *Daemon) mountVolumes(container *container.Container) error {

 	return nil
 }

 func (daemon *Daemon) setupSecretDir(c *container.Container) (setupErr error) {
 	if len(c.SecretReferences) == 0 {
 		return nil
 	}
 

 	localMountPath, err := c.SecretMountPath()
 	if err != nil {
 		return err
 	}

 	logrus.Debugf("secrets: setting up secret dir: %s", localMountPath)
 
 	// create local secret root

 	if err := system.MkdirAllWithACL(localMountPath, 0, system.SddlAdministratorsLocalSystem); err != nil {

 		return errors.Wrap(err, "error creating secret local directory")
 	}
 
 	defer func() {
 		if setupErr != nil {
 			if err := os.RemoveAll(localMountPath); err != nil {
 				logrus.Errorf("error cleaning up secret mount: %s", err)
 			}
 		}
 	}()
 
 	if c.DependencyStore == nil {
 		return fmt.Errorf("secret store is not initialized")
 	}
 
 	for _, s := range c.SecretReferences {
 		// TODO (ehazlett): use type switch when more are supported
 		if s.File == nil {
 			logrus.Error("secret target type is not a file target")
 			continue
 		}
 
 		// secrets are created in the SecretMountPath on the host, at a
 		// single level

 		fPath, err := c.SecretFilePath(*s)
 		if err != nil {
 			return err
 		}

 		logrus.WithFields(logrus.Fields{
 			"name": s.File.Name,
 			"path": fPath,
 		}).Debug("injecting secret")

 		secret, err := c.DependencyStore.Secrets().Get(s.SecretID)
 		if err != nil {
 			return errors.Wrap(err, "unable to get secret from secret store")

 		}
 		if err := ioutil.WriteFile(fPath, secret.Spec.Data, s.File.Mode); err != nil {
 			return errors.Wrap(err, "error injecting secret")
 		}
 	}
 
 	return nil
 }
 

 func killProcessDirectly(container *container.Container) error {

 	return nil
 }

 
 func isLinkable(child *container.Container) bool {
 	return false
 }

 
 func enableIPOnPredefinedNetwork() bool {
 	return true
 }

 // serviceDiscoveryOnDefaultNetwork indicates if service discovery is supported on the default network
 func serviceDiscoveryOnDefaultNetwork() bool {
 	return true
 }
 

 func (daemon *Daemon) setupPathsAndSandboxOptions(container *container.Container, sboxOptions *[]libnetwork.SandboxOption) error {

 	return nil
 }
 

 func (daemon *Daemon) initializeNetworkingPaths(container *container.Container, nc *container.Container) error {
 
 	if nc.HostConfig.Isolation.IsHyperV() {
 		return fmt.Errorf("sharing of hyperv containers network is not supported")
 	}
 

 	container.NetworkSharedContainerID = nc.ID

 
 	if nc.NetworkSettings != nil {
 		for n := range nc.NetworkSettings.Networks {

 			sn, err := daemon.FindNetwork(n)

 			if err != nil {
 				continue
 			}
 

 			ep, err := getEndpointInNetwork(nc.Name, sn)

 			if err != nil {
 				continue
 			}
 
 			data, err := ep.DriverInfo()
 			if err != nil {
 				continue
 			}
 
 			if data["GW_INFO"] != nil {
 				gwInfo := data["GW_INFO"].(map[string]interface{})
 				if gwInfo["hnsid"] != nil {
 					container.SharedEndpointList = append(container.SharedEndpointList, gwInfo["hnsid"].(string))
 				}
 			}
 
 			if data["hnsid"] != nil {
 				container.SharedEndpointList = append(container.SharedEndpointList, data["hnsid"].(string))
 			}
 		}
 	}
 
 	return nil

 }