2016-06-07 07:45:21 +00:00
|
|
|
// +build linux freebsd solaris
|
2015-11-12 19:55:17 +00:00
|
|
|
|
|
|
|
package container
|
|
|
|
|
|
|
|
import (
|
|
|
|
"fmt"
|
|
|
|
"io/ioutil"
|
|
|
|
"os"
|
|
|
|
"path/filepath"
|
|
|
|
"strings"
|
|
|
|
|
|
|
|
"github.com/Sirupsen/logrus"
|
2016-09-06 18:18:12 +00:00
|
|
|
containertypes "github.com/docker/docker/api/types/container"
|
2016-09-22 20:14:15 +00:00
|
|
|
mounttypes "github.com/docker/docker/api/types/mount"
|
2015-11-12 19:55:17 +00:00
|
|
|
"github.com/docker/docker/pkg/chrootarchive"
|
2016-03-08 02:41:44 +00:00
|
|
|
"github.com/docker/docker/pkg/stringid"
|
2015-11-12 19:55:17 +00:00
|
|
|
"github.com/docker/docker/pkg/symlink"
|
|
|
|
"github.com/docker/docker/pkg/system"
|
|
|
|
"github.com/docker/docker/utils"
|
|
|
|
"github.com/docker/docker/volume"
|
|
|
|
"github.com/opencontainers/runc/libcontainer/label"
|
2016-06-07 07:45:21 +00:00
|
|
|
"golang.org/x/sys/unix"
|
2015-11-12 19:55:17 +00:00
|
|
|
)
|
|
|
|
|
2016-10-19 16:22:02 +00:00
|
|
|
const (
|
2016-10-26 20:30:53 +00:00
|
|
|
// DefaultSHMSize is the default size (64MB) of the SHM which will be mounted in the container
|
2016-10-19 16:22:02 +00:00
|
|
|
DefaultSHMSize int64 = 67108864
|
|
|
|
containerSecretMountPath = "/run/secrets"
|
|
|
|
)
|
2015-11-12 19:55:17 +00:00
|
|
|
|
2016-01-14 05:46:59 +00:00
|
|
|
// Container holds the fields specific to unixen implementations.
|
|
|
|
// See CommonContainer for standard fields common to all containers.
|
2015-11-12 19:55:17 +00:00
|
|
|
type Container struct {
|
|
|
|
CommonContainer
|
|
|
|
|
|
|
|
// Fields below here are platform specific.
|
|
|
|
AppArmorProfile string
|
|
|
|
HostnamePath string
|
|
|
|
HostsPath string
|
|
|
|
ShmPath string
|
|
|
|
ResolvConfPath string
|
2015-11-15 02:02:26 +00:00
|
|
|
SeccompProfile string
|
2016-02-22 05:31:21 +00:00
|
|
|
NoNewPrivileges bool
|
2015-11-12 19:55:17 +00:00
|
|
|
}
|
|
|
|
|
2016-03-18 18:50:19 +00:00
|
|
|
// ExitStatus provides exit reasons for a container.
|
|
|
|
type ExitStatus struct {
|
|
|
|
// The exit code with which the container exited.
|
|
|
|
ExitCode int
|
|
|
|
|
|
|
|
// Whether the container encountered an OOM.
|
|
|
|
OOMKilled bool
|
|
|
|
}
|
|
|
|
|
2015-11-12 19:55:17 +00:00
|
|
|
// CreateDaemonEnvironment returns the list of all environment variables given the list of
|
|
|
|
// environment variables related to links.
|
|
|
|
// Sets PATH, HOSTNAME and if container.Config.Tty is set: TERM.
|
|
|
|
// The defaults set here do not override the values in container.Config.Env
|
2016-09-28 22:21:33 +00:00
|
|
|
func (container *Container) CreateDaemonEnvironment(tty bool, linkedEnv []string) []string {
|
2015-11-12 19:55:17 +00:00
|
|
|
// Setup environment
|
|
|
|
env := []string{
|
2015-12-10 14:35:53 +00:00
|
|
|
"PATH=" + system.DefaultPathEnv,
|
2016-02-13 23:44:05 +00:00
|
|
|
"HOSTNAME=" + container.Config.Hostname,
|
2015-11-12 19:55:17 +00:00
|
|
|
}
|
2016-09-28 22:21:33 +00:00
|
|
|
if tty {
|
2015-11-12 19:55:17 +00:00
|
|
|
env = append(env, "TERM=xterm")
|
|
|
|
}
|
|
|
|
env = append(env, linkedEnv...)
|
|
|
|
// because the env on the container can override certain default values
|
|
|
|
// we need to replace the 'env' keys where they match and append anything
|
|
|
|
// else.
|
|
|
|
env = utils.ReplaceOrAppendEnvValues(env, container.Config.Env)
|
|
|
|
return env
|
|
|
|
}
|
|
|
|
|
|
|
|
// TrySetNetworkMount attempts to set the network mounts given a provided destination and
|
|
|
|
// the path to use for it; return true if the given destination was a network mount file
|
|
|
|
func (container *Container) TrySetNetworkMount(destination string, path string) bool {
|
|
|
|
if destination == "/etc/resolv.conf" {
|
|
|
|
container.ResolvConfPath = path
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
if destination == "/etc/hostname" {
|
|
|
|
container.HostnamePath = path
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
if destination == "/etc/hosts" {
|
|
|
|
container.HostsPath = path
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
|
|
|
// BuildHostnameFile writes the container's hostname file.
|
|
|
|
func (container *Container) BuildHostnameFile() error {
|
|
|
|
hostnamePath, err := container.GetRootResourcePath("hostname")
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
container.HostnamePath = hostnamePath
|
|
|
|
return ioutil.WriteFile(container.HostnamePath, []byte(container.Config.Hostname+"\n"), 0644)
|
|
|
|
}
|
|
|
|
|
|
|
|
// NetworkMounts returns the list of network mounts.
|
2016-03-18 18:50:19 +00:00
|
|
|
func (container *Container) NetworkMounts() []Mount {
|
|
|
|
var mounts []Mount
|
2015-11-12 19:55:17 +00:00
|
|
|
shared := container.HostConfig.NetworkMode.IsContainer()
|
|
|
|
if container.ResolvConfPath != "" {
|
|
|
|
if _, err := os.Stat(container.ResolvConfPath); err != nil {
|
|
|
|
logrus.Warnf("ResolvConfPath set to %q, but can't stat this filename (err = %v); skipping", container.ResolvConfPath, err)
|
|
|
|
} else {
|
2016-05-25 19:59:55 +00:00
|
|
|
if !container.HasMountFor("/etc/resolv.conf") {
|
|
|
|
label.Relabel(container.ResolvConfPath, container.MountLabel, shared)
|
|
|
|
}
|
2015-11-12 19:55:17 +00:00
|
|
|
writable := !container.HostConfig.ReadonlyRootfs
|
|
|
|
if m, exists := container.MountPoints["/etc/resolv.conf"]; exists {
|
|
|
|
writable = m.RW
|
|
|
|
}
|
2016-03-18 18:50:19 +00:00
|
|
|
mounts = append(mounts, Mount{
|
2015-11-12 19:55:17 +00:00
|
|
|
Source: container.ResolvConfPath,
|
|
|
|
Destination: "/etc/resolv.conf",
|
|
|
|
Writable: writable,
|
2016-08-15 16:13:18 +00:00
|
|
|
Propagation: string(volume.DefaultPropagationMode),
|
2015-11-12 19:55:17 +00:00
|
|
|
})
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if container.HostnamePath != "" {
|
|
|
|
if _, err := os.Stat(container.HostnamePath); err != nil {
|
|
|
|
logrus.Warnf("HostnamePath set to %q, but can't stat this filename (err = %v); skipping", container.HostnamePath, err)
|
|
|
|
} else {
|
2016-05-25 19:59:55 +00:00
|
|
|
if !container.HasMountFor("/etc/hostname") {
|
|
|
|
label.Relabel(container.HostnamePath, container.MountLabel, shared)
|
|
|
|
}
|
2015-11-12 19:55:17 +00:00
|
|
|
writable := !container.HostConfig.ReadonlyRootfs
|
|
|
|
if m, exists := container.MountPoints["/etc/hostname"]; exists {
|
|
|
|
writable = m.RW
|
|
|
|
}
|
2016-03-18 18:50:19 +00:00
|
|
|
mounts = append(mounts, Mount{
|
2015-11-12 19:55:17 +00:00
|
|
|
Source: container.HostnamePath,
|
|
|
|
Destination: "/etc/hostname",
|
|
|
|
Writable: writable,
|
2016-08-15 16:13:18 +00:00
|
|
|
Propagation: string(volume.DefaultPropagationMode),
|
2015-11-12 19:55:17 +00:00
|
|
|
})
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if container.HostsPath != "" {
|
|
|
|
if _, err := os.Stat(container.HostsPath); err != nil {
|
|
|
|
logrus.Warnf("HostsPath set to %q, but can't stat this filename (err = %v); skipping", container.HostsPath, err)
|
|
|
|
} else {
|
2016-05-25 19:59:55 +00:00
|
|
|
if !container.HasMountFor("/etc/hosts") {
|
|
|
|
label.Relabel(container.HostsPath, container.MountLabel, shared)
|
|
|
|
}
|
2015-11-12 19:55:17 +00:00
|
|
|
writable := !container.HostConfig.ReadonlyRootfs
|
|
|
|
if m, exists := container.MountPoints["/etc/hosts"]; exists {
|
|
|
|
writable = m.RW
|
|
|
|
}
|
2016-03-18 18:50:19 +00:00
|
|
|
mounts = append(mounts, Mount{
|
2015-11-12 19:55:17 +00:00
|
|
|
Source: container.HostsPath,
|
|
|
|
Destination: "/etc/hosts",
|
|
|
|
Writable: writable,
|
2016-08-15 16:13:18 +00:00
|
|
|
Propagation: string(volume.DefaultPropagationMode),
|
2015-11-12 19:55:17 +00:00
|
|
|
})
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return mounts
|
|
|
|
}
|
|
|
|
|
2016-10-26 20:30:53 +00:00
|
|
|
// SecretMountPath returns the path of the secret mount for the container
|
2016-10-19 16:22:02 +00:00
|
|
|
func (container *Container) SecretMountPath() string {
|
|
|
|
return filepath.Join(container.Root, "secrets")
|
|
|
|
}
|
|
|
|
|
2015-11-12 19:55:17 +00:00
|
|
|
// CopyImagePathContent copies files in destination to the volume.
|
|
|
|
func (container *Container) CopyImagePathContent(v volume.Volume, destination string) error {
|
|
|
|
rootfs, err := symlink.FollowSymlinkInScope(filepath.Join(container.BaseFS, destination), container.BaseFS)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
if _, err = ioutil.ReadDir(rootfs); err != nil {
|
|
|
|
if os.IsNotExist(err) {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2016-03-08 02:41:44 +00:00
|
|
|
id := stringid.GenerateNonCryptoID()
|
|
|
|
path, err := v.Mount(id)
|
2015-11-12 19:55:17 +00:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2016-03-08 02:41:44 +00:00
|
|
|
|
|
|
|
defer func() {
|
|
|
|
if err := v.Unmount(id); err != nil {
|
|
|
|
logrus.Warnf("error while unmounting volume %s: %v", v.Name(), err)
|
|
|
|
}
|
|
|
|
}()
|
2016-06-07 07:45:21 +00:00
|
|
|
if err := label.Relabel(path, container.MountLabel, true); err != nil && err != unix.ENOTSUP {
|
2016-05-26 15:11:28 +00:00
|
|
|
return err
|
|
|
|
}
|
2016-03-15 03:31:42 +00:00
|
|
|
return copyExistingContents(rootfs, path)
|
2015-11-12 19:55:17 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// ShmResourcePath returns path to shm
|
|
|
|
func (container *Container) ShmResourcePath() (string, error) {
|
|
|
|
return container.GetRootResourcePath("shm")
|
|
|
|
}
|
|
|
|
|
|
|
|
// HasMountFor checks if path is a mountpoint
|
|
|
|
func (container *Container) HasMountFor(path string) bool {
|
|
|
|
_, exists := container.MountPoints[path]
|
|
|
|
return exists
|
|
|
|
}
|
|
|
|
|
|
|
|
// UnmountIpcMounts uses the provided unmount function to unmount shm and mqueue if they were mounted
|
|
|
|
func (container *Container) UnmountIpcMounts(unmount func(pth string) error) {
|
|
|
|
if container.HostConfig.IpcMode.IsContainer() || container.HostConfig.IpcMode.IsHost() {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
var warnings []string
|
|
|
|
|
|
|
|
if !container.HasMountFor("/dev/shm") {
|
|
|
|
shmPath, err := container.ShmResourcePath()
|
|
|
|
if err != nil {
|
|
|
|
logrus.Error(err)
|
|
|
|
warnings = append(warnings, err.Error())
|
|
|
|
} else if shmPath != "" {
|
2016-04-06 11:34:31 +00:00
|
|
|
if err := unmount(shmPath); err != nil && !os.IsNotExist(err) {
|
2015-11-12 19:55:17 +00:00
|
|
|
warnings = append(warnings, fmt.Sprintf("failed to umount %s: %v", shmPath, err))
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if len(warnings) > 0 {
|
|
|
|
logrus.Warnf("failed to cleanup ipc mounts:\n%v", strings.Join(warnings, "\n"))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// IpcMounts returns the list of IPC mounts
|
2016-03-18 18:50:19 +00:00
|
|
|
func (container *Container) IpcMounts() []Mount {
|
|
|
|
var mounts []Mount
|
2015-11-12 19:55:17 +00:00
|
|
|
|
|
|
|
if !container.HasMountFor("/dev/shm") {
|
|
|
|
label.SetFileLabel(container.ShmPath, container.MountLabel)
|
2016-03-18 18:50:19 +00:00
|
|
|
mounts = append(mounts, Mount{
|
2015-11-12 19:55:17 +00:00
|
|
|
Source: container.ShmPath,
|
|
|
|
Destination: "/dev/shm",
|
|
|
|
Writable: true,
|
2016-08-15 16:13:18 +00:00
|
|
|
Propagation: string(volume.DefaultPropagationMode),
|
2015-11-12 19:55:17 +00:00
|
|
|
})
|
|
|
|
}
|
|
|
|
|
2016-03-18 18:50:19 +00:00
|
|
|
return mounts
|
2015-12-28 11:19:26 +00:00
|
|
|
}
|
|
|
|
|
2016-10-27 22:51:02 +00:00
|
|
|
// SecretMount returns the mount for the secret path
|
2016-10-27 07:41:32 +00:00
|
|
|
func (container *Container) SecretMount() *Mount {
|
2016-11-15 15:04:36 +00:00
|
|
|
if len(container.SecretReferences) > 0 {
|
2016-10-27 07:41:32 +00:00
|
|
|
return &Mount{
|
2016-10-19 16:22:02 +00:00
|
|
|
Source: container.SecretMountPath(),
|
|
|
|
Destination: containerSecretMountPath,
|
|
|
|
Writable: false,
|
2016-10-26 20:30:53 +00:00
|
|
|
}
|
2016-10-19 16:22:02 +00:00
|
|
|
}
|
|
|
|
|
2016-10-27 07:41:32 +00:00
|
|
|
return nil
|
2016-10-19 16:22:02 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// UnmountSecrets unmounts the local tmpfs for secrets
|
|
|
|
func (container *Container) UnmountSecrets() error {
|
2016-10-29 00:30:22 +00:00
|
|
|
if _, err := os.Stat(container.SecretMountPath()); err != nil {
|
|
|
|
if os.IsNotExist(err) {
|
|
|
|
return nil
|
|
|
|
}
|
2016-10-31 15:53:43 +00:00
|
|
|
return err
|
2016-10-29 00:30:22 +00:00
|
|
|
}
|
|
|
|
|
2016-10-19 16:22:02 +00:00
|
|
|
return detachMounted(container.SecretMountPath())
|
|
|
|
}
|
|
|
|
|
2016-01-04 15:58:20 +00:00
|
|
|
// UpdateContainer updates configuration of a container.
|
2016-01-22 04:49:02 +00:00
|
|
|
func (container *Container) UpdateContainer(hostConfig *containertypes.HostConfig) error {
|
2015-12-28 11:19:26 +00:00
|
|
|
container.Lock()
|
2016-03-18 18:50:19 +00:00
|
|
|
defer container.Unlock()
|
2015-12-28 11:19:26 +00:00
|
|
|
|
2016-01-04 15:58:20 +00:00
|
|
|
// update resources of container
|
2015-12-28 11:19:26 +00:00
|
|
|
resources := hostConfig.Resources
|
|
|
|
cResources := &container.HostConfig.Resources
|
|
|
|
if resources.BlkioWeight != 0 {
|
|
|
|
cResources.BlkioWeight = resources.BlkioWeight
|
|
|
|
}
|
|
|
|
if resources.CPUShares != 0 {
|
|
|
|
cResources.CPUShares = resources.CPUShares
|
|
|
|
}
|
|
|
|
if resources.CPUPeriod != 0 {
|
|
|
|
cResources.CPUPeriod = resources.CPUPeriod
|
|
|
|
}
|
|
|
|
if resources.CPUQuota != 0 {
|
|
|
|
cResources.CPUQuota = resources.CPUQuota
|
|
|
|
}
|
|
|
|
if resources.CpusetCpus != "" {
|
|
|
|
cResources.CpusetCpus = resources.CpusetCpus
|
|
|
|
}
|
|
|
|
if resources.CpusetMems != "" {
|
|
|
|
cResources.CpusetMems = resources.CpusetMems
|
|
|
|
}
|
|
|
|
if resources.Memory != 0 {
|
2016-08-08 10:36:03 +00:00
|
|
|
// if memory limit smaller than already set memoryswap limit and doesn't
|
|
|
|
// update the memoryswap limit, then error out.
|
|
|
|
if resources.Memory > cResources.MemorySwap && resources.MemorySwap == 0 {
|
|
|
|
return fmt.Errorf("Memory limit should be smaller than already set memoryswap limit, update the memoryswap at the same time")
|
|
|
|
}
|
2015-12-28 11:19:26 +00:00
|
|
|
cResources.Memory = resources.Memory
|
|
|
|
}
|
|
|
|
if resources.MemorySwap != 0 {
|
|
|
|
cResources.MemorySwap = resources.MemorySwap
|
|
|
|
}
|
|
|
|
if resources.MemoryReservation != 0 {
|
|
|
|
cResources.MemoryReservation = resources.MemoryReservation
|
|
|
|
}
|
|
|
|
if resources.KernelMemory != 0 {
|
|
|
|
cResources.KernelMemory = resources.KernelMemory
|
|
|
|
}
|
2016-01-04 15:58:20 +00:00
|
|
|
|
|
|
|
// update HostConfig of container
|
|
|
|
if hostConfig.RestartPolicy.Name != "" {
|
2016-08-15 08:38:47 +00:00
|
|
|
if container.HostConfig.AutoRemove && !hostConfig.RestartPolicy.IsNone() {
|
|
|
|
return fmt.Errorf("Restart policy cannot be updated because AutoRemove is enabled for the container")
|
|
|
|
}
|
2016-01-04 15:58:20 +00:00
|
|
|
container.HostConfig.RestartPolicy = hostConfig.RestartPolicy
|
|
|
|
}
|
2015-12-28 11:19:26 +00:00
|
|
|
|
2016-03-18 18:50:19 +00:00
|
|
|
if err := container.ToDisk(); err != nil {
|
2015-12-28 11:19:26 +00:00
|
|
|
logrus.Errorf("Error saving updated container: %v", err)
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2016-10-03 17:53:06 +00:00
|
|
|
// DetachAndUnmount uses a detached mount on all mount destinations, then
|
|
|
|
// unmounts each volume normally.
|
|
|
|
// This is used from daemon/archive for `docker cp`
|
|
|
|
func (container *Container) DetachAndUnmount(volumeEventLog func(name, action string, attributes map[string]string)) error {
|
|
|
|
networkMounts := container.NetworkMounts()
|
|
|
|
mountPaths := make([]string, 0, len(container.MountPoints)+len(networkMounts))
|
2015-11-12 19:55:17 +00:00
|
|
|
|
|
|
|
for _, mntPoint := range container.MountPoints {
|
|
|
|
dest, err := container.GetResourcePath(mntPoint.Destination)
|
|
|
|
if err != nil {
|
2016-10-03 17:53:06 +00:00
|
|
|
logrus.Warnf("Failed to get volume destination path for container '%s' at '%s' while lazily unmounting: %v", container.ID, mntPoint.Destination, err)
|
|
|
|
continue
|
2015-11-12 19:55:17 +00:00
|
|
|
}
|
2016-10-03 17:53:06 +00:00
|
|
|
mountPaths = append(mountPaths, dest)
|
2015-11-12 19:55:17 +00:00
|
|
|
}
|
|
|
|
|
2016-10-03 17:53:06 +00:00
|
|
|
for _, m := range networkMounts {
|
|
|
|
dest, err := container.GetResourcePath(m.Destination)
|
|
|
|
if err != nil {
|
|
|
|
logrus.Warnf("Failed to get volume destination path for container '%s' at '%s' while lazily unmounting: %v", container.ID, m.Destination, err)
|
|
|
|
continue
|
2015-11-12 19:55:17 +00:00
|
|
|
}
|
2016-10-03 17:53:06 +00:00
|
|
|
mountPaths = append(mountPaths, dest)
|
|
|
|
}
|
2015-11-12 19:55:17 +00:00
|
|
|
|
2016-10-03 17:53:06 +00:00
|
|
|
for _, mountPath := range mountPaths {
|
|
|
|
if err := detachMounted(mountPath); err != nil {
|
|
|
|
logrus.Warnf("%s unmountVolumes: Failed to do lazy umount fo volume '%s': %v", container.ID, mountPath, err)
|
2015-11-12 19:55:17 +00:00
|
|
|
}
|
|
|
|
}
|
2016-10-03 17:53:06 +00:00
|
|
|
return container.UnmountVolumes(volumeEventLog)
|
2015-11-12 19:55:17 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// copyExistingContents copies from the source to the destination and
|
|
|
|
// ensures the ownership is appropriately set.
|
|
|
|
func copyExistingContents(source, destination string) error {
|
|
|
|
volList, err := ioutil.ReadDir(source)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
if len(volList) > 0 {
|
|
|
|
srcList, err := ioutil.ReadDir(destination)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
if len(srcList) == 0 {
|
2016-01-14 05:46:59 +00:00
|
|
|
// If the source volume is empty, copies files from the root into the volume
|
2015-11-12 19:55:17 +00:00
|
|
|
if err := chrootarchive.CopyWithTar(source, destination); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return copyOwnership(source, destination)
|
|
|
|
}
|
|
|
|
|
|
|
|
// copyOwnership copies the permissions and uid:gid of the source file
|
|
|
|
// to the destination file
|
|
|
|
func copyOwnership(source, destination string) error {
|
|
|
|
stat, err := system.Stat(source)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
if err := os.Chown(destination, int(stat.UID()), int(stat.GID())); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
return os.Chmod(destination, os.FileMode(stat.Mode()))
|
|
|
|
}
|
|
|
|
|
|
|
|
// TmpfsMounts returns the list of tmpfs mounts
|
2016-09-22 20:14:15 +00:00
|
|
|
func (container *Container) TmpfsMounts() ([]Mount, error) {
|
2016-03-18 18:50:19 +00:00
|
|
|
var mounts []Mount
|
2015-11-12 19:55:17 +00:00
|
|
|
for dest, data := range container.HostConfig.Tmpfs {
|
2016-03-18 18:50:19 +00:00
|
|
|
mounts = append(mounts, Mount{
|
2015-11-12 19:55:17 +00:00
|
|
|
Source: "tmpfs",
|
|
|
|
Destination: dest,
|
|
|
|
Data: data,
|
|
|
|
})
|
|
|
|
}
|
2016-09-22 20:14:15 +00:00
|
|
|
for dest, mnt := range container.MountPoints {
|
|
|
|
if mnt.Type == mounttypes.TypeTmpfs {
|
2016-11-08 06:46:23 +00:00
|
|
|
data, err := volume.ConvertTmpfsOptions(mnt.Spec.TmpfsOptions, mnt.Spec.ReadOnly)
|
2016-09-22 20:14:15 +00:00
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
mounts = append(mounts, Mount{
|
|
|
|
Source: "tmpfs",
|
|
|
|
Destination: dest,
|
|
|
|
Data: data,
|
|
|
|
})
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return mounts, nil
|
2015-11-12 19:55:17 +00:00
|
|
|
}
|
2016-01-27 21:03:09 +00:00
|
|
|
|
|
|
|
// cleanResourcePath cleans a resource path and prepares to combine with mnt path
|
|
|
|
func cleanResourcePath(path string) string {
|
|
|
|
return filepath.Join(string(os.PathSeparator), path)
|
|
|
|
}
|
2016-03-01 18:23:43 +00:00
|
|
|
|
2016-09-13 00:17:09 +00:00
|
|
|
// EnableServiceDiscoveryOnDefaultNetwork Enable service discovery on default network
|
|
|
|
func (container *Container) EnableServiceDiscoveryOnDefaultNetwork() bool {
|
|
|
|
return false
|
|
|
|
}
|