func (s *ImportSuite) TestImportModel(c *gc.C) {
model, err := s.State.Export()
c.Check(err, jc.ErrorIsNil)
controllerConfig, err := s.State.ModelConfig()
c.Check(err, jc.ErrorIsNil)
// Update the config values in the exported model for different values for
// "state-port", "api-port", and "ca-cert". Also give the model a new UUID
// and name so we can import it nicely.
model.UpdateConfig(map[string]interface{}{
"name": "new-model",
"uuid": utils.MustNewUUID().String(),
"state-port": 12345,
"api-port": 54321,
"ca-cert": "not really a cert",
})
bytes, err := description.Serialize(model)
c.Check(err, jc.ErrorIsNil)
dbModel, dbState, err := migration.ImportModel(s.State, bytes)
c.Check(err, jc.ErrorIsNil)
defer dbState.Close()
dbConfig, err := dbModel.Config()
c.Assert(err, jc.ErrorIsNil)
attrs := dbConfig.AllAttrs()
c.Assert(attrs["state-port"], gc.Equals, controllerConfig.StatePort())
c.Assert(attrs["api-port"], gc.Equals, controllerConfig.APIPort())
cacert, ok := controllerConfig.CACert()
c.Assert(ok, jc.IsTrue)
c.Assert(attrs["ca-cert"], gc.Equals, cacert)
c.Assert(attrs["controller-uuid"], gc.Equals, controllerConfig.UUID())
}
func (s *ImportSuite) TestImportModel(c *gc.C) {
model, err := s.State.Export()
c.Check(err, jc.ErrorIsNil)
// Update the config values in the exported model for different values for
// "state-port", "api-port", and "ca-cert". Also give the model a new UUID
// and name so we can import it nicely.
uuid := utils.MustNewUUID().String()
model.UpdateConfig(map[string]interface{}{
"name": "new-model",
"uuid": uuid,
})
bytes, err := description.Serialize(model)
c.Check(err, jc.ErrorIsNil)
dbModel, dbState, err := migration.ImportModel(s.State, bytes)
c.Check(err, jc.ErrorIsNil)
defer dbState.Close()
dbConfig, err := dbModel.Config()
c.Assert(err, jc.ErrorIsNil)
c.Assert(dbConfig.UUID(), gc.Equals, uuid)
c.Assert(dbConfig.Name(), gc.Equals, "new-model")
}
// ExportModel creates a description.Model representation of the
// active model for StateExporter (typically a *state.State), and
// returns the serialized version. It provides the symmetric
// functionality to ImportModel.
func ExportModel(st StateExporter) ([]byte, error) {
model, err := st.Export()
if err != nil {
return nil, errors.Trace(err)
}
bytes, err := description.Serialize(model)
if err != nil {
return nil, errors.Trace(err)
}
return bytes, nil
}
func (s *Suite) makeExportedModel(c *gc.C) (string, []byte) {
model, err := s.State.Export()
c.Assert(err, jc.ErrorIsNil)
newUUID := utils.MustNewUUID().String()
model.UpdateConfig(map[string]interface{}{
"name": "some-model",
"uuid": newUUID,
})
bytes, err := description.Serialize(model)
c.Assert(err, jc.ErrorIsNil)
return newUUID, bytes
}
// Export serializes the model associated with the API connection.
func (api *API) Export() (params.SerializedModel, error) {
var serialized params.SerializedModel
model, err := api.backend.Export()
if err != nil {
return serialized, err
}
bytes, err := description.Serialize(model)
if err != nil {
return serialized, err
}
serialized.Bytes = bytes
serialized.Charms = getUsedCharms(model)
serialized.Tools = getUsedTools(model)
return serialized, nil
}