func (s *MigrationBaseSuite) makeUnitWithStorage(c *gc.C) (*state.Application, *state.Unit, names.StorageTag) { pool := "loop-pool" kind := "block" // Create a default pool for block devices. pm := poolmanager.New(state.NewStateSettings(s.State), dummy.StorageProviders()) _, err := pm.Create(pool, provider.LoopProviderType, map[string]interface{}{}) c.Assert(err, jc.ErrorIsNil) // There are test charms called "storage-block" and // "storage-filesystem" which are what you'd expect. ch := s.AddTestingCharm(c, "storage-"+kind) storage := map[string]state.StorageConstraints{ "data": makeStorageCons(pool, 1024, 1), } service := s.AddTestingServiceWithStorage(c, "storage-"+kind, ch, storage) unit, err := service.AddUnit() machine := s.Factory.MakeMachine(c, nil) err = unit.AssignToMachine(machine) c.Assert(err, jc.ErrorIsNil) c.Assert(err, jc.ErrorIsNil) storageTag := names.NewStorageTag("data/0") agentVersion := version.MustParseBinary("2.0.1-quantal-and64") err = unit.SetAgentVersion(agentVersion) c.Assert(err, jc.ErrorIsNil) return service, unit, storageTag }
func (cs *ConnSuite) SetUpTest(c *gc.C) { c.Log("SetUpTest") cs.policy = statetesting.MockPolicy{ GetStorageProviderRegistry: func() (storage.ProviderRegistry, error) { return dummy.StorageProviders(), nil }, } cs.StateSuite.NewPolicy = func(*state.State) state.Policy { return &cs.policy } cs.StateSuite.SetUpTest(c) cs.modelTag = cs.State.ModelTag() jujuDB := cs.MgoSuite.Session.DB("juju") cs.annotations = jujuDB.C("annotations") cs.charms = jujuDB.C("charms") cs.machines = jujuDB.C("machines") cs.instanceData = jujuDB.C("instanceData") cs.relations = jujuDB.C("relations") cs.services = jujuDB.C("applications") cs.units = jujuDB.C("units") cs.controllers = jujuDB.C("controllers") c.Log("SetUpTest done") }
func (s *VolumeStateSuite) TestAddServiceDefaultPool(c *gc.C) { // Register a default pool. pm := poolmanager.New(state.NewStateSettings(s.State), dummy.StorageProviders()) _, err := pm.Create("default-block", provider.LoopProviderType, map[string]interface{}{}) c.Assert(err, jc.ErrorIsNil) err = s.State.UpdateModelConfig(map[string]interface{}{ "storage-default-block-source": "default-block", }, nil, nil) c.Assert(err, jc.ErrorIsNil) ch := s.AddTestingCharm(c, "storage-block") storage := map[string]state.StorageConstraints{ "data": makeStorageCons("", 1024, 1), } service := s.AddTestingServiceWithStorage(c, "storage-block", ch, storage) cons, err := service.StorageConstraints() c.Assert(err, jc.ErrorIsNil) c.Assert(cons, jc.DeepEquals, map[string]state.StorageConstraints{ "data": state.StorageConstraints{ Pool: "default-block", Size: 1024, Count: 1, }, "allecto": state.StorageConstraints{ Pool: "loop", Size: 1024, Count: 0, }, }) }
func setupTestStorageSupport(c *gc.C, s *state.State) { stsetts := state.NewStateSettings(s) poolManager := poolmanager.New(stsetts, dummy.StorageProviders()) _, err := poolManager.Create(testPool, provider.LoopProviderType, map[string]interface{}{"it": "works"}) c.Assert(err, jc.ErrorIsNil) _, err = poolManager.Create(testPersistentPool, "environscoped", map[string]interface{}{"persistent": true}) c.Assert(err, jc.ErrorIsNil) }
func (s *StorageStateSuiteBase) SetUpTest(c *gc.C) { s.ConnSuite.SetUpTest(c) // Create a default pool for block devices. pm := poolmanager.New(state.NewStateSettings(s.State), dummy.StorageProviders()) _, err := pm.Create("loop-pool", provider.LoopProviderType, map[string]interface{}{}) c.Assert(err, jc.ErrorIsNil) // Create a pool that creates persistent block devices. _, err = pm.Create("persistent-block", "environscoped-block", map[string]interface{}{ "persistent": true, }) c.Assert(err, jc.ErrorIsNil) }
func assertPoolExists(c *gc.C, st *state.State, pname, provider, attr string) { stsetts := state.NewStateSettings(st) poolManager := poolmanager.New(stsetts, dummy.StorageProviders()) found, err := poolManager.List() c.Assert(err, jc.ErrorIsNil) c.Assert(len(found) > 0, jc.IsTrue) exists := false for _, one := range found { if one.Name() == pname { exists = true c.Assert(string(one.Provider()), gc.Equals, provider) // At this stage, only 1 attr is expected and checked expectedAttrs := strings.Split(attr, "=") value, ok := one.Attrs()[expectedAttrs[0]] c.Assert(ok, jc.IsTrue) c.Assert(value, gc.Equals, expectedAttrs[1]) } } c.Assert(exists, jc.IsTrue) }
func (s *withoutControllerSuite) TestProvisioningInfoWithStorage(c *gc.C) { pm := poolmanager.New(state.NewStateSettings(s.State), dummy.StorageProviders()) _, err := pm.Create("static-pool", "static", map[string]interface{}{"foo": "bar"}) c.Assert(err, jc.ErrorIsNil) cons := constraints.MustParse("cores=123 mem=8G") template := state.MachineTemplate{ Series: "quantal", Jobs: []state.MachineJob{state.JobHostUnits}, Constraints: cons, Placement: "valid", Volumes: []state.MachineVolumeParams{ {Volume: state.VolumeParams{Size: 1000, Pool: "static-pool"}}, {Volume: state.VolumeParams{Size: 2000, Pool: "static-pool"}}, }, } placementMachine, err := s.State.AddOneMachine(template) c.Assert(err, jc.ErrorIsNil) args := params.Entities{Entities: []params.Entity{ {Tag: s.machines[0].Tag().String()}, {Tag: placementMachine.Tag().String()}, }} result, err := s.provisioner.ProvisioningInfo(args) c.Assert(err, jc.ErrorIsNil) controllerCfg := coretesting.FakeControllerConfig() // Dummy provider uses a random port, which is added to cfg used to create environment. apiPort := dummy.ApiPort(s.Environ.Provider()) controllerCfg["api-port"] = apiPort expected := params.ProvisioningInfoResults{ Results: []params.ProvisioningInfoResult{ {Result: ¶ms.ProvisioningInfo{ ControllerConfig: controllerCfg, Series: "quantal", Jobs: []multiwatcher.MachineJob{multiwatcher.JobHostUnits}, Tags: map[string]string{ tags.JujuController: coretesting.ControllerTag.Id(), tags.JujuModel: coretesting.ModelTag.Id(), }, }}, {Result: ¶ms.ProvisioningInfo{ ControllerConfig: controllerCfg, Series: "quantal", Constraints: template.Constraints, Placement: template.Placement, Jobs: []multiwatcher.MachineJob{multiwatcher.JobHostUnits}, Tags: map[string]string{ tags.JujuController: coretesting.ControllerTag.Id(), tags.JujuModel: coretesting.ModelTag.Id(), }, Volumes: []params.VolumeParams{{ VolumeTag: "volume-0", Size: 1000, Provider: "static", Attributes: map[string]interface{}{"foo": "bar"}, Tags: map[string]string{ tags.JujuController: coretesting.ControllerTag.Id(), tags.JujuModel: coretesting.ModelTag.Id(), }, Attachment: ¶ms.VolumeAttachmentParams{ MachineTag: placementMachine.Tag().String(), VolumeTag: "volume-0", Provider: "static", }, }, { VolumeTag: "volume-1", Size: 2000, Provider: "static", Attributes: map[string]interface{}{"foo": "bar"}, Tags: map[string]string{ tags.JujuController: coretesting.ControllerTag.Id(), tags.JujuModel: coretesting.ModelTag.Id(), }, Attachment: ¶ms.VolumeAttachmentParams{ MachineTag: placementMachine.Tag().String(), VolumeTag: "volume-1", Provider: "static", }, }}, }}, }, } // The order of volumes is not predictable, so we make sure we // compare the right ones. This only applies to Results[1] since // it is the only result to contain volumes. if expected.Results[1].Result.Volumes[0].VolumeTag != result.Results[1].Result.Volumes[0].VolumeTag { vols := expected.Results[1].Result.Volumes vols[0], vols[1] = vols[1], vols[0] } c.Assert(result, jc.DeepEquals, expected) }
func (s *withoutControllerSuite) TestSetInstanceInfo(c *gc.C) { pm := poolmanager.New(state.NewStateSettings(s.State), dummy.StorageProviders()) _, err := pm.Create("static-pool", "static", map[string]interface{}{"foo": "bar"}) c.Assert(err, jc.ErrorIsNil) err = s.State.UpdateModelConfig(map[string]interface{}{ "storage-default-block-source": "static-pool", }, nil, nil) c.Assert(err, jc.ErrorIsNil) // Provision machine 0 first. hwChars := instance.MustParseHardware("arch=i386", "mem=4G") err = s.machines[0].SetInstanceInfo("i-am", "fake_nonce", &hwChars, nil, nil, nil, nil) c.Assert(err, jc.ErrorIsNil) volumesMachine, err := s.State.AddOneMachine(state.MachineTemplate{ Series: "quantal", Jobs: []state.MachineJob{state.JobHostUnits}, Volumes: []state.MachineVolumeParams{{ Volume: state.VolumeParams{Size: 1000}, }}, }) c.Assert(err, jc.ErrorIsNil) args := params.InstancesInfo{Machines: []params.InstanceInfo{{ Tag: s.machines[0].Tag().String(), InstanceId: "i-was", Nonce: "fake_nonce", }, { Tag: s.machines[1].Tag().String(), InstanceId: "i-will", Nonce: "fake_nonce", Characteristics: &hwChars, }, { Tag: s.machines[2].Tag().String(), InstanceId: "i-am-too", Nonce: "fake", Characteristics: nil, }, { Tag: volumesMachine.Tag().String(), InstanceId: "i-am-also", Nonce: "fake", Volumes: []params.Volume{{ VolumeTag: "volume-0", Info: params.VolumeInfo{ VolumeId: "vol-0", Size: 1234, }, }}, VolumeAttachments: map[string]params.VolumeAttachmentInfo{ "volume-0": { DeviceName: "sda", }, }, }, {Tag: "machine-42"}, {Tag: "unit-foo-0"}, {Tag: "application-bar"}, }} result, err := s.provisioner.SetInstanceInfo(args) c.Assert(err, jc.ErrorIsNil) c.Assert(result, jc.DeepEquals, params.ErrorResults{ Results: []params.ErrorResult{ {¶ms.Error{ Message: `cannot record provisioning info for "i-was": cannot set instance data for machine "0": already set`, }}, {nil}, {nil}, {nil}, {apiservertesting.NotFoundError("machine 42")}, {apiservertesting.ErrUnauthorized}, {apiservertesting.ErrUnauthorized}, }, }) // Verify machine 1 and 2 were provisioned. c.Assert(s.machines[1].Refresh(), gc.IsNil) c.Assert(s.machines[2].Refresh(), gc.IsNil) instanceId, err := s.machines[1].InstanceId() c.Assert(err, jc.ErrorIsNil) c.Check(instanceId, gc.Equals, instance.Id("i-will")) instanceId, err = s.machines[2].InstanceId() c.Assert(err, jc.ErrorIsNil) c.Check(instanceId, gc.Equals, instance.Id("i-am-too")) c.Check(s.machines[1].CheckProvisioned("fake_nonce"), jc.IsTrue) c.Check(s.machines[2].CheckProvisioned("fake"), jc.IsTrue) gotHardware, err := s.machines[1].HardwareCharacteristics() c.Assert(err, jc.ErrorIsNil) c.Check(gotHardware, gc.DeepEquals, &hwChars) // Verify the machine with requested volumes was provisioned, and the // volume information recorded in state. volumeAttachments, err := s.State.MachineVolumeAttachments(volumesMachine.MachineTag()) c.Assert(err, jc.ErrorIsNil) c.Assert(volumeAttachments, gc.HasLen, 1) volumeAttachmentInfo, err := volumeAttachments[0].Info() c.Assert(err, jc.ErrorIsNil) c.Assert(volumeAttachmentInfo, gc.Equals, state.VolumeAttachmentInfo{DeviceName: "sda"}) volume, err := s.State.Volume(volumeAttachments[0].Volume()) c.Assert(err, jc.ErrorIsNil) volumeInfo, err := volume.Info() c.Assert(err, jc.ErrorIsNil) c.Assert(volumeInfo, gc.Equals, state.VolumeInfo{VolumeId: "vol-0", Pool: "static-pool", Size: 1234}) // Verify the machine without requested volumes still has no volume // attachments recorded in state. volumeAttachments, err = s.State.MachineVolumeAttachments(s.machines[1].MachineTag()) c.Assert(err, jc.ErrorIsNil) c.Assert(volumeAttachments, gc.HasLen, 0) }