func (*NetworkSuite) TestGenerateNetworkConfig(c *gc.C) {
for _, test := range []struct {
config *container.NetworkConfig
net string
link string
}{{
config: nil,
net: "veth",
link: "lxcbr0",
}, {
config: lxc.DefaultNetworkConfig(),
net: "veth",
link: "lxcbr0",
}, {
config: container.BridgeNetworkConfig("foo"),
net: "veth",
link: "foo",
}, {
config: container.PhysicalNetworkConfig("foo"),
net: "phys",
link: "foo",
}} {
config := lxc.GenerateNetworkConfig(test.config)
c.Assert(config, jc.Contains, fmt.Sprintf("lxc.network.type = %s\n", test.net))
c.Assert(config, jc.Contains, fmt.Sprintf("lxc.network.link = %s\n", test.link))
}
}
func (s *LxcSuite) createTemplate(c *gc.C) golxc.Container {
name := "juju-series-template"
s.ensureTemplateStopped(name)
network := container.BridgeNetworkConfig("nic42")
authorizedKeys := "authorized keys list"
aptProxy := osenv.ProxySettings{}
template, err := lxc.EnsureCloneTemplate(
"ext4", "series", network, authorizedKeys, aptProxy)
c.Assert(err, gc.IsNil)
c.Assert(template.Name(), gc.Equals, name)
s.AssertEvent(c, <-s.events, mock.Created, name)
s.AssertEvent(c, <-s.events, mock.Started, name)
s.AssertEvent(c, <-s.events, mock.Stopped, name)
autostartLink := lxc.RestartSymlink(name)
config, err := ioutil.ReadFile(lxc.ContainerConfigFilename(name))
c.Assert(err, gc.IsNil)
expected := `
lxc.network.type = veth
lxc.network.link = nic42
lxc.network.flags = up
`
// NOTE: no autostart, no mounting the log dir
c.Assert(string(config), gc.Equals, expected)
c.Assert(autostartLink, jc.DoesNotExist)
return template
}
func (s *KVMSuite) createRunningContainer(c *gc.C, name string) kvm.Container {
kvmContainer := s.Factory.New(name)
network := container.BridgeNetworkConfig("testbr0")
c.Assert(kvmContainer.Start(kvm.StartParams{
Series: "quantal",
Arch: version.Current.Arch,
UserDataFile: "userdata.txt",
Network: network}), gc.IsNil)
return kvmContainer
}
// StartInstance is specified in the Broker interface.
func (broker *kvmBroker) StartInstance(args environs.StartInstanceParams) (instance.Instance, *instance.HardwareCharacteristics, []network.Info, error) {
if args.MachineConfig.HasNetworks() {
return nil, nil, nil, fmt.Errorf("starting kvm containers with networks is not supported yet.")
}
// TODO: refactor common code out of the container brokers.
machineId := args.MachineConfig.MachineId
kvmLogger.Infof("starting kvm container for machineId: %s", machineId)
// TODO: Default to using the host network until we can configure. Yes,
// this is using the LxcBridge value, we should put it in the api call for
// container config.
bridgeDevice := broker.agentConfig.Value(agent.LxcBridge)
if bridgeDevice == "" {
bridgeDevice = kvm.DefaultKvmBridge
}
network := container.BridgeNetworkConfig(bridgeDevice)
// TODO: series doesn't necessarily need to be the same as the host.
series := args.Tools.OneSeries()
args.MachineConfig.MachineContainerType = instance.KVM
args.MachineConfig.Tools = args.Tools[0]
config, err := broker.api.ContainerConfig()
if err != nil {
kvmLogger.Errorf("failed to get container config: %v", err)
return nil, nil, nil, err
}
if err := environs.PopulateMachineConfig(
args.MachineConfig,
config.ProviderType,
config.AuthorizedKeys,
config.SSLHostnameVerification,
config.Proxy,
config.AptProxy,
); err != nil {
kvmLogger.Errorf("failed to populate machine config: %v", err)
return nil, nil, nil, err
}
inst, hardware, err := broker.manager.CreateContainer(args.MachineConfig, series, network)
if err != nil {
kvmLogger.Errorf("failed to start container: %v", err)
return nil, nil, nil, err
}
kvmLogger.Infof("started kvm container for machineId: %s, %s, %s", machineId, inst.Id(), hardware.String())
return inst, hardware, nil, nil
}
func CreateContainer(c *gc.C, manager container.Manager, machineId string) instance.Instance {
stateInfo := jujutesting.FakeStateInfo(machineId)
apiInfo := jujutesting.FakeAPIInfo(machineId)
machineConfig := environs.NewMachineConfig(machineId, "fake-nonce", nil, nil, stateInfo, apiInfo)
machineConfig.Tools = &tools.Tools{
Version: version.MustParseBinary("2.3.4-foo-bar"),
URL: "http://tools.testing.invalid/2.3.4-foo-bar.tgz",
}
series := "series"
network := container.BridgeNetworkConfig("nic42")
inst, hardware, err := manager.CreateContainer(machineConfig, series, network)
c.Assert(err, gc.IsNil)
c.Assert(hardware, gc.NotNil)
c.Assert(hardware.String(), gc.Not(gc.Equals), "")
return inst
}
// StartInstance is specified in the Broker interface.
func (broker *lxcBroker) StartInstance(args environs.StartInstanceParams) (instance.Instance, *instance.HardwareCharacteristics, []network.Info, error) {
if args.MachineConfig.HasNetworks() {
return nil, nil, nil, fmt.Errorf("starting lxc containers with networks is not supported yet.")
}
// TODO: refactor common code out of the container brokers.
machineId := args.MachineConfig.MachineId
lxcLogger.Infof("starting lxc container for machineId: %s", machineId)
// Default to using the host network until we can configure.
bridgeDevice := broker.agentConfig.Value(agent.LxcBridge)
if bridgeDevice == "" {
bridgeDevice = lxc.DefaultLxcBridge
}
network := container.BridgeNetworkConfig(bridgeDevice)
series := args.Tools.OneSeries()
args.MachineConfig.MachineContainerType = instance.LXC
args.MachineConfig.Tools = args.Tools[0]
config, err := broker.api.ContainerConfig()
if err != nil {
lxcLogger.Errorf("failed to get container config: %v", err)
return nil, nil, nil, err
}
if err := environs.PopulateMachineConfig(
args.MachineConfig,
config.ProviderType,
config.AuthorizedKeys,
config.SSLHostnameVerification,
config.Proxy,
config.AptProxy,
); err != nil {
lxcLogger.Errorf("failed to populate machine config: %v", err)
return nil, nil, nil, err
}
inst, hardware, err := broker.manager.CreateContainer(args.MachineConfig, series, network)
if err != nil {
lxcLogger.Errorf("failed to start container: %v", err)
return nil, nil, nil, err
}
lxcLogger.Infof("started lxc container for machineId: %s, %s, %s", machineId, inst.Id(), hardware.String())
return inst, hardware, nil, nil
}
func createContainer(c *gc.C, manager container.Manager, machineId string) instance.Instance {
machineNonce := "fake-nonce"
stateInfo := jujutesting.FakeStateInfo(machineId)
apiInfo := jujutesting.FakeAPIInfo(machineId)
machineConfig := environs.NewMachineConfig(machineId, machineNonce, nil, nil, stateInfo, apiInfo)
network := container.BridgeNetworkConfig("virbr0")
machineConfig.Tools = &tools.Tools{
Version: version.MustParseBinary("2.3.4-foo-bar"),
URL: "http://tools.testing.invalid/2.3.4-foo-bar.tgz",
}
environConfig := dummyConfig(c)
err := environs.FinishMachineConfig(machineConfig, environConfig, constraints.Value{})
c.Assert(err, gc.IsNil)
inst, hardware, err := manager.CreateContainer(machineConfig, "precise", network)
c.Assert(err, gc.IsNil)
c.Assert(hardware, gc.NotNil)
expected := fmt.Sprintf("arch=%s cpu-cores=1 mem=512M root-disk=8192M", version.Current.Arch)
c.Assert(hardware.String(), gc.Equals, expected)
return inst
}
// DefaultNetworkConfig returns a valid NetworkConfig to use the
// defaultLxcBridge that is created by the lxc package.
func DefaultNetworkConfig() *container.NetworkConfig {
return container.BridgeNetworkConfig(DefaultLxcBridge)
}