func (s *ImportSuite) TestStreamCharmsTools(c *gc.C) {
model := description.NewModel(description.ModelArgs{
Owner: names.NewUserTag("me"),
})
model.AddService(description.ServiceArgs{
Tag: names.NewServiceTag("magic"),
CharmURL: "local:trusty/magic",
})
model.AddService(description.ServiceArgs{
Tag: names.NewServiceTag("magic"),
CharmURL: "cs:trusty/postgresql-42",
})
uploader := &fakeUploader{charms: make(map[string]string)}
config := migration.UploadBinariesConfig{
State: &fakeStateStorage{},
Model: model,
Target: &fakeAPIConnection{},
GetCharmUploader: func(api.Connection) migration.CharmUploader { return uploader },
GetToolsUploader: func(target api.Connection) migration.ToolsUploader { return &noOpUploader{} },
GetStateStorage: func(migration.UploadBackend) storage.Storage { return &fakeCharmsStorage{} },
GetCharmStoragePath: func(_ migration.UploadBackend, u *charm.URL) (string, error) {
return "/path/for/" + u.String(), nil
},
}
err := migration.UploadBinaries(config)
c.Assert(err, jc.ErrorIsNil)
c.Assert(uploader.charms, jc.DeepEquals, map[string]string{
"local:trusty/magic": "fake file at /path/for/local:trusty/magic",
"cs:trusty/postgresql-42": "fake file at /path/for/cs:trusty/postgresql-42",
})
}
func (s *ImportSuite) TestUploadBinariesTools(c *gc.C) {
// Create a model that has three different tools versions:
// one for a machine, one for a container, and one for a unit agent.
// We don't care about the actual validity of the model (it isn't).
model := description.NewModel(description.ModelArgs{
Owner: names.NewUserTag("me"),
})
machine := model.AddMachine(description.MachineArgs{
Id: names.NewMachineTag("0"),
})
machine.SetTools(description.AgentToolsArgs{
Version: version.MustParseBinary("2.0.1-trusty-amd64"),
})
container := machine.AddContainer(description.MachineArgs{
Id: names.NewMachineTag("0/lxc/0"),
})
container.SetTools(description.AgentToolsArgs{
Version: version.MustParseBinary("2.0.5-trusty-amd64"),
})
service := model.AddService(description.ServiceArgs{
Tag: names.NewServiceTag("magic"),
CharmURL: "local:trusty/magic",
})
unit := service.AddUnit(description.UnitArgs{
Tag: names.NewUnitTag("magic/0"),
})
unit.SetTools(description.AgentToolsArgs{
Version: version.MustParseBinary("2.0.3-trusty-amd64"),
})
uploader := &fakeUploader{tools: make(map[version.Binary]string)}
config := migration.UploadBinariesConfig{
State: &fakeStateStorage{},
Model: model,
Target: &fakeAPIConnection{},
GetCharmUploader: func(api.Connection) migration.CharmUploader { return &noOpUploader{} },
GetToolsUploader: func(target api.Connection) migration.ToolsUploader {
return uploader
},
GetStateStorage: func(migration.UploadBackend) storage.Storage { return &fakeCharmsStorage{} },
GetCharmStoragePath: func(migration.UploadBackend, *charm.URL) (string, error) { return "", nil },
}
err := migration.UploadBinaries(config)
c.Assert(err, jc.ErrorIsNil)
c.Assert(uploader.tools, jc.DeepEquals, map[version.Binary]string{
version.MustParseBinary("2.0.1-trusty-amd64"): "fake tools 2.0.1-trusty-amd64",
version.MustParseBinary("2.0.3-trusty-amd64"): "fake tools 2.0.3-trusty-amd64",
version.MustParseBinary("2.0.5-trusty-amd64"): "fake tools 2.0.5-trusty-amd64",
})
}
func (s *InternalSuite) TestUpdateConfigFromProvider(c *gc.C) {
controllerConfig := testing.ModelConfig(c)
configAttrs := testing.FakeConfig()
configAttrs["type"] = "dummy"
// Fake the "state-id" so the provider thinks it is prepared already.
configAttrs["state-id"] = "42"
// We need to specify a valid provider type, so we use dummy.
// The dummy provider grabs the UUID from the controller config
// and returns it in the map with the key "controller-uuid", similar
// to what the azure provider will need to do.
model := description.NewModel(description.ModelArgs{
Owner: names.NewUserTag("test-admin"),
Config: configAttrs,
})
err := migration.UpdateConfigFromProvider(model, controllerConfig)
c.Assert(err, jc.ErrorIsNil)
modelConfig := model.Config()
c.Assert(modelConfig["controller-uuid"], gc.Equals, controllerConfig.UUID())
}
func (s *Suite) SetUpTest(c *gc.C) {
s.BaseSuite.SetUpTest(c)
s.model = description.NewModel(description.ModelArgs{
Config: map[string]interface{}{"uuid": modelUUID},
Owner: names.NewUserTag("admin"),
LatestToolsVersion: jujuversion.Current,
})
s.stub = new(testing.Stub)
s.backend = &stubBackend{
migration: &stubMigration{stub: s.stub},
stub: s.stub,
model: s.model,
}
s.resources = common.NewResources()
s.AddCleanup(func(*gc.C) { s.resources.StopAll() })
s.authorizer = apiservertesting.FakeAuthorizer{
EnvironManager: true,
}
}
// Export the current model for the State.
func (st *State) Export() (description.Model, error) {
dbModel, err := st.Model()
if err != nil {
return nil, errors.Trace(err)
}
export := exporter{
st: st,
dbModel: dbModel,
logger: loggo.GetLogger("juju.state.export-model"),
}
if err := export.readAllStatuses(); err != nil {
return nil, errors.Annotate(err, "reading statuses")
}
if err := export.readAllStatusHistory(); err != nil {
return nil, errors.Trace(err)
}
if err := export.readAllSettings(); err != nil {
return nil, errors.Trace(err)
}
if err := export.readAllAnnotations(); err != nil {
return nil, errors.Trace(err)
}
if err := export.readAllConstraints(); err != nil {
return nil, errors.Trace(err)
}
envConfig, found := export.settings[modelGlobalKey]
if !found {
return nil, errors.New("missing environ config")
}
blocks, err := export.readBlocks()
if err != nil {
return nil, errors.Trace(err)
}
args := description.ModelArgs{
Owner: dbModel.Owner(),
Config: envConfig.Settings,
LatestToolsVersion: dbModel.LatestToolsVersion(),
Blocks: blocks,
}
export.model = description.NewModel(args)
modelKey := dbModel.globalKey()
export.model.SetAnnotations(export.getAnnotations(modelKey))
if err := export.sequences(); err != nil {
return nil, errors.Trace(err)
}
constraintsArgs, err := export.constraintsArgs(modelKey)
if err != nil {
return nil, errors.Trace(err)
}
export.model.SetConstraints(constraintsArgs)
if err := export.modelUsers(); err != nil {
return nil, errors.Trace(err)
}
if err := export.machines(); err != nil {
return nil, errors.Trace(err)
}
if err := export.services(); err != nil {
return nil, errors.Trace(err)
}
if err := export.relations(); err != nil {
return nil, errors.Trace(err)
}
if err := export.model.Validate(); err != nil {
return nil, errors.Trace(err)
}
export.logExtras()
return export.model, nil
}
// Export the current model for the State.
func (st *State) Export() (description.Model, error) {
dbModel, err := st.Model()
if err != nil {
return nil, errors.Trace(err)
}
export := exporter{
st: st,
dbModel: dbModel,
logger: loggo.GetLogger("juju.state.export-model"),
}
if err := export.readAllStatuses(); err != nil {
return nil, errors.Annotate(err, "reading statuses")
}
if err := export.readAllStatusHistory(); err != nil {
return nil, errors.Trace(err)
}
if err := export.readAllSettings(); err != nil {
return nil, errors.Trace(err)
}
if err := export.readAllStorageConstraints(); err != nil {
return nil, errors.Trace(err)
}
if err := export.readAllAnnotations(); err != nil {
return nil, errors.Trace(err)
}
if err := export.readAllConstraints(); err != nil {
return nil, errors.Trace(err)
}
modelConfig, found := export.modelSettings[modelGlobalKey]
if !found {
return nil, errors.New("missing model config")
}
blocks, err := export.readBlocks()
if err != nil {
return nil, errors.Trace(err)
}
args := description.ModelArgs{
Cloud: dbModel.Cloud(),
CloudRegion: dbModel.CloudRegion(),
Owner: dbModel.Owner(),
Config: modelConfig.Settings,
LatestToolsVersion: dbModel.LatestToolsVersion(),
Blocks: blocks,
}
export.model = description.NewModel(args)
modelKey := dbModel.globalKey()
export.model.SetAnnotations(export.getAnnotations(modelKey))
if err := export.sequences(); err != nil {
return nil, errors.Trace(err)
}
constraintsArgs, err := export.constraintsArgs(modelKey)
if err != nil {
return nil, errors.Trace(err)
}
export.model.SetConstraints(constraintsArgs)
if err := export.modelUsers(); err != nil {
return nil, errors.Trace(err)
}
if err := export.machines(); err != nil {
return nil, errors.Trace(err)
}
if err := export.applications(); err != nil {
return nil, errors.Trace(err)
}
if err := export.relations(); err != nil {
return nil, errors.Trace(err)
}
if err := export.spaces(); err != nil {
return nil, errors.Trace(err)
}
if err := export.subnets(); err != nil {
return nil, errors.Trace(err)
}
if err := export.ipaddresses(); err != nil {
return nil, errors.Trace(err)
}
if err := export.linklayerdevices(); err != nil {
return nil, errors.Trace(err)
}
if err := export.sshHostKeys(); err != nil {
return nil, errors.Trace(err)
}
if err := export.storage(); err != nil {
return nil, errors.Trace(err)
}
if err := export.actions(); err != nil {
return nil, errors.Trace(err)
}
if err := export.cloudimagemetadata(); err != nil {
return nil, errors.Trace(err)
}
if err := export.model.Validate(); err != nil {
return nil, errors.Trace(err)
}
export.logExtras()
return export.model, nil
}