chore: update changelog

Author: ctrombley

CHANGELOG.md

@@ -1,7 +1,8 @@
 # Unreleased
 
 ## Enhancements
-* Exports the StackConfiguration UploadTarGzip receiver function[#1219](https://github.com/hashicorp/go-tfe/pull/1219)
+* Exports the StackConfiguration UploadTarGzip receiver function [#1219](https://github.com/hashicorp/go-tfe/pull/1219)
+* Updates BETA stacks resource schemas to match latest API spec by @ctrombley [#1220](https://github.com/hashicorp/go-tfe/pull/1220)
 
 ## Deprecations
 

stack.go

@@ -26,6 +26,9 @@ type Stacks interface {
 	// Update updates a stack.
 	Update(ctx context.Context, stackID string, options StackUpdateOptions) (*Stack, error)
 
+	// Update updates the agent pool in use by a stack.
+	UpdateAgentPool(ctx context.Context, stackID string, agentPoolID string) (*Stack, error)
+
 	// Delete deletes a stack.
 	Delete(ctx context.Context, stackID string) error
 
@@ -34,7 +37,14 @@ type Stacks interface {
 
 	// FetchLatestFromVcs updates the configuration of a stack, triggering stack preparation.
 	FetchLatestFromVcs(ctx context.Context, stackID string) (*Stack, error)
-}
+
+	// ListDeployments returns a list of deployments for the given stack.
+	ListDeployments(ctx context.Context, stackID string, options *StackListDeploymentsOptions) (*StackDeploymentList, error)
+
+	// ListDeploymentRunsForDeployment returns a list of deployments for the given
+	// stack and deployment.
+	ListDeploymentRunsForDeployment(ctx context.Context, stackID string, deployment string, options *StackListDeploymentRunsForDeploymentOptions) (*StackDeploymentRunList, error)
+
 
 // stacks implements Stacks.
 type stacks struct {
@@ -86,6 +96,7 @@ type StackVCSRepoOptions struct {
 // Stack represents a stack.
 type Stack struct {
 	ID                 string        `jsonapi:"primary,stacks"`
+
 	Name               string        `jsonapi:"attr,name"`
 	Description        string        `jsonapi:"attr,description"`
 	VCSRepo            *StackVCSRepo `jsonapi:"attr,vcs-repo"`
@@ -138,23 +149,6 @@ type StackConfiguration struct {
 	IngressAttributes *IngressAttributes `jsonapi:"relation,ingress-attributes"`
 }
 
-// StackState represents a stack state
-type StackState struct {
-	// Attributes
-	ID                    string `jsonapi:"primary,stack-states"`
-	Description           string `jsonapi:"attr,description"`
-	Generation            int    `jsonapi:"attr,generation"`
-	Status                string `jsonapi:"attr,status"`
-	Deployment            string `jsonapi:"attr,deployment"`
-	Components            string `jsonapi:"attr,components"`
-	IsCurrent             bool   `jsonapi:"attr,is-current"`
-	ResourceInstanceCount int    `jsonapi:"attr,resource-instance-count"`
-
-	// Relationships
-	Stack              *Stack              `jsonapi:"relation,stack"`
-	StackDeploymentRun *StackDeploymentRun `jsonapi:"relation,stack-deployment-run"`
-}
-
 // StackListOptions represents the options for listing stacks.
 type StackListOptions struct {
 	ListOptions
@@ -163,6 +157,10 @@ type StackListOptions struct {
 	SearchByName string          `url:"search[name],omitempty"`
 }
 
+func (s *StackListOptions) valid() error {
+	return nil
+}
+
 // StackCreateOptions represents the options for creating a stack. The project
 // relation is required.
 type StackCreateOptions struct {
@@ -174,6 +172,18 @@ type StackCreateOptions struct {
 	AgentPool   *AgentPool           `jsonapi:"relation,agent-pool"`
 }
 
+func (s StackCreateOptions) valid() error {
+	if s.Name == "" {
+		return ErrRequiredName
+	}
+
+	if s.Project.ID == "" {
+		return ErrRequiredProject
+	}
+
+	return nil
+}
+
 // StackUpdateOptions represents the options for updating a stack.
 type StackUpdateOptions struct {
 	Name        *string              `jsonapi:"attr,name,omitempty"`
@@ -286,6 +296,27 @@ func (s stacks) Update(ctx context.Context, stackID string, options StackUpdateO
 	return stack, nil
 }
 
+// UpdateAgentPool updates the agent pool in use by a stack.
+func (s stacks) UpdateAgentPool(ctx context.Context, stackID string, agentPoolID string) (*Stack, error) {
+	options := StackUpdateOptions{
+		AgentPool: &AgentPool{
+			ID: agentPoolID,
+		},
+	}
+
+	req, err := s.client.NewRequest("PATCH", fmt.Sprintf("stacks/%s", url.PathEscape(stackID)), &options)
+	if err != nil {
+		return nil, err
+	}
+
+	stack := &Stack{}
+	if err = req.Do(ctx, stack); err != nil {
+		return nil, err
+	}
+
+	return stack, nil
+}
+
 // Delete deletes a stack.
 func (s stacks) Delete(ctx context.Context, stackID string) error {
 	req, err := s.client.NewRequest("DELETE", fmt.Sprintf("stacks/%s", url.PathEscape(stackID)), nil)
@@ -306,22 +337,81 @@ func (s stacks) ForceDelete(ctx context.Context, stackID string) error {
 	return req.Do(ctx, nil)
 }
 
-func (s *StackListOptions) valid() error {
+// StackListDeploymentsOptions represents the options for listing stack
+// deployments.
+type StackListDeploymentsOptions struct {
+	ListOptions
+}
+
+// valid validates the StackListDeploymentsOptions values.
+func (s *StackListDeploymentsOptions) valid() error {
 	return nil
 }
 
-func (s StackCreateOptions) valid() error {
-	if s.Name == "" {
-		return ErrRequiredName
+// StackDeploymentList represents a list of stack deployments.
+type StackDeploymentList struct {
+	*Pagination
+	Items []*StackDeployment
+}
+
+// StackDeployment represents a stack deployment.
+type StackDeployment struct {
+	// Attributes
+	ID   string `jsonapi:"primary,stack-states"`
+	Name string `jsonapi:"attr,name"`
+
+	// Relationships
+	Stack               *Stack              `jsonapi:"relation,stack"`
+	LatestDeploymentRun *StackDeploymentRun `jsonapi:"relation,latest-deployment-run"`
+}
+
+// ListDeployments returns a list of deployments for the given stack.
+func (s stacks) ListDeployments(ctx context.Context, stackID string, options *StackListDeploymentsOptions) (*StackDeploymentList, error) {
+	if err := options.valid(); err != nil {
+		return nil, err
 	}
 
-	if s.Project.ID == "" {
-		return ErrRequiredProject
+	req, err := s.client.NewRequest("GET", fmt.Sprintf("stacks/%s/deployments", url.PathEscape(stackID)), options)
+	if err != nil {
+		return nil, err
 	}
 
+	sdl := &StackDeploymentList{}
+	if err = req.Do(ctx, sdl); err != nil {
+		return nil, err
+	}
+
+	return sdl, nil
+}
+
+type StackListDeploymentRunsForDeploymentOptions struct {
+	ListOptions
+}
+
+func (s *StackListDeploymentRunsForDeploymentOptions) valid() error {
 	return nil
 }
 
+// ListDeploymentRunsForDeployment returns a list of deployment runs for the
+// given stack and deployment.
+func (s stacks) ListDeploymentRunsForDeployment(ctx context.Context, stackID, deployment string, options *StackListDeploymentRunsForDeploymentOptions) (*StackDeploymentRunList, error) {
+	if err := options.valid(); err != nil {
+		return nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", fmt.Sprintf("stacks/%s/stack-deployments/%s/stack-deployment-runs", url.PathEscape(stackID), url.PathEscape(deployment)), options)
+	if err != nil {
+		return nil, err
+	}
+
+	sdl := &StackDeploymentRunList{}
+	if err := req.Do(ctx, sdl); err != nil {
+		return nil, err
+	}
+
+	return sdl, nil
+}
+
 // awaitPoll is a helper function that uses a callback to read a status, then
 // waits for a terminal status or an error. The callback should return the
 // current status, or an error. For each time the status changes, the channel

stack_configuration.go

@@ -24,10 +24,10 @@ type StackConfigurations interface {
 	// Upload a tar gzip archive to the specified stack configuration upload URL.
 	UploadTarGzip(ctx context.Context, url string, archive io.Reader) error
 
-	// ReadConfiguration returns a stack configuration by its ID.
+	// Read returns a stack configuration by its ID.
 	Read(ctx context.Context, id string) (*StackConfiguration, error)
 
-	// ListStackConfigurations returns a list of stack configurations for a stack.
+	// List returns a list of stack configurations for a stack.
 	List(ctx context.Context, stackID string, options *StackConfigurationListOptions) (*StackConfigurationList, error)
 
 	// JSONSchemas returns a byte slice of the JSON schema for the stack configuration.
@@ -42,6 +42,11 @@ type StackConfigurations interface {
 	// stack configuration as it progresses, until that status is "<status>",
 	// "errored", "canceled".
 	AwaitStatus(ctx context.Context, stackConfigurationID string, status StackConfigurationStatus) <-chan WaitForStatusResult
+
+	ListDeploymentRuns(ctx context.Context, stackConfigurationID string, options *StackDeploymentRunListOptions) (*StackDeploymentRunList, error)
+
+	// Diagnostics retrieves stack diagnostics for a given stack configuration.
+	Diagnostics(ctx context.Context, stackConfigurationID string) ([]*StackDiagnostic, error)
 }
 
 type StackConfigurationStatus string
@@ -204,6 +209,36 @@ func (s stackConfigurations) CreateAndUpload(ctx context.Context, stackID, path
 	return sc, nil
 }
 
+func (s stackConfigurations) ListDeploymentRuns(ctx context.Context, stackConfigurationID string, options *StackDeploymentRunListOptions) (*StackDeploymentRunList, error) {
+	req, err := s.client.NewRequest("GET", fmt.Sprintf("stack-configurations/%s/stack-deployment-runs", url.PathEscape(stackConfigurationID)), options)
+	if err != nil {
+		return nil, err
+	}
+
+	sdrl := &StackDeploymentRunList{}
+	err = req.Do(ctx, sdrl)
+	if err != nil {
+		return nil, err
+	}
+
+	return sdrl, nil
+}
+
+func (s stackConfigurations) Diagnostics(ctx context.Context, stackConfigurationID string) ([]*StackDiagnostic, error) {
+	req, err := s.client.NewRequest("GET", fmt.Sprintf("stack-configurations/%s/stack-diagnostics", url.PathEscape(stackConfigurationID)), nil)
+	if err != nil {
+		return nil, err
+	}
+
+	var diagnostics []*StackDiagnostic
+	err = req.Do(ctx, &diagnostics)
+	if err != nil {
+		return nil, err
+	}
+
+	return diagnostics, nil
+}
+
 // PollForUploadURL polls for the upload URL of a stack configuration until it becomes available.
 // It makes a request every 2 seconds until the upload URL is present in the response.
 // It will timeout after 10 seconds.

stack_configuration_integration_test.go

@@ -122,3 +122,61 @@ func TestStackConfigurationCreateUploadAndRead(t *testing.T) {
 		require.Fail(t, "timed out waiting for stack configuration to be processed")
 	}
 }
+
+func TestStackConfigurationListDeploymentRuns(t *testing.T) {
+	skipUnlessBeta(t)
+
+	client := testClient(t)
+	ctx := context.Background()
+
+	orgTest, orgTestCleanup := createOrganization(t, client)
+	t.Cleanup(orgTestCleanup)
+
+	oauthClient, cleanup := createOAuthClient(t, client, orgTest, nil)
+	t.Cleanup(cleanup)
+
+	stack, err := client.Stacks.Create(ctx, StackCreateOptions{
+		Name: "test-stack-list",
+		VCSRepo: &StackVCSRepoOptions{
+			Identifier:   "ctrombley/linked-stacks-demo-network",
+			OAuthTokenID: oauthClient.OAuthTokens[0].ID,
+		},
+		Project: &Project{
+			ID: orgTest.DefaultProject.ID,
+		},
+	})
+	require.NoError(t, err)
+
+	// Trigger stack configuration with a fetch from VCS
+	_, err = client.Stacks.FetchLatestFromVcs(ctx, stack.ID)
+	require.NoError(t, err)
+
+	list, err := client.StackConfigurations.List(ctx, stack.ID, nil)
+	require.NoError(t, err)
+	require.NotNil(t, list)
+	assert.Equal(t, len(list.Items), 1)
+
+	cfg := list.Items[0]
+
+	// List deployment runs for the configuration
+	listRuns, err := client.StackConfigurations.ListDeploymentRuns(ctx, cfg.ID, nil)
+	require.NoError(t, err)
+	require.NotNil(t, listRuns)
+	assert.Equal(t, len(listRuns.Items), 1)
+
+	// Test with pagination options
+	t.Run("with pagination options", func(t *testing.T) {
+		options := &StackDeploymentRunListOptions{
+			ListOptions: ListOptions{
+				PageNumber: 1,
+				PageSize:   10,
+			},
+		}
+
+		// List deployment runs for the configuration
+		listRuns, err := client.StackConfigurations.ListDeploymentRuns(ctx, cfg.ID, options)
+		require.NoError(t, err)
+		require.NotNil(t, listRuns)
+		assert.Equal(t, len(listRuns.Items), 1)
+	})
+}

stack_deployment_steps.go

@@ -21,6 +21,12 @@ type StackDeploymentSteps interface {
 	Read(ctx context.Context, stackDeploymentStepID string) (*StackDeploymentStep, error)
 	// Advance advances the stack deployment step when in the "pending_operator" state.
 	Advance(ctx context.Context, stackDeploymentStepID string) error
+	// Fail fails the deployment step.
+	Fail(ctx context.Context, stackDeploymentStepID string) error
+	// Diagnostics retrieves stack diagnostics for a given step.
+	Diagnostics(ctx context.Context, stackDeploymentStepID string) ([]*StackDiagnostic, error)
+	// Artifacts retrieves artifacts for a given step.
+	Artifacts(ctx context.Context, stackDeploymentStepID string) ([]*StackDiagnostic, error)
 }
 
 // StackDeploymentStep represents a step from a stack deployment
@@ -94,3 +100,43 @@ func (s stackDeploymentSteps) Advance(ctx context.Context, stackDeploymentStepID
 
 	return req.Do(ctx, nil)
 }
+
+func (s stackDeploymentSteps) Fail(ctx context.Context, stackDeploymentStepID string) error {
+	req, err := s.client.NewRequest("POST", fmt.Sprintf("stack-deployment-steps/%s/fail", url.PathEscape(stackDeploymentStepID)), nil)
+	if err != nil {
+		return err
+	}
+
+	return req.Do(ctx, nil)
+}
+
+func (s stackDeploymentSteps) Diagnostics(ctx context.Context, stackDeploymentStepID string) ([]*StackDiagnostic, error) {
+	req, err := s.client.NewRequest("GET", fmt.Sprintf("stack-deployment-steps/%s/stack-diagnostics", url.PathEscape(stackDeploymentStepID)), nil)
+	if err != nil {
+		return nil, err
+	}
+
+	err = req.Do(ctx, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	diagnostics := []*StackDiagnostic{}
+	return diagnostics, nil
+}
+
+// Artifacts retrieves artifacts for a given step.
+func (s stackDeploymentSteps) Artifacts(ctx context.Context, stackDeploymentStepID string) ([]*StackDiagnostic, error) {
+	req, err := s.client.NewRequest("GET", fmt.Sprintf("stack-deployment-steps/%s/artifacts", url.PathEscape(stackDeploymentStepID)), nil)
+	if err != nil {
+		return nil, err
+	}
+
+	err = req.Do(ctx, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	artifacts := []*StackDiagnostic{}
+	return artifacts, nil
+}