func (s *MigrationExportSuite) TestUnits(c *gc.C) {
unit := s.Factory.MakeUnit(c, &factory.UnitParams{
Constraints: constraints.MustParse("arch=amd64 mem=8G"),
})
err := unit.SetMeterStatus("GREEN", "some info")
c.Assert(err, jc.ErrorIsNil)
for _, version := range []string{"garnet", "amethyst", "pearl", "steven"} {
err = unit.SetWorkloadVersion(version)
c.Assert(err, jc.ErrorIsNil)
}
err = s.State.SetAnnotations(unit, testAnnotations)
c.Assert(err, jc.ErrorIsNil)
s.primeStatusHistory(c, unit, status.Active, addedHistoryCount)
s.primeStatusHistory(c, unit.Agent(), status.Idle, addedHistoryCount)
model, err := s.State.Export()
c.Assert(err, jc.ErrorIsNil)
applications := model.Applications()
c.Assert(applications, gc.HasLen, 1)
application := applications[0]
units := application.Units()
c.Assert(units, gc.HasLen, 1)
exported := units[0]
c.Assert(exported.Name(), gc.Equals, unit.Name())
c.Assert(exported.Tag(), gc.Equals, unit.UnitTag())
c.Assert(exported.Validate(), jc.ErrorIsNil)
c.Assert(exported.MeterStatusCode(), gc.Equals, "GREEN")
c.Assert(exported.MeterStatusInfo(), gc.Equals, "some info")
c.Assert(exported.WorkloadVersion(), gc.Equals, "steven")
c.Assert(exported.Annotations(), jc.DeepEquals, testAnnotations)
constraints := exported.Constraints()
c.Assert(constraints, gc.NotNil)
c.Assert(constraints.Architecture(), gc.Equals, "amd64")
c.Assert(constraints.Memory(), gc.Equals, 8*gig)
workloadHistory := exported.WorkloadStatusHistory()
c.Assert(workloadHistory, gc.HasLen, expectedHistoryCount)
s.checkStatusHistory(c, workloadHistory[:addedHistoryCount], status.Active)
agentHistory := exported.AgentStatusHistory()
c.Assert(agentHistory, gc.HasLen, expectedHistoryCount)
s.checkStatusHistory(c, agentHistory[:addedHistoryCount], status.Idle)
versionHistory := exported.WorkloadVersionHistory()
// There are extra entries at the start that we don't care about.
c.Assert(len(versionHistory) >= 4, jc.IsTrue)
versions := make([]string, 4)
for i, status := range versionHistory[:4] {
versions[i] = status.Message()
}
// The exporter reads history in reverse time order.
c.Assert(versions, gc.DeepEquals, []string{"steven", "pearl", "amethyst", "garnet"})
}
func (s *MigrationExportSuite) assertMigrateApplications(c *gc.C, cons constraints.Value) {
application := s.Factory.MakeApplication(c, &factory.ApplicationParams{
Settings: map[string]interface{}{
"foo": "bar",
},
Constraints: cons,
})
err := application.UpdateLeaderSettings(&goodToken{}, map[string]string{
"leader": "true",
})
c.Assert(err, jc.ErrorIsNil)
err = application.SetMetricCredentials([]byte("sekrit"))
c.Assert(err, jc.ErrorIsNil)
err = s.State.SetAnnotations(application, testAnnotations)
c.Assert(err, jc.ErrorIsNil)
s.primeStatusHistory(c, application, status.Active, addedHistoryCount)
model, err := s.State.Export()
c.Assert(err, jc.ErrorIsNil)
applications := model.Applications()
c.Assert(applications, gc.HasLen, 1)
exported := applications[0]
c.Assert(exported.Name(), gc.Equals, application.Name())
c.Assert(exported.Tag(), gc.Equals, application.ApplicationTag())
c.Assert(exported.Series(), gc.Equals, application.Series())
c.Assert(exported.Annotations(), jc.DeepEquals, testAnnotations)
c.Assert(exported.Settings(), jc.DeepEquals, map[string]interface{}{
"foo": "bar",
})
c.Assert(exported.LeadershipSettings(), jc.DeepEquals, map[string]interface{}{
"leader": "true",
})
c.Assert(exported.MetricsCredentials(), jc.DeepEquals, []byte("sekrit"))
constraints := exported.Constraints()
c.Assert(constraints, gc.NotNil)
c.Assert(constraints.Architecture(), gc.Equals, *cons.Arch)
c.Assert(constraints.Memory(), gc.Equals, *cons.Mem)
if cons.HasVirtType() {
c.Assert(constraints.VirtType(), gc.Equals, *cons.VirtType)
}
history := exported.StatusHistory()
c.Assert(history, gc.HasLen, expectedHistoryCount)
s.checkStatusHistory(c, history[:addedHistoryCount], status.Active)
}
func (s *MigrationExportSuite) TestServices(c *gc.C) {
service := s.Factory.MakeService(c, &factory.ServiceParams{
Settings: map[string]interface{}{
"foo": "bar",
},
Constraints: constraints.MustParse("arch=amd64 mem=8G"),
})
err := service.UpdateLeaderSettings(&goodToken{}, map[string]string{
"leader": "true",
})
c.Assert(err, jc.ErrorIsNil)
err = service.SetMetricCredentials([]byte("sekrit"))
c.Assert(err, jc.ErrorIsNil)
err = s.State.SetAnnotations(service, testAnnotations)
c.Assert(err, jc.ErrorIsNil)
s.primeStatusHistory(c, service, status.StatusActive, addedHistoryCount)
model, err := s.State.Export()
c.Assert(err, jc.ErrorIsNil)
services := model.Services()
c.Assert(services, gc.HasLen, 1)
exported := services[0]
c.Assert(exported.Name(), gc.Equals, service.Name())
c.Assert(exported.Tag(), gc.Equals, service.ServiceTag())
c.Assert(exported.Series(), gc.Equals, service.Series())
c.Assert(exported.Annotations(), jc.DeepEquals, testAnnotations)
c.Assert(exported.Settings(), jc.DeepEquals, map[string]interface{}{
"foo": "bar",
})
c.Assert(exported.SettingsRefCount(), gc.Equals, 1)
c.Assert(exported.LeadershipSettings(), jc.DeepEquals, map[string]interface{}{
"leader": "true",
})
c.Assert(exported.MetricsCredentials(), jc.DeepEquals, []byte("sekrit"))
constraints := exported.Constraints()
c.Assert(constraints, gc.NotNil)
c.Assert(constraints.Architecture(), gc.Equals, "amd64")
c.Assert(constraints.Memory(), gc.Equals, 8*gig)
history := exported.StatusHistory()
c.Assert(history, gc.HasLen, expectedHistoryCount)
s.checkStatusHistory(c, history[:addedHistoryCount], status.StatusActive)
}
func (s *MigrationExportSuite) assertMachinesMigrated(c *gc.C, cons constraints.Value) {
// Add a machine with an LXC container.
machine1 := s.Factory.MakeMachine(c, &factory.MachineParams{
Constraints: cons,
})
nested := s.Factory.MakeMachineNested(c, machine1.Id(), nil)
err := s.State.SetAnnotations(machine1, testAnnotations)
c.Assert(err, jc.ErrorIsNil)
s.primeStatusHistory(c, machine1, status.Started, addedHistoryCount)
model, err := s.State.Export()
c.Assert(err, jc.ErrorIsNil)
machines := model.Machines()
c.Assert(machines, gc.HasLen, 1)
exported := machines[0]
c.Assert(exported.Tag(), gc.Equals, machine1.MachineTag())
c.Assert(exported.Series(), gc.Equals, machine1.Series())
c.Assert(exported.Annotations(), jc.DeepEquals, testAnnotations)
constraints := exported.Constraints()
c.Assert(constraints, gc.NotNil)
c.Assert(constraints.Architecture(), gc.Equals, *cons.Arch)
c.Assert(constraints.Memory(), gc.Equals, *cons.Mem)
if cons.HasVirtType() {
c.Assert(constraints.VirtType(), gc.Equals, *cons.VirtType)
}
tools, err := machine1.AgentTools()
c.Assert(err, jc.ErrorIsNil)
exTools := exported.Tools()
c.Assert(exTools, gc.NotNil)
c.Assert(exTools.Version(), jc.DeepEquals, tools.Version)
history := exported.StatusHistory()
c.Assert(history, gc.HasLen, expectedHistoryCount)
s.checkStatusHistory(c, history[:addedHistoryCount], status.Started)
containers := exported.Containers()
c.Assert(containers, gc.HasLen, 1)
container := containers[0]
c.Assert(container.Tag(), gc.Equals, nested.MachineTag())
}
func (s *MigrationExportSuite) TestModelInfo(c *gc.C) {
stModel, err := s.State.Model()
c.Assert(err, jc.ErrorIsNil)
err = s.State.SetAnnotations(stModel, testAnnotations)
c.Assert(err, jc.ErrorIsNil)
latestTools := version.MustParse("2.0.1")
s.setLatestTools(c, latestTools)
err = s.State.SetModelConstraints(constraints.MustParse("arch=amd64 mem=8G"))
c.Assert(err, jc.ErrorIsNil)
machineSeq := s.setRandSequenceValue(c, "machine")
fooSeq := s.setRandSequenceValue(c, "application-foo")
s.State.SwitchBlockOn(state.ChangeBlock, "locked down")
model, err := s.State.Export()
c.Assert(err, jc.ErrorIsNil)
dbModel, err := s.State.Model()
c.Assert(err, jc.ErrorIsNil)
c.Assert(model.Tag(), gc.Equals, dbModel.ModelTag())
c.Assert(model.Owner(), gc.Equals, dbModel.Owner())
dbModelCfg, err := dbModel.Config()
c.Assert(err, jc.ErrorIsNil)
modelAttrs := dbModelCfg.AllAttrs()
modelCfg := model.Config()
// Config as read from state has resources tags coerced to a map.
modelCfg["resource-tags"] = map[string]string{}
c.Assert(modelCfg, jc.DeepEquals, modelAttrs)
c.Assert(model.LatestToolsVersion(), gc.Equals, latestTools)
c.Assert(model.Annotations(), jc.DeepEquals, testAnnotations)
constraints := model.Constraints()
c.Assert(constraints, gc.NotNil)
c.Assert(constraints.Architecture(), gc.Equals, "amd64")
c.Assert(constraints.Memory(), gc.Equals, 8*gig)
c.Assert(model.Sequences(), jc.DeepEquals, map[string]int{
"machine": machineSeq,
"application-foo": fooSeq,
// blocks is added by the switch block on call above.
"block": 1,
})
c.Assert(model.Blocks(), jc.DeepEquals, map[string]string{
"all-changes": "locked down",
})
}
func (s *MigrationExportSuite) TestUnits(c *gc.C) {
unit := s.Factory.MakeUnit(c, &factory.UnitParams{
Constraints: constraints.MustParse("arch=amd64 mem=8G"),
})
err := unit.SetMeterStatus("GREEN", "some info")
c.Assert(err, jc.ErrorIsNil)
err = s.State.SetAnnotations(unit, testAnnotations)
c.Assert(err, jc.ErrorIsNil)
s.primeStatusHistory(c, unit, status.StatusActive, addedHistoryCount)
s.primeStatusHistory(c, unit.Agent(), status.StatusIdle, addedHistoryCount)
model, err := s.State.Export()
c.Assert(err, jc.ErrorIsNil)
services := model.Services()
c.Assert(services, gc.HasLen, 1)
service := services[0]
units := service.Units()
c.Assert(units, gc.HasLen, 1)
exported := units[0]
c.Assert(exported.Name(), gc.Equals, unit.Name())
c.Assert(exported.Tag(), gc.Equals, unit.UnitTag())
c.Assert(exported.Validate(), jc.ErrorIsNil)
c.Assert(exported.MeterStatusCode(), gc.Equals, "GREEN")
c.Assert(exported.MeterStatusInfo(), gc.Equals, "some info")
c.Assert(exported.Annotations(), jc.DeepEquals, testAnnotations)
constraints := exported.Constraints()
c.Assert(constraints, gc.NotNil)
c.Assert(constraints.Architecture(), gc.Equals, "amd64")
c.Assert(constraints.Memory(), gc.Equals, 8*gig)
workloadHistory := exported.WorkloadStatusHistory()
c.Assert(workloadHistory, gc.HasLen, expectedHistoryCount)
s.checkStatusHistory(c, workloadHistory[:addedHistoryCount], status.StatusActive)
agentHistory := exported.AgentStatusHistory()
c.Assert(agentHistory, gc.HasLen, expectedHistoryCount)
s.checkStatusHistory(c, agentHistory[:addedHistoryCount], status.StatusIdle)
}