This change adds support for lists and maps in config. We now allow lists/maps (and nested structures) in `Pulumi.<stack>.yaml` (or `Pulumi.<stack>.json`; yes, we currently support that). For example: ```yaml config: proj:blah: - a - b - c proj:hello: world proj:outer: inner: value proj:servers: - port: 80 ``` While such structures could be specified in the `.yaml` file manually, we support setting values in maps/lists from the command line. As always, you can specify single values with: ```shell $ pulumi config set hello world ``` Which results in the following YAML: ```yaml proj:hello world ``` And single value secrets via: ```shell $ pulumi config set --secret token shhh ``` Which results in the following YAML: ```yaml proj:token: secure: v1:VZAhuroR69FkEPTk:isKafsoZVMWA9pQayGzbWNynww== ``` Values in a list can be set from the command line using the new `--path` flag, which indicates the config key contains a path to a property in a map or list: ```shell $ pulumi config set --path names[0] a $ pulumi config set --path names[1] b $ pulumi config set --path names[2] c ``` Which results in: ```yaml proj:names - a - b - c ``` Values can be obtained similarly: ```shell $ pulumi config get --path names[1] b ``` Or setting values in a map: ```shell $ pulumi config set --path outer.inner value ``` Which results in: ```yaml proj:outer: inner: value ``` Of course, setting values in nested structures is supported: ```shell $ pulumi config set --path servers[0].port 80 ``` Which results in: ```yaml proj:servers: - port: 80 ``` If you want to include a period in the name of a property, it can be specified as: ``` $ pulumi config set --path 'nested["foo.bar"]' baz ``` Which results in: ```yaml proj:nested: foo.bar: baz ``` Examples of valid paths: - root - root.nested - 'root["nested"]' - root.double.nest - 'root["double"].nest' - 'root["double"]["nest"]' - root.array[0] - root.array[100] - root.array[0].nested - root.array[0][1].nested - root.nested.array[0].double[1] - 'root["key with \"escaped\" quotes"]' - 'root["key with a ."]' - '["root key with \"escaped\" quotes"].nested' - '["root key with a ."][100]' Note: paths that contain quotes can be surrounded by single quotes. When setting values with `--path`, if the value is `"false"` or `"true"`, it will be saved as the boolean value, and if it is convertible to an integer, it will be saved as an integer. Secure values are supported in lists/maps as well: ```shell $ pulumi config set --path --secret tokens[0] shh ``` Will result in: ```yaml proj:tokens: - secure: v1:wpZRCe36sFg1RxwG:WzPeQrCn4n+m4Ks8ps15MxvFXg== ``` Note: maps of length 1 with a key of “secure” and string value are reserved for storing secret values. Attempting to create such a value manually will result in an error: ```shell $ pulumi config set --path parent.secure foo error: "secure" key in maps of length 1 are reserved ``` **Accessing config values from the command line with JSON** ```shell $ pulumi config --json ``` Will output: ```json { "proj:hello": { "value": "world", "secret": false, "object": false }, "proj:names": { "value": "[\"a\",\"b\",\"c\"]", "secret": false, "object": true, "objectValue": [ "a", "b", "c" ] }, "proj:nested": { "value": "{\"foo.bar\":\"baz\"}", "secret": false, "object": true, "objectValue": { "foo.bar": "baz" } }, "proj:outer": { "value": "{\"inner\":\"value\"}", "secret": false, "object": true, "objectValue": { "inner": "value" } }, "proj:servers": { "value": "[{\"port\":80}]", "secret": false, "object": true, "objectValue": [ { "port": 80 } ] }, "proj:token": { "secret": true, "object": false }, "proj:tokens": { "secret": true, "object": true } } ``` If the value is a map or list, `"object"` will be `true`. `"value"` will contain the object as serialized JSON and a new `"objectValue"` property will be available containing the value of the object. If the object contains any secret values, `"secret"` will be `true`, and just like with scalar values, the value will not be outputted unless `--show-secrets` is specified. **Accessing config values from Pulumi programs** Map/list values are available to Pulumi programs as serialized JSON, so the existing `getObject`/`requireObject`/`getSecretObject`/`requireSecretObject` functions can be used to retrieve such values, e.g.: ```typescript import * as pulumi from "@pulumi/pulumi"; interface Server { port: number; } const config = new pulumi.Config(); const names = config.requireObject<string[]>("names"); for (const n of names) { console.log(n); } const servers = config.requireObject<Server[]>("servers"); for (const s of servers) { console.log(s.port); } ```
207 lines
6.6 KiB
Go
207 lines
6.6 KiB
Go
// Copyright 2018, Pulumi Corporation.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
package cmd
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"sort"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/dustin/go-humanize"
|
|
"github.com/pkg/errors"
|
|
"github.com/spf13/cobra"
|
|
|
|
"github.com/pulumi/pulumi/pkg/backend"
|
|
"github.com/pulumi/pulumi/pkg/backend/display"
|
|
"github.com/pulumi/pulumi/pkg/diag/colors"
|
|
"github.com/pulumi/pulumi/pkg/resource/config"
|
|
"github.com/pulumi/pulumi/pkg/util/cmdutil"
|
|
"github.com/pulumi/pulumi/pkg/util/contract"
|
|
)
|
|
|
|
func newHistoryCmd() *cobra.Command {
|
|
var stack string
|
|
var jsonOut bool
|
|
var showSecrets bool
|
|
var cmd = &cobra.Command{
|
|
Use: "history",
|
|
Aliases: []string{"hist"},
|
|
SuggestFor: []string{"updates"},
|
|
Short: "[PREVIEW] Update history for a stack",
|
|
Long: `Update history for a stack
|
|
|
|
This command lists data about previous updates for a stack.`,
|
|
Args: cmdutil.NoArgs,
|
|
Run: cmdutil.RunFunc(func(cmd *cobra.Command, args []string) error {
|
|
opts := display.Options{
|
|
Color: cmdutil.GetGlobalColorization(),
|
|
}
|
|
s, err := requireStack(stack, false /*offerNew */, opts, false /*setCurrent*/)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
b := s.Backend()
|
|
updates, err := b.GetHistory(commandContext(), s.Ref())
|
|
if err != nil {
|
|
return errors.Wrap(err, "getting history")
|
|
}
|
|
var decrypter config.Decrypter
|
|
if showSecrets {
|
|
crypter, err := getStackDencrypter(s)
|
|
if err != nil {
|
|
return errors.Wrap(err, "decrypting secrets")
|
|
}
|
|
decrypter = crypter
|
|
}
|
|
|
|
if jsonOut {
|
|
return displayUpdatesJSON(updates, decrypter)
|
|
}
|
|
|
|
return displayUpdatesConsole(updates, opts)
|
|
}),
|
|
}
|
|
cmd.PersistentFlags().StringVarP(
|
|
&stack, "stack", "s", "",
|
|
"Choose a stack other than the currently selected one")
|
|
cmd.Flags().BoolVar(
|
|
&showSecrets, "show-secrets", false,
|
|
"Show secret values when listing config instead of displaying blinded values")
|
|
cmd.PersistentFlags().BoolVarP(
|
|
&jsonOut, "json", "j", false, "Emit output as JSON")
|
|
return cmd
|
|
}
|
|
|
|
// updateInfoJSON is the shape of the --json output for a configuration value. While we can add fields to this
|
|
// structure in the future, we should not change existing fields.
|
|
type updateInfoJSON struct {
|
|
Kind string `json:"kind"`
|
|
StartTime string `json:"startTime"`
|
|
Message string `json:"message"`
|
|
Environment map[string]string `json:"environment"`
|
|
Config map[string]configValueJSON `json:"config"`
|
|
Result string `json:"result,omitempty"`
|
|
|
|
// These values are only present once the update finishes
|
|
EndTime *string `json:"endTime,omitempty"`
|
|
ResourceChanges *map[string]int `json:"resourceChanges,omitempty"`
|
|
}
|
|
|
|
func displayUpdatesJSON(updates []backend.UpdateInfo, decrypter config.Decrypter) error {
|
|
makeStringRef := func(s string) *string {
|
|
return &s
|
|
}
|
|
|
|
updatesJSON := make([]updateInfoJSON, len(updates))
|
|
for idx, update := range updates {
|
|
info := updateInfoJSON{
|
|
Kind: string(update.Kind),
|
|
StartTime: time.Unix(update.StartTime, 0).UTC().Format(timeFormat),
|
|
Message: update.Message,
|
|
Environment: update.Environment,
|
|
}
|
|
|
|
info.Config = make(map[string]configValueJSON)
|
|
for k, v := range update.Config {
|
|
configValue := configValueJSON{
|
|
Secret: v.Secure(),
|
|
}
|
|
if !v.Secure() || (v.Secure() && decrypter != nil) {
|
|
value, err := v.Value(decrypter)
|
|
contract.AssertNoError(err)
|
|
configValue.Value = makeStringRef(value)
|
|
|
|
if v.Object() {
|
|
var obj interface{}
|
|
if err := json.Unmarshal([]byte(value), &obj); err != nil {
|
|
return err
|
|
}
|
|
configValue.ObjectValue = obj
|
|
}
|
|
}
|
|
|
|
info.Config[k.String()] = configValue
|
|
}
|
|
info.Result = string(update.Result)
|
|
if update.Result != backend.InProgressResult {
|
|
info.EndTime = makeStringRef(time.Unix(update.EndTime, 0).UTC().Format(timeFormat))
|
|
resourceChanges := make(map[string]int)
|
|
for k, v := range update.ResourceChanges {
|
|
resourceChanges[string(k)] = v
|
|
}
|
|
info.ResourceChanges = &resourceChanges
|
|
}
|
|
updatesJSON[idx] = info
|
|
}
|
|
|
|
return printJSON(updatesJSON)
|
|
}
|
|
|
|
func displayUpdatesConsole(updates []backend.UpdateInfo, opts display.Options) error {
|
|
if len(updates) == 0 {
|
|
fmt.Println("Stack has never been updated")
|
|
return nil
|
|
}
|
|
|
|
printResourceChanges := func(background, text, sign, reset string, amount int) {
|
|
msg := opts.Color.Colorize(fmt.Sprintf("%s%s%s%v%s", background, text, sign, amount, reset))
|
|
fmt.Print(msg)
|
|
}
|
|
|
|
for _, update := range updates {
|
|
|
|
fmt.Printf("UpdateKind: %v\n", update.Kind)
|
|
if update.Result == "succeeded" {
|
|
fmt.Print(opts.Color.Colorize(fmt.Sprintf("%sStatus: %v%s\n", colors.Green, update.Result, colors.Reset)))
|
|
} else {
|
|
fmt.Print(opts.Color.Colorize(fmt.Sprintf("%sStatus: %v%s\n", colors.Red, update.Result, colors.Reset)))
|
|
}
|
|
fmt.Printf("Message: %v\n", update.Message)
|
|
|
|
printResourceChanges(colors.GreenBackground, colors.Black, "+", colors.Reset, update.ResourceChanges["create"])
|
|
printResourceChanges(colors.RedBackground, colors.Black, "-", colors.Reset, update.ResourceChanges["delete"])
|
|
printResourceChanges(colors.YellowBackground, colors.Black, "~", colors.Reset, update.ResourceChanges["update"])
|
|
printResourceChanges(colors.BlueBackground, colors.Black, " ", colors.Reset, update.ResourceChanges["same"])
|
|
|
|
timeStart := time.Unix(update.StartTime, 0)
|
|
timeCreated := humanize.Time(timeStart)
|
|
timeEnd := time.Unix(update.EndTime, 0)
|
|
duration := timeEnd.Sub(timeStart)
|
|
fmt.Printf("%sUpdated %s took %s\n", " ", timeCreated, duration)
|
|
|
|
isEmpty := func(s string) bool {
|
|
return len(strings.TrimSpace(s)) == 0
|
|
}
|
|
var keys []string
|
|
for k := range update.Environment {
|
|
keys = append(keys, k)
|
|
}
|
|
sort.Strings(keys)
|
|
indent := 4
|
|
for _, k := range keys {
|
|
if k == backend.GitHead && !isEmpty(update.Environment[k]) {
|
|
fmt.Print(opts.Color.Colorize(
|
|
fmt.Sprintf("%*s%s%s: %s%s\n", indent, "", colors.Yellow, k, update.Environment[k], colors.Reset)))
|
|
} else if !isEmpty(update.Environment[k]) {
|
|
fmt.Printf("%*s%s: %s\n", indent, "", k, update.Environment[k])
|
|
}
|
|
}
|
|
fmt.Println("")
|
|
}
|
|
|
|
return nil
|
|
}
|