func (c *registerCommand) maybeSetCurrentModel(ctx *cmd.Context, store jujuclient.ClientStore, controllerName, userName string, models []base.UserModel) error { if len(models) == 0 { fmt.Fprintf(ctx.Stderr, "\n%s\n\n", errNoModels.Error()) return nil } // If we get to here, there is at least one model. if len(models) == 1 { // There is exactly one model shared, // so set it as the current model. model := models[0] owner := names.NewUserTag(model.Owner) modelName := jujuclient.JoinOwnerModelName(owner, model.Name) err := store.SetCurrentModel(controllerName, modelName) if err != nil { return errors.Trace(err) } fmt.Fprintf(ctx.Stderr, "\nCurrent model set to %q.\n\n", modelName) } else { fmt.Fprintf(ctx.Stderr, ` There are %d models available. Use "juju switch" to select one of them: `, len(models)) user := names.NewUserTag(userName) ownerModelNames := make(set.Strings) otherModelNames := make(set.Strings) for _, model := range models { if model.Owner == userName { ownerModelNames.Add(model.Name) continue } owner := names.NewUserTag(model.Owner) modelName := common.OwnerQualifiedModelName(model.Name, owner, user) otherModelNames.Add(modelName) } for _, modelName := range ownerModelNames.SortedValues() { fmt.Fprintf(ctx.Stderr, " - juju switch %s\n", modelName) } for _, modelName := range otherModelNames.SortedValues() { fmt.Fprintf(ctx.Stderr, " - juju switch %s\n", modelName) } fmt.Fprintln(ctx.Stderr) } return nil }
// Run implements Command.Run func (c *whoAmICommand) Run(ctx *cmd.Context) error { controllerName, err := c.store.CurrentController() if err != nil && !errors.IsNotFound(err) { return err } if err != nil { fmt.Fprintln(ctx.Stderr, "There is no current controller.\nRun juju list-controllers to see available controllers.") return nil } modelName, err := c.store.CurrentModel(controllerName) if err != nil && !errors.IsNotFound(err) { return err } userDetails, err := c.store.AccountDetails(controllerName) if err != nil && !errors.IsNotFound(err) { return err } if err != nil { fmt.Fprintf(ctx.Stderr, "You are not logged in to controller %q and model %q.\nRun juju login if you want to login.\n", controllerName, modelName) return nil } // Only qualify model name if there is a current model. if modelName != "" { if unqualifiedModelName, owner, err := jujuclient.SplitModelName(modelName); err == nil { user := names.NewUserTag(userDetails.User) modelName = common.OwnerQualifiedModelName(unqualifiedModelName, owner, user) } } result := whoAmI{ ControllerName: controllerName, ModelName: modelName, UserName: userDetails.User, } return c.out.Write(ctx, result) }
// convertControllerDetails takes a map of Controllers and // the recently used model for each and creates a list of // amalgamated controller and model details. func (c *listControllersCommand) convertControllerDetails(storeControllers map[string]jujuclient.ControllerDetails) (map[string]ControllerItem, []string) { if len(storeControllers) == 0 { return nil, nil } errs := []string{} addError := func(msg, controllerName string, err error) { logger.Errorf(fmt.Sprintf("getting current %s for controller %s: %v", msg, controllerName, err)) errs = append(errs, msg) } controllers := map[string]ControllerItem{} for controllerName, details := range storeControllers { serverName := "" // The most recently connected-to address // is the first in the list. if len(details.APIEndpoints) > 0 { serverName = details.APIEndpoints[0] } var userName, access string accountDetails, err := c.store.AccountDetails(controllerName) if err != nil { if !errors.IsNotFound(err) { addError("account details", controllerName, err) continue } } else { userName = accountDetails.User access = accountDetails.LastKnownAccess } var modelName string currentModel, err := c.store.CurrentModel(controllerName) if err != nil { if !errors.IsNotFound(err) { addError("model", controllerName, err) continue } } else { modelName = currentModel if userName != "" { // There's a user logged in, so display the // model name relative to that user. if unqualifiedModelName, owner, err := jujuclient.SplitModelName(modelName); err == nil { user := names.NewUserTag(userName) modelName = common.OwnerQualifiedModelName(unqualifiedModelName, owner, user) } } } item := ControllerItem{ ModelName: modelName, User: userName, Access: access, Server: serverName, APIEndpoints: details.APIEndpoints, ControllerUUID: details.ControllerUUID, CACert: details.CACert, Cloud: details.Cloud, CloudRegion: details.CloudRegion, AgentVersion: details.AgentVersion, } if details.MachineCount != nil && *details.MachineCount > 0 { item.MachineCount = details.MachineCount } if details.ModelCount != nil && *details.ModelCount > 0 { item.ModelCount = details.ModelCount } if details.ControllerMachineCount > 0 { item.ControllerMachines = &ControllerMachines{ Total: details.ControllerMachineCount, Active: details.ActiveControllerMachineCount, } } controllers[controllerName] = item } return controllers, errs }
// formatTabular takes an interface{} to adhere to the cmd.Formatter interface func (c *modelsCommand) formatTabular(writer io.Writer, value interface{}) error { modelSet, ok := value.(ModelSet) if !ok { return errors.Errorf("expected value of type %T, got %T", modelSet, value) } // We need the tag of the user for which we're listing models, // and for the logged-in user. We use these below when formatting // the model display names. loggedInUser := names.NewUserTag(c.loggedInUser) userForLastConn := loggedInUser var userForListing names.UserTag if c.user != "" { userForListing = names.NewUserTag(c.user) userForLastConn = userForListing } tw := output.TabWriter(writer) w := output.Wrapper{tw} w.Println("Controller: " + c.ControllerName()) w.Println() w.Print("Model") if c.listUUID { w.Print("UUID") } // Only owners, or users with write access or above get to see machines and cores. haveMachineInfo := false for _, m := range modelSet.Models { if haveMachineInfo = len(m.Machines) > 0; haveMachineInfo { break } } if haveMachineInfo { w.Println("Owner", "Status", "Machines", "Cores", "Access", "Last connection") offset := 0 if c.listUUID { offset++ } tw.SetColumnAlignRight(3 + offset) tw.SetColumnAlignRight(4 + offset) } else { w.Println("Owner", "Status", "Access", "Last connection") } for _, model := range modelSet.Models { owner := names.NewUserTag(model.Owner) name := common.OwnerQualifiedModelName(model.Name, owner, userForListing) if jujuclient.JoinOwnerModelName(owner, model.Name) == modelSet.CurrentModelQualified { name += "*" w.PrintColor(output.CurrentHighlight, name) } else { w.Print(name) } if c.listUUID { w.Print(model.UUID) } lastConnection := model.Users[userForLastConn.Id()].LastConnection if lastConnection == "" { lastConnection = "never connected" } userForAccess := loggedInUser if c.user != "" { userForAccess = names.NewUserTag(c.user) } access := model.Users[userForAccess.Id()].Access w.Print(model.Owner, model.Status.Current) if haveMachineInfo { machineInfo := fmt.Sprintf("%d", len(model.Machines)) cores := uint64(0) for _, m := range model.Machines { cores += m.Cores } coresInfo := "-" if cores > 0 { coresInfo = fmt.Sprintf("%d", cores) } w.Print(machineInfo, coresInfo) } w.Println(access, lastConnection) } tw.Flush() return nil }
// Run implements Command.Run func (c *modelsCommand) Run(ctx *cmd.Context) error { accountDetails, err := c.ClientStore().AccountDetails(c.ControllerName()) if err != nil { return err } c.loggedInUser = accountDetails.User // First get a list of the models. var models []base.UserModel if c.all { models, err = c.getAllModels() } else { if c.user == "" { c.user = accountDetails.User } models, err = c.getUserModels() } if err != nil { return errors.Annotate(err, "cannot list models") } // And now get the full details of the models. paramsModelInfo, err := c.getModelInfo(models) if err != nil { return errors.Annotate(err, "cannot get model details") } // TODO(perrito666) 2016-05-02 lp:1558657 now := time.Now() modelInfo := make([]common.ModelInfo, 0, len(models)) for _, info := range paramsModelInfo { model, err := common.ModelInfoFromParams(info, now) if err != nil { return errors.Trace(err) } model.ControllerName = c.ControllerName() modelInfo = append(modelInfo, model) } modelSet := ModelSet{Models: modelInfo} current, err := c.ClientStore().CurrentModel(c.ControllerName()) if err != nil && !errors.IsNotFound(err) { return err } modelSet.CurrentModelQualified = current modelSet.CurrentModel = current if c.user != "" { userForListing := names.NewUserTag(c.user) unqualifiedModelName, owner, err := jujuclient.SplitModelName(current) if err == nil { modelSet.CurrentModel = common.OwnerQualifiedModelName( unqualifiedModelName, owner, userForListing, ) } } if err := c.out.Write(ctx, modelSet); err != nil { return err } if len(models) == 0 && c.out.Name() == "tabular" { // When the output is tabular, we inform the user when there // are no models available, and tell them how to go about // creating or granting access to them. fmt.Fprintln(ctx.Stderr, noModelsMessage) } return nil }