Merge lp:~wallyworld/golxc/support-cmd-env into lp:golxc

[Ian Booth]

Add support for passing environment variables to the container Create command. This can potentially be added to other commands too, but for now is just needed for Create().

Also, the gocheck import was out of date, so was updated.

Add support for passing environment variables to the container Create command. This can potentially be added to other commands too, but for now is just needed for Create().

Also, the gocheck import was out of date, so was updated.

[Andrew Wilkins (axwalk)]

LGTM with comments addressed.

review: Approve

[lp:~wallyworld/golxc/support-cmd-env]

14. By Ian Booth on 2014-11-21

Enahnce test

15. By Ian Booth on 2014-11-21

Improve comment

=== modified file 'golxc.go'
--- golxc.go	2014-07-30 01:57:14 +0000
+++ golxc.go	2014-11-21 03:15:57 +0000
@@ -70,7 +70,9 @@
 	Name() string
 
 	// Create creates a new container based on the given template.
-	Create(configFile, template string, extraArgs []string, templateArgs []string) error
+	// envArgs, if not nil, are assigned to the environment of the process, otherwise the
+	// environment of the current process is used.
+	Create(configFile, template string, extraArgs []string, templateArgs []string, envArgs []string) error
 
 	// Start runs the container as a daemon.
 	Start(configFile, consoleFile string) error
@@ -157,7 +159,7 @@
 
 // List returns all the existing containers on the system.
 func (factory *containerFactory) List() ([]Container, error) {
-	out, err := run("lxc-ls", "-1")
+	out, err := run("lxc-ls", nil, "-1")
 	if err != nil {
 		return nil, err
 	}
@@ -192,7 +194,7 @@
 }
 
 // Create creates a new container based on the given template.
-func (c *container) Create(configFile, template string, extraArgs []string, templateArgs []string) error {
+func (c *container) Create(configFile, template string, extraArgs []string, templateArgs []string, envArgs []string) error {
 	if c.IsConstructed() {
 		return fmt.Errorf("container %q is already created", c.Name())
 	}
@@ -212,7 +214,7 @@
 		args = append(args, "--")
 		args = append(args, templateArgs...)
 	}
-	_, err := run("lxc-create", args...)
+	_, err := run("lxc-create", envArgs, args...)
 	if err != nil {
 		return err
 	}
@@ -238,11 +240,11 @@
 	if consoleFile != "" {
 		startArgs = append(args, "--console-log", consoleFile)
 	}
-	_, err := run("lxc-start", startArgs...)
+	_, err := run("lxc-start", nil, startArgs...)
 	// We may need to fallback to the older --console arg name.
 	if err != nil && consoleFile != "" {
 		startArgs = append(args, "--console", consoleFile)
-		_, err = run("lxc-start", startArgs...)
+		_, err = run("lxc-start", nil, startArgs...)
 	}
 	if err != nil {
 		return err
@@ -271,7 +273,7 @@
 	if c.logFile != "" {
 		args = append(args, "--logfile", c.logFile, "--logpriority", string(c.logLevel))
 	}
-	_, err := run("lxc-stop", args...)
+	_, err := run("lxc-stop", nil, args...)
 	if err != nil {
 		return err
 	}
@@ -306,7 +308,7 @@
 		args = append(args, "--")
 		args = append(args, templateArgs...)
 	}
-	_, err := run("lxc-clone", args...)
+	_, err := run("lxc-clone", nil, args...)
 	if err != nil {
 		return nil, err
 	}
@@ -327,7 +329,7 @@
 	if c.logFile != "" {
 		args = append(args, "--logfile", c.logFile, "--logpriority", string(c.logLevel))
 	}
-	_, err := run("lxc-freeze", args...)
+	_, err := run("lxc-freeze", nil, args...)
 	if err != nil {
 		return err
 	}
@@ -348,7 +350,7 @@
 	if c.logFile != "" {
 		args = append(args, "--logfile", c.logFile, "--logpriority", string(c.logLevel))
 	}
-	_, err := run("lxc-unfreeze", args...)
+	_, err := run("lxc-unfreeze", nil, args...)
 	if err != nil {
 		return err
 	}
@@ -363,7 +365,7 @@
 	if err := c.Stop(); err != nil {
 		return err
 	}
-	_, err := run("lxc-destroy", "-n", c.name)
+	_, err := run("lxc-destroy", nil, "-n", c.name)
 	if err != nil {
 		return err
 	}
@@ -380,7 +382,7 @@
 		stateStrs[i] = string(state)
 	}
 	waitStates := strings.Join(stateStrs, "|")
-	_, err := run("lxc-wait", "--name", c.name, "--state", waitStates)
+	_, err := run("lxc-wait", nil, "--name", c.name, "--state", waitStates)
 	if err != nil {
 		return err
 	}
