github.com/altoros/juju-vmware@v0.0.0-20150312064031-f19ae857ccca/api/networker/networker_test.go (about)

     1  // Copyright 2014 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package networker_test
     5  
     6  import (
     7  	"github.com/juju/names"
     8  	jc "github.com/juju/testing/checkers"
     9  	"github.com/juju/utils"
    10  	gc "gopkg.in/check.v1"
    11  
    12  	"github.com/juju/juju/api"
    13  	"github.com/juju/juju/api/networker"
    14  	"github.com/juju/juju/apiserver/params"
    15  	"github.com/juju/juju/instance"
    16  	"github.com/juju/juju/juju/testing"
    17  	"github.com/juju/juju/network"
    18  	"github.com/juju/juju/state"
    19  	statetesting "github.com/juju/juju/state/testing"
    20  )
    21  
    22  type networkerSuite struct {
    23  	testing.JujuConnSuite
    24  
    25  	networks []state.NetworkInfo
    26  
    27  	machine         *state.Machine
    28  	container       *state.Machine
    29  	nestedContainer *state.Machine
    30  
    31  	machineIfaces         []state.NetworkInterfaceInfo
    32  	containerIfaces       []state.NetworkInterfaceInfo
    33  	nestedContainerIfaces []state.NetworkInterfaceInfo
    34  
    35  	st        *api.State
    36  	networker *networker.State
    37  }
    38  
    39  var _ = gc.Suite(&networkerSuite{})
    40  
    41  // Create several networks.
    42  func (s *networkerSuite) setUpNetworks(c *gc.C) {
    43  	s.networks = []state.NetworkInfo{{
    44  		Name:       "net1",
    45  		ProviderId: "net1",
    46  		CIDR:       "0.1.2.0/24",
    47  		VLANTag:    0,
    48  	}, {
    49  		Name:       "vlan42",
    50  		ProviderId: "vlan42",
    51  		CIDR:       "0.2.2.0/24",
    52  		VLANTag:    42,
    53  	}, {
    54  		Name:       "vlan69",
    55  		ProviderId: "vlan69",
    56  		CIDR:       "0.3.2.0/24",
    57  		VLANTag:    69,
    58  	}, {
    59  		Name:       "vlan123",
    60  		ProviderId: "vlan123",
    61  		CIDR:       "0.4.2.0/24",
    62  		VLANTag:    123,
    63  	}, {
    64  		Name:       "net2",
    65  		ProviderId: "net2",
    66  		CIDR:       "0.5.2.0/24",
    67  		VLANTag:    0,
    68  	}}
    69  }
    70  
    71  // Create a machine and login to it.
    72  func (s *networkerSuite) setUpMachine(c *gc.C) {
    73  	var err error
    74  	s.machine, err = s.State.AddMachine("quantal", state.JobHostUnits)
    75  	c.Assert(err, jc.ErrorIsNil)
    76  	password, err := utils.RandomPassword()
    77  	c.Assert(err, jc.ErrorIsNil)
    78  	err = s.machine.SetPassword(password)
    79  	c.Assert(err, jc.ErrorIsNil)
    80  	hwChars := instance.MustParseHardware("cpu-cores=123", "mem=4G")
    81  	s.machineIfaces = []state.NetworkInterfaceInfo{{
    82  		MACAddress:    "aa:bb:cc:dd:ee:f0",
    83  		InterfaceName: "eth0",
    84  		NetworkName:   "net1",
    85  		IsVirtual:     false,
    86  	}, {
    87  		MACAddress:    "aa:bb:cc:dd:ee:f1",
    88  		InterfaceName: "eth1",
    89  		NetworkName:   "net1",
    90  		IsVirtual:     false,
    91  	}, {
    92  		MACAddress:    "aa:bb:cc:dd:ee:f1",
    93  		InterfaceName: "eth1.42",
    94  		NetworkName:   "vlan42",
    95  		IsVirtual:     true,
    96  	}, {
    97  		MACAddress:    "aa:bb:cc:dd:ee:f0",
    98  		InterfaceName: "eth0.69",
    99  		NetworkName:   "vlan69",
   100  		IsVirtual:     true,
   101  	}, {
   102  		MACAddress:    "aa:bb:cc:dd:ee:f2",
   103  		InterfaceName: "eth2",
   104  		NetworkName:   "net2",
   105  		IsVirtual:     false,
   106  		Disabled:      true,
   107  	}}
   108  	err = s.machine.SetInstanceInfo("i-am", "fake_nonce", &hwChars, s.networks, s.machineIfaces, nil)
   109  	c.Assert(err, jc.ErrorIsNil)
   110  	s.st = s.OpenAPIAsMachine(c, s.machine.Tag(), password, "fake_nonce")
   111  	c.Assert(s.st, gc.NotNil)
   112  }
   113  
   114  // Create and provision a container and a nested container.
   115  func (s *networkerSuite) setUpContainers(c *gc.C) {
   116  	template := state.MachineTemplate{
   117  		Series: "quantal",
   118  		Jobs:   []state.MachineJob{state.JobHostUnits},
   119  	}
   120  	var err error
   121  	s.container, err = s.State.AddMachineInsideMachine(template, s.machine.Id(), instance.LXC)
   122  	c.Assert(err, jc.ErrorIsNil)
   123  	s.containerIfaces = []state.NetworkInterfaceInfo{{
   124  		MACAddress:    "aa:bb:cc:dd:ee:e0",
   125  		InterfaceName: "eth0",
   126  		NetworkName:   "net1",
   127  		IsVirtual:     false,
   128  	}, {
   129  		MACAddress:    "aa:bb:cc:dd:ee:e1",
   130  		InterfaceName: "eth1",
   131  		NetworkName:   "net1",
   132  		IsVirtual:     false,
   133  	}, {
   134  		MACAddress:    "aa:bb:cc:dd:ee:e1",
   135  		InterfaceName: "eth1.42",
   136  		NetworkName:   "vlan42",
   137  		IsVirtual:     true,
   138  	}}
   139  	hwChars := instance.MustParseHardware("arch=i386", "mem=4G")
   140  	err = s.container.SetInstanceInfo("i-container", "fake_nonce", &hwChars, s.networks[:2],
   141  		s.containerIfaces, nil)
   142  	c.Assert(err, jc.ErrorIsNil)
   143  
   144  	s.nestedContainer, err = s.State.AddMachineInsideMachine(template, s.container.Id(), instance.LXC)
   145  	c.Assert(err, jc.ErrorIsNil)
   146  	s.nestedContainerIfaces = []state.NetworkInterfaceInfo{{
   147  		MACAddress:    "aa:bb:cc:dd:ee:d0",
   148  		InterfaceName: "eth0",
   149  		NetworkName:   "net1",
   150  		IsVirtual:     false,
   151  	}}
   152  	err = s.nestedContainer.SetInstanceInfo("i-too", "fake_nonce", &hwChars, s.networks[:1],
   153  		s.nestedContainerIfaces, nil)
   154  	c.Assert(err, jc.ErrorIsNil)
   155  }
   156  
   157  func (s *networkerSuite) SetUpTest(c *gc.C) {
   158  	s.JujuConnSuite.SetUpTest(c)
   159  
   160  	s.setUpNetworks(c)
   161  	s.setUpMachine(c)
   162  	s.setUpContainers(c)
   163  
   164  	// Create the networker API facade.
   165  	s.networker = s.st.Networker()
   166  	c.Assert(s.networker, gc.NotNil)
   167  }
   168  
   169  func (s *networkerSuite) TestMachineNetworkInfoPermissionDenied(c *gc.C) {
   170  	info, err := s.networker.MachineNetworkInfo(names.NewMachineTag("1"))
   171  	c.Assert(err, gc.ErrorMatches, "permission denied")
   172  	c.Assert(err, jc.Satisfies, params.IsCodeUnauthorized)
   173  	c.Assert(info, gc.IsNil)
   174  }
   175  
   176  func (s *networkerSuite) TestMachineNetworkInfo(c *gc.C) {
   177  	// Expected results of MachineNetworkInfo for a machine and containers
   178  	expectedMachineInfo := []network.InterfaceInfo{{
   179  		MACAddress:    "aa:bb:cc:dd:ee:f0",
   180  		CIDR:          "0.1.2.0/24",
   181  		NetworkName:   "net1",
   182  		ProviderId:    "net1",
   183  		VLANTag:       0,
   184  		InterfaceName: "eth0",
   185  	}, {
   186  		MACAddress:    "aa:bb:cc:dd:ee:f1",
   187  		CIDR:          "0.1.2.0/24",
   188  		NetworkName:   "net1",
   189  		ProviderId:    "net1",
   190  		VLANTag:       0,
   191  		InterfaceName: "eth1",
   192  	}, {
   193  		MACAddress:    "aa:bb:cc:dd:ee:f1",
   194  		CIDR:          "0.2.2.0/24",
   195  		NetworkName:   "vlan42",
   196  		ProviderId:    "vlan42",
   197  		VLANTag:       42,
   198  		InterfaceName: "eth1",
   199  	}, {
   200  		MACAddress:    "aa:bb:cc:dd:ee:f0",
   201  		CIDR:          "0.3.2.0/24",
   202  		NetworkName:   "vlan69",
   203  		ProviderId:    "vlan69",
   204  		VLANTag:       69,
   205  		InterfaceName: "eth0",
   206  	}, {
   207  		MACAddress:    "aa:bb:cc:dd:ee:f2",
   208  		CIDR:          "0.5.2.0/24",
   209  		NetworkName:   "net2",
   210  		ProviderId:    "net2",
   211  		VLANTag:       0,
   212  		InterfaceName: "eth2",
   213  		Disabled:      true,
   214  	}}
   215  	expectedContainerInfo := []network.InterfaceInfo{{
   216  		MACAddress:    "aa:bb:cc:dd:ee:e0",
   217  		CIDR:          "0.1.2.0/24",
   218  		NetworkName:   "net1",
   219  		ProviderId:    "net1",
   220  		VLANTag:       0,
   221  		InterfaceName: "eth0",
   222  	}, {
   223  		MACAddress:    "aa:bb:cc:dd:ee:e1",
   224  		CIDR:          "0.1.2.0/24",
   225  		NetworkName:   "net1",
   226  		ProviderId:    "net1",
   227  		VLANTag:       0,
   228  		InterfaceName: "eth1",
   229  	}, {
   230  		MACAddress:    "aa:bb:cc:dd:ee:e1",
   231  		CIDR:          "0.2.2.0/24",
   232  		NetworkName:   "vlan42",
   233  		ProviderId:    "vlan42",
   234  		VLANTag:       42,
   235  		InterfaceName: "eth1",
   236  	}}
   237  	expectedNestedContainerInfo := []network.InterfaceInfo{{
   238  		MACAddress:    "aa:bb:cc:dd:ee:d0",
   239  		CIDR:          "0.1.2.0/24",
   240  		NetworkName:   "net1",
   241  		ProviderId:    "net1",
   242  		VLANTag:       0,
   243  		InterfaceName: "eth0",
   244  	}}
   245  
   246  	results, err := s.networker.MachineNetworkInfo(names.NewMachineTag("0"))
   247  	c.Assert(err, jc.ErrorIsNil)
   248  	c.Assert(results, gc.DeepEquals, expectedMachineInfo)
   249  
   250  	results, err = s.networker.MachineNetworkInfo(names.NewMachineTag("0/lxc/0"))
   251  	c.Assert(err, jc.ErrorIsNil)
   252  	c.Assert(results, gc.DeepEquals, expectedContainerInfo)
   253  
   254  	results, err = s.networker.MachineNetworkInfo(names.NewMachineTag("0/lxc/0/lxc/0"))
   255  	c.Assert(err, jc.ErrorIsNil)
   256  	c.Assert(results, gc.DeepEquals, expectedNestedContainerInfo)
   257  }
   258  
   259  func (s *networkerSuite) TestWatchInterfacesPermissionDenied(c *gc.C) {
   260  	w, err := s.networker.WatchInterfaces(names.NewMachineTag("1"))
   261  	c.Assert(err, gc.ErrorMatches, "permission denied")
   262  	c.Assert(err, jc.Satisfies, params.IsCodeUnauthorized)
   263  	c.Assert(w, gc.IsNil)
   264  }
   265  
   266  func (s *networkerSuite) TestWatchInterfaces(c *gc.C) {
   267  	// Read dynamically generated document Ids.
   268  	ifaces, err := s.machine.NetworkInterfaces()
   269  	c.Assert(err, jc.ErrorIsNil)
   270  	c.Assert(ifaces, gc.HasLen, 5)
   271  
   272  	// Start network interface watcher.
   273  	w, err := s.networker.WatchInterfaces(names.NewMachineTag("0"))
   274  	defer statetesting.AssertStop(c, w)
   275  	wc := statetesting.NewNotifyWatcherC(c, s.BackingState, w)
   276  	wc.AssertOneChange()
   277  
   278  	// Disable the first interface.
   279  	err = ifaces[0].Disable()
   280  	c.Assert(err, jc.ErrorIsNil)
   281  	wc.AssertOneChange()
   282  
   283  	// Disable the first interface again, should not report.
   284  	err = ifaces[0].Disable()
   285  	c.Assert(err, jc.ErrorIsNil)
   286  	wc.AssertNoChange()
   287  
   288  	// Enable the first interface.
   289  	err = ifaces[0].Enable()
   290  	c.Assert(err, jc.ErrorIsNil)
   291  	wc.AssertOneChange()
   292  
   293  	// Enable the first interface again, should not report.
   294  	err = ifaces[0].Enable()
   295  	c.Assert(err, jc.ErrorIsNil)
   296  	wc.AssertNoChange()
   297  
   298  	// Remove the network interface.
   299  	err = ifaces[0].Remove()
   300  	c.Assert(err, jc.ErrorIsNil)
   301  	wc.AssertOneChange()
   302  
   303  	// Add the new interface.
   304  	_, err = s.machine.AddNetworkInterface(state.NetworkInterfaceInfo{
   305  		MACAddress:    "aa:bb:cc:dd:ee:f3",
   306  		InterfaceName: "eth3",
   307  		NetworkName:   "net2",
   308  	})
   309  	c.Assert(err, jc.ErrorIsNil)
   310  	wc.AssertOneChange()
   311  
   312  	// Add the new interface on the container, should not report.
   313  	_, err = s.container.AddNetworkInterface(state.NetworkInterfaceInfo{
   314  		MACAddress:    "aa:bb:cc:dd:ee:e3",
   315  		InterfaceName: "eth3",
   316  		NetworkName:   "net2",
   317  	})
   318  	c.Assert(err, jc.ErrorIsNil)
   319  	wc.AssertNoChange()
   320  
   321  	// Read dynamically generated document Ids.
   322  	containerIfaces, err := s.container.NetworkInterfaces()
   323  	c.Assert(err, jc.ErrorIsNil)
   324  	c.Assert(containerIfaces, gc.HasLen, 4)
   325  
   326  	// Disable the first interface on the second machine, should not report.
   327  	err = containerIfaces[0].Disable()
   328  	c.Assert(err, jc.ErrorIsNil)
   329  	wc.AssertNoChange()
   330  
   331  	// Remove the network interface on the second machine, should not report.
   332  	err = containerIfaces[0].Remove()
   333  	c.Assert(err, jc.ErrorIsNil)
   334  	wc.AssertNoChange()
   335  
   336  	// Stop watcher; check Changes chan closed.
   337  	statetesting.AssertStop(c, w)
   338  	wc.AssertClosed()
   339  }