Container Manager Interface

container/kvm/container.go

 // Copyright 2013 Canonical Ltd.
 // Licensed under the AGPLv3, see LICENCE file for details.
 
 package kvm
 
 import (
         "fmt"
 
         "launchpad.net/juju-core/container"
         "launchpad.net/juju-core/log"
 )
 
+// KvmStatus is a cached status of the container
+type KvmStatus string
+
+const (
+        Unknown   KvmStatus = "unknown"
+        Stopped   KvmStatus = "stopped"
+        Running   KvmStatus = "running"
+        Destroyed KvmStatus = "destroyed"
+)
+
 type kvmContainer struct {
-        factory *containerFactory
-        name    string
-        // started is a three state boolean, true, false, or unknown
-        // this allows for checking when we don't know, but using a
-        // value if we already know it (like in the list situation).
-        started *bool
+        factory      *containerFactory
+        name         string
+        cachedStatus KvmStatus
 }
 
 var _ Container = (*kvmContainer)(nil)
 
 func (c *kvmContainer) Name() string {
         return c.name
 }
 
-func (c *kvmContainer) Start(params StartParams) error {
+func (c *kvmContainer) Create(params StartParams) error {
+        if c.Exists() {
+                logger.Debugf("%s already exists", c.name)
+                return nil
+        }
         logger.Debugf("Synchronise images for %s %s", params.Series, params.Arch)
         if err := SyncImages(params.Series, params.Arch); err != nil {
                 return err
         }
         var bridge string
         if params.Network != nil {
                 if params.Network.NetworkType == container.BridgeNetwork {
                         bridge = params.Network.Device
                 } else {
                         return log.LoggedErrorf(logger, "Non-bridge network devices not yet supported")
                 }
         }
         logger.Debugf("Create the machine %s", c.name)
         if err := CreateMachine(CreateMachineParams{
                 Hostname:      c.name,
                 Series:        params.Series,
                 Arch:          params.Arch,
                 UserDataFile:  params.UserDataFile,
                 NetworkBridge: bridge,
                 Memory:        params.Memory,
                 CpuCores:      params.CpuCores,
                 RootDisk:      params.RootDisk,
         }); err != nil {
+                c.cachedStatus = Unknown
                 return err
         }
-
+        c.cachedStatus = Running
         logger.Debugf("Set machine %s to autostart", c.name)
         return AutostartMachine(c.name)
 }
 
-func (c *kvmContainer) Stop() error {
-        if !c.IsRunning() {
-                logger.Debugf("%s is already stopped", c.name)
+func (c *kvmContainer) Destroy() error {
+        if !c.Exists() {
+                logger.Debugf("%s does not exist", c.name)
                 return nil
         }
-        // Make started state unknown again.
-        c.started = nil
-        logger.Debugf("Stop %s", c.name)
-        return DestroyMachine(c.name)
+        logger.Debugf("Destroy %s", c.name)
+        if err := DestroyMachine(c.name); err != nil {
+                c.cachedStatus = Unknown
+                return err
+        }
+        c.cachedStatus = Destroyed
+        return nil
+
 }
 
-func (c *kvmContainer) IsRunning() bool {
-        if c.started != nil {
-                return *c.started
+func (c *kvmContainer) Stop() error {
+        if c.Status() == Stopped {
+                logger.Debugf("%s is already Stopped", c.name)
+                return nil
         }
+        logger.Debugf("Stop %s", c.name)
+        if err := StopMachine(c.name); err != nil {
+                c.cachedStatus = Unknown
+                return err
+        }
+        c.cachedStatus = Stopped
+        return nil
+}
+
+func (c *kvmContainer) Start() error {
+        if c.Status() == Running {
+                logger.Debugf("%s is already Running", c.name)
+                return nil
+        }
+        logger.Debugf("start %s", c.name)
+        if err := StartMachine(c.name); err != nil {
+                c.cachedStatus = Unknown
+                return err
+        }
+        c.cachedStatus = Running
+        return nil
+}
+
+func (c *kvmContainer) Status() KvmStatus {
+        if c.cachedStatus == Unknown {
+                c.cachedStatus = GetStatusFromState(c.State())
+        }
+        return c.cachedStatus
+}
+
+func (c *kvmContainer) State() KvmState {
         machines, err := ListMachines()
         if err != nil {
-                return false
+                return KvmState("")
         }
-        c.started = isRunning(machines[c.name])
-        return *c.started
+        return KvmState(machines[c.name])
+}
+
+func (c *kvmContainer) Exists() bool {
+        return c.Status() == Running || c.Status() == Stopped
 }
 
 func (c *kvmContainer) String() string {
         return fmt.Sprintf("<KVM container %v>", *c)
 }