// 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" "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/util/result" "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 := workspace.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, result.Result) { return backend.PreviewStack(ctx, s, op, events) } func (s *cloudStack) Update(ctx context.Context, op backend.UpdateOperation) (sdkDisplay.ResourceChanges, result.Result, ) { return backend.UpdateStack(ctx, s, op) } func (s *cloudStack) Import(ctx context.Context, op backend.UpdateOperation, imports []deploy.Import, ) (sdkDisplay.ResourceChanges, result.Result) { return backend.ImportStack(ctx, s, op, imports) } func (s *cloudStack) Refresh(ctx context.Context, op backend.UpdateOperation) (sdkDisplay.ResourceChanges, result.Result, ) { return backend.RefreshStack(ctx, s, op) } func (s *cloudStack) Destroy(ctx context.Context, op backend.UpdateOperation) (sdkDisplay.ResourceChanges, result.Result, ) { return backend.DestroyStack(ctx, s, op) } func (s *cloudStack) Watch(ctx context.Context, op backend.UpdateOperation, paths []string) result.Result { 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 }