remote_stack.go

// Copyright 2016-2022, 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 auto

import (
	"context"

	"github.com/pulumi/pulumi/sdk/v3/go/auto/optdestroy"
	"github.com/pulumi/pulumi/sdk/v3/go/auto/opthistory"
	"github.com/pulumi/pulumi/sdk/v3/go/auto/optpreview"
	"github.com/pulumi/pulumi/sdk/v3/go/auto/optrefresh"
	"github.com/pulumi/pulumi/sdk/v3/go/auto/optremotedestroy"
	"github.com/pulumi/pulumi/sdk/v3/go/auto/optremotepreview"
	"github.com/pulumi/pulumi/sdk/v3/go/auto/optremoterefresh"
	"github.com/pulumi/pulumi/sdk/v3/go/auto/optremoteup"
	"github.com/pulumi/pulumi/sdk/v3/go/auto/optup"
	"github.com/pulumi/pulumi/sdk/v3/go/common/apitype"
)

// RemoteStack is an isolated, independently configurable instance of a Pulumi program that is
// operated on remotely (up/preview/refresh/destroy).
type RemoteStack struct {
	stack Stack
}

// Name returns the stack name.
func (s *RemoteStack) Name() string {
	return s.stack.Name()
}

// Preview preforms a dry-run update to a stack, returning pending changes.
// https://www.pulumi.com/docs/cli/commands/pulumi_preview/
// This operation runs remotely.
func (s *RemoteStack) Preview(ctx context.Context, opts ...optremotepreview.Option) (PreviewResult, error) {
	preOpts := &optremotepreview.Options{}
	for _, o := range opts {
		o.ApplyOption(preOpts)
	}

	implOpts := []optpreview.Option{}
	if preOpts.ProgressStreams != nil {
		implOpts = append(implOpts, optpreview.ProgressStreams(preOpts.ProgressStreams...))
	}
	if preOpts.ErrorProgressStreams != nil {
		implOpts = append(implOpts, optpreview.ErrorProgressStreams(preOpts.ErrorProgressStreams...))
	}
	if preOpts.EventStreams != nil {
		implOpts = append(implOpts, optpreview.EventStreams(preOpts.EventStreams...))
	}

	return s.stack.Preview(ctx, implOpts...)
}

// Up creates or updates the resources in a stack by executing the program in the Workspace.
// https://www.pulumi.com/docs/cli/commands/pulumi_up/
// This operation runs remotely.
func (s *RemoteStack) Up(ctx context.Context, opts ...optremoteup.Option) (UpResult, error) {
	upOpts := &optremoteup.Options{}
	for _, o := range opts {
		o.ApplyOption(upOpts)
	}

	implOpts := []optup.Option{}
	if upOpts.ProgressStreams != nil {
		implOpts = append(implOpts, optup.ProgressStreams(upOpts.ProgressStreams...))
	}
	if upOpts.ErrorProgressStreams != nil {
		implOpts = append(implOpts, optup.ErrorProgressStreams(upOpts.ErrorProgressStreams...))
	}
	if upOpts.EventStreams != nil {
		implOpts = append(implOpts, optup.EventStreams(upOpts.EventStreams...))
	}

	return s.stack.Up(ctx, implOpts...)
}

// Refresh compares the current stack’s resource state with the state known to exist in the actual
// cloud provider. Any such changes are adopted into the current stack.
// This operation runs remotely.
func (s *RemoteStack) Refresh(ctx context.Context, opts ...optremoterefresh.Option) (RefreshResult, error) {
	refreshOpts := &optremoterefresh.Options{}
	for _, o := range opts {
		o.ApplyOption(refreshOpts)
	}

	implOpts := []optrefresh.Option{}
	if refreshOpts.ProgressStreams != nil {
		implOpts = append(implOpts, optrefresh.ProgressStreams(refreshOpts.ProgressStreams...))
	}
	if refreshOpts.ErrorProgressStreams != nil {
		implOpts = append(implOpts, optrefresh.ErrorProgressStreams(refreshOpts.ErrorProgressStreams...))
	}
	if refreshOpts.EventStreams != nil {
		implOpts = append(implOpts, optrefresh.EventStreams(refreshOpts.EventStreams...))
	}

	return s.stack.Refresh(ctx, implOpts...)
}

// Destroy deletes all resources in a stack, leaving all history and configuration intact.
// This operation runs remotely.
func (s *RemoteStack) Destroy(ctx context.Context, opts ...optremotedestroy.Option) (DestroyResult, error) {
	destroyOpts := &optremotedestroy.Options{}
	for _, o := range opts {
		o.ApplyOption(destroyOpts)
	}

	implOpts := []optdestroy.Option{}
	if destroyOpts.ProgressStreams != nil {
		implOpts = append(implOpts, optdestroy.ProgressStreams(destroyOpts.ProgressStreams...))
	}
	if destroyOpts.ErrorProgressStreams != nil {
		implOpts = append(implOpts, optdestroy.ErrorProgressStreams(destroyOpts.ErrorProgressStreams...))
	}
	if destroyOpts.EventStreams != nil {
		implOpts = append(implOpts, optdestroy.EventStreams(destroyOpts.EventStreams...))
	}

	return s.stack.Destroy(ctx, implOpts...)
}

// Outputs get the current set of Stack outputs from the last Stack.Up().
func (s *RemoteStack) Outputs(ctx context.Context) (OutputMap, error) {
	return s.stack.Workspace().StackOutputs(ctx, s.Name())
}

// History returns a list summarizing all previous and current results from Stack lifecycle operations
// (up/preview/refresh/destroy).
func (s *RemoteStack) History(ctx context.Context, pageSize, page int) ([]UpdateSummary, error) {
	// Note: Find a way to allow options for ShowSecrets(true) that doesn't require loading the project.
	return s.stack.History(ctx, pageSize, page, opthistory.ShowSecrets(false))
}

// Cancel stops a stack's currently running update. It returns an error if no update is currently running.
// Note that this operation is _very dangerous_, and may leave the stack in an inconsistent state
// if a resource operation was pending when the update was canceled.
// This command is not supported for diy backends.
func (s *RemoteStack) Cancel(ctx context.Context) error {
	return s.stack.Cancel(ctx)
}

// Export exports the deployment state of the stack.
// This can be combined with Stack.Import to edit a stack's state (such as recovery from failed deployments).
func (s *RemoteStack) Export(ctx context.Context) (apitype.UntypedDeployment, error) {
	return s.stack.Workspace().ExportStack(ctx, s.Name())
}

// Import imports the specified deployment state into the stack.
// This can be combined with Stack.Export to edit a stack's state (such as recovery from failed deployments).
func (s *RemoteStack) Import(ctx context.Context, state apitype.UntypedDeployment) error {
	return s.stack.Workspace().ImportStack(ctx, s.Name(), state)
}