// ContainerTypeFromId returns the container type if machineId is a container id, or "" // if machineId is not for a container. func ContainerTypeFromId(machineId string) instance.ContainerType { idParts := strings.Split(machineId, "/") if len(idParts) < 3 { return instance.ContainerType("") } return instance.ContainerType(idParts[len(idParts)-2]) }
// SetYAML is required to unmarshall a constraints.Value object // to ensure the container attribute is correctly handled when it is empty. // Because ContainerType is an alias for string, Go's reflect logic used in the // YAML decode determines that *string and *ContainerType are not assignable so // the container value of "" in the YAML is ignored. func (v *Value) SetYAML(tag string, value interface{}) bool { values, ok := value.(map[interface{}]interface{}) if !ok { return false } for k, val := range values { vstr := fmt.Sprintf("%v", val) var err error switch k { case Arch: v.Arch = &vstr case Container: ctype := instance.ContainerType(vstr) v.Container = &ctype case InstanceType: v.InstanceType = &vstr case CpuCores: v.CpuCores, err = parseUint64(vstr) case CpuPower: v.CpuPower, err = parseUint64(vstr) case Mem: v.Mem, err = parseUint64(vstr) case RootDisk: v.RootDisk, err = parseUint64(vstr) case Tags: v.Tags, err = parseYamlTags(val) default: return false } if err != nil { return false } } return true }
func (*factorySuite) TestNewContainerManager(c *gc.C) { for _, test := range []struct { containerType instance.ContainerType valid bool }{{ containerType: instance.LXC, valid: true, }, { containerType: instance.KVM, valid: true, }, { containerType: instance.NONE, valid: false, }, { containerType: instance.ContainerType("other"), valid: false, }} { conf := container.ManagerConfig{container.ConfigName: "test"} manager, err := factory.NewContainerManager(test.containerType, conf) if test.valid { c.Assert(err, gc.IsNil) c.Assert(manager, gc.NotNil) } else { c.Assert(err, gc.ErrorMatches, `unknown container type: ".*"`) c.Assert(manager, gc.IsNil) } } }
func (p *ProvisionerAPI) watchOneMachineContainers(arg params.WatchContainer) (params.StringsWatchResult, error) { nothing := params.StringsWatchResult{} canAccess, err := p.getAuthFunc() if err != nil { return nothing, err } if !canAccess(arg.MachineTag) { return nothing, common.ErrPerm } _, id, err := names.ParseTag(arg.MachineTag, names.MachineTagKind) if err != nil { return nothing, err } machine, err := p.st.Machine(id) if err != nil { return nothing, err } var watch state.StringsWatcher if arg.ContainerType != "" { watch = machine.WatchContainers(instance.ContainerType(arg.ContainerType)) } else { watch = machine.WatchAllContainers() } // Consume the initial event and forward it to the result. if changes, ok := <-watch.Changes(); ok { return params.StringsWatchResult{ StringsWatcherId: p.resources.Register(watch), Changes: changes, }, nil } return nothing, watcher.MustErr(watch) }
func (v *Value) setContainer(str string) error { if v.Container != nil { return fmt.Errorf("already set") } if str == "" { ctype := instance.ContainerType("") v.Container = &ctype } else { ctype, err := instance.ParseContainerTypeOrNone(str) if err != nil { return err } v.Container = &ctype } return nil }
func ctypep(ctype string) *instance.ContainerType { res := instance.ContainerType(ctype) return &res }
func (c *environConfig) container() instance.ContainerType { return instance.ContainerType(c.attrs["container"].(string)) }
// ContainerType returns the type of container hosting this machine. func (m *Machine) ContainerType() instance.ContainerType { return instance.ContainerType(m.doc.ContainerType) }
func (*lxcTest) TestUseFastLXCForContainer(c *gc.C) { c.Assert(local.UseFastLXC(instance.ContainerType("")), jc.IsFalse) c.Assert(local.UseFastLXC(instance.KVM), jc.IsFalse) }