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)
}
