2018-05-22 19:43:36 +00:00
|
|
|
// Copyright 2016-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.
|
2017-03-15 22:40:06 +00:00
|
|
|
|
2017-09-22 02:18:21 +00:00
|
|
|
package cmd
|
2017-03-15 22:40:06 +00:00
|
|
|
|
|
|
|
import (
|
2018-05-05 18:57:09 +00:00
|
|
|
"github.com/pkg/errors"
|
2017-03-15 22:40:06 +00:00
|
|
|
"github.com/spf13/cobra"
|
Make major commands more pleasant
This change eliminates the need to constantly type in the environment
name when performing major commands like configuration, planning, and
deployment. It's probably due to my age, however, I keep fat-fingering
simple commands in front of investors and I am embarrassed!
In the new model, there is a notion of a "current environment", and
I have modeled it kinda sorta just like Git's notion of "current branch."
By default, the current environment is set when you `init` something.
Otherwise, there is the `coco env select <env>` command to change it.
(Running this command w/out a new <env> will show you the current one.)
The major commands `config`, `plan`, `deploy`, and `destroy` will prefer
to use the current environment, unless it is overridden by using the
--env flag. All of the `coco env <cmd> <env>` commands still require the
explicit passing of an environment which seems reasonable since they are,
after all, about manipulating environments.
As part of this, I've overhauled the aging workspace settings cruft,
which had fallen into disrepair since the initial prototype.
2017-03-22 02:23:32 +00:00
|
|
|
|
2018-05-05 18:57:09 +00:00
|
|
|
"github.com/pulumi/pulumi/pkg/backend"
|
2018-09-04 22:40:15 +00:00
|
|
|
"github.com/pulumi/pulumi/pkg/backend/display"
|
2018-05-05 18:57:09 +00:00
|
|
|
"github.com/pulumi/pulumi/pkg/engine"
|
2017-09-22 02:18:21 +00:00
|
|
|
"github.com/pulumi/pulumi/pkg/util/cmdutil"
|
2017-03-15 22:40:06 +00:00
|
|
|
)
|
|
|
|
|
2017-09-22 22:15:42 +00:00
|
|
|
func newPreviewCmd() *cobra.Command {
|
2017-07-14 00:09:46 +00:00
|
|
|
var debug bool
|
2018-05-16 00:33:16 +00:00
|
|
|
var expectNop bool
|
2018-05-05 18:57:09 +00:00
|
|
|
var message string
|
2017-10-16 19:04:35 +00:00
|
|
|
var stack string
|
2018-01-18 19:10:15 +00:00
|
|
|
|
|
|
|
// Flags for engine.UpdateOptions.
|
|
|
|
var analyzers []string
|
Implement a refresh command
This change implements a `pulumi refresh` command. It operates a bit
like `pulumi update`, and friends, in that it supports `--preview` and
`--diff`, along with the usual flags, and will update your checkpoint.
It works through substitution of the deploy.Source abstraction, which
generates a sequence of resource registration events. This new
deploy.RefreshSource takes in a prior checkpoint and will walk it,
refreshing the state via the associated resource providers by invoking
Read for each resource encountered, and merging the resulting state with
the prior checkpoint, to yield a new resource.Goal state. This state is
then fed through the engine in the usual ways with a few minor caveats:
namely, although the engine must generate steps for the logical
operations (permitting us to get nice summaries, progress, and diffs),
it mustn't actually carry them out because the state being imported
already reflects reality (a deleted resource has *already* been deleted,
so of course the engine need not perform the deletion). The diffing
logic also needs to know how to treat the case of refresh slightly
differently, because we are going to be diffing outputs and not inputs.
Note that support for managed stacks is not yet complete, since that
requires updates to the service to support a refresh endpoint. That
will be coming soon ...
2018-04-10 18:22:39 +00:00
|
|
|
var diffDisplay bool
|
2017-09-17 15:10:46 +00:00
|
|
|
var parallel int
|
2017-03-15 22:40:06 +00:00
|
|
|
var showConfig bool
|
2017-08-06 17:05:51 +00:00
|
|
|
var showReplacementSteps bool
|
2017-06-11 15:09:20 +00:00
|
|
|
var showSames bool
|
2018-10-06 21:13:02 +00:00
|
|
|
var suppressOutputs bool
|
2018-01-18 19:10:15 +00:00
|
|
|
|
2017-03-15 22:40:06 +00:00
|
|
|
var cmd = &cobra.Command{
|
2017-10-21 00:36:47 +00:00
|
|
|
Use: "preview",
|
2017-11-13 22:59:11 +00:00
|
|
|
Aliases: []string{"pre"},
|
|
|
|
SuggestFor: []string{"build", "plan"},
|
2018-05-05 18:57:09 +00:00
|
|
|
Short: "Show a preview of updates to a stack's resources",
|
|
|
|
Long: "Show a preview of updates a stack's resources.\n" +
|
|
|
|
"\n" +
|
|
|
|
"This command displays a preview of the updates to an existing stack whose state is\n" +
|
|
|
|
"represented by an existing snapshot file. The new desired state is computed by running\n" +
|
|
|
|
"a Pulumi program, and extracting all resource allocations from its resulting object graph.\n" +
|
|
|
|
"These allocations are then compared against the existing state to determine what\n" +
|
|
|
|
"operations must take place to achieve the desired state. No changes to the stack will\n" +
|
|
|
|
"actually take place.\n" +
|
|
|
|
"\n" +
|
|
|
|
"The program to run is loaded from the project in the current directory. Use the `-C` or\n" +
|
|
|
|
"`--cwd` flag to use a different directory.",
|
|
|
|
Args: cmdutil.NoArgs,
|
2017-04-12 18:12:25 +00:00
|
|
|
Run: cmdutil.RunFunc(func(cmd *cobra.Command, args []string) error {
|
2018-05-05 18:57:09 +00:00
|
|
|
opts := backend.UpdateOptions{
|
|
|
|
Engine: engine.UpdateOptions{
|
|
|
|
Analyzers: analyzers,
|
|
|
|
Parallel: parallel,
|
|
|
|
Debug: debug,
|
|
|
|
},
|
2018-09-04 22:40:15 +00:00
|
|
|
Display: display.Options{
|
2018-07-07 04:30:00 +00:00
|
|
|
Color: cmdutil.GetGlobalColorization(),
|
2018-05-05 18:57:09 +00:00
|
|
|
ShowConfig: showConfig,
|
|
|
|
ShowReplacementSteps: showReplacementSteps,
|
|
|
|
ShowSameResources: showSames,
|
2018-10-06 21:13:02 +00:00
|
|
|
SuppressOutputs: suppressOutputs,
|
2018-09-29 17:49:14 +00:00
|
|
|
IsInteractive: cmdutil.Interactive(),
|
2018-05-05 18:57:09 +00:00
|
|
|
DiffDisplay: diffDisplay,
|
|
|
|
Debug: debug,
|
|
|
|
},
|
|
|
|
}
|
2018-07-07 04:30:00 +00:00
|
|
|
|
Initial support for passing URLs to `new` and `up` (#1727)
* Initial support for passing URLs to `new` and `up`
This PR adds initial support for `pulumi new` using Git under the covers
to manage Pulumi templates, providing the same experience as before.
You can now also optionally pass a URL to a Git repository, e.g.
`pulumi new [<url>]`, including subdirectories within the repository,
and arbitrary branches, tags, or commits.
The following commands result in the same behavior from the user's
perspective:
- `pulumi new javascript`
- `pulumi new https://github.com/pulumi/templates/templates/javascript`
- `pulumi new https://github.com/pulumi/templates/tree/master/templates/javascript`
- `pulumi new https://github.com/pulumi/templates/tree/HEAD/templates/javascript`
To specify an arbitrary branch, tag, or commit:
- `pulumi new https://github.com/pulumi/templates/tree/<branch>/templates/javascript`
- `pulumi new https://github.com/pulumi/templates/tree/<tag>/templates/javascript`
- `pulumi new https://github.com/pulumi/templates/tree/<commit>/templates/javascript`
Branches and tags can include '/' separators, and `pulumi` will still
find the right subdirectory.
URLs to Gists are also supported, e.g.:
`pulumi new https://gist.github.com/justinvp/6673959ceb9d2ac5a14c6d536cb871a6`
If the specified subdirectory in the repository does not contain a
`Pulumi.yaml`, it will look for subdirectories within containing
`Pulumi.yaml` files, and prompt the user to choose a template, along the
lines of how `pulumi new` behaves when no template is specified.
The following commands result in the CLI prompting to choose a template:
- `pulumi new`
- `pulumi new https://github.com/pulumi/templates/templates`
- `pulumi new https://github.com/pulumi/templates/tree/master/templates`
- `pulumi new https://github.com/pulumi/templates/tree/HEAD/templates`
Of course, arbitrary branches, tags, or commits can be specified as well:
- `pulumi new https://github.com/pulumi/templates/tree/<branch>/templates`
- `pulumi new https://github.com/pulumi/templates/tree/<tag>/templates`
- `pulumi new https://github.com/pulumi/templates/tree/<commit>/templates`
This PR also includes initial support for passing URLs to `pulumi up`,
providing a streamlined way to deploy installable cloud applications
with Pulumi, without having to manage source code locally before doing
a deployment.
For example, `pulumi up https://github.com/justinvp/aws` can be used to
deploy a sample AWS app. The stack can be updated with different
versions, e.g.
`pulumi up https://github.com/justinvp/aws/tree/v2 -s <stack-to-update>`
Config values can optionally be passed via command line flags, e.g.
`pulumi up https://github.com/justinvp/aws -c aws:region=us-west-2 -c foo:bar=blah`
Gists can also be used, e.g.
`pulumi up https://gist.github.com/justinvp/62fde0463f243fcb49f5a7222e51bc76`
* Fix panic when hitting ^C from "choose template" prompt
* Add description to templates
When running `pulumi new` without specifying a template, include the template description along with the name in the "choose template" display.
```
$ pulumi new
Please choose a template:
aws-go A minimal AWS Go program
aws-javascript A minimal AWS JavaScript program
aws-python A minimal AWS Python program
aws-typescript A minimal AWS TypeScript program
> go A minimal Go program
hello-aws-javascript A simple AWS serverless JavaScript program
javascript A minimal JavaScript program
python A minimal Python program
typescript A minimal TypeScript program
```
* React to changes to the pulumi/templates repo.
We restructured the `pulumi/templates` repo to have all the templates in the root instead of in a `templates` subdirectory, so make the change here to no longer look for templates in `templates`.
This also fixes an issue around using `Depth: 1` that I found while testing this. When a named template is used, we attempt to clone or pull from the `pulumi/templates` repo to `~/.pulumi/templates`. Having it go in this well-known directory allows us to maintain previous behavior around allowing offline use of templates. If we use `Depth: 1` for the initial clone, it will fail when attempting to pull when there are updates to the remote repository. Unfortunately, there's no built-in `--unshallow` support in `go-git` and setting a larger `Depth` doesn't appear to help. There may be a workaround, but for now, if we're cloning the pulumi templates directory to `~/.pulumi/templates`, we won't use `Depth: 1`. For template URLs, we will continue to use `Depth: 1` as we clone those to a temp directory (which gets deleted) that we'll never try to update.
* List available templates in help text
* Address PR Feedback
* Don't show "Installing dependencies" message for `up`
* Fix secrets handling
When prompting for config, if the existing stack value is a secret, keep it a secret and mask the prompt. If the template says it should be secret, make it a secret.
* Fix ${PROJECT} and ${DESCRIPTION} handling for `up`
Templates used with `up` should already have a filled-in project name and description, but if it's a `new`-style template, that has `${PROJECT}` and/or `${DESCRIPTION}`, be helpful and just replace these with better values.
* Fix stack handling
Add a bool `setCurrent` param to `requireStack` to control whether the current stack should be saved in workspace settings. For the `up <url>` case, we don't want to save. Also, split the `up` code into two separate functions: one for the `up <url>` case and another for the normal `up` case where you have workspace in your current directory. While we may be able to combine them back into a single function, right now it's a bit cleaner being separate, even with some small amount of duplication.
* Fix panic due to nil crypter
Lazily get the crypter only if needed inside `promptForConfig`.
* Embellish comment
* Harden isPreconfiguredEmptyStack check
Fix the code to check to make sure the URL specified on the command line matches the URL stored in the `pulumi:template` config value, and that the rest of the config from the stack satisfies the config requirements of the template.
2018-08-11 01:08:16 +00:00
|
|
|
s, err := requireStack(stack, true, opts.Display, true /*setCurrent*/)
|
2018-07-07 04:30:00 +00:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
proj, root, err := readProject()
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
m, err := getUpdateMetadata("", root)
|
|
|
|
if err != nil {
|
|
|
|
return errors.Wrap(err, "gathering environment metadata")
|
|
|
|
}
|
|
|
|
|
2018-09-05 14:20:25 +00:00
|
|
|
changes, err := s.Preview(commandContext(), backend.UpdateOperation{
|
|
|
|
Proj: proj,
|
|
|
|
Root: root,
|
|
|
|
M: m,
|
|
|
|
Opts: opts,
|
|
|
|
Scopes: cancellationScopes,
|
|
|
|
})
|
2018-05-16 00:33:16 +00:00
|
|
|
switch {
|
|
|
|
case err != nil:
|
Add a list of in-flight operations to the deployment (#1759)
* Add a list of in-flight operations to the deployment
This commit augments 'DeploymentV2' with a list of operations that are
currently in flight. This information is used by the engine to keep
track of whether or not a particular deployment is in a valid state.
The SnapshotManager is responsible for inserting and removing operations
from the in-flight operation list. When the engine registers an intent
to perform an operation, SnapshotManager inserts an Operation into this
list and saves it to the snapshot. When an operation completes, the
SnapshotManager removes it from the snapshot. From this, the engine can
infer that if it ever sees a deployment with pending operations, the
Pulumi CLI must have crashed or otherwise abnormally terminated before
seeing whether or not an operation completed successfully.
To remedy this state, this commit also adds code to 'pulumi stack
import' that clears all pending operations from a deployment, as well as
code to plan generation that will reject any deployments that have
pending operations present.
At the CLI level, if we see that we are in a state where pending
operations were in-flight when the engine died, we'll issue a
human-friendly error message that indicates which resources are in a bad
state and how to recover their stack.
* CR: Multi-line string literals, renaming in-flight -> pending
* CR: Add enum to apitype for operation type, also name status -> type for clarity
* Fix the yaml type
* Fix missed renames
* Add implementation for lifecycle_test.go
* Rebase against master
2018-08-11 04:39:59 +00:00
|
|
|
return PrintEngineError(err)
|
2018-05-16 17:22:09 +00:00
|
|
|
case expectNop && changes != nil && changes.HasChanges():
|
2018-05-16 00:33:16 +00:00
|
|
|
return errors.New("error: no changes were expected but changes were proposed")
|
|
|
|
default:
|
|
|
|
return nil
|
|
|
|
}
|
2017-03-15 22:40:06 +00:00
|
|
|
}),
|
|
|
|
}
|
|
|
|
|
2017-07-14 00:09:46 +00:00
|
|
|
cmd.PersistentFlags().BoolVarP(
|
|
|
|
&debug, "debug", "d", false,
|
|
|
|
"Print detailed debugging output during resource operations")
|
2018-05-16 00:33:16 +00:00
|
|
|
cmd.PersistentFlags().BoolVar(
|
|
|
|
&expectNop, "expect-no-changes", false,
|
|
|
|
"Return an error if any changes are proposed by this preview")
|
Make major commands more pleasant
This change eliminates the need to constantly type in the environment
name when performing major commands like configuration, planning, and
deployment. It's probably due to my age, however, I keep fat-fingering
simple commands in front of investors and I am embarrassed!
In the new model, there is a notion of a "current environment", and
I have modeled it kinda sorta just like Git's notion of "current branch."
By default, the current environment is set when you `init` something.
Otherwise, there is the `coco env select <env>` command to change it.
(Running this command w/out a new <env> will show you the current one.)
The major commands `config`, `plan`, `deploy`, and `destroy` will prefer
to use the current environment, unless it is overridden by using the
--env flag. All of the `coco env <cmd> <env>` commands still require the
explicit passing of an environment which seems reasonable since they are,
after all, about manipulating environments.
As part of this, I've overhauled the aging workspace settings cruft,
which had fallen into disrepair since the initial prototype.
2017-03-22 02:23:32 +00:00
|
|
|
cmd.PersistentFlags().StringVarP(
|
2017-10-16 19:04:35 +00:00
|
|
|
&stack, "stack", "s", "",
|
2018-06-26 00:24:53 +00:00
|
|
|
"The name of the stack to operate on. Defaults to the current stack")
|
2018-01-18 19:10:15 +00:00
|
|
|
|
2018-05-05 18:57:09 +00:00
|
|
|
cmd.PersistentFlags().StringVarP(
|
|
|
|
&message, "message", "m", "",
|
|
|
|
"Optional message to associate with the preview operation")
|
|
|
|
|
2018-01-18 19:10:15 +00:00
|
|
|
// Flags for engine.UpdateOptions.
|
|
|
|
cmd.PersistentFlags().StringSliceVar(
|
|
|
|
&analyzers, "analyzer", []string{},
|
|
|
|
"Run one or more analyzers as part of this update")
|
Implement a refresh command
This change implements a `pulumi refresh` command. It operates a bit
like `pulumi update`, and friends, in that it supports `--preview` and
`--diff`, along with the usual flags, and will update your checkpoint.
It works through substitution of the deploy.Source abstraction, which
generates a sequence of resource registration events. This new
deploy.RefreshSource takes in a prior checkpoint and will walk it,
refreshing the state via the associated resource providers by invoking
Read for each resource encountered, and merging the resulting state with
the prior checkpoint, to yield a new resource.Goal state. This state is
then fed through the engine in the usual ways with a few minor caveats:
namely, although the engine must generate steps for the logical
operations (permitting us to get nice summaries, progress, and diffs),
it mustn't actually carry them out because the state being imported
already reflects reality (a deleted resource has *already* been deleted,
so of course the engine need not perform the deletion). The diffing
logic also needs to know how to treat the case of refresh slightly
differently, because we are going to be diffing outputs and not inputs.
Note that support for managed stacks is not yet complete, since that
requires updates to the service to support a refresh endpoint. That
will be coming soon ...
2018-04-10 18:22:39 +00:00
|
|
|
cmd.PersistentFlags().BoolVar(
|
|
|
|
&diffDisplay, "diff", false,
|
|
|
|
"Display operation as a rich diff showing the overall change")
|
2017-09-17 15:10:46 +00:00
|
|
|
cmd.PersistentFlags().IntVarP(
|
2018-08-27 23:41:20 +00:00
|
|
|
¶llel, "parallel", "p", defaultParallel,
|
2018-10-29 17:24:04 +00:00
|
|
|
"Allow P resource operations to run in parallel at once (1 for no parallelism). Defaults to unbounded.")
|
2017-03-15 22:40:06 +00:00
|
|
|
cmd.PersistentFlags().BoolVar(
|
|
|
|
&showConfig, "show-config", false,
|
|
|
|
"Show configuration keys and variables")
|
Implement `get` functions on all resources
This change implements the `get` function for resources. Per pulumi/lumi#83,
this allows Lumi scripts to actually read from the target environment.
For example, we can now look up a SecurityGroup from its ARN:
let group = aws.ec2.SecurityGroup.get(
"arn:aws:ec2:us-west-2:153052954103:security-group:sg-02150d79");
The returned object is a fully functional resource object. So, we can then
link it up with an EC2 instance, for example, in the usual ways:
let instance = new aws.ec2.Instance(..., {
securityGroups: [ group ],
});
This didn't require any changes to the RPC or provider model, since we
already implement the Get function.
There are a few loose ends; two are short term:
1) URNs are not rehydrated.
2) Query is not yet implemented.
One is mid-term:
3) We probably want a URN-based lookup function. But we will likely
wait until we tackle pulumi/lumi#109 before adding this.
And one is long term (and subtle):
4) These amount to I/O and are not repeatable! A change in the target
environment may cause a script to generate a different plan
intermittently. Most likely we want to apply a different kind of
deployment "policy" for such scripts. These are inching towards the
scripting model of pulumi/lumi#121, which is an entirely different
beast than the repeatable immutable infrastructure deployments.
Finally, it is worth noting that with this, we have some of the fundamental
underpinnings required to finally tackle "inference" (pulumi/lumi#142).
2017-06-20 00:24:00 +00:00
|
|
|
cmd.PersistentFlags().BoolVar(
|
2017-08-06 17:05:51 +00:00
|
|
|
&showReplacementSteps, "show-replacement-steps", false,
|
|
|
|
"Show detailed resource replacement creates and deletes instead of a single step")
|
2017-03-15 22:40:06 +00:00
|
|
|
cmd.PersistentFlags().BoolVar(
|
2017-06-11 15:09:20 +00:00
|
|
|
&showSames, "show-sames", false,
|
2017-03-15 22:40:06 +00:00
|
|
|
"Show resources that needn't be updated because they haven't changed, alongside those that do")
|
2018-10-06 21:13:02 +00:00
|
|
|
cmd.PersistentFlags().BoolVar(
|
|
|
|
&suppressOutputs, "suppress-outputs", false,
|
|
|
|
"Suppress display of stack outputs (in case they contain sensitive values)")
|
2017-03-15 22:40:06 +00:00
|
|
|
|
|
|
|
return cmd
|
|
|
|
}
|