func updateConfigFromProvider(model description.Model, controllerConfig *config.Config) error { newConfig, err := config.New(config.NoDefaults, model.Config()) if err != nil { return errors.Trace(err) } provider, err := environs.New(newConfig) if err != nil { return errors.Trace(err) } updater, ok := provider.(environs.MigrationConfigUpdater) if !ok { return nil } model.UpdateConfig(updater.MigrationConfigUpdate(controllerConfig)) return nil }
// Import the database agnostic model representation into the database. func (st *State) Import(model description.Model) (_ *Model, _ *State, err error) { logger := loggo.GetLogger("juju.state.import-model") logger.Debugf("import starting for model %s", model.Tag().Id()) // At this stage, attempting to import a model with the same // UUID as an existing model will error. tag := model.Tag() _, err = st.GetModel(tag) if err == nil { // We have an existing matching model. return nil, nil, errors.AlreadyExistsf("model with UUID %s", tag.Id()) } else if !errors.IsNotFound(err) { return nil, nil, errors.Trace(err) } // Create the model. cfg, err := config.New(config.NoDefaults, model.Config()) if err != nil { return nil, nil, errors.Trace(err) } dbModel, newSt, err := st.NewModel(cfg, model.Owner()) if err != nil { return nil, nil, errors.Trace(err) } logger.Debugf("model created %s/%s", dbModel.Owner().Canonical(), dbModel.Name()) defer func() { if err != nil { newSt.Close() } }() // I would have loved to use import, but that is a reserved word. restore := importer{ st: newSt, dbModel: dbModel, model: model, logger: logger, } if err := restore.sequences(); err != nil { return nil, nil, errors.Annotate(err, "sequences") } // We need to import the sequences first as we may add blocks // in the modelExtras which will touch the block sequence. if err := restore.modelExtras(); err != nil { return nil, nil, errors.Annotate(err, "base model aspects") } if err := newSt.SetModelConstraints(restore.constraints(model.Constraints())); err != nil { return nil, nil, errors.Annotate(err, "model constraints") } if err := restore.modelUsers(); err != nil { return nil, nil, errors.Annotate(err, "modelUsers") } if err := restore.machines(); err != nil { return nil, nil, errors.Annotate(err, "machines") } if err := restore.services(); err != nil { return nil, nil, errors.Annotate(err, "services") } if err := restore.relations(); err != nil { return nil, nil, errors.Annotate(err, "relations") } // NOTE: at the end of the import make sure that the mode of the model // is set to "imported" not "active" (or whatever we call it). This way // we don't start model workers for it before the migration process // is complete. // Update the sequences to match that the source. logger.Debugf("import success") return dbModel, newSt, nil }
// Import the database agnostic model representation into the database. func (st *State) Import(model description.Model) (_ *Model, _ *State, err error) { logger := loggo.GetLogger("juju.state.import-model") logger.Debugf("import starting for model %s", model.Tag().Id()) // At this stage, attempting to import a model with the same // UUID as an existing model will error. tag := model.Tag() _, err = st.GetModel(tag) if err == nil { // We have an existing matching model. return nil, nil, errors.AlreadyExistsf("model with UUID %s", tag.Id()) } else if !errors.IsNotFound(err) { return nil, nil, errors.Trace(err) } // Create the model. cfg, err := config.New(config.NoDefaults, model.Config()) if err != nil { return nil, nil, errors.Trace(err) } dbModel, newSt, err := st.NewModel(ModelArgs{ CloudName: model.Cloud(), CloudRegion: model.CloudRegion(), Config: cfg, Owner: model.Owner(), MigrationMode: MigrationModeImporting, // NOTE(axw) we create the model without any storage // pools. We'll need to import the storage pools from // the model description before adding any volumes, // filesystems or storage instances. StorageProviderRegistry: storage.StaticProviderRegistry{}, }) if err != nil { return nil, nil, errors.Trace(err) } logger.Debugf("model created %s/%s", dbModel.Owner().Canonical(), dbModel.Name()) defer func() { if err != nil { newSt.Close() } }() // I would have loved to use import, but that is a reserved word. restore := importer{ st: newSt, dbModel: dbModel, model: model, logger: logger, } if err := restore.sequences(); err != nil { return nil, nil, errors.Annotate(err, "sequences") } // We need to import the sequences first as we may add blocks // in the modelExtras which will touch the block sequence. if err := restore.modelExtras(); err != nil { return nil, nil, errors.Annotate(err, "base model aspects") } if err := newSt.SetModelConstraints(restore.constraints(model.Constraints())); err != nil { return nil, nil, errors.Annotate(err, "model constraints") } if err := restore.sshHostKeys(); err != nil { return nil, nil, errors.Annotate(err, "sshHostKeys") } if err := restore.cloudimagemetadata(); err != nil { return nil, nil, errors.Annotate(err, "cloudimagemetadata") } if err := restore.actions(); err != nil { return nil, nil, errors.Annotate(err, "actions") } if err := restore.modelUsers(); err != nil { return nil, nil, errors.Annotate(err, "modelUsers") } if err := restore.machines(); err != nil { return nil, nil, errors.Annotate(err, "machines") } if err := restore.applications(); err != nil { return nil, nil, errors.Annotate(err, "applications") } if err := restore.relations(); err != nil { return nil, nil, errors.Annotate(err, "relations") } if err := restore.spaces(); err != nil { return nil, nil, errors.Annotate(err, "spaces") } if err := restore.linklayerdevices(); err != nil { return nil, nil, errors.Annotate(err, "linklayerdevices") } if err := restore.subnets(); err != nil { return nil, nil, errors.Annotate(err, "subnets") } if err := restore.ipaddresses(); err != nil { return nil, nil, errors.Annotate(err, "ipaddresses") } if err := restore.storage(); err != nil { return nil, nil, errors.Annotate(err, "storage") } // NOTE: at the end of the import make sure that the mode of the model // is set to "imported" not "active" (or whatever we call it). This way // we don't start model workers for it before the migration process // is complete. // Update the sequences to match that the source. logger.Debugf("import success") return dbModel, newSt, nil }