Golang container.MachineTag函數代碼示例

func (s *provisionerSuite) TestReleaseContainerAddresses(c *gc.C) {
	// This test exercises just the success path, all the other cases
	// are already tested in the apiserver package.
	template := state.MachineTemplate{
		Series: "quantal",
		Jobs:   []state.MachineJob{state.JobHostUnits},
	}
	container, err := s.State.AddMachineInsideMachine(template, s.machine.Id(), instance.LXC)

	// allocate some addresses to release
	subInfo := state.SubnetInfo{
		ProviderId:        "dummy-private",
		CIDR:              "0.10.0.0/24",
		VLANTag:           0,
		AllocatableIPLow:  "0.10.0.0",
		AllocatableIPHigh: "0.10.0.10",
	}
	sub, err := s.State.AddSubnet(subInfo)
	c.Assert(err, jc.ErrorIsNil)
	for i := 0; i < 3; i++ {
		addr := network.NewAddress(fmt.Sprintf("0.10.0.%d", i))
		ipaddr, err := s.State.AddIPAddress(addr, sub.ID())
		c.Check(err, jc.ErrorIsNil)
		err = ipaddr.AllocateTo(container.Id(), "nic42", "aa:bb:cc:dd:ee:f0")
		c.Check(err, jc.ErrorIsNil)
	}
	c.Assert(err, jc.ErrorIsNil)
	password, err := utils.RandomPassword()
	c.Assert(err, jc.ErrorIsNil)
	err = container.SetPassword(password)
	c.Assert(err, jc.ErrorIsNil)
	err = container.SetProvisioned("foo", "fake_nonce", nil)
	c.Assert(err, jc.ErrorIsNil)

	err = s.provisioner.ReleaseContainerAddresses(container.MachineTag())
	c.Assert(err, jc.ErrorIsNil)

	addresses, err := s.State.AllocatedIPAddresses(container.Id())
	c.Assert(err, jc.ErrorIsNil)
	c.Assert(addresses, gc.HasLen, 3)
	for _, addr := range addresses {
		c.Assert(addr.Life(), gc.Equals, state.Dead)
	}
}

func (s *provisionerSuite) TestPrepareContainerInterfaceInfo(c *gc.C) {
	c.Skip("dimitern: test disabled as it needs proper fixing in the face of removing address-allocation feature flag")
	// This test exercises just the success path, all the other cases
	// are already tested in the apiserver package.
	template := state.MachineTemplate{
		Series: "quantal",
		Jobs:   []state.MachineJob{state.JobHostUnits},
	}
	container, err := s.State.AddMachineInsideMachine(template, s.machine.Id(), instance.LXC)
	c.Assert(err, jc.ErrorIsNil)

	ifaceInfo, err := s.provisioner.PrepareContainerInterfaceInfo(container.MachineTag())
	c.Assert(err, jc.ErrorIsNil)
	c.Assert(ifaceInfo, gc.HasLen, 1)

	expectInfo := []network.InterfaceInfo{{
		DeviceIndex:      0,
		CIDR:             "0.10.0.0/24",
		ProviderId:       "dummy-eth0",
		ProviderSubnetId: "dummy-private",
		VLANTag:          0,
		InterfaceName:    "eth0",
		InterfaceType:    "ethernet",
		Disabled:         false,
		NoAutoStart:      false,
		ConfigType:       network.ConfigStatic,
		DNSServers:       network.NewAddresses("ns1.dummy", "ns2.dummy"),
		GatewayAddress:   network.NewAddress("0.10.0.2"),
		ExtraConfig:      nil,
		// Overwrite Address and MACAddress fields below with the actual ones,
		// as they are chosen randomly.
		Address:    network.Address{},
		MACAddress: "",
	}}
	c.Assert(ifaceInfo[0].Address, gc.Not(gc.DeepEquals), network.Address{})
	c.Assert(ifaceInfo[0].MACAddress, gc.Not(gc.DeepEquals), "")
	expectInfo[0].Address = ifaceInfo[0].Address
	expectInfo[0].MACAddress = ifaceInfo[0].MACAddress
	c.Assert(ifaceInfo, jc.DeepEquals, expectInfo)
}

func (s *provisionerSuite) TestPrepareContainerInterfaceInfo(c *gc.C) {
	// This test exercises just the success path, all the other cases
	// are already tested in the apiserver package.
	template := state.MachineTemplate{
		Series: "quantal",
		Jobs:   []state.MachineJob{state.JobHostUnits},
	}
	container, err := s.State.AddMachineInsideMachine(template, s.machine.Id(), instance.LXC)
	c.Assert(err, jc.ErrorIsNil)

	expectInfo := []network.InterfaceInfo{{
		DeviceIndex:      0,
		MACAddress:       "aa:bb:cc:dd:ee:f0",
		CIDR:             "0.10.0.0/24",
		NetworkName:      "juju-private",
		ProviderId:       "dummy-eth0",
		ProviderSubnetId: "dummy-private",
		VLANTag:          0,
		InterfaceName:    "eth0",
		Disabled:         false,
		NoAutoStart:      false,
		ConfigType:       network.ConfigStatic,
		// Overwrite the Address field below with the actual one, as
		// it's chosen randomly.
		Address:        network.Address{},
		DNSServers:     network.NewAddresses("ns1.dummy", "ns2.dummy"),
		GatewayAddress: network.NewAddress("0.10.0.2"),
		ExtraConfig:    nil,
	}}
	ifaceInfo, err := s.provisioner.PrepareContainerInterfaceInfo(container.MachineTag())
	c.Assert(err, jc.ErrorIsNil)
	c.Assert(ifaceInfo, gc.HasLen, 1)
	c.Assert(ifaceInfo[0].Address, gc.Not(gc.DeepEquals), network.Address{})
	expectInfo[0].Address = ifaceInfo[0].Address
	c.Assert(ifaceInfo, jc.DeepEquals, expectInfo)
}