golxc: added networking

golxc_test.go

 package golxc_test
 
 import (
         "io/ioutil"
         . "launchpad.net/gocheck"
-        "launchpad.net/golxc"
         "os"
         "os/user"
         "path/filepath"
-        "strings"
         "testing"
+
+        "launchpad.net/golxc"
 )
 
 func Test(t *testing.T) { TestingT(t) }
 
-type ConfigurationSuite struct{}
-
-var _ = Suite(&ConfigurationSuite{})
-
-var cfgs = `# Leading commment.
-VALUE1 = 12345
-VALUE2="foo"
-VALUE3 = "foo # bar"
-VALUE4 = "foo = bar"
-VALUE5 = "bar" # Trailing comment.
-VALUE6 = bar # foo
-
-# Comment inbetween.
-
-VALUE7 =
-VALUE8 = ""
-VALUE9 =foo `
-
-var icfgs = `some_invalid_kind_of_data_that_is_no_configuration`
-
-func (s *ConfigurationSuite) TestParseConfiguration(c *C) {
-        // Test the parsing of a valid configuration.
-        cr := strings.NewReader(cfgs)
-        cfg, err := golxc.ParseConfiguration(cr)
-        c.Assert(err, IsNil)
-        c.Assert(len(cfg), Equals, 9)
-        c.Assert(cfg["VALUE1"], Equals, "12345")
-        c.Assert(cfg["VALUE2"], Equals, "foo")
-        c.Assert(cfg["VALUE3"], Equals, "foo # bar")
-        c.Assert(cfg["VALUE4"], Equals, "foo = bar")
-        c.Assert(cfg["VALUE5"], Equals, "bar")
-        c.Assert(cfg["VALUE6"], Equals, "bar")
-        c.Assert(cfg["VALUE7"], Equals, "")
-        c.Assert(cfg["VALUE8"], Equals, "")
-        c.Assert(cfg["VALUE9"], Equals, "foo")
-}
-
-func (s *ConfigurationSuite) TestReadInvalidConfiguration(c *C) {
-        // Test the reading of an invalid configuration.
-        cr := strings.NewReader(icfgs)
-        _, err := golxc.ParseConfiguration(cr)
-        c.Assert(err, ErrorMatches, "invalid config line: .*")
-}
-
-var env = `# MIRROR to be used by ubuntu template at container creation:
+var lxcfile = `# MIRROR to be used by ubuntu template at container creation:
 # Leaving it undefined is fine
 #MIRROR="http://archive.ubuntu.com/ubuntu"
 # or·
 #MIRROR="http://<host-ip-addr>:3142/archive.ubuntu.com/ubuntu"
 
 # LXC_AUTO - whether or not to start containers symlinked under
 # /etc/lxc/auto
 LXC_AUTO="true"
 
 # Leave USE_LXC_BRIDGE as "true" if you want to use lxcbr0 for your
 # containers.  Set to "false" if you'll use virbr0 or another existing
 # bridge, or mavlan to your host's NIC.
 USE_LXC_BRIDGE="true"
 
 # LXC_BRIDGE and LXC_ADDR are changed against original for
 # testing purposes.
+# LXC_BRIDGE="lxcbr1"
 LXC_BRIDGE="lxcbr9"
+# LXC_ADDR="10.0.1.1"
 LXC_ADDR="10.0.9.1"
 LXC_NETMASK="255.255.255.0"
 LXC_NETWORK="10.0.9.0/24"
 LXC_DHCP_RANGE="10.0.9.2,10.0.9.254"
 LXC_DHCP_MAX="253"
