Use lxc clone by default

state/api/provisioner/provisioner_test.go

 // Copyright 2013 Canonical Ltd.
 // Licensed under the AGPLv3, see LICENCE file for details.
 
 package provisioner_test
 
 import (
         stdtesting "testing"
 
         jc "github.com/juju/testing/checkers"
         gc "launchpad.net/gocheck"
@@ skipping 532 matching lines @@
         })
 }
 
 func (s *provisionerSuite) TestContainerManagerConfigLXC(c *gc.C) {
         args := params.ContainerManagerConfigParams{Type: instance.LXC}
         st, err := state.Open(s.StateInfo(c), state.DialOpts{}, state.Policy(nil))
         c.Assert(err, gc.IsNil)
         defer st.Close()
 
         tests := []struct {
-                lxcUseClone      bool
-                expectedUseClone string
+                lxcUseClone          bool
+                lxcUseCloneAufs      bool
+                expectedUseClone     string
+                expectedUseCloneAufs string
         }{{
-                lxcUseClone:      false,
-                expectedUseClone: "false",
+                lxcUseClone:          true,
+                expectedUseClone:     "true",
+                expectedUseCloneAufs: "false",
         }, {
-                lxcUseClone:      true,
-                expectedUseClone: "true",
+                lxcUseClone:          false,
+                expectedUseClone:     "false",
+                expectedUseCloneAufs: "false",
+        }, {
+                lxcUseCloneAufs:      false,
+                expectedUseClone:     "false",
+                expectedUseCloneAufs: "false",
+        }, {
+                lxcUseClone:          true,
+                lxcUseCloneAufs:      true,
+                expectedUseClone:     "true",
+                expectedUseCloneAufs: "true",
         }}
 
-        // Change lxc-use-clone, and ensure it gets picked up.
+        result, err := s.provisioner.ContainerManagerConfig(args)
+        c.Assert(err, gc.IsNil)
+        c.Assert(result.ManagerConfig[container.ConfigName], gc.Equals, "juju")
+        c.Assert(result.ManagerConfig["use-clone"], gc.Equals, "")
+
+        // Change lxc-clone, and ensure it gets picked up.
         for i, t := range tests {
                 c.Logf("test %d: %+v", i, t)
                 err = st.UpdateEnvironConfig(map[string]interface{}{
-                        "lxc-use-clone": t.lxcUseClone,
+                        "lxc-clone":      t.lxcUseClone,
+                        "lxc-clone-aufs": t.lxcUseCloneAufs,
                 }, nil, nil)
                 c.Assert(err, gc.IsNil)
                 result, err := s.provisioner.ContainerManagerConfig(args)
                 c.Assert(err, gc.IsNil)
-                c.Assert(result.ManagerConfig, gc.DeepEquals, map[string]string{
-                        container.ConfigName: "juju",
-                        "use-clone":          t.expectedUseClone,
-                })
+                c.Assert(result.ManagerConfig[container.ConfigName], gc.Equals, "juju")
+                c.Assert(result.ManagerConfig["use-clone"], gc.Equals, t.expectedUseClone)
+                c.Assert(result.ManagerConfig["use-aufs"], gc.Equals, t.expectedUseCloneAufs)
         }
 }
 
 func (s *provisionerSuite) TestContainerManagerConfigPermissive(c *gc.C) {
         // ContainerManagerConfig is permissive of container types, and
         // will just return the basic type-independent configuration.
         args := params.ContainerManagerConfigParams{Type: "invalid"}
         result, err := s.provisioner.ContainerManagerConfig(args)
         c.Assert(err, gc.IsNil)
         c.Assert(result.ManagerConfig, gc.DeepEquals, map[string]string{
@@ skipping 47 matching lines @@
         c.Assert(err, gc.IsNil)
         err = apiMachine.SupportsNoContainers()
         c.Assert(err, gc.IsNil)
 
         err = s.machine.Refresh()
         c.Assert(err, gc.IsNil)
         containers, ok := s.machine.SupportedContainers()
         c.Assert(ok, jc.IsTrue)
         c.Assert(containers, gc.DeepEquals, []instance.ContainerType{})
 }