@@ -389,7 +391,7 @@
 
 // Info returns the status and the process id of the container.
 func (c *container) Info() (State, int, error) {
-	out, err := run("lxc-info", "--name", c.name)
+	out, err := run("lxc-info", nil, "--name", c.name)
 	if err != nil {
 		return StateUnknown, -1, err
 	}
@@ -441,10 +443,11 @@
 }
 
 // run executes the passed command and returns the out.
-func run(name string, args ...string) (string, error) {
+func run(name string, env []string, args ...string) (string, error) {
 	logger := loggo.GetLogger(fmt.Sprintf("golxc.run.%s", name))
 	logger.Tracef("run: %s %v", name, args)
 	cmd := exec.Command(name, args...)
+	cmd.Env = env
 	// LXC tools do not use stdout and stderr in a predictable
 	// way; based on experimentation, the most convenient
 	// solution is to combine them and leave the client to
@@ -510,7 +513,7 @@
 // GetDefaultLXCContainerDir returns the current lxc.lxcpath value otherwise
 // the const DefaultLXCDir is returned.
 func GetDefaultLXCContainerDir() string {
-	result, err := run("lxc-config", "lxc.lxcpath")
+	result, err := run("lxc-config", nil, "lxc.lxcpath")
 
 	if err != nil {
 		return DefaultLXCDir
 
=== modified file 'golxc_test.go'
--- golxc_test.go	2014-07-30 01:57:14 +0000
+++ golxc_test.go	2014-11-21 03:15:57 +0000
@@ -11,7 +11,7 @@
 
 	"github.com/juju/testing"
 	jc "github.com/juju/testing/checkers"
-	. "launchpad.net/gocheck"
+	gc "gopkg.in/check.v1"
 
 	"launchpad.net/golxc"
 )
@@ -52,154 +52,154 @@
 
 type ConfigSuite struct{}
 
-var _ = Suite(&ConfigSuite{})
+var _ = gc.Suite(&ConfigSuite{})
 
-func (s *ConfigSuite) TestReadConf(c *C) {
+func (s *ConfigSuite) TestReadConf(c *gc.C) {
 	// Test reading the configuration.
 	cf := filepath.Join(c.MkDir(), "lxc-test")
-	c.Assert(ioutil.WriteFile(cf, []byte(lxcfile), 0555), IsNil)
+	c.Assert(ioutil.WriteFile(cf, []byte(lxcfile), 0555), gc.IsNil)
 
 	defer golxc.SetConfPath(golxc.SetConfPath(cf))
 
 	conf, err := golxc.ReadConf()
-	c.Assert(err, IsNil)
-	c.Assert(conf, DeepEquals, lxcconf)
+	c.Assert(err, gc.IsNil)
+	c.Assert(conf, gc.DeepEquals, lxcconf)
 }
 
-func (s *ConfigSuite) TestReadNotExistingDefaultEnvironment(c *C) {
+func (s *ConfigSuite) TestReadNotExistingDefaultEnvironment(c *gc.C) {
 	// Test reading a not existing environment.
 	defer golxc.SetConfPath(golxc.SetConfPath(filepath.Join(c.MkDir(), "foo")))
 
 	_, err := golxc.ReadConf()
-	c.Assert(err, ErrorMatches, "open .*: no such file or directory")
+	c.Assert(err, gc.ErrorMatches, "open .*: no such file or directory")
 }
 
-func (s *ConfigSuite) TestNetworkAttributes(c *C) {
+func (s *ConfigSuite) TestNetworkAttributes(c *gc.C) {
 	// Test reading the network attribute form an environment.
 	cf := filepath.Join(c.MkDir(), "lxc-test")
-	c.Assert(ioutil.WriteFile(cf, []byte(lxcfile), 0555), IsNil)
+	c.Assert(ioutil.WriteFile(cf, []byte(lxcfile), 0555), gc.IsNil)
 
 	defer golxc.SetConfPath(golxc.SetConfPath(cf))
 
 	addr, bridge, err := golxc.NetworkAttributes()
-	c.Assert(err, IsNil)
-	c.Assert(addr, Equals, "10.0.9.1")
-	c.Assert(bridge, Equals, "lxcbr9")
+	c.Assert(err, gc.IsNil)
+	c.Assert(addr, gc.Equals, "10.0.9.1")
+	c.Assert(bridge, gc.Equals, "lxcbr9")
 }
 
 type NetworkSuite struct{}
 
-var _ = Suite(&NetworkSuite{})
+var _ = gc.Suite(&NetworkSuite{})
 
-func (s *NetworkSuite) SetUpSuite(c *C) {
+func (s *NetworkSuite) SetUpSuite(c *gc.C) {
 	u, err := user.Current()
-	c.Assert(err, IsNil)
+	c.Assert(err, gc.IsNil)
 	if u.Uid != "0" {
 		// Has to be run as root!
 		c.Skip("tests must run as root")
 	}
 }
 
-func (s *NetworkSuite) TestStartStopNetwork(c *C) {
+func (s *NetworkSuite) TestStartStopNetwork(c *gc.C) {
 	// Test starting and stoping of the LXC network.
 	initialRunning, err := golxc.IsNetworkRunning()
-	c.Assert(err, IsNil)
+	c.Assert(err, gc.IsNil)
 	defer func() {
 		if initialRunning {
-			c.Assert(golxc.StartNetwork(), IsNil)
+			c.Assert(golxc.StartNetwork(), gc.IsNil)
 		}
 	}()
-	c.Assert(golxc.StartNetwork(), IsNil)
+	c.Assert(golxc.StartNetwork(), gc.IsNil)
 	running, err := golxc.IsNetworkRunning()
-	c.Assert(err, IsNil)
-	c.Assert(running, Equals, true)
-	c.Assert(golxc.StopNetwork(), IsNil)
+	c.Assert(err, gc.IsNil)
+	c.Assert(running, gc.Equals, true)
+	c.Assert(golxc.StopNetwork(), gc.IsNil)
 	running, err = golxc.IsNetworkRunning()
-	c.Assert(err, IsNil)
-	c.Assert(running, Equals, false)
+	c.Assert(err, gc.IsNil)
+	c.Assert(running, gc.Equals, false)
 }
 
-func (s *NetworkSuite) TestNotExistingNetworkAttributes(c *C) {
+func (s *NetworkSuite) TestNotExistingNetworkAttributes(c *gc.C) {
 	// Test reading of network attributes from a not existing environment.
 	defer golxc.SetConfPath(golxc.SetConfPath(filepath.Join(c.MkDir(), "foo")))
 
 	_, _, err := golxc.NetworkAttributes()
-	c.Assert(err, ErrorMatches, "open .*: no such file or directory")
+	c.Assert(err, gc.ErrorMatches, "open .*: no such file or directory")
 }
 
 type LXCSuite struct {
 	factory golxc.ContainerFactory
 }
 
-var _ = Suite(&LXCSuite{golxc.Factory()})
+var _ = gc.Suite(&LXCSuite{golxc.Factory()})
 
-func (s *LXCSuite) SetUpSuite(c *C) {
+func (s *LXCSuite) SetUpSuite(c *gc.C) {
 	u, err := user.Current()
-	c.Assert(err, IsNil)
+	c.Assert(err, gc.IsNil)
 	if u.Uid != "0" {
 		// Has to be run as root!
 		c.Skip("tests must run as root")
 	}
 }
 
-func (s *LXCSuite) createContainer(c *C) golxc.Container {
+func (s *LXCSuite) createContainer(c *gc.C) golxc.Container {
 	container := s.factory.New("golxc")
-	c.Assert(container.IsConstructed(), Equals, false)
-	err := container.Create("", "ubuntu", nil, nil)
-	c.Assert(err, IsNil)
-	c.Assert(container.IsConstructed(), Equals, true)
+	c.Assert(container.IsConstructed(), gc.Equals, false)
+	err := container.Create("", "ubuntu", nil, nil, nil)
+	c.Assert(err, gc.IsNil)
+	c.Assert(container.IsConstructed(), gc.Equals, true)
 	return container
 }
 
-func (s *LXCSuite) TestCreateDestroy(c *C) {
+func (s *LXCSuite) TestCreateDestroy(c *gc.C) {
 	// Test clean creation and destroying of a container.
 	lc := s.factory.New("golxc")
-	c.Assert(lc.IsConstructed(), Equals, false)
+	c.Assert(lc.IsConstructed(), gc.Equals, false)
 	home := golxc.ContainerHome(lc)
 	_, err := os.Stat(home)
-	c.Assert(err, ErrorMatches, "stat .*: no such file or directory")
-	err = lc.Create("", "ubuntu", nil, nil)
-	c.Assert(err, IsNil)
-	c.Assert(lc.IsConstructed(), Equals, true)
+	c.Assert(err, gc.ErrorMatches, "stat .*: no such file or directory")
+	err = lc.Create("", "ubuntu", nil, nil, nil)
+	c.Assert(err, gc.IsNil)
+	c.Assert(lc.IsConstructed(), gc.Equals, true)
 	defer func() {
 		err = lc.Destroy()
-		c.Assert(err, IsNil)
+		c.Assert(err, gc.IsNil)
 		_, err = os.Stat(home)
-		c.Assert(err, ErrorMatches, "stat .*: no such file or directory")
+		c.Assert(err, gc.ErrorMatches, "stat .*: no such file or directory")
 	}()
 	fi, err := os.Stat(golxc.ContainerHome(lc))
-	c.Assert(err, IsNil)
-	c.Assert(fi.IsDir(), Equals, true)
+	c.Assert(err, gc.IsNil)
+	c.Assert(fi.IsDir(), gc.Equals, true)
 }
 
-func (s *LXCSuite) TestCreateTwice(c *C) {
+func (s *LXCSuite) TestCreateTwice(c *gc.C) {
 	// Test that a container cannot be created twice.
 	lc1 := s.createContainer(c)
-	c.Assert(lc1.IsConstructed(), Equals, true)
+	c.Assert(lc1.IsConstructed(), gc.Equals, true)
 	defer func() {
-		c.Assert(lc1.Destroy(), IsNil)
+		c.Assert(lc1.Destroy(), gc.IsNil)
 	}()
 	lc2 := s.factory.New("golxc")
-	err := lc2.Create("", "ubuntu", nil, nil)
-	c.Assert(err, ErrorMatches, "container .* is already created")
+	err := lc2.Create("", "ubuntu", nil, nil, nil)
+	c.Assert(err, gc.ErrorMatches, "container .* is already created")
 }
 
-func (s *LXCSuite) TestCreateIllegalTemplate(c *C) {
+func (s *LXCSuite) TestCreateIllegalTemplate(c *gc.C) {
 	// Test that a container creation fails correctly in
 	// case of an illegal template.
 	lc := s.factory.New("golxc")
-	c.Assert(lc.IsConstructed(), Equals, false)
-	err := lc.Create("", "name-of-a-not-existing-template-for-golxc", nil, nil)
-	c.Assert(err, ErrorMatches, `error executing "lxc-create": .*bad template.*`)
-	c.Assert(lc.IsConstructed(), Equals, false)
+	c.Assert(lc.IsConstructed(), gc.Equals, false)
+	err := lc.Create("", "name-of-a-not-existing-template-for-golxc", nil, nil, nil)
+	c.Assert(err, gc.ErrorMatches, `error executing "lxc-create": .*bad template.*`)
+	c.Assert(lc.IsConstructed(), gc.Equals, false)
 }
 
-func (s *LXCSuite) TestDestroyNotCreated(c *C) {
+func (s *LXCSuite) TestDestroyNotCreated(c *gc.C) {
 	// Test that a non-existing container can't be destroyed.
 	lc := s.factory.New("golxc")
-	c.Assert(lc.IsConstructed(), Equals, false)
+	c.Assert(lc.IsConstructed(), gc.Equals, false)
 	err := lc.Destroy()
-	c.Assert(err, ErrorMatches, "container .* is not yet created")
+	c.Assert(err, gc.ErrorMatches, "container .* is not yet created")
 }
 
 func contains(lcs []golxc.Container, lc golxc.Container) bool {
@@ -211,148 +211,148 @@
 	return false
 }
 
-func (s *LXCSuite) TestList(c *C) {
+func (s *LXCSuite) TestList(c *gc.C) {
 	// Test the listing of created containers.
 	lcs, err := s.factory.List()
 	oldLen := len(lcs)
-	c.Assert(err, IsNil)
-	c.Assert(oldLen >= 0, Equals, true)
+	c.Assert(err, gc.IsNil)
+	c.Assert(oldLen >= 0, gc.Equals, true)
 	lc := s.createContainer(c)
 	defer func() {
-		c.Assert(lc.Destroy(), IsNil)
+		c.Assert(lc.Destroy(), gc.IsNil)
 	}()
 	lcs, _ = s.factory.List()
 	newLen := len(lcs)
-	c.Assert(newLen == oldLen+1, Equals, true)
-	c.Assert(contains(lcs, lc), Equals, true)
+	c.Assert(newLen == oldLen+1, gc.Equals, true)
+	c.Assert(contains(lcs, lc), gc.Equals, true)
 }
 
-func (s *LXCSuite) TestClone(c *C) {
+func (s *LXCSuite) TestClone(c *gc.C) {
 	// Test the cloning of an existing container.
 	lc1 := s.createContainer(c)
 	defer func() {
-		c.Assert(lc1.Destroy(), IsNil)
+		c.Assert(lc1.Destroy(), gc.IsNil)
 	}()
 	lcs, _ := s.factory.List()
 	oldLen := len(lcs)
 	lc2, err := lc1.Clone("golxcclone", nil, nil)
-	c.Assert(err, IsNil)
-	c.Assert(lc2.IsConstructed(), Equals, true)
+	c.Assert(err, gc.IsNil)
+	c.Assert(lc2.IsConstructed(), gc.Equals, true)
 	defer func() {
-		c.Assert(lc2.Destroy(), IsNil)
+		c.Assert(lc2.Destroy(), gc.IsNil)
 	}()
 	lcs, _ = s.factory.List()
 	newLen := len(lcs)
-	c.Assert(newLen == oldLen+1, Equals, true)
-	c.Assert(contains(lcs, lc1), Equals, true)
-	c.Assert(contains(lcs, lc2), Equals, true)
+	c.Assert(newLen == oldLen+1, gc.Equals, true)
+	c.Assert(contains(lcs, lc1), gc.Equals, true)
+	c.Assert(contains(lcs, lc2), gc.Equals, true)
 }
 
-func (s *LXCSuite) TestCloneNotCreated(c *C) {
+func (s *LXCSuite) TestCloneNotCreated(c *gc.C) {
 	// Test the cloning of a non-existing container.
 	lc := s.factory.New("golxc")
-	c.Assert(lc.IsConstructed(), Equals, false)
+	c.Assert(lc.IsConstructed(), gc.Equals, false)
 	_, err := lc.Clone("golxcclone", nil, nil)
-	c.Assert(err, ErrorMatches, "container .* is not yet created")
+	c.Assert(err, gc.ErrorMatches, "container .* is not yet created")
 }
 
-func (s *LXCSuite) TestStartStop(c *C) {
+func (s *LXCSuite) TestStartStop(c *gc.C) {
 	// Test starting and stopping a container.
 	lc := s.createContainer(c)
 	defer func() {
-		c.Assert(lc.Destroy(), IsNil)
+		c.Assert(lc.Destroy(), gc.IsNil)
 	}()
-	c.Assert(lc.Start("", ""), IsNil)
-	c.Assert(lc.IsRunning(), Equals, true)
-	c.Assert(lc.Stop(), IsNil)
-	c.Assert(lc.IsRunning(), Equals, false)
+	c.Assert(lc.Start("", ""), gc.IsNil)
+	c.Assert(lc.IsRunning(), gc.Equals, true)
+	c.Assert(lc.Stop(), gc.IsNil)
+	c.Assert(lc.IsRunning(), gc.Equals, false)
 }
 
-func (s *LXCSuite) TestStartNotCreated(c *C) {
+func (s *LXCSuite) TestStartNotCreated(c *gc.C) {
 	// Test that a non-existing container can't be started.
 	lc := s.factory.New("golxc")
-	c.Assert(lc.IsConstructed(), Equals, false)
-	c.Assert(lc.Start("", ""), ErrorMatches, "container .* is not yet created")
+	c.Assert(lc.IsConstructed(), gc.Equals, false)
+	c.Assert(lc.Start("", ""), gc.ErrorMatches, "container .* is not yet created")
 }
 
-func (s *LXCSuite) TestStopNotRunning(c *C) {
+func (s *LXCSuite) TestStopNotRunning(c *gc.C) {
 	// Test that a not running container can't be stopped.
 	lc := s.createContainer(c)
 	defer func() {
-		c.Assert(lc.Destroy(), IsNil)
+		c.Assert(lc.Destroy(), gc.IsNil)
 	}()
-	c.Assert(lc.Stop(), IsNil)
+	c.Assert(lc.Stop(), gc.IsNil)
 }
 
-func (s *LXCSuite) TestWait(c *C) {
+func (s *LXCSuite) TestWait(c *gc.C) {
 	// Test waiting for one of a number of states of a container.
 	// ATTN: Using a not reached state blocks the test until timeout!
 	lc := s.factory.New("golxc")
-	c.Assert(lc.IsConstructed(), Equals, false)
-	c.Assert(lc.Wait(), ErrorMatches, "no states specified")
-	c.Assert(lc.Wait(golxc.StateStopped), IsNil)
-	c.Assert(lc.Wait(golxc.StateStopped, golxc.StateRunning), IsNil)
-	c.Assert(lc.Create("", "ubuntu", nil, nil), IsNil)
+	c.Assert(lc.IsConstructed(), gc.Equals, false)
+	c.Assert(lc.Wait(), gc.ErrorMatches, "no states specified")
+	c.Assert(lc.Wait(golxc.StateStopped), gc.IsNil)
+	c.Assert(lc.Wait(golxc.StateStopped, golxc.StateRunning), gc.IsNil)
+	c.Assert(lc.Create("", "ubuntu", nil, nil, nil), gc.IsNil)
 	defer func() {
-		c.Assert(lc.Destroy(), IsNil)
+		c.Assert(lc.Destroy(), gc.IsNil)
 	}()
 	go func() {
-		c.Assert(lc.Start("", ""), IsNil)
+		c.Assert(lc.Start("", ""), gc.IsNil)
 	}()
-	c.Assert(lc.Wait(golxc.StateRunning), IsNil)
+	c.Assert(lc.Wait(golxc.StateRunning), gc.IsNil)
 }
 
-func (s *LXCSuite) TestFreezeUnfreeze(c *C) {
+func (s *LXCSuite) TestFreezeUnfreeze(c *gc.C) {
 	// Test the freezing and unfreezing of a started container.
 	lc := s.createContainer(c)
 	defer func() {
-		c.Assert(lc.Destroy(), IsNil)
+		c.Assert(lc.Destroy(), gc.IsNil)
 	}()
-	c.Assert(lc.Start("", ""), IsNil)
+	c.Assert(lc.Start("", ""), gc.IsNil)
 	defer func() {
-		c.Assert(lc.Stop(), IsNil)
+		c.Assert(lc.Stop(), gc.IsNil)
 	}()
-	c.Assert(lc.IsRunning(), Equals, true)
-	c.Assert(lc.Freeze(), IsNil)
-	c.Assert(lc.IsRunning(), Equals, false)
-	c.Assert(lc.Unfreeze(), IsNil)
-	c.Assert(lc.IsRunning(), Equals, true)
+	c.Assert(lc.IsRunning(), gc.Equals, true)
+	c.Assert(lc.Freeze(), gc.IsNil)
+	c.Assert(lc.IsRunning(), gc.Equals, false)
+	c.Assert(lc.Unfreeze(), gc.IsNil)
+	c.Assert(lc.IsRunning(), gc.Equals, true)
 }
 
-func (s *LXCSuite) TestFreezeNotStarted(c *C) {
+func (s *LXCSuite) TestFreezeNotStarted(c *gc.C) {
 	// Test that a not running container can't be frozen.
 	lc := s.createContainer(c)
 	defer func() {
-		c.Assert(lc.Destroy(), IsNil)
+		c.Assert(lc.Destroy(), gc.IsNil)
 	}()
-	c.Assert(lc.Freeze(), ErrorMatches, "container .* is not running")
+	c.Assert(lc.Freeze(), gc.ErrorMatches, "container .* is not running")
 }
 
-func (s *LXCSuite) TestFreezeNotCreated(c *C) {
+func (s *LXCSuite) TestFreezeNotCreated(c *gc.C) {
 	// Test that a non-existing container can't be frozen.
 	lc := s.factory.New("golxc")
-	c.Assert(lc.IsConstructed(), Equals, false)
-	c.Assert(lc.Freeze(), ErrorMatches, "container .* is not yet created")
+	c.Assert(lc.IsConstructed(), gc.Equals, false)
+	c.Assert(lc.Freeze(), gc.ErrorMatches, "container .* is not yet created")
 }
 
-func (s *LXCSuite) TestUnfreezeNotCreated(c *C) {
+func (s *LXCSuite) TestUnfreezeNotCreated(c *gc.C) {
 	// Test that a non-existing container can't be unfrozen.
 	lc := s.factory.New("golxc")
-	c.Assert(lc.IsConstructed(), Equals, false)
-	c.Assert(lc.Unfreeze(), ErrorMatches, "container .* is not yet created")
+	c.Assert(lc.IsConstructed(), gc.Equals, false)
+	c.Assert(lc.Unfreeze(), gc.ErrorMatches, "container .* is not yet created")
 }
 
-func (s *LXCSuite) TestUnfreezeNotFrozen(c *C) {
+func (s *LXCSuite) TestUnfreezeNotFrozen(c *gc.C) {
 	// Test that a running container can't be unfrozen.
 	lc := s.createContainer(c)
 	defer func() {
-		c.Assert(lc.Destroy(), IsNil)
+		c.Assert(lc.Destroy(), gc.IsNil)
 	}()
-	c.Assert(lc.Start("", ""), IsNil)
+	c.Assert(lc.Start("", ""), gc.IsNil)
 	defer func() {
-		c.Assert(lc.Stop(), IsNil)
+		c.Assert(lc.Stop(), gc.IsNil)
 	}()
-	c.Assert(lc.Unfreeze(), ErrorMatches, "container .* is not frozen")
+	c.Assert(lc.Unfreeze(), gc.ErrorMatches, "container .* is not frozen")
 }
 
 type commandArgs struct {
@@ -360,20 +360,20 @@
 	originalPath string
 }
 
-var _ = Suite(&commandArgs{})
+var _ = gc.Suite(&commandArgs{})
 
-func (s *commandArgs) SetUpSuite(c *C) {
+func (s *commandArgs) SetUpSuite(c *gc.C) {
 	// lxc-create requires the PATH to be set.
 	s.originalPath = os.Getenv("PATH")
 	s.IsolationSuite.SetUpSuite(c)
 }
 
-func (s *commandArgs) setupLxcStart(c *C) {
+func (s *commandArgs) setupLxcStart(c *gc.C) {
 	dir := c.MkDir()
 	// Make the rootfs for the "test" container so it thinks it is created.
 	rootfs := filepath.Join(dir, "test", "rootfs")
 	err := os.MkdirAll(rootfs, 0755)
-	c.Assert(err, IsNil)
+	c.Assert(err, gc.IsNil)
 	c.Assert(rootfs, jc.IsDirectory)
 
 	s.PatchValue(&golxc.ContainerDir, dir)
@@ -384,12 +384,12 @@
 	testing.PatchExecutable(c, s, "lxc-info", "#!/bin/sh\necho '"+info+"'\n")
 }
 
-func (s *commandArgs) TestStartArgs(c *C) {
+func (s *commandArgs) TestStartArgs(c *gc.C) {
 	s.setupLxcStart(c)
 	factory := golxc.Factory()
 	container := factory.New("test")
 	err := container.Start("config-file", "console-log")
-	c.Assert(err, IsNil)
+	c.Assert(err, gc.IsNil)
 	testing.AssertEchoArgs(
 		c, "lxc-start",
 		"--daemon",
@@ -398,12 +398,12 @@
 		"--console-log", "console-log")
 }
 
-func (s *commandArgs) TestStartArgsNoConsoleLog(c *C) {
+func (s *commandArgs) TestStartArgsNoConsoleLog(c *gc.C) {
 	s.setupLxcStart(c)
 	factory := golxc.Factory()
 	container := factory.New("test")
 	err := container.Start("config-file", "")
-	c.Assert(err, IsNil)
+	c.Assert(err, gc.IsNil)
 	testing.AssertEchoArgs(
 		c, "lxc-start",
 		"--daemon",
@@ -411,12 +411,12 @@
 		"--rcfile", "config-file")
 }
 
-func (s *commandArgs) TestStartArgsFallback(c *C) {
+func (s *commandArgs) TestStartArgsFallback(c *gc.C) {
 	dir := c.MkDir()
 	// Make the rootfs for the "test" container so it thinks it is created.
 	rootfs := filepath.Join(dir, "test", "rootfs")
 	err := os.MkdirAll(rootfs, 0755)
-	c.Assert(err, IsNil)
+	c.Assert(err, gc.IsNil)
 	c.Assert(rootfs, jc.IsDirectory)
 
 	s.PatchValue(&golxc.ContainerDir, dir)
@@ -442,7 +442,7 @@
 	factory := golxc.Factory()
 	container := factory.New("test")
 	err = container.Start("config-file", "console-log")
-	c.Assert(err, IsNil)
+	c.Assert(err, gc.IsNil)
 	testing.AssertEchoArgs(
 		c, "lxc-start",
 		"--daemon",
@@ -451,7 +451,7 @@
 		"--console", "console-log")
 }
 
-func (s *commandArgs) TestCreateArgs(c *C) {
+func (s *commandArgs) TestCreateArgs(c *gc.C) {
 	s.PatchValue(&golxc.ContainerDir, c.MkDir())
 	s.PatchEnvironment("PATH", s.originalPath)
 	testing.PatchExecutableAsEchoArgs(c, s, "lxc-create")
@@ -462,8 +462,9 @@
 		"config-file", "template",
 		[]string{"extra-1", "extra-2"},
 		[]string{"template-1", "template-2"},
+		nil,
 	)
-	c.Assert(err, IsNil)
+	c.Assert(err, gc.IsNil)
 	testing.AssertEchoArgs(
 		c, "lxc-create",
 		"-n", "test",
@@ -473,7 +474,46 @@
 		"--", "template-1", "template-2")
 }
 
-func (s *commandArgs) TestCloneArgs(c *C) {
+func (s *commandArgs) TestCreateWithEnv(c *gc.C) {
+	s.PatchValue(&golxc.ContainerDir, c.MkDir())
+	s.PatchEnvironment("PATH", s.originalPath)
+
+	EchoEnvHello := `#!/bin/bash
+name=` + "`basename $0`" + `
+argfile="$name.out"
+rm -f $argfile
+printf "%s" $name | tee -a $argfile
+printf " \"%s\""  "$HELLO" | tee -a $argfile
+if [ -n "$FOO" ]; then
+    printf " \"%s\""  "$FOO" | tee -a $argfile
+fi
+printf "\n" | tee -a $argfile
+`
+
+	testing.PatchExecutable(
+		c, s, "lxc-create", EchoEnvHello)
+	s.AddCleanup(func(*gc.C) {
+		os.Remove("lxc-create.out")
+	})
+
+	// Add an environment variable to the calling process
+	// to show that these don't get passed through.
+	s.PatchEnvironment("FOO", "BAR")
+	// Only the explicitly set env variables are propagated.
+	envArgs := []string{"HELLO=WORLD!"}
+	factory := golxc.Factory()
+	container := factory.New("test")
+	err := container.Create(
+		"config-file", "template",
+		[]string{"extra-1", "extra-2"},
+		[]string{"template-1", "template-2"},
+		envArgs,
+	)
+	c.Assert(err, gc.IsNil)
+	testing.AssertEchoArgs(c, "lxc-create", "WORLD!")
+}
+
+func (s *commandArgs) TestCloneArgs(c *gc.C) {
 	dir := c.MkDir()
 	s.PatchValue(&golxc.ContainerDir, dir)
 	s.PatchEnvironment("PATH", s.originalPath)
@@ -486,7 +526,7 @@
 	// Make the rootfs for the "test" container so it thinks it is created.
 	rootfs := filepath.Join(dir, "test", "rootfs")
 	err := os.MkdirAll(rootfs, 0755)
-	c.Assert(err, IsNil)
+	c.Assert(err, gc.IsNil)
 	c.Assert(rootfs, jc.IsDirectory)
 	c.Assert(container.IsConstructed(), jc.IsTrue)
 	clone, err := container.Clone(
@@ -494,29 +534,29 @@
 		[]string{"extra-1", "extra-2"},
 		[]string{"template-1", "template-2"},
 	)
-	c.Assert(err, IsNil)
+	c.Assert(err, gc.IsNil)
 	testing.AssertEchoArgs(
 		c, "lxc-clone",
 		"-o", "test",
 		"-n", "name",
 		"extra-1", "extra-2",
 		"--", "template-1", "template-2")
-	c.Assert(clone.Name(), Equals, "name")
+	c.Assert(clone.Name(), gc.Equals, "name")
 }
 
 type UtilsSuite struct {
 	testing.IsolationSuite
 }
 
-var _ = Suite(&UtilsSuite{})
+var _ = gc.Suite(&UtilsSuite{})
 
-func (s *UtilsSuite) TestGetDefaultLXCContainerDirDefaultValue(c *C) {
+func (s *UtilsSuite) TestGetDefaultLXCContainerDirDefaultValue(c *gc.C) {
 	testing.PatchExecutable(c, s, "lxc-config", "#!/bin/sh\nexit -1\n")
-	c.Assert(golxc.GetDefaultLXCContainerDir(), Equals, golxc.DefaultLXCDir)
+	c.Assert(golxc.GetDefaultLXCContainerDir(), gc.Equals, golxc.DefaultLXCDir)
 }
 
-func (s *UtilsSuite) TestGetDefaultLXCContainerDir(c *C) {
+func (s *UtilsSuite) TestGetDefaultLXCContainerDir(c *gc.C) {
 	const path = "/var/lib/non-standard-lxc"
 	testing.PatchExecutable(c, s, "lxc-config", "#!/bin/sh\necho '"+path+"'\n")
-	c.Assert(golxc.GetDefaultLXCContainerDir(), Equals, path)
+	c.Assert(golxc.GetDefaultLXCContainerDir(), gc.Equals, path)
 }
 
=== modified file 'network.go'
--- network.go	2014-07-03 21:37:49 +0000
+++ network.go	2014-11-21 03:15:57 +0000
@@ -20,7 +20,7 @@
 		return err
 	}
 	if goal != "start" {
-		_, err := run("start", "lxc-net")
+		_, err := run("start", nil, "lxc-net")
 		if err != nil {
 			return err
 		}
@@ -35,7 +35,7 @@
 		return err
 	}
 	if goal != "stop" {
-		_, err := run("stop", "lxc-net")
+		_, err := run("stop", nil, "lxc-net")
 		if err != nil {
 			return err
 		}
@@ -73,7 +73,7 @@
 
 // networkStatus returns the status of the lxc network subsystem.
 func networkStatus() (goal, status string, err error) {
-	output, err := run("status", "lxc-net")
+	output, err := run("status", nil, "lxc-net")
 	if err != nil {
 		return "", "", err
 	}
 
=== modified file 'package_test.go'
--- package_test.go	2014-03-11 00:34:54 +0000
+++ package_test.go	2014-11-21 03:15:57 +0000
@@ -6,7 +6,7 @@
 import (
 	"testing"
 
-	gc "launchpad.net/gocheck"
+	gc "gopkg.in/check.v1"
 )
 
 func Test(t *testing.T) {