2018-03-21 20:43:21 +01:00
|
|
|
// Copyright 2016-2018, Pulumi Corporation. All rights reserved.
|
2017-10-19 00:37:18 +02:00
|
|
|
|
2017-10-03 01:37:12 +02:00
|
|
|
package cmd
|
|
|
|
|
|
|
|
import (
|
2017-10-05 23:08:46 +02:00
|
|
|
"fmt"
|
2017-10-03 01:37:12 +02:00
|
|
|
"os"
|
2017-10-25 19:20:08 +02:00
|
|
|
"os/user"
|
2018-01-25 03:22:41 +01:00
|
|
|
"path"
|
2017-10-25 19:20:08 +02:00
|
|
|
"path/filepath"
|
Make some stack-related CLI improvements (#947)
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.
2018-02-17 00:03:54 +01:00
|
|
|
"sort"
|
2017-10-25 19:20:08 +02:00
|
|
|
"strings"
|
|
|
|
|
2017-10-08 16:18:53 +02:00
|
|
|
"github.com/pkg/errors"
|
Make some stack-related CLI improvements (#947)
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.
2018-02-17 00:03:54 +01:00
|
|
|
"gopkg.in/AlecAivazis/survey.v1"
|
|
|
|
surveycore "gopkg.in/AlecAivazis/survey.v1/core"
|
Improve the overall cloud CLI experience
This improves the overall cloud CLI experience workflow.
Now whether a stack is local or cloud is inherent to the stack
itself. If you interact with a cloud stack, we transparently talk
to the cloud; if you interact with a local stack, we just do the
right thing, and perform all operations locally. Aside from sometimes
seeing a cloud emoji pop-up ☁️, the experience is quite similar.
For example, to initialize a new cloud stack, simply:
$ pulumi login
Logging into Pulumi Cloud: https://pulumi.com/
Enter Pulumi access token: <enter your token>
$ pulumi stack init my-cloud-stack
Note that you may log into a specific cloud if you'd like. For
now, this is just for our own testing purposes, but someday when we
support custom clouds (e.g., Enterprise), you can just say:
$ pulumi login --cloud-url https://corp.acme.my-ppc.net:9873
The cloud is now the default. If you instead prefer a "fire and
forget" style of stack, you can skip the login and pass `--local`:
$ pulumi stack init my-faf-stack --local
If you are logged in and run `pulumi`, we tell you as much:
$ pulumi
Usage:
pulumi [command]
// as before...
Currently logged into the Pulumi Cloud ☁️
https://pulumi.com/
And if you list your stacks, we tell you which one is local or not:
$ pulumi stack ls
NAME LAST UPDATE RESOURCE COUNT CLOUD URL
my-cloud-stack 2017-12-01 ... 3 https://pulumi.com/
my-faf-stack n/a 0 n/a
And `pulumi stack` by itself prints information like your cloud org,
PPC name, and so on, in addition to the usuals.
I shall write up more details and make sure to document these changes.
This change also fairly significantly refactors the layout of cloud
versus local logic, so that the cmd/ package is resonsible for CLI
things, and the new pkg/backend/ package is responsible for the
backends. The following is the overall resulting package architecture:
* The backend.Backend interface can be implemented to substitute
a new backend. This has operations to get and list stacks,
perform updates, and so on.
* The backend.Stack struct is a wrapper around a stack that has
or is being manipulated by a Backend. It resembles our existing
Stack notions in the engine, but carries additional metadata
about its source. Notably, it offers functions that allow
operations like updating and deleting on the Backend from which
it came.
* There is very little else in the pkg/backend/ package.
* A new package, pkg/backend/local/, encapsulates all local state
management for "fire and forget" scenarios. It simply implements
the above logic and contains anything specific to the local
experience.
* A peer package, pkg/backend/cloud/, encapsulates all logic
required for the cloud experience. This includes its subpackage
apitype/ which contains JSON schema descriptions required for
REST calls against the cloud backend. It also contains handy
functions to list which clouds we have authenticated with.
* A subpackage here, pkg/backend/state/, is not a provider at all.
Instead, it contains all of the state management functions that
are currently shared between local and cloud backends. This
includes configuration logic -- including encryption -- as well
as logic pertaining to which stacks are known to the workspace.
This addresses pulumi/pulumi#629 and pulumi/pulumi#494.
2017-12-02 16:29:46 +01:00
|
|
|
git "gopkg.in/src-d/go-git.v4"
|
2018-01-25 03:22:41 +01:00
|
|
|
"gopkg.in/src-d/go-git.v4/plumbing"
|
2017-10-08 16:18:53 +02:00
|
|
|
|
Improve the overall cloud CLI experience
This improves the overall cloud CLI experience workflow.
Now whether a stack is local or cloud is inherent to the stack
itself. If you interact with a cloud stack, we transparently talk
to the cloud; if you interact with a local stack, we just do the
right thing, and perform all operations locally. Aside from sometimes
seeing a cloud emoji pop-up ☁️, the experience is quite similar.
For example, to initialize a new cloud stack, simply:
$ pulumi login
Logging into Pulumi Cloud: https://pulumi.com/
Enter Pulumi access token: <enter your token>
$ pulumi stack init my-cloud-stack
Note that you may log into a specific cloud if you'd like. For
now, this is just for our own testing purposes, but someday when we
support custom clouds (e.g., Enterprise), you can just say:
$ pulumi login --cloud-url https://corp.acme.my-ppc.net:9873
The cloud is now the default. If you instead prefer a "fire and
forget" style of stack, you can skip the login and pass `--local`:
$ pulumi stack init my-faf-stack --local
If you are logged in and run `pulumi`, we tell you as much:
$ pulumi
Usage:
pulumi [command]
// as before...
Currently logged into the Pulumi Cloud ☁️
https://pulumi.com/
And if you list your stacks, we tell you which one is local or not:
$ pulumi stack ls
NAME LAST UPDATE RESOURCE COUNT CLOUD URL
my-cloud-stack 2017-12-01 ... 3 https://pulumi.com/
my-faf-stack n/a 0 n/a
And `pulumi stack` by itself prints information like your cloud org,
PPC name, and so on, in addition to the usuals.
I shall write up more details and make sure to document these changes.
This change also fairly significantly refactors the layout of cloud
versus local logic, so that the cmd/ package is resonsible for CLI
things, and the new pkg/backend/ package is responsible for the
backends. The following is the overall resulting package architecture:
* The backend.Backend interface can be implemented to substitute
a new backend. This has operations to get and list stacks,
perform updates, and so on.
* The backend.Stack struct is a wrapper around a stack that has
or is being manipulated by a Backend. It resembles our existing
Stack notions in the engine, but carries additional metadata
about its source. Notably, it offers functions that allow
operations like updating and deleting on the Backend from which
it came.
* There is very little else in the pkg/backend/ package.
* A new package, pkg/backend/local/, encapsulates all local state
management for "fire and forget" scenarios. It simply implements
the above logic and contains anything specific to the local
experience.
* A peer package, pkg/backend/cloud/, encapsulates all logic
required for the cloud experience. This includes its subpackage
apitype/ which contains JSON schema descriptions required for
REST calls against the cloud backend. It also contains handy
functions to list which clouds we have authenticated with.
* A subpackage here, pkg/backend/state/, is not a provider at all.
Instead, it contains all of the state management functions that
are currently shared between local and cloud backends. This
includes configuration logic -- including encryption -- as well
as logic pertaining to which stacks are known to the workspace.
This addresses pulumi/pulumi#629 and pulumi/pulumi#494.
2017-12-02 16:29:46 +01:00
|
|
|
"github.com/pulumi/pulumi/pkg/backend"
|
|
|
|
"github.com/pulumi/pulumi/pkg/backend/cloud"
|
|
|
|
"github.com/pulumi/pulumi/pkg/backend/local"
|
|
|
|
"github.com/pulumi/pulumi/pkg/backend/state"
|
2017-12-18 20:42:32 +01:00
|
|
|
"github.com/pulumi/pulumi/pkg/diag/colors"
|
2018-04-05 00:31:01 +02:00
|
|
|
"github.com/pulumi/pulumi/pkg/resource/config"
|
2017-10-03 01:37:12 +02:00
|
|
|
"github.com/pulumi/pulumi/pkg/tokens"
|
2017-12-13 19:46:54 +01:00
|
|
|
"github.com/pulumi/pulumi/pkg/util/cmdutil"
|
2017-10-05 23:08:46 +02:00
|
|
|
"github.com/pulumi/pulumi/pkg/util/contract"
|
Improve the overall cloud CLI experience
This improves the overall cloud CLI experience workflow.
Now whether a stack is local or cloud is inherent to the stack
itself. If you interact with a cloud stack, we transparently talk
to the cloud; if you interact with a local stack, we just do the
right thing, and perform all operations locally. Aside from sometimes
seeing a cloud emoji pop-up ☁️, the experience is quite similar.
For example, to initialize a new cloud stack, simply:
$ pulumi login
Logging into Pulumi Cloud: https://pulumi.com/
Enter Pulumi access token: <enter your token>
$ pulumi stack init my-cloud-stack
Note that you may log into a specific cloud if you'd like. For
now, this is just for our own testing purposes, but someday when we
support custom clouds (e.g., Enterprise), you can just say:
$ pulumi login --cloud-url https://corp.acme.my-ppc.net:9873
The cloud is now the default. If you instead prefer a "fire and
forget" style of stack, you can skip the login and pass `--local`:
$ pulumi stack init my-faf-stack --local
If you are logged in and run `pulumi`, we tell you as much:
$ pulumi
Usage:
pulumi [command]
// as before...
Currently logged into the Pulumi Cloud ☁️
https://pulumi.com/
And if you list your stacks, we tell you which one is local or not:
$ pulumi stack ls
NAME LAST UPDATE RESOURCE COUNT CLOUD URL
my-cloud-stack 2017-12-01 ... 3 https://pulumi.com/
my-faf-stack n/a 0 n/a
And `pulumi stack` by itself prints information like your cloud org,
PPC name, and so on, in addition to the usuals.
I shall write up more details and make sure to document these changes.
This change also fairly significantly refactors the layout of cloud
versus local logic, so that the cmd/ package is resonsible for CLI
things, and the new pkg/backend/ package is responsible for the
backends. The following is the overall resulting package architecture:
* The backend.Backend interface can be implemented to substitute
a new backend. This has operations to get and list stacks,
perform updates, and so on.
* The backend.Stack struct is a wrapper around a stack that has
or is being manipulated by a Backend. It resembles our existing
Stack notions in the engine, but carries additional metadata
about its source. Notably, it offers functions that allow
operations like updating and deleting on the Backend from which
it came.
* There is very little else in the pkg/backend/ package.
* A new package, pkg/backend/local/, encapsulates all local state
management for "fire and forget" scenarios. It simply implements
the above logic and contains anything specific to the local
experience.
* A peer package, pkg/backend/cloud/, encapsulates all logic
required for the cloud experience. This includes its subpackage
apitype/ which contains JSON schema descriptions required for
REST calls against the cloud backend. It also contains handy
functions to list which clouds we have authenticated with.
* A subpackage here, pkg/backend/state/, is not a provider at all.
Instead, it contains all of the state management functions that
are currently shared between local and cloud backends. This
includes configuration logic -- including encryption -- as well
as logic pertaining to which stacks are known to the workspace.
This addresses pulumi/pulumi#629 and pulumi/pulumi#494.
2017-12-02 16:29:46 +01:00
|
|
|
"github.com/pulumi/pulumi/pkg/util/fsutil"
|
2018-01-08 22:01:40 +01:00
|
|
|
"github.com/pulumi/pulumi/pkg/workspace"
|
2017-10-03 01:37:12 +02:00
|
|
|
)
|
|
|
|
|
2018-04-05 00:31:01 +02:00
|
|
|
func currentBackend() (backend.Backend, error) {
|
|
|
|
creds, err := workspace.GetStoredCredentials()
|
2017-10-03 01:37:12 +02:00
|
|
|
if err != nil {
|
2018-04-05 00:31:01 +02:00
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
if local.IsLocalBackendURL(creds.Current) {
|
|
|
|
return local.New(cmdutil.Diag()), nil
|
2017-10-03 01:37:12 +02:00
|
|
|
}
|
2018-04-05 00:31:01 +02:00
|
|
|
return cloud.Login(cmdutil.Diag(), creds.Current)
|
|
|
|
}
|
|
|
|
|
|
|
|
func isLoggedIn() (bool, error) {
|
|
|
|
creds, err := workspace.GetStoredCredentials()
|
|
|
|
if err != nil {
|
|
|
|
return false, err
|
|
|
|
}
|
|
|
|
if creds.Current == "" {
|
|
|
|
return false, nil
|
|
|
|
} else if local.IsLocalBackendURL(creds.Current) {
|
|
|
|
return true, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
return cloud.IsValidAccessToken(creds.Current, creds.AccessTokens[creds.Current])
|
2017-10-03 01:37:12 +02:00
|
|
|
}
|
|
|
|
|
Make some stack-related CLI improvements (#947)
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.
2018-02-17 00:03:54 +01:00
|
|
|
// createStack creates a stack with the given name, and selects it as the current.
|
|
|
|
func createStack(b backend.Backend, stackName tokens.QName, opts interface{}) (backend.Stack, error) {
|
|
|
|
stack, err := b.CreateStack(stackName, opts)
|
|
|
|
if err != nil {
|
|
|
|
return nil, errors.Wrapf(err, "could not create stack")
|
|
|
|
}
|
|
|
|
|
|
|
|
if err = state.SetCurrentStack(stackName); err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
return stack, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// requireStack will require that a stack exists. If stackName is blank, the currently selected stack from
|
|
|
|
// the workspace is returned. If no stack with either the given name, or a currently selected stack, exists,
|
|
|
|
// and we are in an interactive terminal, the user will be prompted to create a new stack.
|
|
|
|
func requireStack(stackName tokens.QName, offerNew bool) (backend.Stack, error) {
|
2017-11-01 22:55:16 +01:00
|
|
|
if stackName == "" {
|
Make some stack-related CLI improvements (#947)
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.
2018-02-17 00:03:54 +01:00
|
|
|
return requireCurrentStack(offerNew)
|
2017-11-01 22:55:16 +01:00
|
|
|
}
|
Make some stack-related CLI improvements (#947)
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.
2018-02-17 00:03:54 +01:00
|
|
|
|
|
|
|
// Search all known backends for this stack.
|
2018-04-05 00:31:01 +02:00
|
|
|
b, err := currentBackend()
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
stack, err := state.Stack(stackName, b)
|
2017-10-17 01:01:34 +02:00
|
|
|
if err != nil {
|
2017-10-17 21:28:03 +02:00
|
|
|
return nil, err
|
2017-10-17 01:01:34 +02:00
|
|
|
}
|
Make some stack-related CLI improvements (#947)
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.
2018-02-17 00:03:54 +01:00
|
|
|
if stack != nil {
|
|
|
|
return stack, err
|
|
|
|
}
|
|
|
|
|
|
|
|
// No stack was found. If we're in a terminal, prompt to create one.
|
|
|
|
if cmdutil.Interactive() {
|
|
|
|
fmt.Printf("The stack '%s' does not exist.\n", stackName)
|
|
|
|
fmt.Printf("\n")
|
2018-04-05 00:31:01 +02:00
|
|
|
_, err = cmdutil.ReadConsole("If you would like to create this stack now, please press <ENTER>, otherwise " +
|
|
|
|
"press ^C")
|
Make some stack-related CLI improvements (#947)
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.
2018-02-17 00:03:54 +01:00
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
return createStack(b, stackName, nil)
|
|
|
|
}
|
|
|
|
|
|
|
|
return nil, errors.Errorf("no stack named '%s' found; double check that you're logged in", stackName)
|
2017-10-19 00:37:18 +02:00
|
|
|
}
|
|
|
|
|
Make some stack-related CLI improvements (#947)
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.
2018-02-17 00:03:54 +01:00
|
|
|
func requireCurrentStack(offerNew bool) (backend.Stack, error) {
|
|
|
|
// Search for the current stack.
|
2018-04-05 00:31:01 +02:00
|
|
|
b, err := currentBackend()
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
stack, err := state.CurrentStack(b)
|
2017-10-19 00:37:18 +02:00
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
Make some stack-related CLI improvements (#947)
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.
2018-02-17 00:03:54 +01:00
|
|
|
} else if stack != nil {
|
|
|
|
return stack, nil
|
2017-10-19 00:37:18 +02:00
|
|
|
}
|
Make some stack-related CLI improvements (#947)
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.
2018-02-17 00:03:54 +01:00
|
|
|
|
|
|
|
// If no current stack exists, and we are interactive, prompt to select or create one.
|
2018-04-05 00:31:01 +02:00
|
|
|
return chooseStack(b, offerNew)
|
Make some stack-related CLI improvements (#947)
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.
2018-02-17 00:03:54 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
// chooseStack will prompt the user to choose amongst the full set of stacks in the given backends. If offerNew is
|
|
|
|
// true, then the option to create an entirely new stack is provided and will create one as desired.
|
2018-04-05 00:31:01 +02:00
|
|
|
func chooseStack(b backend.Backend, offerNew bool) (backend.Stack, error) {
|
Make some stack-related CLI improvements (#947)
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.
2018-02-17 00:03:54 +01:00
|
|
|
// Prepare our error in case we need to issue it. Bail early if we're not interactive.
|
|
|
|
var chooseStackErr string
|
|
|
|
if offerNew {
|
|
|
|
chooseStackErr = "no stack selected; please use `pulumi stack select` or `pulumi stack init` to choose one"
|
|
|
|
} else {
|
|
|
|
chooseStackErr = "no stack selected; please use `pulumi stack select` to choose one"
|
|
|
|
}
|
|
|
|
if !cmdutil.Interactive() {
|
|
|
|
return nil, errors.New(chooseStackErr)
|
|
|
|
}
|
|
|
|
|
|
|
|
// First create a list and map of stack names.
|
|
|
|
var options []string
|
|
|
|
stacks := make(map[string]backend.Stack)
|
2018-04-05 00:31:01 +02:00
|
|
|
allStacks, err := b.ListStacks()
|
|
|
|
if err != nil {
|
|
|
|
return nil, errors.Wrapf(err, "could not query backend for stacks")
|
|
|
|
}
|
|
|
|
for _, stack := range allStacks {
|
|
|
|
name := string(stack.Name())
|
|
|
|
options = append(options, name)
|
|
|
|
stacks[name] = stack
|
Make some stack-related CLI improvements (#947)
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.
2018-02-17 00:03:54 +01:00
|
|
|
}
|
|
|
|
sort.Strings(options)
|
|
|
|
|
|
|
|
// If we are offering to create a new stack, add that to the end of the list.
|
|
|
|
newOption := "<create a new stack>"
|
|
|
|
if offerNew {
|
|
|
|
options = append(options, newOption)
|
|
|
|
} else if len(options) == 0 {
|
|
|
|
// If no options are available, we can't offer a choice!
|
|
|
|
return nil, errors.New("this command requires a stack, but there are none; are you logged in?")
|
|
|
|
}
|
|
|
|
|
|
|
|
// If a stack is already selected, make that the default.
|
|
|
|
var current string
|
2018-04-05 00:31:01 +02:00
|
|
|
currStack, currErr := state.CurrentStack(b)
|
Make some stack-related CLI improvements (#947)
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.
2018-02-17 00:03:54 +01:00
|
|
|
contract.IgnoreError(currErr)
|
|
|
|
if currStack != nil {
|
|
|
|
current = string(currStack.Name())
|
|
|
|
}
|
|
|
|
|
|
|
|
// Customize the prompt a little bit (and disable color since it doesn't match our scheme).
|
|
|
|
surveycore.DisableColor = true
|
|
|
|
surveycore.QuestionIcon = ""
|
|
|
|
surveycore.SelectFocusIcon = colors.ColorizeText(colors.BrightGreen + ">" + colors.Reset)
|
|
|
|
message := "\rPlease choose a stack"
|
|
|
|
if offerNew {
|
|
|
|
message += ", or create a new one:"
|
|
|
|
} else {
|
|
|
|
message += ":"
|
|
|
|
}
|
|
|
|
message = colors.ColorizeText(colors.BrightWhite + message + colors.Reset)
|
|
|
|
|
|
|
|
var option string
|
|
|
|
if err := survey.AskOne(&survey.Select{
|
|
|
|
Message: message,
|
|
|
|
Options: options,
|
|
|
|
Default: current,
|
|
|
|
}, &option, nil); err != nil {
|
|
|
|
return nil, errors.New(chooseStackErr)
|
|
|
|
}
|
|
|
|
|
|
|
|
if option == newOption {
|
|
|
|
stackName, err := cmdutil.ReadConsole("Please enter your desired stack name")
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
return createStack(b, tokens.QName(stackName), nil)
|
|
|
|
}
|
|
|
|
|
|
|
|
return stacks[option], nil
|
2017-10-19 00:37:18 +02:00
|
|
|
}
|
2017-10-25 19:20:08 +02:00
|
|
|
|
|
|
|
func detectOwnerAndName(dir string) (string, string, error) {
|
|
|
|
owner, repo, err := getGitHubProjectForOrigin(dir)
|
|
|
|
if err == nil {
|
|
|
|
return owner, repo, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
user, err := user.Current()
|
|
|
|
if err != nil {
|
|
|
|
return "", "", err
|
|
|
|
}
|
|
|
|
|
|
|
|
return user.Username, filepath.Base(dir), nil
|
|
|
|
}
|
|
|
|
|
2018-01-25 03:22:41 +01:00
|
|
|
// getGitRepository returns the git repository by walking up from the provided directory.
|
|
|
|
// If no repository is found, will return (nil, nil).
|
|
|
|
func getGitRepository(dir string) (*git.Repository, error) {
|
2017-10-25 19:20:08 +02:00
|
|
|
gitRoot, err := fsutil.WalkUp(dir, func(s string) bool { return filepath.Base(s) == ".git" }, nil)
|
|
|
|
if err != nil {
|
2018-01-25 03:22:41 +01:00
|
|
|
return nil, errors.Wrapf(err, "searching for git repository from %v", dir)
|
2017-10-25 19:20:08 +02:00
|
|
|
}
|
|
|
|
if gitRoot == "" {
|
2018-01-25 03:22:41 +01:00
|
|
|
return nil, nil
|
2017-10-25 19:20:08 +02:00
|
|
|
}
|
|
|
|
|
2018-01-25 03:22:41 +01:00
|
|
|
// Open the git repo in the .git folder's parent, not the .git folder itself.
|
|
|
|
repo, err := git.PlainOpen(path.Join(gitRoot, ".."))
|
|
|
|
if err == git.ErrRepositoryNotExists {
|
|
|
|
return nil, nil
|
|
|
|
}
|
|
|
|
if err != nil {
|
|
|
|
return nil, errors.Wrap(err, "reading git repository")
|
|
|
|
}
|
|
|
|
return repo, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func getGitHubProjectForOrigin(dir string) (string, string, error) {
|
|
|
|
repo, err := getGitRepository(dir)
|
|
|
|
if repo == nil {
|
|
|
|
return "", "", fmt.Errorf("no git repository found from %v", dir)
|
|
|
|
}
|
2017-10-25 19:20:08 +02:00
|
|
|
if err != nil {
|
|
|
|
return "", "", err
|
|
|
|
}
|
2018-01-25 03:22:41 +01:00
|
|
|
return getGitHubProjectForOriginByRepo(repo)
|
|
|
|
}
|
2017-10-25 19:20:08 +02:00
|
|
|
|
2018-01-25 03:22:41 +01:00
|
|
|
// Returns the GitHub login, and GitHub repo name if the "origin" remote is
|
|
|
|
// a GitHub URL.
|
|
|
|
func getGitHubProjectForOriginByRepo(repo *git.Repository) (string, string, error) {
|
2017-10-25 19:20:08 +02:00
|
|
|
remote, err := repo.Remote("origin")
|
|
|
|
if err != nil {
|
|
|
|
return "", "", errors.Wrap(err, "could not read origin information")
|
|
|
|
}
|
|
|
|
|
2018-01-25 03:22:41 +01:00
|
|
|
remoteURL := ""
|
|
|
|
if len(remote.Config().URLs) > 0 {
|
|
|
|
remoteURL = remote.Config().URLs[0]
|
|
|
|
}
|
2017-10-25 19:20:08 +02:00
|
|
|
project := ""
|
|
|
|
|
|
|
|
const GitHubSSHPrefix = "git@github.com:"
|
|
|
|
const GitHubHTTPSPrefix = "https://github.com/"
|
|
|
|
const GitHubRepositorySuffix = ".git"
|
|
|
|
|
|
|
|
if strings.HasPrefix(remoteURL, GitHubSSHPrefix) {
|
|
|
|
project = trimGitRemoteURL(remoteURL, GitHubSSHPrefix, GitHubRepositorySuffix)
|
|
|
|
} else if strings.HasPrefix(remoteURL, GitHubHTTPSPrefix) {
|
|
|
|
project = trimGitRemoteURL(remoteURL, GitHubHTTPSPrefix, GitHubRepositorySuffix)
|
|
|
|
}
|
|
|
|
|
|
|
|
split := strings.Split(project, "/")
|
|
|
|
|
|
|
|
if len(split) != 2 {
|
|
|
|
return "", "", errors.Errorf("could not detect GitHub project from url: %v", remote)
|
|
|
|
}
|
|
|
|
|
|
|
|
return split[0], split[1], nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func trimGitRemoteURL(url string, prefix string, suffix string) string {
|
|
|
|
return strings.TrimSuffix(strings.TrimPrefix(url, prefix), suffix)
|
|
|
|
}
|
2017-12-14 20:53:02 +01:00
|
|
|
|
2018-02-14 22:56:16 +01:00
|
|
|
// readProject attempts to detect and read the project for the current workspace. If an error occurs, it will be
|
|
|
|
// printed to Stderr, and the returned value will be nil. If the project is successfully detected and read, it
|
|
|
|
// is returned along with the path to its containing directory, which will be used as the root of the project's
|
2018-01-08 22:01:40 +01:00
|
|
|
// Pulumi program.
|
2018-02-14 22:56:16 +01:00
|
|
|
func readProject() (*workspace.Project, string, error) {
|
2018-01-08 22:01:40 +01:00
|
|
|
pwd, err := os.Getwd()
|
|
|
|
if err != nil {
|
|
|
|
return nil, "", err
|
|
|
|
}
|
|
|
|
|
|
|
|
// Now that we got here, we have a path, so we will try to load it.
|
2018-02-14 22:56:16 +01:00
|
|
|
path, err := workspace.DetectProjectPathFrom(pwd)
|
2018-01-08 22:01:40 +01:00
|
|
|
if err != nil {
|
2018-02-14 22:56:16 +01:00
|
|
|
return nil, "", errors.Wrapf(err,
|
|
|
|
"could not locate Pulumi.yaml project file (searching upwards from %s)", pwd)
|
|
|
|
} else if path == "" {
|
|
|
|
return nil, "", errors.Errorf(
|
|
|
|
"no Pulumi.yaml project file found (searching upwards from %s)", pwd)
|
2018-01-08 22:01:40 +01:00
|
|
|
}
|
2018-02-14 22:56:16 +01:00
|
|
|
proj, err := workspace.LoadProject(path)
|
2018-01-08 22:01:40 +01:00
|
|
|
if err != nil {
|
|
|
|
return nil, "", err
|
|
|
|
}
|
|
|
|
|
2018-02-14 22:56:16 +01:00
|
|
|
return proj, filepath.Dir(path), nil
|
2018-01-08 22:01:40 +01:00
|
|
|
}
|
2018-01-18 20:10:15 +01:00
|
|
|
|
|
|
|
type colorFlag struct {
|
|
|
|
value colors.Colorization
|
|
|
|
}
|
|
|
|
|
|
|
|
func (cf *colorFlag) String() string {
|
|
|
|
return string(cf.Colorization())
|
|
|
|
}
|
|
|
|
|
|
|
|
func (cf *colorFlag) Set(value string) error {
|
|
|
|
switch value {
|
|
|
|
case "always":
|
|
|
|
cf.value = colors.Always
|
|
|
|
case "never":
|
|
|
|
cf.value = colors.Never
|
|
|
|
case "raw":
|
|
|
|
cf.value = colors.Raw
|
|
|
|
// Backwards compat for old flag values.
|
|
|
|
case "auto":
|
|
|
|
cf.value = colors.Always
|
|
|
|
default:
|
|
|
|
return errors.Errorf("unsupported color option: '%s'. Supported values are: always, never, raw", value)
|
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (cf *colorFlag) Type() string {
|
|
|
|
return "colors.Colorization"
|
|
|
|
}
|
|
|
|
|
|
|
|
func (cf *colorFlag) Colorization() colors.Colorization {
|
|
|
|
if cf.value == "" {
|
|
|
|
return colors.Always
|
|
|
|
}
|
|
|
|
|
|
|
|
return cf.value
|
|
|
|
}
|
2018-01-25 03:22:41 +01:00
|
|
|
|
|
|
|
// getUpdateMetadata returns an UpdateMetadata object, with optional data about the environment
|
|
|
|
// performing the update.
|
|
|
|
func getUpdateMetadata(msg, root string) (backend.UpdateMetadata, error) {
|
|
|
|
m := backend.UpdateMetadata{
|
|
|
|
Message: msg,
|
|
|
|
Environment: make(map[string]string),
|
|
|
|
}
|
|
|
|
|
|
|
|
// Gather git-related data as appropriate. (Returns nil, nil if no repo found.)
|
|
|
|
repo, err := getGitRepository(root)
|
|
|
|
if err != nil {
|
|
|
|
return m, errors.Wrap(err, "looking for git repository")
|
|
|
|
}
|
|
|
|
if repo != nil && err == nil {
|
|
|
|
const gitErrCtx = "reading git repo (%v)" // Message passed with wrapped errors from go-git.
|
|
|
|
|
|
|
|
// Commit at HEAD.
|
|
|
|
head, err := repo.Head()
|
|
|
|
if err == nil {
|
|
|
|
m.Environment[backend.GitHead] = head.Hash().String()
|
|
|
|
} else {
|
|
|
|
// Ignore "reference not found" in the odd case where the HEAD commit doesn't exist.
|
|
|
|
// (git init, but no commits yet.)
|
|
|
|
if err != plumbing.ErrReferenceNotFound {
|
|
|
|
return m, errors.Wrapf(err, gitErrCtx, "getting head")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// If the current commit is dirty.
|
|
|
|
w, err := repo.Worktree()
|
|
|
|
if err != nil {
|
|
|
|
return m, errors.Wrapf(err, gitErrCtx, "getting worktree")
|
|
|
|
}
|
|
|
|
s, err := w.Status()
|
|
|
|
if err != nil {
|
|
|
|
return m, errors.Wrapf(err, gitErrCtx, "getting worktree status")
|
|
|
|
}
|
|
|
|
dirty := !s.IsClean()
|
|
|
|
m.Environment[backend.GitDirty] = fmt.Sprint(dirty)
|
|
|
|
|
|
|
|
// GitHub repo slug if applicable. We don't require GitHub, so swallow errors.
|
|
|
|
ghLogin, ghRepo, err := getGitHubProjectForOriginByRepo(repo)
|
|
|
|
if err == nil {
|
|
|
|
m.Environment[backend.GitHubLogin] = ghLogin
|
|
|
|
m.Environment[backend.GitHubRepo] = ghRepo
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return m, nil
|
|
|
|
}
|
2018-04-05 00:31:01 +02:00
|
|
|
|
|
|
|
// upgradeConfigurationFiles does an upgrade to move from the old configuration system (where we had config stored) in
|
|
|
|
// workspace settings and Pulumi.yaml, to the new system where configuration data is stored in Pulumi.<stack-name>.yaml
|
|
|
|
func upgradeConfigurationFiles() error {
|
|
|
|
// If there's no workspace, don't even try to upgrade.
|
|
|
|
_, err := workspace.New()
|
|
|
|
if err != nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// If we aren't logged in, also don't try. We ignore errors here, and just assume we aren't logged in.
|
|
|
|
if hasLogin, loginErr := isLoggedIn(); !hasLogin {
|
|
|
|
contract.IgnoreError(loginErr)
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
b, err := currentBackend()
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
stacks, err := b.ListStacks()
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
for _, stack := range stacks {
|
|
|
|
stackName := stack.Name()
|
|
|
|
|
|
|
|
// If the new file exists, we can skip upgrading this stack.
|
|
|
|
newFile, err := workspace.DetectProjectStackPath(stackName)
|
|
|
|
if err != nil {
|
|
|
|
return errors.Wrap(err, "upgrade project")
|
|
|
|
}
|
|
|
|
|
|
|
|
_, err = os.Stat(newFile)
|
|
|
|
if err != nil && !os.IsNotExist(err) {
|
|
|
|
return errors.Wrap(err, "upgrading project")
|
|
|
|
} else if err == nil {
|
|
|
|
// new file was present, skip upgrading this stack.
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
|
|
|
|
cfg, salt, err := getOldConfiguration(stackName)
|
|
|
|
if err != nil {
|
|
|
|
return errors.Wrap(err, "upgrading project")
|
|
|
|
}
|
|
|
|
|
|
|
|
ps, err := workspace.DetectProjectStack(stackName)
|
|
|
|
if err != nil {
|
|
|
|
return errors.Wrap(err, "upgrading project")
|
|
|
|
}
|
|
|
|
|
|
|
|
ps.Config = cfg
|
|
|
|
ps.EncryptionSalt = salt
|
|
|
|
|
|
|
|
if err := workspace.SaveProjectStack(stackName, ps); err != nil {
|
|
|
|
return errors.Wrap(err, "upgrading project")
|
|
|
|
}
|
|
|
|
|
|
|
|
if err := removeOldConfiguration(stackName); err != nil {
|
|
|
|
return errors.Wrap(err, "upgrading project")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return removeOldProjectConfiguration()
|
|
|
|
}
|
|
|
|
|
|
|
|
// getOldConfiguration reads the configuration for a given stack from the current workspace. It applies a hierarchy
|
|
|
|
// of configuration settings based on stack overrides and workspace-wide global settings. If any of the workspace
|
|
|
|
// settings had an impact on the values returned, the second return value will be true. It also returns the encryption
|
|
|
|
// salt used for the stack.
|
|
|
|
func getOldConfiguration(stackName tokens.QName) (config.Map, string, error) {
|
|
|
|
contract.Require(stackName != "", "stackName")
|
|
|
|
|
|
|
|
// Get the workspace and package and get ready to merge their views of the configuration.
|
|
|
|
ws, err := workspace.New()
|
|
|
|
if err != nil {
|
|
|
|
return nil, "", err
|
|
|
|
}
|
|
|
|
proj, err := workspace.DetectProject()
|
|
|
|
if err != nil {
|
|
|
|
return nil, "", err
|
|
|
|
}
|
|
|
|
|
|
|
|
// We need to apply workspace and project configuration values in the right order. Basically, we want to
|
|
|
|
// end up taking the most specific settings, where per-stack configuration is more specific than global, and
|
|
|
|
// project configuration is more specific than workspace.
|
|
|
|
result := make(config.Map)
|
|
|
|
|
|
|
|
// First, apply project-local stack-specific configuration.
|
|
|
|
if stack, has := proj.StacksDeprecated[stackName]; has {
|
|
|
|
for key, value := range stack.Config {
|
|
|
|
result[key] = value
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Now, apply workspace stack-specific configuration.
|
|
|
|
if wsStackConfig, has := ws.Settings().ConfigDeprecated[stackName]; has {
|
|
|
|
for key, value := range wsStackConfig {
|
|
|
|
if _, has := result[key]; !has {
|
|
|
|
result[key] = value
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Next, take anything from the global settings in our project file.
|
|
|
|
for key, value := range proj.ConfigDeprecated {
|
|
|
|
if _, has := result[key]; !has {
|
|
|
|
result[key] = value
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Finally, take anything left in the workspace's global configuration.
|
|
|
|
if wsGlobalConfig, has := ws.Settings().ConfigDeprecated[""]; has {
|
|
|
|
for key, value := range wsGlobalConfig {
|
|
|
|
if _, has := result[key]; !has {
|
|
|
|
result[key] = value
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Now, get the encryption key. A stack specific one overrides the global one (global encryption keys were
|
|
|
|
// deprecated previously)
|
|
|
|
encryptionSalt := proj.EncryptionSaltDeprecated
|
|
|
|
if stack, has := proj.StacksDeprecated[stackName]; has && stack.EncryptionSalt != "" {
|
|
|
|
encryptionSalt = stack.EncryptionSalt
|
|
|
|
}
|
|
|
|
|
|
|
|
return result, encryptionSalt, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// removeOldConfiguration deletes all configuration information about a stack from both the workspace
|
|
|
|
// and the project file. It does not touch the newly added Pulumi.<stack-name>.yaml file.
|
|
|
|
func removeOldConfiguration(stackName tokens.QName) error {
|
|
|
|
ws, err := workspace.New()
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
proj, err := workspace.DetectProject()
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
delete(proj.StacksDeprecated, stackName)
|
|
|
|
delete(ws.Settings().ConfigDeprecated, stackName)
|
|
|
|
|
|
|
|
if err := ws.Save(); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
return workspace.SaveProject(proj)
|
|
|
|
}
|
|
|
|
|
|
|
|
// removeOldProjectConfiguration deletes all project level configuration information from both the workspace and the
|
|
|
|
// project file.
|
|
|
|
func removeOldProjectConfiguration() error {
|
|
|
|
ws, err := workspace.New()
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
proj, err := workspace.DetectProject()
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
proj.EncryptionSaltDeprecated = ""
|
|
|
|
proj.ConfigDeprecated = nil
|
|
|
|
ws.Settings().ConfigDeprecated = nil
|
|
|
|
|
|
|
|
if err := ws.Save(); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
return workspace.SaveProject(proj)
|
|
|
|
}
|