Previously `new` was operating under the assumption that it was always going to be creating a new project/stack, and would always prompt for these values. However, we want to be able to use `new` to pull down the source for an existing stack. This change adds a `--stack` flag to `new` that can be used to specify an existing stack. If the specified stack already exists, we won't prompt for the project name/description, and instead just use the existing stack's values. If `--stack` is specified, but doesn't already exist, it will just use that as the stack name (instead of prompting) when creating the stack. `new` also now handles configuration like `up <url>`: if the stack is a preconfigured empty stack (i.e. it was created/configured in the Pulumi Console via Pulumi Button or New Project), we will use the existing stack's config without prompting. Otherwise we will prompt for config, and just like `up <url>`, we'll use the existing stack's config values as defaults when prompting, or if the stack didn't exist, use the defaults from the template. Previously `up <url>`'s handling of the project name/description wasn't correct: it would always automatically use the values from the template without prompting. Now, just like `new`: - When updating an existing stack, it will not prompt, and just use the existing stack's values. - When creating a new stack, it will prompt for the project name/description, using the defaults from the template. This PR consolidates some of the `new`/`up` implementation so it shares code for this functionality. There's definitely opportunities for a lot more code reuse, but that cleanup can happen down the line if/when we have the cycles.
155 lines
5.2 KiB
Go
155 lines
5.2 KiB
Go
// 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.
|
|
|
|
package httpstate
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
|
|
"github.com/pkg/errors"
|
|
"github.com/pulumi/pulumi/pkg/apitype"
|
|
"github.com/pulumi/pulumi/pkg/backend"
|
|
"github.com/pulumi/pulumi/pkg/engine"
|
|
"github.com/pulumi/pulumi/pkg/operations"
|
|
"github.com/pulumi/pulumi/pkg/resource/config"
|
|
"github.com/pulumi/pulumi/pkg/resource/deploy"
|
|
"github.com/pulumi/pulumi/pkg/tokens"
|
|
)
|
|
|
|
// Stack is a cloud stack. This simply adds some cloud-specific properties atop the standard backend stack interface.
|
|
type Stack interface {
|
|
backend.Stack
|
|
CloudURL() string // the URL to the cloud containing this stack.
|
|
OrgName() string // the organization that owns this stack.
|
|
ConsoleURL() (string, error) // the URL to view the stack's information on Pulumi.com
|
|
Tags() map[apitype.StackTagName]string // the stack's tags.
|
|
}
|
|
|
|
type cloudBackendReference struct {
|
|
name tokens.QName
|
|
owner string
|
|
b *cloudBackend
|
|
}
|
|
|
|
func (c cloudBackendReference) String() string {
|
|
curUser, err := c.b.client.GetPulumiAccountName(context.Background())
|
|
if err != nil {
|
|
curUser = ""
|
|
}
|
|
|
|
if c.owner == curUser {
|
|
return string(c.name)
|
|
}
|
|
|
|
return fmt.Sprintf("%s/%s", c.owner, c.name)
|
|
}
|
|
|
|
func (c cloudBackendReference) Name() tokens.QName {
|
|
return c.name
|
|
}
|
|
|
|
// nolint: lll
|
|
// cloudStack is a cloud stack descriptor.
|
|
type cloudStack struct {
|
|
ref backend.StackReference // the stack's ref (unique name).
|
|
cloudURL string // the URL to the cloud containing this stack.
|
|
orgName string // the organization that owns this stack.
|
|
config config.Map // the stack's config bag.
|
|
snapshot **deploy.Snapshot // a snapshot representing the latest deployment state (allocated on first use)
|
|
b *cloudBackend // a pointer to the backend this stack belongs to.
|
|
tags map[apitype.StackTagName]string // the stack's tags.
|
|
}
|
|
|
|
func newStack(apistack apitype.Stack, b *cloudBackend) Stack {
|
|
// Now assemble all the pieces into a stack structure.
|
|
return &cloudStack{
|
|
ref: cloudBackendReference{
|
|
owner: apistack.OrgName,
|
|
name: apistack.StackName,
|
|
b: b,
|
|
},
|
|
cloudURL: b.CloudURL(),
|
|
orgName: apistack.OrgName,
|
|
config: nil, // TODO[pulumi/pulumi-service#249]: add the config variables.
|
|
snapshot: nil, // We explicitly allocate the snapshot on first use, since it is expensive to compute.
|
|
tags: apistack.Tags,
|
|
b: b,
|
|
}
|
|
}
|
|
|
|
func (s *cloudStack) Ref() backend.StackReference { return s.ref }
|
|
func (s *cloudStack) Config() config.Map { return s.config }
|
|
func (s *cloudStack) Backend() backend.Backend { return s.b }
|
|
func (s *cloudStack) CloudURL() string { return s.cloudURL }
|
|
func (s *cloudStack) OrgName() string { return s.orgName }
|
|
func (s *cloudStack) Tags() map[apitype.StackTagName]string { return s.tags }
|
|
|
|
func (s *cloudStack) Snapshot(ctx context.Context) (*deploy.Snapshot, error) {
|
|
if s.snapshot != nil {
|
|
return *s.snapshot, nil
|
|
}
|
|
|
|
snap, err := s.b.getSnapshot(ctx, s.ref)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
s.snapshot = &snap
|
|
return *s.snapshot, nil
|
|
}
|
|
|
|
func (s *cloudStack) Remove(ctx context.Context, force bool) (bool, error) {
|
|
return backend.RemoveStack(ctx, s, force)
|
|
}
|
|
|
|
func (s *cloudStack) Preview(ctx context.Context, op backend.UpdateOperation) (engine.ResourceChanges, error) {
|
|
return backend.PreviewStack(ctx, s, op)
|
|
}
|
|
|
|
func (s *cloudStack) Update(ctx context.Context, op backend.UpdateOperation) (engine.ResourceChanges, error) {
|
|
return backend.UpdateStack(ctx, s, op)
|
|
}
|
|
|
|
func (s *cloudStack) Refresh(ctx context.Context, op backend.UpdateOperation) (engine.ResourceChanges, error) {
|
|
return backend.RefreshStack(ctx, s, op)
|
|
}
|
|
|
|
func (s *cloudStack) Destroy(ctx context.Context, op backend.UpdateOperation) (engine.ResourceChanges, error) {
|
|
return backend.DestroyStack(ctx, s, op)
|
|
}
|
|
|
|
func (s *cloudStack) GetLogs(ctx context.Context, query operations.LogQuery) ([]operations.LogEntry, error) {
|
|
return backend.GetStackLogs(ctx, s, query)
|
|
}
|
|
|
|
func (s *cloudStack) ExportDeployment(ctx context.Context) (*apitype.UntypedDeployment, error) {
|
|
return backend.ExportStackDeployment(ctx, s)
|
|
}
|
|
|
|
func (s *cloudStack) ImportDeployment(ctx context.Context, deployment *apitype.UntypedDeployment) error {
|
|
return backend.ImportStackDeployment(ctx, s, deployment)
|
|
}
|
|
|
|
func (s *cloudStack) ConsoleURL() (string, error) {
|
|
path, err := s.b.StackConsoleURL(s.ref)
|
|
if err != nil {
|
|
return "", nil
|
|
}
|
|
url := s.b.CloudConsoleURL(path)
|
|
if url == "" {
|
|
return "", errors.New("could not determine clould console URL")
|
|
}
|
|
return url, nil
|
|
}
|