// Run implements Command.Run
func (c *showControllerCommand) Run(ctx *cmd.Context) error {
controllerNames := c.controllerNames
if len(controllerNames) == 0 {
currentController, err := modelcmd.ReadCurrentController()
if err != nil {
return errors.Trace(err)
}
if currentController == "" {
return errors.New("there is no active controller")
}
controllerNames = []string{currentController}
}
controllers := make(map[string]ShowControllerDetails)
for _, name := range controllerNames {
actualName, err := modelcmd.ResolveControllerName(c.store, name)
if err != nil {
return err
}
one, err := c.store.ControllerByName(actualName)
if err != nil {
return err
}
controllers[name] = c.convertControllerForShow(actualName, one)
}
return c.out.Write(ctx, controllers)
}
func (c *migrateCommand) getMigrationSpec() (*controller.ModelMigrationSpec, error) {
store := c.ClientStore()
modelInfo, err := store.ModelByName(c.ControllerName(), c.AccountName(), c.model)
if err != nil {
return nil, err
}
controllerName, err := modelcmd.ResolveControllerName(store, c.targetController)
if err != nil {
return nil, err
}
controllerInfo, err := store.ControllerByName(controllerName)
if err != nil {
return nil, err
}
accountName, err := store.CurrentAccount(controllerName)
if err != nil {
return nil, err
}
accountInfo, err := store.AccountByName(controllerName, accountName)
if err != nil {
return nil, err
}
return &controller.ModelMigrationSpec{
ModelUUID: modelInfo.ModelUUID,
TargetControllerUUID: controllerInfo.ControllerUUID,
TargetAddrs: controllerInfo.APIEndpoints,
TargetCACert: controllerInfo.CACert,
TargetUser: accountInfo.User,
TargetPassword: accountInfo.Password,
}, nil
}
func (s *ControllerSuite) TestNotFound(c *gc.C) {
_, err := modelcmd.ResolveControllerName(s.store, "foo")
c.Assert(err, jc.Satisfies, errors.IsNotFound)
// We should report on the passed in controller name.
c.Assert(err, gc.ErrorMatches, ".* foo .*")
}
func (s *ControllerSuite) TestOnlyLocalController(c *gc.C) {
name, err := modelcmd.ResolveControllerName(s.store, "local.anothercontroller")
c.Assert(name, gc.DeepEquals, "local.anothercontroller")
c.Assert(err, jc.ErrorIsNil)
}
func (s *ControllerSuite) TestLocalNameFallback(c *gc.C) {
name, err := modelcmd.ResolveControllerName(s.store, "controller")
c.Assert(name, gc.DeepEquals, "local.controller")
c.Assert(err, jc.ErrorIsNil)
}
func (c *switchCommand) Run(ctx *cmd.Context) (resultErr error) {
// Get the current name for logging the transition or printing
// the current controller/model.
currentControllerName, err := c.ReadCurrentController()
if err != nil {
return errors.Trace(err)
}
if c.Target == "" {
currentName, err := c.name(currentControllerName, true)
if err != nil {
return errors.Trace(err)
}
if currentName == "" {
return errors.New("no currently specified model")
}
fmt.Fprintf(ctx.Stdout, "%s\n", currentName)
return nil
}
currentName, err := c.name(currentControllerName, false)
if err != nil {
return errors.Trace(err)
}
var newName string
defer func() {
if resultErr != nil {
return
}
logSwitch(ctx, currentName, &newName)
}()
// Switch is an alternative way of dealing with environments than using
// the JUJU_MODEL environment setting, and as such, doesn't play too well.
// If JUJU_MODEL is set we should report that as the current environment,
// and not allow switching when it is set.
if model := os.Getenv(osenv.JujuModelEnvKey); model != "" {
return errors.Errorf("cannot switch when JUJU_MODEL is overriding the model (set to %q)", model)
}
// If the target identifies a controller, then set that as the current controller.
var newControllerName string
if newControllerName, err = modelcmd.ResolveControllerName(c.Store, c.Target); err == nil {
if newControllerName == currentControllerName {
newName = currentName
return nil
} else {
newName, err = c.name(newControllerName, false)
if err != nil {
return errors.Trace(err)
}
return errors.Trace(c.WriteCurrentController(newControllerName))
}
} else if !errors.IsNotFound(err) {
return errors.Trace(err)
}
// The target is not a controller, so check for a model with
// the given name. The name can be qualified with the controller
// name (<controller>:<model>), or unqualified; in the latter
// case, the model must exist in the current controller.
newControllerName, modelName := modelcmd.SplitModelName(c.Target)
if newControllerName != "" {
// A controller was specified so see if we should use a local version.
newControllerName, err = modelcmd.ResolveControllerName(c.Store, newControllerName)
if err != nil {
return errors.Trace(err)
}
newName = modelcmd.JoinModelName(newControllerName, modelName)
} else {
if currentControllerName == "" {
return unknownSwitchTargetError(c.Target)
}
newControllerName = currentControllerName
newName = modelcmd.JoinModelName(newControllerName, modelName)
}
accountName, err := c.Store.CurrentAccount(newControllerName)
if err != nil {
return errors.Trace(err)
}
err = c.Store.SetCurrentModel(newControllerName, accountName, modelName)
if errors.IsNotFound(err) {
// The model isn't known locally, so we must query the controller.
if err := c.RefreshModels(c.Store, newControllerName, accountName); err != nil {
return errors.Annotate(err, "refreshing models cache")
}
err := c.Store.SetCurrentModel(newControllerName, accountName, modelName)
if errors.IsNotFound(err) {
return unknownSwitchTargetError(c.Target)
} else if err != nil {
return errors.Trace(err)
}
} else if err != nil {
return errors.Trace(err)
}
if currentControllerName != newControllerName {
if err := c.WriteCurrentController(newControllerName); err != nil {
return errors.Trace(err)
}
}
return nil
}