func (r *Reboot) runningContainers() ([]instance.Instance, error) {
var runningInstances []instance.Instance
for _, val := range instance.ContainerTypes {
managerConfig := container.ManagerConfig{container.ConfigName: container.DefaultNamespace}
if namespace := r.acfg.Value(agent.Namespace); namespace != "" {
managerConfig[container.ConfigName] = namespace
}
cfg := container.ManagerConfig(managerConfig)
manager, err := factory.NewContainerManager(val, cfg, nil)
if err != nil {
return nil, errors.Annotatef(err, "failed to get manager for container type %v", val)
}
if !manager.IsInitialized() {
logger.Infof("container type %q not supported", val)
continue
}
instances, err := manager.ListContainers()
if err != nil {
return nil, errors.Annotate(err, "failed to list containers")
}
runningInstances = append(runningInstances, instances...)
}
return runningInstances, nil
}
func (r *Reboot) runningContainers() ([]instance.Instance, error) {
runningInstances := []instance.Instance{}
for _, val := range instance.ContainerTypes {
managerConfig := container.ManagerConfig{container.ConfigName: container.DefaultNamespace}
if namespace := r.acfg.Value(agent.Namespace); namespace != "" {
managerConfig[container.ConfigName] = namespace
}
cfg := container.ManagerConfig(managerConfig)
manager, err := factory.NewContainerManager(val, cfg, nil)
if err != nil {
logger.Warningf("Failed to get manager for container type %v: %v", val, err)
continue
}
if !manager.IsInitialized() {
continue
}
instances, err := manager.ListContainers()
if err != nil {
logger.Warningf("Failed to list containers: %v", err)
}
runningInstances = append(runningInstances, instances...)
}
return runningInstances, nil
}
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, nil)
if test.valid {
c.Assert(err, jc.ErrorIsNil)
c.Assert(manager, gc.NotNil)
} else {
c.Assert(err, gc.ErrorMatches, `unknown container type: ".*"`)
c.Assert(manager, gc.IsNil)
}
}
}
func (r *Reboot) runningContainers() ([]instance.Instance, error) {
var runningInstances []instance.Instance
modelUUID := r.acfg.Model().Id()
for _, val := range instance.ContainerTypes {
managerConfig := container.ManagerConfig{
container.ConfigModelUUID: modelUUID}
cfg := container.ManagerConfig(managerConfig)
manager, err := factory.NewContainerManager(val, cfg)
if err != nil {
return nil, errors.Annotatef(err, "failed to get manager for container type %v", val)
}
if !manager.IsInitialized() {
logger.Infof("container type %q not supported", val)
continue
}
instances, err := manager.ListContainers()
if err != nil {
return nil, errors.Annotate(err, "failed to list containers")
}
runningInstances = append(runningInstances, instances...)
}
return runningInstances, nil
}
func (*factorySuite) TestNewContainerManager(c *gc.C) {
for _, test := range []struct {
containerType instance.ContainerType
valid bool
}{{
containerType: instance.LXD,
valid: true,
}, {
containerType: instance.LXD,
valid: true,
}, {
containerType: instance.KVM,
valid: true,
}, {
containerType: instance.NONE,
valid: false,
}, {
containerType: instance.ContainerType("other"),
valid: false,
}} {
/* LXD isn't available in go 1.2 */
if test.containerType == instance.LXD && !lxd.HasLXDSupport() {
continue
}
conf := container.ManagerConfig{container.ConfigModelUUID: testing.ModelTag.Id()}
manager, err := factory.NewContainerManager(test.containerType, conf)
if test.valid {
c.Assert(err, jc.ErrorIsNil)
c.Assert(manager, gc.NotNil)
} else {
c.Assert(err, gc.ErrorMatches, `unknown container type: ".*"`)
c.Assert(manager, gc.IsNil)
}
}
}
// SetConfig is specified in the Environ interface.
func (env *localEnviron) SetConfig(cfg *config.Config) error {
ecfg, err := providerInstance.newConfig(cfg)
if err != nil {
logger.Errorf("failed to create new environ config: %v", err)
return errors.Trace(err)
}
env.localMutex.Lock()
defer env.localMutex.Unlock()
env.config = ecfg
env.name = ecfg.Name()
containerType := ecfg.container()
managerConfig := container.ManagerConfig{
container.ConfigName: env.config.namespace(),
container.ConfigLogDir: env.config.logDir(),
}
var imageURLGetter container.ImageURLGetter
if containerType == instance.LXC {
if useLxcClone, ok := cfg.LXCUseClone(); ok {
managerConfig["use-clone"] = fmt.Sprint(useLxcClone)
}
if useLxcCloneAufs, ok := cfg.LXCUseCloneAUFS(); ok {
managerConfig["use-aufs"] = fmt.Sprint(useLxcCloneAufs)
}
// For lxc containers, we cache image tarballs in the environment storage, so here
// we construct a URL getter.
if uuid, ok := ecfg.UUID(); ok {
var caCert []byte = nil
if cert, ok := cfg.CACert(); ok {
caCert = []byte(cert)
}
baseUrl := ecfg.CloudImageBaseURL()
imageURLGetter = container.NewImageURLGetter(
// Explicitly call the non-named constructor so if anyone
// adds additional fields, this fails.
container.ImageURLGetterConfig{
ecfg.stateServerAddr(), uuid, caCert, baseUrl,
container.ImageDownloadURL,
})
}
}
env.containerManager, err = factory.NewContainerManager(
containerType, managerConfig, imageURLGetter)
if err != nil {
return errors.Trace(err)
}
// When the localEnviron value is created on the client
// side, the bootstrap-ip attribute will not exist,
// because it is only set *within* the running
// environment, not in the configuration created by
// Prepare.
if addr := ecfg.bootstrapIPAddress(); addr != "" {
env.bridgeAddress = addr
return nil
}
// If we get to here, it is because we haven't yet bootstrapped an
// environment, and saved the config in it, or we are running a command
// from the command line, so it is ok to work on the assumption that we
// have direct access to the directories.
if err := env.config.createDirs(); err != nil {
return errors.Trace(err)
}
// Record the network bridge address and create a filestorage.
if err := env.resolveBridgeAddress(cfg); err != nil {
return errors.Trace(err)
}
return nil
}
