mirror of https://github.com/pulumi/pulumi.git
253 lines
8.5 KiB
Go
253 lines
8.5 KiB
Go
// Copyright 2016-2023, 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"
|
|
"sync/atomic"
|
|
"time"
|
|
|
|
"github.com/pulumi/pulumi/pkg/v3/backend"
|
|
"github.com/pulumi/pulumi/pkg/v3/backend/httpstate/client"
|
|
sdkDisplay "github.com/pulumi/pulumi/pkg/v3/display"
|
|
"github.com/pulumi/pulumi/pkg/v3/engine"
|
|
"github.com/pulumi/pulumi/pkg/v3/operations"
|
|
"github.com/pulumi/pulumi/pkg/v3/resource/deploy"
|
|
"github.com/pulumi/pulumi/pkg/v3/secrets"
|
|
"github.com/pulumi/pulumi/pkg/v3/secrets/service"
|
|
pkgWorkspace "github.com/pulumi/pulumi/pkg/v3/workspace"
|
|
"github.com/pulumi/pulumi/sdk/v3/go/common/apitype"
|
|
"github.com/pulumi/pulumi/sdk/v3/go/common/tokens"
|
|
"github.com/pulumi/pulumi/sdk/v3/go/common/util/cmdutil"
|
|
"github.com/pulumi/pulumi/sdk/v3/go/common/util/contract"
|
|
"github.com/pulumi/pulumi/sdk/v3/go/common/workspace"
|
|
)
|
|
|
|
// Stack is a cloud stack. This simply adds some cloud-specific properties atop the standard backend stack interface.
|
|
type Stack interface {
|
|
backend.Stack
|
|
OrgName() string // the organization that owns this stack.
|
|
CurrentOperation() *apitype.OperationStatus // in progress operation, if applicable.
|
|
StackIdentifier() client.StackIdentifier
|
|
}
|
|
|
|
type cloudBackendReference struct {
|
|
name tokens.StackName
|
|
project tokens.Name
|
|
owner string
|
|
b *cloudBackend
|
|
}
|
|
|
|
func (c cloudBackendReference) String() string {
|
|
// If the user has asked us to fully qualify names, we won't elide any
|
|
// information.
|
|
if cmdutil.FullyQualifyStackNames {
|
|
return fmt.Sprintf("%s/%s/%s", c.owner, c.project, c.name)
|
|
}
|
|
|
|
// When stringifying backend references, we take the current project (if present) into account.
|
|
currentProject := c.b.currentProject
|
|
|
|
// If the project names match, we can elide them.
|
|
if currentProject != nil && c.project == tokens.Name(currentProject.Name) {
|
|
// Elide owner too, if it is the default owner.
|
|
defaultOrg, err := pkgWorkspace.GetBackendConfigDefaultOrg(currentProject)
|
|
if err == nil && defaultOrg != "" {
|
|
// The default owner is the org
|
|
if c.owner == defaultOrg {
|
|
return c.name.String()
|
|
}
|
|
} else {
|
|
currentUser, _, _, userErr := c.b.CurrentUser()
|
|
if userErr == nil && c.owner == currentUser {
|
|
return c.name.String()
|
|
}
|
|
}
|
|
return fmt.Sprintf("%s/%s", c.owner, c.name)
|
|
}
|
|
|
|
return fmt.Sprintf("%s/%s/%s", c.owner, c.project, c.name)
|
|
}
|
|
|
|
func (c cloudBackendReference) Name() tokens.StackName {
|
|
return c.name
|
|
}
|
|
|
|
func (c cloudBackendReference) Project() (tokens.Name, bool) {
|
|
return c.project, true
|
|
}
|
|
|
|
func (c cloudBackendReference) FullyQualifiedName() tokens.QName {
|
|
return tokens.IntoQName(fmt.Sprintf("%v/%v/%v", c.owner, c.project, c.name.String()))
|
|
}
|
|
|
|
// cloudStack is a cloud stack descriptor.
|
|
type cloudStack struct {
|
|
// ref is the stack's unique name.
|
|
ref cloudBackendReference
|
|
// orgName is the organization that owns this stack.
|
|
orgName string
|
|
// currentOperation contains information about any current operation being performed on the stack, as applicable.
|
|
currentOperation *apitype.OperationStatus
|
|
// snapshot contains the latest deployment state, allocated on first use. It's valid for the snapshot
|
|
// itself to be nil.
|
|
snapshot atomic.Pointer[*deploy.Snapshot]
|
|
// b is a pointer to the backend that this stack belongs to.
|
|
b *cloudBackend
|
|
// tags contains metadata tags describing additional, extensible properties about this stack.
|
|
tags map[apitype.StackTagName]string
|
|
}
|
|
|
|
func newStack(apistack apitype.Stack, b *cloudBackend) Stack {
|
|
stackName, err := tokens.ParseStackName(apistack.StackName.String())
|
|
contract.AssertNoErrorf(err, "unexpected invalid stack name: %v", apistack.StackName)
|
|
|
|
// Now assemble all the pieces into a stack structure.
|
|
return &cloudStack{
|
|
ref: cloudBackendReference{
|
|
owner: apistack.OrgName,
|
|
project: tokens.Name(apistack.ProjectName),
|
|
name: stackName,
|
|
b: b,
|
|
},
|
|
orgName: apistack.OrgName,
|
|
currentOperation: apistack.CurrentOperation,
|
|
tags: apistack.Tags,
|
|
b: b,
|
|
// We explicitly allocate the snapshot on first use, since it is expensive to compute.
|
|
}
|
|
}
|
|
func (s *cloudStack) Ref() backend.StackReference { return s.ref }
|
|
func (s *cloudStack) Backend() backend.Backend { return s.b }
|
|
func (s *cloudStack) OrgName() string { return s.orgName }
|
|
func (s *cloudStack) CurrentOperation() *apitype.OperationStatus { return s.currentOperation }
|
|
func (s *cloudStack) Tags() map[apitype.StackTagName]string { return s.tags }
|
|
|
|
func (s *cloudStack) StackIdentifier() client.StackIdentifier {
|
|
si, err := s.b.getCloudStackIdentifier(s.ref)
|
|
// the above only fails when ref is of the wrong type.
|
|
contract.AssertNoErrorf(err, "unexpected stack reference type: %T", s.ref)
|
|
return si
|
|
}
|
|
|
|
func (s *cloudStack) Snapshot(ctx context.Context, secretsProvider secrets.Provider) (*deploy.Snapshot, error) {
|
|
if v := s.snapshot.Load(); v != nil {
|
|
return *v, nil
|
|
}
|
|
|
|
snap, err := s.b.getSnapshot(ctx, secretsProvider, s.ref)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
s.snapshot.Store(&snap)
|
|
return snap, nil
|
|
}
|
|
|
|
func (s *cloudStack) Remove(ctx context.Context, force bool) (bool, error) {
|
|
return backend.RemoveStack(ctx, s, force)
|
|
}
|
|
|
|
func (s *cloudStack) Rename(ctx context.Context, newName tokens.QName) (backend.StackReference, error) {
|
|
return backend.RenameStack(ctx, s, newName)
|
|
}
|
|
|
|
func (s *cloudStack) Preview(
|
|
ctx context.Context,
|
|
op backend.UpdateOperation,
|
|
events chan<- engine.Event,
|
|
) (*deploy.Plan, sdkDisplay.ResourceChanges, error) {
|
|
return backend.PreviewStack(ctx, s, op, events)
|
|
}
|
|
|
|
func (s *cloudStack) Update(ctx context.Context, op backend.UpdateOperation) (sdkDisplay.ResourceChanges,
|
|
error,
|
|
) {
|
|
return backend.UpdateStack(ctx, s, op)
|
|
}
|
|
|
|
func (s *cloudStack) Import(ctx context.Context, op backend.UpdateOperation,
|
|
imports []deploy.Import,
|
|
) (sdkDisplay.ResourceChanges, error) {
|
|
return backend.ImportStack(ctx, s, op, imports)
|
|
}
|
|
|
|
func (s *cloudStack) Refresh(ctx context.Context, op backend.UpdateOperation) (sdkDisplay.ResourceChanges,
|
|
error,
|
|
) {
|
|
return backend.RefreshStack(ctx, s, op)
|
|
}
|
|
|
|
func (s *cloudStack) Destroy(ctx context.Context, op backend.UpdateOperation) (sdkDisplay.ResourceChanges,
|
|
error,
|
|
) {
|
|
return backend.DestroyStack(ctx, s, op)
|
|
}
|
|
|
|
func (s *cloudStack) Watch(ctx context.Context, op backend.UpdateOperation, paths []string) error {
|
|
return backend.WatchStack(ctx, s, op, paths)
|
|
}
|
|
|
|
func (s *cloudStack) GetLogs(ctx context.Context, secretsProvider secrets.Provider, cfg backend.StackConfiguration,
|
|
query operations.LogQuery,
|
|
) ([]operations.LogEntry, error) {
|
|
return backend.GetStackLogs(ctx, secretsProvider, s, cfg, 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) DefaultSecretManager(info *workspace.ProjectStack) (secrets.Manager, error) {
|
|
return service.NewServiceSecretsManager(s.b.Client(), s.StackIdentifier(), info)
|
|
}
|
|
|
|
// cloudStackSummary implements the backend.StackSummary interface, by wrapping
|
|
// an apitype.StackSummary struct.
|
|
type cloudStackSummary struct {
|
|
summary apitype.StackSummary
|
|
b *cloudBackend
|
|
}
|
|
|
|
func (css cloudStackSummary) Name() backend.StackReference {
|
|
contract.Assertf(css.summary.ProjectName != "", "project name must not be empty")
|
|
stackName, err := tokens.ParseStackName(css.summary.StackName)
|
|
contract.AssertNoErrorf(err, "unexpected invalid stack name: %v", css.summary.StackName)
|
|
|
|
return cloudBackendReference{
|
|
owner: css.summary.OrgName,
|
|
project: tokens.Name(css.summary.ProjectName),
|
|
name: stackName,
|
|
b: css.b,
|
|
}
|
|
}
|
|
|
|
func (css cloudStackSummary) LastUpdate() *time.Time {
|
|
if css.summary.LastUpdate == nil {
|
|
return nil
|
|
}
|
|
t := time.Unix(*css.summary.LastUpdate, 0)
|
|
return &t
|
|
}
|
|
|
|
func (css cloudStackSummary) ResourceCount() *int {
|
|
return css.summary.ResourceCount
|
|
}
|