golxc: add first container tests

golxc.go

 //
 // golxc - Go package to interact with Linux Containers (LXC).
 //
 // https://launchpad.net/golxc/
 //
 // Copyright (c) 2012 Canonical Ltd.
 //
 
 package golxc
 
 import (
-        "bytes"
         "fmt"
         "os"
         "os/exec"
         "strconv"
         "strings"
 )
+
+// Error reports the failure of a LXC command.
+type Error struct {
+        Name   string
+        Err    error
+        Output []string
+}
+
+func (e Error) Error() string {
+        if e.Output == nil {
+                return fmt.Sprintf("error executing %q: %v", e.Name, e.Err)
+        }
+        if len(e.Output) == 1 {
+                return fmt.Sprintf("error executing %q: %v", e.Name, e.Output[0])
+        }
+        return fmt.Sprintf("error executing %q: %s", e.Name, strings.Join(e.Output, "; "))
+}
 
 // State represents a container state.
 type State string
 
 const (
         StateUnknown  State = "UNKNOWN"
         StateStopped  State = "STOPPED"
         StateStarting State = "STARTING"
         StateRunning  State = "RUNNING"
         StateAborting State = "ABORTING"
@@ skipping 24 matching lines @@
 // New returns a container instance which can then be used for operations
 // like Create(), Start(), Stop() or Destroy().
 func New(name string) *Container {
         return &Container{
                 name: name,
         }
 }
 
 // List lists the existing containers on the system.
 func List() ([]*Container, error) {
-        outbuf, _, err := run("lxc-ls", "-1")
+        stdout, err := run("lxc-ls", "-1")
         if err != nil {
                 return nil, err
         }
-        names := nameSet(outbuf)
+        names := nameSet(stdout)
         containers := make([]*Container, len(names))
         for i, name := range names {
                 containers[i] = New(name)
         }
         return containers, nil
 }
 
 // Name returns the name of the container.
 func (c *Container) Name() string {
         return c.name
 }
 
 // Create creates a new container based on the given template.
 func (c *Container) Create(template string, tmplArgs ...string) error {
         if c.IsConstructed() {
-                return nil
+                return fmt.Errorf("container %q is already created", c.Name())
         }
         args := []string{
                 "-n", c.name,
                 "-t", template,
                 "--",
         }
         if len(tmplArgs) != 0 {
                 args = append(args, tmplArgs...)
         }
-        _, _, err := run("lxc-create", args...)
+        _, err := run("lxc-create", args...)
         if err != nil {
                 return err
         }
         return nil
 }
 
 // Start runs the container as a daemon.
 func (c *Container) Start(configFile, consoleFile string) error {
+        if !c.IsConstructed() {
+                return fmt.Errorf("container %q is not yet created", c.name)
+        }
         args := []string{
                 "--daemon",
                 "-n", c.name,
         }
         if configFile != "" {
                 args = append(args, "-f", configFile)
         }
         if consoleFile != "" {
                 args = append(args, "-c", consoleFile)
         }
         if c.LogFile != "" {
                 args = append(args, "-o", c.LogFile, "-l", string(c.LogLevel))
         }
-        _, _, err := run("lxc-start", args...)
+        _, err := run("lxc-start", args...)
         if err != nil {
                 return err
         }
         return c.Wait(StateRunning)
 }
 
 // Stop terminates the running container.
 func (c *Container) Stop() error {
+        if !c.IsConstructed() {
+                return fmt.Errorf("container %q is not yet created", c.name)
+        }
         args := []string{
                 "-n", c.name,
         }
         if c.LogFile != "" {
                 args = append(args, "-o", c.LogFile, "-l", string(c.LogLevel))
         }
-        _, _, err := run("lxc-stop", args...)
+        _, err := run("lxc-stop", args...)
         if err != nil {
                 return err
         }
         return c.Wait(StateStopped)
 }
 
 // Clone creates a copy of the container, it gets the given name.
 func (c *Container) Clone(name string) (*Container, error) {
         if !c.IsConstructed() {
                 return nil, fmt.Errorf("container %q is not yet created", c.name)
         }
         cc := &Container{
                 name: name,
         }
         if cc.IsConstructed() {
                 return cc, nil
         }
         args := []string{
                 "-o", c.name,
                 "-n", name,
         }
-        _, _, err := run("lxc-clone", args...)
+        _, err := run("lxc-clone", args...)
         if err != nil {
                 return nil, err
         }
         return cc, nil
 }
 
-// Freeze freezes all the container'ss processes.
+// Freeze freezes all the container's processes.
 func (c *Container) Freeze() error {
         if !c.IsConstructed() {
                 return fmt.Errorf("container %q is not yet created", c.name)
+        }
+        if !c.IsRunning() {
+                return fmt.Errorf("container %q is not running", c.name)
         }
         args := []string{
                 "-n", c.name,
         }
         if c.LogFile != "" {
                 args = append(args, "-o", c.LogFile, "-l", string(c.LogLevel))
         }
-        _, _, err := run("lxc-freeze", args...)
-        if err != nil {
-                return err
-        }
-        return nil
-}
-
-// Unfreeze thaws all a froozen container's processes.
+        _, err := run("lxc-freeze", args...)
+        if err != nil {
+                return err
+        }
+        return nil
+}
+
+// Unfreeze thaws all frozen container's processes.
 func (c *Container) Unfreeze() error {
         if !c.IsConstructed() {
                 return fmt.Errorf("container %q is not yet created", c.name)
+        }
+        if c.IsRunning() {
+                return fmt.Errorf("container %q is not frozen", c.name)
         }
         args := []string{
                 "-n", c.name,
         }
         if c.LogFile != "" {
                 args = append(args, "-o", c.LogFile, "-l", string(c.LogLevel))
         }
-        _, _, err := run("lxc-unfreeze", args...)
+        _, err := run("lxc-unfreeze", args...)
         if err != nil {
                 return err
         }
         return nil
 }
 
 // Destroy stops and removes the container.
 func (c *Container) Destroy() error {
         if !c.IsConstructed() {
                 return fmt.Errorf("container %q is not yet created", c.name)
         }
         if err := c.Stop(); err != nil {
                 return err
         }
-        _, _, err := run("lxc-destroy", "-n", c.name)
-        if err != nil {
-                return err
-        }
-        return nil
-}
-
-// Wait waits for the passed container states.
+        _, err := run("lxc-destroy", "-n", c.name)
+        if err != nil {
+                return err
+        }
+        return nil
+}
+
+// Wait waits for one of the specified container states.
 func (c *Container) Wait(states ...State) error {
+        if len(states) == 0 {
+                return fmt.Errorf("no states specified")
+        }
         stateStrs := make([]string, len(states))
         for i, state := range states {
                 stateStrs[i] = string(state)
         }
-        combinedStates := strings.Join(stateStrs, "|")
-        _, _, err := run("lxc-wait", "-n", c.name, "-s", combinedStates)

[fwereade, 2012/11/21 17:32:53]

I guess LXC will complain about impossible state combinations?

[TheMue, 2012/11/22 12:53:23]

To LXC there are no impossible combinations. It's an "or", so it waits until any
one of those states. But I renamed it to "waitStates" beside checking for the
case that no state is passed (which indeed is an error). Thx.

+        waitStates := strings.Join(stateStrs, "|")
+        _, err := run("lxc-wait", "-n", c.name, "-s", waitStates)
         if err != nil {
                 return err
         }
         return nil
 }
 
 // Info returns the status and the process id of the container.
 func (c *Container) Info() (State, int, error) {
-        stdout, _, err := run("lxc-info", "-n", c.name)
+        stdout, err := run("lxc-info", "-n", c.name)
         if err != nil {
                 return StateUnknown, -1, err
         }
         kv := keyValues(stdout, ": ")
         state := State(kv["state"])
         pid, err := strconv.Atoi(kv["pid"])
         if err != nil {
                 return StateUnknown, -1, fmt.Errorf("cannot read the pid: %v", err)
         }
         return state, pid, nil
@@ skipping 10 matching lines @@
 
 // IsRunning checks if the state of the container is 'RUNNING'.
 func (c *Container) IsRunning() bool {
         state, _, err := c.Info()
         if err != nil {
                 return false
         }
         return state == StateRunning
 }
 
-// String returns a short information about the container.

[fwereade, 2012/11/21 17:32:53]

s/a short/brief/

perhaps?

[TheMue, 2012/11/22 12:53:23]

Done.

+// String returns information about the container.
 func (c *Container) String() string {
         state, pid, err := c.Info()
         if err != nil {
                 return fmt.Sprintf("cannot retrieve container info for %q: %v", c.name, err)
         }
-        return fmt.Sprintf("container %q has state %q and pid %d", c.name, state, pid)
+        return fmt.Sprintf("container %q (%s, pid %d)", c.name, state, pid)
 }
 
 // containerHome returns the name of the container directory.
 func (c *Container) containerHome() string {
         return "/var/lib/lxc/" + c.name
 }
 
 // rootfs returns the name of the directory containing the
 // root filesystem of the container.
 func (c *Container) rootfs() string {
         return c.containerHome() + "/rootfs/"
 }
 
-// run executes the passed command and returns stdout and stderr.
-func run(c string, args ...string) (stdout, stderr string, err error) {
-        var outbuf bytes.Buffer
-        var errbuf bytes.Buffer
-        cmd := exec.Command(c, args...)
-        cmd.Stdout = &outbuf
-        cmd.Stderr = &errbuf
-        err = cmd.Run()
-        if err != nil {
-                if _, ok := err.(*exec.ExitError); !ok {
-                        return "", "", err
+// run executes the passed command and returns the output.
+func run(name string, args ...string) (string, error) {
+        cmd := exec.Command(name, args...)
+        output, err := cmd.CombinedOutput()
+        if err != nil {
+                return "", runError(name, err, output)
+        }
+        return string(output), nil
+}
+
+// runError creates an error if run fails.
+func runError(name string, err error, output []byte) error {
+        e := &Error{name, err, nil}
+        for _, l := range strings.Split(string(output), "\n") {
+                if strings.HasPrefix(l, name+": ") {
+                        l = l[len(name)+2:]
                 }
-        }
-        return outbuf.String(), errbuf.String(), err
+                if l != "" {
+                        e.Output = append(e.Output, l)
+                }
+        }
+        return e
 }
 
 // keyValues retrieves key/value pairs out of a command output.
 func keyValues(raw string, sep string) map[string]string {
         kv := map[string]string{}
         lines := strings.Split(raw, "\n")
         for _, line := range lines {
                 parts := strings.SplitN(line, sep, 2)
                 if len(parts) == 2 {
                         kv[parts[0]] = strings.TrimSpace(parts[1])
@@ skipping 11 matching lines @@
                 name := strings.TrimSpace(line)
                 if name != "" {
                         collector[name] = struct{}{}
                 }
         }
         for name := range collector {
                 set = append(set, name)
         }
         return set
 }