2014-04-17 17:43:01 -04:00
|
|
|
package daemon
|
2014-02-14 20:15:40 -05:00
|
|
|
|
|
|
|
import (
|
2015-05-12 21:21:26 -04:00
|
|
|
"errors"
|
2014-02-14 20:15:40 -05:00
|
|
|
"os"
|
|
|
|
"path/filepath"
|
|
|
|
"strings"
|
2014-05-05 17:45:14 -04:00
|
|
|
|
2015-06-12 09:25:32 -04:00
|
|
|
"github.com/docker/docker/api/types"
|
2015-09-09 22:23:06 -04:00
|
|
|
"github.com/docker/docker/daemon/execdriver"
|
2015-09-17 14:54:14 -04:00
|
|
|
derr "github.com/docker/docker/errors"
|
2015-09-09 22:23:06 -04:00
|
|
|
"github.com/docker/docker/runconfig"
|
2015-05-19 16:05:25 -04:00
|
|
|
"github.com/docker/docker/volume"
|
2015-09-09 22:23:06 -04:00
|
|
|
"github.com/opencontainers/runc/libcontainer/label"
|
2014-02-14 20:15:40 -05:00
|
|
|
)
|
|
|
|
|
2015-06-12 09:25:32 -04:00
|
|
|
var (
|
|
|
|
// ErrVolumeReadonly is used to signal an error when trying to copy data into
|
|
|
|
// a volume mount that is not writable.
|
|
|
|
ErrVolumeReadonly = errors.New("mounted volume is marked read-only")
|
|
|
|
)
|
2015-05-12 21:21:26 -04:00
|
|
|
|
2015-09-09 22:23:06 -04:00
|
|
|
type mounts []execdriver.Mount
|
2014-12-16 10:06:45 -05:00
|
|
|
|
2015-09-09 22:23:06 -04:00
|
|
|
// volumeToAPIType converts a volume.Volume to the type used by the remote API
|
|
|
|
func volumeToAPIType(v volume.Volume) *types.Volume {
|
|
|
|
return &types.Volume{
|
|
|
|
Name: v.Name(),
|
|
|
|
Driver: v.DriverName(),
|
|
|
|
Mountpoint: v.Path(),
|
2014-08-21 17:57:46 -04:00
|
|
|
}
|
2015-09-09 22:23:06 -04:00
|
|
|
}
|
2014-08-21 17:57:46 -04:00
|
|
|
|
2015-09-09 22:23:06 -04:00
|
|
|
// createVolume creates a volume.
|
|
|
|
func (daemon *Daemon) createVolume(name, driverName string, opts map[string]string) (volume.Volume, error) {
|
|
|
|
v, err := daemon.volumes.Create(name, driverName, opts)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
2014-08-28 10:18:08 -04:00
|
|
|
}
|
2015-09-09 22:23:06 -04:00
|
|
|
daemon.volumes.Increment(v)
|
|
|
|
return v, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// Len returns the number of mounts. Used in sorting.
|
|
|
|
func (m mounts) Len() int {
|
|
|
|
return len(m)
|
|
|
|
}
|
2014-08-28 10:18:08 -04:00
|
|
|
|
2015-09-09 22:23:06 -04:00
|
|
|
// Less returns true if the number of parts (a/b/c would be 3 parts) in the
|
|
|
|
// mount indexed by parameter 1 is less than that of the mount indexed by
|
|
|
|
// parameter 2. Used in sorting.
|
|
|
|
func (m mounts) Less(i, j int) bool {
|
|
|
|
return m.parts(i) < m.parts(j)
|
2014-12-16 10:06:45 -05:00
|
|
|
}
|
|
|
|
|
2015-09-09 22:23:06 -04:00
|
|
|
// Swap swaps two items in an array of mounts. Used in sorting
|
|
|
|
func (m mounts) Swap(i, j int) {
|
|
|
|
m[i], m[j] = m[j], m[i]
|
|
|
|
}
|
2015-05-12 21:21:26 -04:00
|
|
|
|
2015-09-09 22:23:06 -04:00
|
|
|
// parts returns the number of parts in the destination of a mount. Used in sorting.
|
|
|
|
func (m mounts) parts(i int) int {
|
|
|
|
return strings.Count(filepath.Clean(m[i].Destination), string(os.PathSeparator))
|
2015-05-12 21:21:26 -04:00
|
|
|
}
|
|
|
|
|
2015-09-09 22:23:06 -04:00
|
|
|
// registerMountPoints initializes the container mount points with the configured volumes and bind mounts.
|
|
|
|
// It follows the next sequence to decide what to mount in each final destination:
|
|
|
|
//
|
|
|
|
// 1. Select the previously configured mount points for the containers, if any.
|
|
|
|
// 2. Select the volumes mounted from another containers. Overrides previously configured mount point destination.
|
|
|
|
// 3. Select the bind mounts set by the client. Overrides previously configured mount point destinations.
|
2015-11-18 05:04:23 -05:00
|
|
|
// 4. Cleanup old volumes that are about to be reasigned.
|
2015-09-09 22:23:06 -04:00
|
|
|
func (daemon *Daemon) registerMountPoints(container *Container, hostConfig *runconfig.HostConfig) error {
|
|
|
|
binds := map[string]bool{}
|
|
|
|
mountPoints := map[string]*volume.MountPoint{}
|
|
|
|
|
|
|
|
// 1. Read already configured mount points.
|
|
|
|
for name, point := range container.MountPoints {
|
|
|
|
mountPoints[name] = point
|
2014-08-21 17:57:46 -04:00
|
|
|
}
|
|
|
|
|
2015-09-09 22:23:06 -04:00
|
|
|
// 2. Read volumes from other containers.
|
|
|
|
for _, v := range hostConfig.VolumesFrom {
|
|
|
|
containerID, mode, err := volume.ParseVolumesFrom(v)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2014-08-21 17:57:46 -04:00
|
|
|
|
2015-09-09 22:23:06 -04:00
|
|
|
c, err := daemon.Get(containerID)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
for _, m := range c.MountPoints {
|
|
|
|
cp := &volume.MountPoint{
|
|
|
|
Name: m.Name,
|
|
|
|
Source: m.Source,
|
|
|
|
RW: m.RW && volume.ReadWrite(mode),
|
|
|
|
Driver: m.Driver,
|
|
|
|
Destination: m.Destination,
|
|
|
|
}
|
|
|
|
|
|
|
|
if len(cp.Source) == 0 {
|
|
|
|
v, err := daemon.createVolume(cp.Name, cp.Driver, nil)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
cp.Volume = v
|
|
|
|
}
|
|
|
|
|
|
|
|
mountPoints[cp.Destination] = cp
|
|
|
|
}
|
2014-05-19 18:18:37 -04:00
|
|
|
}
|
2015-09-09 22:23:06 -04:00
|
|
|
|
|
|
|
// 3. Read bind mounts
|
|
|
|
for _, b := range hostConfig.Binds {
|
|
|
|
// #10618
|
|
|
|
bind, err := volume.ParseMountSpec(b, hostConfig.VolumeDriver)
|
2014-05-19 18:04:51 -04:00
|
|
|
if err != nil {
|
2014-03-18 18:28:40 -04:00
|
|
|
return err
|
2014-02-14 20:15:40 -05:00
|
|
|
}
|
2015-09-09 22:23:06 -04:00
|
|
|
|
|
|
|
if binds[bind.Destination] {
|
|
|
|
return derr.ErrorCodeVolumeDup.WithArgs(bind.Destination)
|
|
|
|
}
|
|
|
|
|
|
|
|
if len(bind.Name) > 0 && len(bind.Driver) > 0 {
|
|
|
|
// create the volume
|
|
|
|
v, err := daemon.createVolume(bind.Name, bind.Driver, nil)
|
|
|
|
if err != nil {
|
2014-02-14 20:15:40 -05:00
|
|
|
return err
|
|
|
|
}
|
2015-09-09 22:23:06 -04:00
|
|
|
bind.Volume = v
|
|
|
|
bind.Source = v.Path()
|
|
|
|
// bind.Name is an already existing volume, we need to use that here
|
|
|
|
bind.Driver = v.DriverName()
|
|
|
|
bind = setBindModeIfNull(bind)
|
|
|
|
}
|
2015-10-28 15:41:46 -04:00
|
|
|
if label.RelabelNeeded(bind.Mode) {
|
|
|
|
if err := label.Relabel(bind.Source, container.MountLabel, label.IsShared(bind.Mode)); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2014-02-14 20:15:40 -05:00
|
|
|
}
|
2015-09-09 22:23:06 -04:00
|
|
|
binds[bind.Destination] = true
|
|
|
|
mountPoints[bind.Destination] = bind
|
2014-05-19 18:18:37 -04:00
|
|
|
}
|
2015-06-12 09:25:32 -04:00
|
|
|
|
2015-09-09 22:23:06 -04:00
|
|
|
container.Lock()
|
2015-11-18 05:04:23 -05:00
|
|
|
|
|
|
|
// 4. Cleanup old volumes that are about to be reasigned.
|
|
|
|
for _, m := range mountPoints {
|
|
|
|
if m.BackwardsCompatible() {
|
|
|
|
if mp, exists := container.MountPoints[m.Destination]; exists && mp.Volume != nil {
|
|
|
|
daemon.volumes.Decrement(mp.Volume)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2015-09-09 22:23:06 -04:00
|
|
|
container.MountPoints = mountPoints
|
|
|
|
|
|
|
|
container.Unlock()
|
|
|
|
|
|
|
|
return nil
|
2015-06-12 09:25:32 -04:00
|
|
|
}
|