func getBindOptions(mode []string) *mount.BindOptions { for _, item := range mode { for _, propagation := range mount.Propagations { if mount.Propagation(item) == propagation { return &mount.BindOptions{Propagation: mount.Propagation(item)} } } } return nil }
// ValidMountMode will make sure the mount mode is valid. // returns if it's a valid mount mode or not. func ValidMountMode(mode string) bool { rwModeCount := 0 labelModeCount := 0 propagationModeCount := 0 copyModeCount := 0 for _, o := range strings.Split(mode, ",") { switch { case rwModes[o]: rwModeCount++ case labelModes[o]: labelModeCount++ case propagationModes[mounttypes.Propagation(o)]: propagationModeCount++ case copyModeExists(o): copyModeCount++ default: return false } } // Only one string for each mode is allowed. if rwModeCount > 1 || labelModeCount > 1 || propagationModeCount > 1 || copyModeCount > 1 { return false } return true }
func getBindOptions(mode []string) *mount.BindOptions { for _, item := range mode { if strings.Contains(item, "private") || strings.Contains(item, "shared") || strings.Contains(item, "slave") { return &mount.BindOptions{Propagation: mount.Propagation(item)} } } return nil }
// HasPropagation checks if there is a valid propagation mode present in // passed string. Returns true if a valid propagation mode specifier is // present, false otherwise. func HasPropagation(mode string) bool { for _, o := range strings.Split(mode, ",") { if propagationModes[mounttypes.Propagation(o)] { return true } } return false }
// GetPropagation extracts and returns the mount propagation mode. If there // are no specifications, then by default it is "private". func GetPropagation(mode string) mounttypes.Propagation { for _, o := range strings.Split(mode, ",") { prop := mounttypes.Propagation(o) if propagationModes[prop] { return prop } } return DefaultPropagationMode }
func containerSpecFromGRPC(c *swarmapi.ContainerSpec) types.ContainerSpec { containerSpec := types.ContainerSpec{ Image: c.Image, Labels: c.Labels, Command: c.Command, Args: c.Args, Hostname: c.Hostname, Env: c.Env, Dir: c.Dir, User: c.User, Groups: c.Groups, TTY: c.TTY, } // Mounts for _, m := range c.Mounts { mount := mounttypes.Mount{ Target: m.Target, Source: m.Source, Type: mounttypes.Type(strings.ToLower(swarmapi.Mount_MountType_name[int32(m.Type)])), ReadOnly: m.ReadOnly, } if m.BindOptions != nil { mount.BindOptions = &mounttypes.BindOptions{ Propagation: mounttypes.Propagation(strings.ToLower(swarmapi.Mount_BindOptions_MountPropagation_name[int32(m.BindOptions.Propagation)])), } } if m.VolumeOptions != nil { mount.VolumeOptions = &mounttypes.VolumeOptions{ NoCopy: m.VolumeOptions.NoCopy, Labels: m.VolumeOptions.Labels, } if m.VolumeOptions.DriverConfig != nil { mount.VolumeOptions.DriverConfig = &mounttypes.Driver{ Name: m.VolumeOptions.DriverConfig.Name, Options: m.VolumeOptions.DriverConfig.Options, } } } containerSpec.Mounts = append(containerSpec.Mounts, mount) } if c.StopGracePeriod != nil { grace, _ := ptypes.Duration(c.StopGracePeriod) containerSpec.StopGracePeriod = &grace } if c.Healthcheck != nil { containerSpec.Healthcheck = healthConfigFromGRPC(c.Healthcheck) } return containerSpec }
// Set a new mount value func (m *MountOpt) Set(value string) error { csvReader := csv.NewReader(strings.NewReader(value)) fields, err := csvReader.Read() if err != nil { return err } mount := mounttypes.Mount{} volumeOptions := func() *mounttypes.VolumeOptions { if mount.VolumeOptions == nil { mount.VolumeOptions = &mounttypes.VolumeOptions{ Labels: make(map[string]string), } } if mount.VolumeOptions.DriverConfig == nil { mount.VolumeOptions.DriverConfig = &mounttypes.Driver{} } return mount.VolumeOptions } bindOptions := func() *mounttypes.BindOptions { if mount.BindOptions == nil { mount.BindOptions = new(mounttypes.BindOptions) } return mount.BindOptions } setValueOnMap := func(target map[string]string, value string) { parts := strings.SplitN(value, "=", 2) if len(parts) == 1 { target[value] = "" } else { target[parts[0]] = parts[1] } } mount.Type = mounttypes.TypeVolume // default to volume mounts // Set writable as the default for _, field := range fields { parts := strings.SplitN(field, "=", 2) key := strings.ToLower(parts[0]) if len(parts) == 1 { switch key { case "readonly", "ro": mount.ReadOnly = true continue case "volume-nocopy": volumeOptions().NoCopy = true continue } } if len(parts) != 2 { return fmt.Errorf("invalid field '%s' must be a key=value pair", field) } value := parts[1] switch key { case "type": mount.Type = mounttypes.Type(strings.ToLower(value)) case "source", "src": mount.Source = value case "target", "dst", "destination": mount.Target = value case "readonly", "ro": mount.ReadOnly, err = strconv.ParseBool(value) if err != nil { return fmt.Errorf("invalid value for %s: %s", key, value) } case "bind-propagation": bindOptions().Propagation = mounttypes.Propagation(strings.ToLower(value)) case "volume-nocopy": volumeOptions().NoCopy, err = strconv.ParseBool(value) if err != nil { return fmt.Errorf("invalid value for populate: %s", value) } case "volume-label": setValueOnMap(volumeOptions().Labels, value) case "volume-driver": volumeOptions().DriverConfig.Name = value case "volume-opt": if volumeOptions().DriverConfig.Options == nil { volumeOptions().DriverConfig.Options = make(map[string]string) } setValueOnMap(volumeOptions().DriverConfig.Options, value) default: return fmt.Errorf("unexpected key '%s' in '%s'", key, field) } } if mount.Type == "" { return fmt.Errorf("type is required") } if mount.Target == "" { return fmt.Errorf("target is required") } if mount.VolumeOptions != nil && mount.Source == "" { return fmt.Errorf("source is required when specifying volume-* options") } if mount.Type == mounttypes.TypeBind && mount.VolumeOptions != nil { return fmt.Errorf("cannot mix 'volume-*' options with mount type '%s'", mounttypes.TypeBind) } if mount.Type == mounttypes.TypeVolume && mount.BindOptions != nil { return fmt.Errorf("cannot mix 'bind-*' options with mount type '%s'", mounttypes.TypeVolume) } m.values = append(m.values, mount) return nil }