Tests now target managed stacks instead of local stacks. The existing logged in user and target backend API are used unless PULUMI_ACCES_TOKEN is defined, in which case tests are run under that access token and against the PULUMI_API backend. For developer machines, we will now need to be logged in to Pulumi to run tests, and whichever default API backend is logged in (the one listed as current in ~/.pulumi/credentials.json) will be used. If you need to override these, provide PULUMI_ACCESS_TOKEN and possibly PULUMI_API. For Travis, we currently target the staging service using the Pulumi Bot user. We have decided to run tests in the pulumi organization. This can be overridden for local testing (or in Travis in the future) by defining PULUMI_API_OWNER_ORGANIZATION and using an access token with access to that organization. Part of pulumi/home#195.
97 lines
3.3 KiB
Go
97 lines
3.3 KiB
Go
// Copyright 2016-2018, Pulumi Corporation. All rights reserved.
|
|
|
|
package cmd
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"os"
|
|
|
|
"github.com/hashicorp/go-multierror"
|
|
"github.com/pkg/errors"
|
|
"github.com/spf13/cobra"
|
|
|
|
"github.com/pulumi/pulumi/pkg/apitype"
|
|
"github.com/pulumi/pulumi/pkg/diag"
|
|
"github.com/pulumi/pulumi/pkg/util/cmdutil"
|
|
)
|
|
|
|
func newStackImportCmd() *cobra.Command {
|
|
var force bool
|
|
var file string
|
|
cmd := &cobra.Command{
|
|
Use: "import",
|
|
Args: cmdutil.MaximumNArgs(0),
|
|
Short: "Import a deployment from standard in into an existing stack",
|
|
Long: "Import a deployment from standard in into an existing stack.\n" +
|
|
"\n" +
|
|
"A deployment that was exported from a stack using `pulumi stack export` and\n" +
|
|
"hand-edited to correct inconsistencies due to failed updates, manual changes\n" +
|
|
"to cloud resources, etc. can be reimported to the stack using this command.\n" +
|
|
"The updated deployment will be read from standard in.",
|
|
Run: cmdutil.RunFunc(func(cmd *cobra.Command, args []string) error {
|
|
// Fetch the current stack and import a deployment.
|
|
s, err := requireCurrentStack(false)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
// Read from stdin or a specified file
|
|
reader := os.Stdin
|
|
if file != "" {
|
|
reader, err = os.Open(file)
|
|
if err != nil {
|
|
return errors.Wrap(err, "could not open file")
|
|
}
|
|
}
|
|
|
|
// Read the checkpoint from stdin. We decode this into a json.RawMessage so as not to lose any fields
|
|
// sent by the server that the client CLI does not recognize (enabling round-tripping).
|
|
var deployment apitype.UntypedDeployment
|
|
if err = json.NewDecoder(reader).Decode(&deployment); err != nil {
|
|
return err
|
|
}
|
|
|
|
// We do, however, now want to unmarshal the json.RawMessage into a real, typed deployment. We do this so
|
|
// we can check that the deployment doesn't contain resources from a stack other than the selected one. This
|
|
// catches errors wherein someone imports the wrong stack's deployment (which can seriously hork things).
|
|
var typed apitype.Deployment
|
|
if err = json.Unmarshal(deployment.Deployment, &typed); err != nil {
|
|
return err
|
|
}
|
|
var result error
|
|
for _, res := range typed.Resources {
|
|
if res.URN.Stack() != s.Name() {
|
|
msg := fmt.Sprintf("resource '%s' is from a different stack (%s != %s)",
|
|
res.URN, res.URN.Stack(), s.Name())
|
|
if force {
|
|
// If --force was passed, just issue a warning and proceed anyway.
|
|
cmdutil.Diag().Warningf(diag.Message(msg))
|
|
} else {
|
|
// Otherwise, gather up an error so that we can quit before doing damage.
|
|
result = multierror.Append(result, errors.New(msg))
|
|
}
|
|
}
|
|
}
|
|
if result != nil {
|
|
return multierror.Append(result,
|
|
errors.New("importing this file could be dangerous; rerun with --force to proceed anyway"))
|
|
}
|
|
|
|
// Now perform the deployment.
|
|
if err = s.ImportDeployment(&deployment); err != nil {
|
|
return errors.Wrap(err, "could not import deployment")
|
|
}
|
|
fmt.Printf("Import successful.\n")
|
|
return nil
|
|
}),
|
|
}
|
|
|
|
cmd.PersistentFlags().BoolVarP(
|
|
&force, "force", "f", false,
|
|
"Force the import to occur, even if apparent errors are discovered beforehand (not recommended)")
|
|
cmd.PersistentFlags().StringVarP(
|
|
&file, "file", "", "", "A filename to read stack input from")
|
|
|
|
return cmd
|
|
}
|