Container Manager Interface

container/lxc/lxc.go

 // Copyright 2013 Canonical Ltd.
 // Licensed under the AGPLv3, see LICENCE file for details.
 
 package lxc
 
 import (
         "fmt"
         "io/ioutil"
         "os"
         "os/exec"
@@ skipping 98 matching lines @@
                 createWithClone:   useClone,
                 useAUFS:           useAUFS,
                 backingFilesystem: backingFS,
         }, nil
 }
 
 func (manager *containerManager) StartContainer(instance instance.Instance) error {
         name := string(instance.Id())
         lxcContainer := LxcObjectFactory.New(name)
         // Create the cloud-init.
-        directory, err := container.NewDirectory(manager.name)
+        directory, err := container.NewDirectory(name)
         if err != nil {
                 return err
         }
         // Start the lxc container with the appropriate settings for grabbing the
         // console output and a log file.
         consoleFile := filepath.Join(directory, "console.log")
-        //lxcContainer.SetLogFile(filepath.Join(directory, "container.log"), golxc.LogDebug)
+        lxcContainer.SetLogFile(filepath.Join(directory, "container.log"), golxc.LogDebug)
         logger.Tracef("start the container")
         // We explicitly don't pass through the config file to the container.Start
         // method as we have passed it through at container creation time.  This
         // is necessary to get the appropriate rootfs reference without explicitly
         // setting it ourselves.
         if err = lxcContainer.Start("", consoleFile); err != nil {
                 logger.Errorf("container failed to start: %v", err)
                 return err
         }
         return nil
@@ skipping 91 matching lines @@
                 }
                 logger.Tracef("lxc container created")
         }
         if err := autostartContainer(name); err != nil {
                 return nil, nil, err
         }
         if err := mountHostLogDir(name, manager.logdir); err != nil {
                 return nil, nil, err
         }
 
-        manager.StartContainer(&lxcInstance{lxcContainer, name})
+        container := &lxcInstance{lxcContainer, name}
+
+        manager.StartContainer(container)
 
         arch := version.Current.Arch
         hardware := &instance.HardwareCharacteristics{
                 Arch: &arch,
         }
         logger.Tracef("container %q started: %v", name, time.Now().Sub(start))
-        return &lxcInstance{lxcContainer, name}, hardware, nil
+        return container, hardware, nil
 }
 
 func appendToContainerConfig(name, line string) error {
         file, err := os.OpenFile(
                 containerConfigFilename(name), os.O_RDWR|os.O_APPEND, 0644)
         if err != nil {
                 return err
         }
         defer file.Close()
         _, err = file.WriteString(line)
@@ skipping 137 matching lines @@
 // Newer versions don't do this, but instead have a config value inside the
 // lxc.conf file.
 func useRestartDir() bool {
         if _, err := os.Stat(LxcRestartDir); err != nil {
                 if os.IsNotExist(err) {
                         return false
                 }
         }
         return true
 }