func (*ModelCommandSuite) TestSplitModelName(c *gc.C) {
assert := func(in, controller, model string) {
outController, outModel := modelcmd.SplitModelName(in)
c.Assert(outController, gc.Equals, controller)
c.Assert(outModel, gc.Equals, model)
}
assert("model", "", "model")
assert("ctrl:model", "ctrl", "model")
assert("ctrl:", "ctrl", "")
assert(":model", "", "model")
}
func (s *baseDestroySuite) SetUpTest(c *gc.C) {
s.FakeJujuXDGDataHomeSuite.SetUpTest(c)
s.clientapi = &fakeDestroyAPIClient{}
owner := names.NewUserTag("owner")
s.api = &fakeDestroyAPI{
envStatus: map[string]base.ModelStatus{},
}
s.apierror = nil
s.store = jujuclienttesting.NewMemStore()
s.store.Controllers["local.test1"] = jujuclient.ControllerDetails{
APIEndpoints: []string{"localhost"},
CACert: testing.CACert,
ControllerUUID: test1UUID,
}
s.store.Controllers["test3"] = jujuclient.ControllerDetails{
APIEndpoints: []string{"localhost"},
CACert: testing.CACert,
ControllerUUID: test3UUID,
}
s.store.Accounts["local.test1"] = &jujuclient.ControllerAccounts{
CurrentAccount: "admin@local",
}
var modelList = []struct {
name string
serverUUID string
modelUUID string
bootstrapCfg map[string]interface{}
}{
{
name: "local.test1:admin",
serverUUID: test1UUID,
modelUUID: test1UUID,
bootstrapCfg: createBootstrapInfo(c, "admin"),
}, {
name: "test2:test2",
serverUUID: test1UUID,
modelUUID: test2UUID,
}, {
name: "test3:admin",
serverUUID: test3UUID,
modelUUID: test3UUID,
},
}
for _, model := range modelList {
controllerName, modelName := modelcmd.SplitModelName(model.name)
s.store.UpdateController(controllerName, jujuclient.ControllerDetails{
ControllerUUID: model.serverUUID,
APIEndpoints: []string{"localhost"},
CACert: testing.CACert,
})
s.store.UpdateModel(controllerName, "admin@local", modelName, jujuclient.ModelDetails{
ModelUUID: model.modelUUID,
})
if model.bootstrapCfg != nil {
s.store.BootstrapConfig[controllerName] = jujuclient.BootstrapConfig{
Config: createBootstrapInfo(c, "admin"),
}
}
uuid := model.modelUUID
s.api.allEnvs = append(s.api.allEnvs, base.UserModel{
Name: model.name,
UUID: uuid,
Owner: owner.Canonical(),
})
s.api.envStatus[model.modelUUID] = base.ModelStatus{
UUID: uuid,
Life: params.Dead,
HostedMachineCount: 0,
ServiceCount: 0,
Owner: owner.Canonical(),
}
}
}
func checkModelRemovedFromStore(c *gc.C, name string, store jujuclient.ClientStore) {
controller, model := modelcmd.SplitModelName(name)
_, err := store.ModelByName(controller, model)
c.Assert(err, jc.Satisfies, errors.IsNotFound)
}
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
}
func checkModelExistsInStore(c *gc.C, name string, store jujuclient.ClientStore) {
controller, model := modelcmd.SplitModelName(name)
_, err := store.ModelByName(controller, model)
c.Assert(err, jc.ErrorIsNil)
}
