This change includes a handful of stack-related CLI formatting improvements that I've been noodling on in the background for a while, based on things that tend to trip up demos and the inner loop workflow. This includes: * If `pulumi stack select` is run by itself, use an interactive CLI menu to let the user select an existing stack, or choose to create a new one. This looks as follows $ pulumi stack select Please choose a stack, or choose to create a new one: abcdef babblabblabble > currentlyselected defcon <create a new stack> and is navigated in the usual way (key up, down, enter). * If a stack name is passed that does not exist, prompt the user to ask whether s/he wants to create one on-demand. This hooks interesting moments in time, like `pulumi stack select foo`, and cuts down on the need to run additional commands. * If a current stack is required, but none is currently selected, then pop the same interactive menu shown above to select one. Depending on the command being run, we may or may not show the option to create a new stack (e.g., that doesn't make much sense when you're running `pulumi destroy`, but might when you're running `pulumi stack`). This again lets you do with a single command what would have otherwise entailed an error with multiple commands to recover from it. * If you run `pulumi stack init` without any additional arguments, we interactively prompt for the stack name. Before, we would error and you'd then need to run `pulumi stack init <name>`. * Colorize some things nicely; for example, now all prompts will by default become bright white.
173 lines
4.8 KiB
Go
173 lines
4.8 KiB
Go
// Copyright 2016-2017, Pulumi Corporation. All rights reserved.
|
|
|
|
package cmd
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"sort"
|
|
"strconv"
|
|
|
|
"github.com/dustin/go-humanize"
|
|
"github.com/spf13/cobra"
|
|
|
|
"github.com/pulumi/pulumi/pkg/backend/cloud"
|
|
"github.com/pulumi/pulumi/pkg/resource/stack"
|
|
"github.com/pulumi/pulumi/pkg/util/cmdutil"
|
|
)
|
|
|
|
func newStackCmd() *cobra.Command {
|
|
var showIDs bool
|
|
var showURNs bool
|
|
cmd := &cobra.Command{
|
|
Use: "stack",
|
|
Short: "Manage stacks",
|
|
Long: "Manage stacks\n" +
|
|
"\n" +
|
|
"An stack is a named update target, and a single project may have many of them.\n" +
|
|
"Each stack has a configuration and update history associated with it, stored in\n" +
|
|
"the workspace, in addition to a full checkpoint of the last known good update.\n",
|
|
Args: cmdutil.NoArgs,
|
|
Run: cmdutil.RunFunc(func(cmd *cobra.Command, args []string) error {
|
|
s, err := requireCurrentStack(true)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
// First print general info about the current stack.
|
|
fmt.Printf("Current stack is %v:\n", s.Name())
|
|
|
|
be := s.Backend()
|
|
fmt.Printf(" Managed by %s", be.Name())
|
|
if _, isCloud := be.(cloud.Backend); isCloud {
|
|
fmt.Printf(" ☁️\n")
|
|
if cs, ok := s.(cloud.Stack); ok {
|
|
fmt.Printf(" Organization %s\n", cs.OrgName())
|
|
fmt.Printf(" PPC %s\n", cs.CloudName())
|
|
}
|
|
} else {
|
|
fmt.Printf("\n")
|
|
}
|
|
|
|
snap := s.Snapshot()
|
|
if snap != nil {
|
|
if t := snap.Manifest.Time; t.IsZero() {
|
|
fmt.Printf(" Last update time unknown\n")
|
|
} else {
|
|
fmt.Printf(" Last updated %s (%v)\n", humanize.Time(t), t)
|
|
}
|
|
var cliver string
|
|
if snap.Manifest.Version == "" {
|
|
cliver = "?"
|
|
} else {
|
|
cliver = snap.Manifest.Version
|
|
}
|
|
fmt.Printf(" Pulumi version %s\n", cliver)
|
|
for _, plugin := range snap.Manifest.Plugins {
|
|
var plugver string
|
|
if plugin.Version == "" {
|
|
plugver = "?"
|
|
} else {
|
|
plugver = plugin.Version
|
|
}
|
|
fmt.Printf(" Plugin %s [%s] version %s\n", plugin.Name, plugin.Type, plugver)
|
|
}
|
|
} else {
|
|
fmt.Printf(" No updates yet; run 'pulumi update'\n")
|
|
}
|
|
|
|
cfg := s.Config()
|
|
if cfg != nil && len(cfg) > 0 {
|
|
fmt.Printf(" %v configuration variables set (see `pulumi config` for details)\n", len(cfg))
|
|
}
|
|
fmt.Printf("\n")
|
|
|
|
// Now show the resources.
|
|
var rescnt int
|
|
if snap != nil {
|
|
rescnt = len(snap.Resources)
|
|
}
|
|
fmt.Printf("Current stack resources (%d):\n", rescnt)
|
|
if rescnt == 0 {
|
|
fmt.Printf(" No resources currently in this stack\n")
|
|
} else {
|
|
fmt.Printf(" %-48s %s\n", "TYPE", "NAME")
|
|
for _, res := range snap.Resources {
|
|
fmt.Printf(" %-48s %s\n", res.Type, res.URN.Name())
|
|
|
|
// If the ID and/or URN is requested, show it on the following line. It would be nice to do
|
|
// this on a single line, but this can get quite lengthy and so this formatting is better.
|
|
if showURNs {
|
|
fmt.Printf(" URN: %s\n", res.URN)
|
|
}
|
|
if showIDs && res.ID != "" {
|
|
fmt.Printf(" ID: %s\n", res.ID)
|
|
}
|
|
}
|
|
|
|
// Print out the output properties for the stack, if present.
|
|
if res, outputs := stack.GetRootStackResource(snap); res != nil {
|
|
fmt.Printf("\n")
|
|
printStackOutputs(outputs)
|
|
}
|
|
}
|
|
fmt.Printf("\n")
|
|
|
|
fmt.Printf("Use `pulumi stack select` to change stack; `pulumi stack ls` lists known ones\n")
|
|
|
|
return nil
|
|
}),
|
|
}
|
|
|
|
cmd.PersistentFlags().BoolVarP(
|
|
&showIDs, "show-ids", "i", false, "Display each resource's provider-assigned unique ID")
|
|
cmd.PersistentFlags().BoolVarP(
|
|
&showURNs, "show-urns", "u", false, "Display each resource's Pulumi-assigned globally unique URN")
|
|
|
|
cmd.AddCommand(newStackInitCmd())
|
|
cmd.AddCommand(newStackLsCmd())
|
|
cmd.AddCommand(newStackOutputCmd())
|
|
cmd.AddCommand(newStackExportCmd())
|
|
cmd.AddCommand(newStackImportCmd())
|
|
cmd.AddCommand(newStackRmCmd())
|
|
cmd.AddCommand(newStackSelectCmd())
|
|
|
|
return cmd
|
|
}
|
|
|
|
func printStackOutputs(outputs map[string]interface{}) {
|
|
fmt.Printf("Current stack outputs (%d):\n", len(outputs))
|
|
if len(outputs) == 0 {
|
|
fmt.Printf(" No output values currently in this stack\n")
|
|
} else {
|
|
maxkey := 48
|
|
var outkeys []string
|
|
for outkey := range outputs {
|
|
if len(outkey) > maxkey {
|
|
maxkey = len(outkey)
|
|
}
|
|
outkeys = append(outkeys, outkey)
|
|
}
|
|
sort.Strings(outkeys)
|
|
fmt.Printf(" %-"+strconv.Itoa(maxkey)+"s %s\n", "OUTPUT", "VALUE")
|
|
for _, key := range outkeys {
|
|
fmt.Printf(" %-"+strconv.Itoa(maxkey)+"s %s\n", key, stringifyOutput(outputs[key]))
|
|
}
|
|
}
|
|
}
|
|
|
|
// stringifyOutput formats an output value for presentation to a user. We use JSON formatting, except in the case
|
|
// of top level strings, where we just return the raw value.
|
|
func stringifyOutput(v interface{}) string {
|
|
s, ok := v.(string)
|
|
if ok {
|
|
return s
|
|
}
|
|
|
|
b, err := json.Marshal(v)
|
|
if err != nil {
|
|
return "error: could not format value"
|
|
}
|
|
|
|
return string(b)
|
|
}
|