// match returns true if itype can satisfy the supplied constraints. If so,
// it also returns a copy of itype with any arches that do not match the
// constraints filtered out.
func (itype InstanceType) match(cons constraints.Value) (InstanceType, bool) {
nothing := InstanceType{}
if cons.Arch != nil {
itype.Arches = filterArches(itype.Arches, []string{*cons.Arch})
}
if itype.Deprecated && !cons.HasInstanceType() {
return nothing, false
}
if cons.HasInstanceType() && itype.Name != *cons.InstanceType {
return nothing, false
}
if len(itype.Arches) == 0 {
return nothing, false
}
if cons.CpuCores != nil && itype.CpuCores < *cons.CpuCores {
return nothing, false
}
if cons.CpuPower != nil && itype.CpuPower != nil && *itype.CpuPower < *cons.CpuPower {
return nothing, false
}
if cons.Mem != nil && itype.Mem < *cons.Mem {
return nothing, false
}
if cons.RootDisk != nil && itype.RootDisk > 0 && itype.RootDisk < *cons.RootDisk {
return nothing, false
}
if cons.Tags != nil && len(*cons.Tags) > 0 && !tagsMatch(*cons.Tags, itype.Tags) {
return nothing, false
}
if cons.HasVirtType() && (itype.VirtType == nil || *itype.VirtType != *cons.VirtType) {
return nothing, false
}
return itype, true
}
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) 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())
}