// 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)
}