+# And for testing LXC_BRIDGE="lxcbr99" and LXC_ADDR="10.0.99.1".
 
 LXC_SHUTDOWN_TIMEOUT=120`
 
-func (s *ConfigurationSuite) TestReadDefaultEnvironment(c *C) {
-        // Test reading the environment.
-        f, err := ioutil.TempFile("/tmp", "lxc-test")
-        c.Assert(err, IsNil)
-        defer func() {
-                c.Assert(os.Remove(f.Name()), IsNil)
-        }()
-        _, err = f.WriteString(env)
-        c.Assert(err, IsNil)
-        c.Assert(f.Close(), IsNil)
-
-        orig := golxc.SetLXCDefaultFile(f.Name())
-        defer golxc.SetLXCDefaultFile(orig)
-
-        env, err := golxc.ReadDefaultEnvironment()
-        c.Assert(err, IsNil)
-        c.Assert(env["LXC_BRIDGE"], Equals, "lxcbr9")
-        c.Assert(env["LXC_ADDR"], Equals, "10.0.9.1")
-        c.Assert(env["MIRROR"], Equals, "")
-}
-
-func (s *ConfigurationSuite) TestReadNotExistingDefaultEnvironment(c *C) {
+var lxcconf = map[string]string{
+        "address": "10.0.9.1",
+        "bridge":  "lxcbr9",
+}
+
+type ConfigSuite struct{}
+
+var _ = Suite(&ConfigSuite{})
+
+func (s *ConfigSuite) TestReadConf(c *C) {
+        // Test reading the configuration.
+        cf := filepath.Join(c.MkDir(), "lxc-test")
+        c.Assert(ioutil.WriteFile(cf, []byte(lxcfile), 0555), IsNil)
+
+        defer golxc.SetConfPath(golxc.SetConfPath(cf))
+
+        conf, err := golxc.ReadConf()
+        c.Assert(err, IsNil)
+        c.Assert(conf, DeepEquals, lxcconf)
+}
+
+func (s *ConfigSuite) TestReadNotExistingDefaultEnvironment(c *C) {
         // Test reading a not existing environment.
-        orig := golxc.SetLXCDefaultFile("/tmp/not-existing-exc-test")
-        defer golxc.SetLXCDefaultFile(orig)
-
-        _, err := golxc.ReadDefaultEnvironment()
+        defer golxc.SetConfPath(golxc.SetConfPath(filepath.Join(c.MkDir(), "foo")))
+
+        _, err := golxc.ReadConf()
         c.Assert(err, ErrorMatches, "open .*: no such file or directory")
+}
+
+func (s *ConfigSuite) TestNetworkAttributes(c *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)
+
+        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")
 }
 
 type NetworkSuite struct{}
 
 var _ = Suite(&NetworkSuite{})
 
 func (s *NetworkSuite) SetUpSuite(c *C) {
         u, err := user.Current()
         c.Assert(err, IsNil)
         if u.Uid != "0" {
@@ skipping 14 matching lines @@
         c.Assert(golxc.StartNetwork(), IsNil)
         running, err := golxc.IsNetworkRunning()
         c.Assert(err, IsNil)
         c.Assert(running, Equals, true)
         c.Assert(golxc.StopNetwork(), IsNil)
         running, err = golxc.IsNetworkRunning()
         c.Assert(err, IsNil)
         c.Assert(running, Equals, false)
 }
 
-func (s *ConfigurationSuite) TestNetworkAttributes(c *C) {
-        // Test reading the network attribute form an environment.
-        cf := filepath.Join(c.MkDir(), "lxc-test")
-        c.Assert(ioutil.WriteFile(cf, []byte(env), 0555), IsNil)
-
-        orig := golxc.SetLXCDefaultFile(cf)
-        defer golxc.SetLXCDefaultFile(orig)
-
-        addr, bridge, err := golxc.NetworkAttributes()
-        c.Assert(err, IsNil)
-        c.Assert(addr, Equals, "10.0.9.1")
-        c.Assert(bridge, Equals, "lxcbr9")
-}
-
 func (s *NetworkSuite) TestNotExistingNetworkAttributes(c *C) {
         // Test reading of network attributes from a not existing environment.
-        orig := golxc.SetLXCDefaultFile("/any/path/to/non-existing/lxc-file")

[fwereade, 2013/02/04 14:51:30]

I don't think you can guarantee this path doesn't exist either ;).

[TheMue, 2013/02/05 14:21:32]

Done.

-        defer golxc.SetLXCDefaultFile(orig)
+        defer golxc.SetConfPath(golxc.SetConfPath(filepath.Join(c.MkDir(), "foo")))
 
         _, _, err := golxc.NetworkAttributes()
         c.Assert(err, ErrorMatches, "open .*: no such file or directory")
 }
 
 type LXCSuite struct{}
 
 var _ = Suite(&LXCSuite{})
 
 func (s *LXCSuite) SetUpSuite(c *C) {
@@ skipping 220 matching lines @@
         c.Assert(lc.Create("ubuntu"), IsNil)
         defer func() {
                 c.Assert(lc.Destroy(), IsNil)
         }()
         c.Assert(lc.Start("", ""), IsNil)
         defer func() {
                 c.Assert(lc.Stop(), IsNil)
         }()
         c.Assert(lc.Unfreeze(), ErrorMatches, "container .* is not frozen")
 }