run

type CLI struct {
	// contains filtered or unexported fields
}

type Change struct {
	Actions []ChangeAction
}

type ChangeAction string

type Chunk struct {
	// TODO: this is better set as a monotonic serial rather than a TFE ID.
	ID resource.TfeID `json:"chunk_id"` // Uniquely identifies the chunk.

	RunID  resource.TfeID `json:"run_id"`  // ID of run that generated the chunk
	Phase  PhaseType      `json:"phase"`   // Phase that generated the chunk
	Offset int            `json:"_offset"` // Position within logs.
	Data   PostgresHex    `json:"chunk"`   // The log data
}

type Client struct {
	*otfapi.Client
}

type ConfigurationVersionService configversion.Service

type CreateOptions struct {
	IsDestroy   *bool
	Refresh     *bool
	RefreshOnly *bool
	Message     *string
	// Specifies the configuration version to use for this run. If the
	// configuration version ID is nil, the run will be created using the
	// workspace's latest configuration version.
	ConfigurationVersionID *resource.TfeID
	TargetAddrs            []string
	ReplaceAddrs           []string
	AutoApply              *bool
	Source                 source.Source
	TerraformVersion       *string
	AllowEmptyApply        *bool
	// PlanOnly specifies if this is a speculative, plan-only run that
	// Terraform cannot apply. Takes precedence over whether the
	// configuration version is marked as speculative or not.
	PlanOnly  *bool
	Variables []Variable
	// contains filtered or unexported fields
}

type Event struct {
	ID                     resource.TfeID   `json:"run_id"`
	CreatedAt              time.Time        `json:"created_at"`
	CancelSignaledAt       *time.Time       `json:"cancel_signaled_at"`
	IsDestroy              bool             `json:"is_destroy"`
	PositionInQueue        int              `json:"position_in_queue"`
	Refresh                bool             `json:"refresh"`
	RefreshOnly            bool             `json:"refresh_only"`
	ReplaceAddrs           []string         `json:"replace_addrs"`
	TargetAddrs            []string         `json:"target_addrs"`
	Status                 runstatus.Status `json:"status"`
	WorkspaceID            resource.TfeID   `json:"workspace_id"`
	ConfigurationVersionID resource.TfeID   `json:"configuration_version_id"`
	AutoApply              bool             `json:"auto_apply"`
	PlanOnly               bool             `json:"plan_only"`
	CreatedBy              *user.Username   `json:"created_by"`
	Source                 source.Source    `json:"source"`
	EngineVersion          string           `json:"engine_version"`
	AllowEmptyApply        bool             `json:"allow_empty_apply"`
	Engine                 *engine.Engine   `json:"engine"`
}

type GetChunkOptions struct {
	RunID  resource.TfeID `schema:"run_id,required"`
	Phase  PhaseType      `schema:"phase,required"`
	Limit  int            `schema:"limit"`  // size of the chunk to retrieve
	Offset int            `schema:"offset"` // position in overall data to seek from.
}

type ListOptions struct {
	resource.PageOptions
	// Filter by workspace ID
	WorkspaceID *resource.TfeID `schema:"workspace_id,omitempty"`
	// Filter by organization name
	Organization *organization.Name `schema:"organization_name,omitempty"`
	// Filter by workspace name
	WorkspaceName *string `schema:"workspace_name,omitempty"`
	// Filter by run statuses (with an implicit OR condition)
	Statuses []runstatus.Status `schema:"search[status],omitempty"`
	// Filter by plan-only runs
	PlanOnly *bool `schema:"-"`
	// Filter by sources
	Sources []source.Source
	// Filter by commit SHA that triggered a run
	CommitSHA *string
	// Filter by VCS user's username that triggered a run
	VCSUsername *string
}

type MetricsCollector struct {
	Service *Service
	// contains filtered or unexported fields
}

type Operation string

type Options struct {
	Authorizer         *authz.Authorizer
	VCSEventSubscriber vcs.Subscriber

	WorkspaceService     *workspace.Service
	OrganizationService  *organization.Service
	ConfigVersionService *configversion.Service
	EngineService        *engine.Service
	VCSProviderService   *vcs.Service
	TokensService        *tokens.Service
	UsersService         *user.Service

	logr.Logger
	internal.Cache
	*sql.DB
	*tfeapi.Responder
	*surl.Signer
	*sql.Listener
}

type PeriodReport struct {
	TotalTime time.Duration  `json:"total_time"`
	Periods   []StatusPeriod `json:"periods"`
}

type Phase struct {
	RunID  resource.TfeID `json:"run_id"`
	Status PhaseStatus    `json:"status"`

	// Timestamps of when a state transition occured. Ordered earliest
	// first.
	StatusTimestamps []PhaseStatusTimestamp `json:"status_timestamps"`

	PhaseType `json:"phase"`

	// report of planned or applied resource changes
	ResourceReport *Report `json:"resource_report"`
	// report of planned or applied output changes
	OutputReport *Report `json:"output_report"`
}

type PhaseFinishOptions struct {
	Errored bool `json:"errored,omitempty"`
}

type PhaseStartOptions struct {
	Type    string         `jsonapi:"primary,phase"`
	AgentID resource.TfeID `jsonapi:"attribute" json:"agent-id,omitempty"`
}

type PhaseStatus string

type PhaseStatusTimestamp struct {
	Phase     PhaseType
	Status    PhaseStatus `json:"status"`
	Timestamp time.Time   `json:"timestamp"`
}

type PhaseType string

type PhaseWriter struct {
	PutChunkService // for uploading logs to server
	// contains filtered or unexported fields
}

type PhaseWriterOptions struct {
	RunID  resource.TfeID
	Phase  PhaseType
	Writer PutChunkService
}

type PlanFile struct {
	ResourceChanges []ResourceChange  `json:"resource_changes"`
	OutputChanges   map[string]Change `json:"output_changes"`
}

type PlanFileOptions struct {
	Format PlanFormat `schema:"format,required"`
}

type PlanFormat string

type PostgresHex []byte

type PutChunkOptions struct {
	RunID  resource.TfeID `schema:"run_id,required"`
	Phase  PhaseType      `schema:"phase,required"`
	Offset int            `schema:"offset,required"`
	Data   []byte
}

type PutChunkService interface {
	PutChunk(ctx context.Context, opts PutChunkOptions) error
}

type Report struct {
	Additions    int `json:"additions"`
	Changes      int `json:"changes"`
	Destructions int `json:"destructions"`
}

type Reporter struct {
	logr.Logger
	*internal.HostnameService

	Configs    reporterConfigClient
	Workspaces reporterWorkspaceClient
	VCS        reporterVCSClient
	Runs       reporterRunClient

	// Cache most recently set status for each incomplete run to ensure the
	// same status is not set more than once on an upstream VCS provider.
	// This is important to avoid hitting rate limits on VCS providers, e.g.
	// GitHub has a limit of 1000 status updates on a commit:
	//
	// https://docs.github.com/en/rest/commits/statuses?apiVersion=2022-11-28#create-a-commit-status
	//
	// Key is the run ID.
	Cache map[resource.TfeID]vcs.Status
}

type ResourceChange struct {
	Change Change
}

type Run struct {
	ID                     resource.TfeID          `jsonapi:"primary,runs"`
	CreatedAt              time.Time               `jsonapi:"attribute" json:"created_at"`
	UpdatedAt              time.Time               `jsonapi:"attribute" json:"updated_at"`
	IsDestroy              bool                    `jsonapi:"attribute" json:"is_destroy"`
	CancelSignaledAt       *time.Time              `jsonapi:"attribute" json:"cancel_signaled_at"`
	Message                string                  `jsonapi:"attribute" json:"message"`
	Organization           organization.Name       `jsonapi:"attribute" json:"organization"`
	Refresh                bool                    `jsonapi:"attribute" json:"refresh"`
	RefreshOnly            bool                    `jsonapi:"attribute" json:"refresh_only"`
	ReplaceAddrs           []string                `jsonapi:"attribute" json:"replace_addrs"`
	PositionInQueue        int                     `jsonapi:"attribute" json:"position_in_queue"`
	TargetAddrs            []string                `jsonapi:"attribute" json:"target_addrs"`
	EngineVersion          string                  `jsonapi:"attribute" json:"engine_version"`
	Engine                 *engine.Engine          `jsonapi:"attribute" json:"engine"`
	AllowEmptyApply        bool                    `jsonapi:"attribute" json:"allow_empty_apply"`
	AutoApply              bool                    `jsonapi:"attribute" json:"auto_apply"`
	PlanOnly               bool                    `jsonapi:"attribute" json:"plan_only"`
	Source                 source.Source           `jsonapi:"attribute" json:"source"`
	SourceIcon             templ.Component         `json:"-"`
	Status                 runstatus.Status        `jsonapi:"attribute" json:"status"`
	WorkspaceID            resource.TfeID          `jsonapi:"attribute" json:"workspace_id"`
	ConfigurationVersionID resource.TfeID          `jsonapi:"attribute" json:"configuration_version_id"`
	ExecutionMode          workspace.ExecutionMode `jsonapi:"attribute" json:"execution_mode"`
	Variables              []Variable              `jsonapi:"attribute" json:"variables"`
	Plan                   Phase                   `jsonapi:"attribute" json:"plan"`
	Apply                  Phase                   `jsonapi:"attribute" json:"apply"`

	// Timestamps of when a state transition occured. Ordered earliest
	// first.
	StatusTimestamps []StatusTimestamp `jsonapi:"attribute" json:"status_timestamps"`

	Latest bool `jsonapi:"attribute" json:"latest"` // is latest run for workspace

	// IngressAttributes is non-nil if run was triggered by a VCS event.
	IngressAttributes *configversion.IngressAttributes `jsonapi:"attribute" json:"ingress_attributes"`

	// Username of user who created the run. This is nil if the run was
	// instead triggered by a VCS event.
	CreatedBy *user.Username

	// OTF doesn't support cost estimation but some go-tfe API tests expect
	// a run to enter the RunCostEstimated state, and this boolean
	// determines whether to enter that state upon finishing a plan.
	CostEstimationEnabled bool
}

type SchedulerOptions struct {
	logr.Logger

	WorkspaceClient schedulerWorkspaceClient
	RunClient       schedulerRunClient
}

type Service struct {
	logr.Logger
	authz.Interface
	// contains filtered or unexported fields
}

type Spawner struct {
	logr.Logger
	// contains filtered or unexported fields
}

type StatusPeriod struct {
	Status runstatus.Status `json:"status"`
	Period time.Duration    `json:"period"`
}

type StatusTimestamp struct {
	Status    runstatus.Status `json:"status"`
	Timestamp time.Time        `json:"timestamp"`
}

type TFEApply struct {
	ID               resource.TfeID            `jsonapi:"primary,applies"`
	LogReadURL       string                    `jsonapi:"attribute" json:"log-read-url"`
	Status           string                    `jsonapi:"attribute" json:"status"`
	StatusTimestamps *TFEPhaseStatusTimestamps `jsonapi:"attribute" json:"status-timestamps"`

	TFEResourceReport
}

type TFEPhaseStatusTimestamps struct {
	CanceledAt    *time.Time `json:"canceled-at,omitempty"`
	ErroredAt     *time.Time `json:"errored-at,omitempty"`
	FinishedAt    *time.Time `json:"finished-at,omitempty"`
	PendingAt     *time.Time `json:"pending-at,omitempty"`
	QueuedAt      *time.Time `json:"queued-at,omitempty"`
	StartedAt     *time.Time `json:"started-at,omitempty"`
	UnreachableAt *time.Time `json:"unreachable-at,omitempty"`
}

type TFEPlan struct {
	ID               resource.TfeID            `jsonapi:"primary,plans"`
	HasChanges       bool                      `jsonapi:"attribute" json:"has-changes"`
	LogReadURL       string                    `jsonapi:"attribute" json:"log-read-url"`
	Status           string                    `jsonapi:"attribute" json:"status"`
	StatusTimestamps *TFEPhaseStatusTimestamps `jsonapi:"attribute" json:"status-timestamps"`

	TFEResourceReport
}

type TFEResourceReport struct {
	Additions    *int `json:"resource-additions"`
	Changes      *int `json:"resource-changes"`
	Destructions *int `json:"resource-destructions"`
}

type TFERun struct {
	ID                     resource.TfeID          `jsonapi:"primary,runs"`
	Actions                *TFERunActions          `jsonapi:"attribute" json:"actions"`
	AllowEmptyApply        bool                    `jsonapi:"attribute" json:"allow-empty-apply"`
	AutoApply              bool                    `jsonapi:"attribute" json:"auto-apply"`
	CreatedAt              time.Time               `jsonapi:"attribute" json:"created-at"`
	ForceCancelAvailableAt *time.Time              `jsonapi:"attribute" json:"force-cancel-available-at"`
	ExecutionMode          string                  `jsonapi:"attribute" json:"execution-mode"`
	HasChanges             bool                    `jsonapi:"attribute" json:"has-changes"`
	IsDestroy              bool                    `jsonapi:"attribute" json:"is-destroy"`
	Message                string                  `jsonapi:"attribute" json:"message"`
	Permissions            *TFERunPermissions      `jsonapi:"attribute" json:"permissions"`
	PlanOnly               bool                    `jsonapi:"attribute" json:"plan-only"`
	PositionInQueue        int                     `jsonapi:"attribute" json:"position-in-queue"`
	Refresh                bool                    `jsonapi:"attribute" json:"refresh"`
	RefreshOnly            bool                    `jsonapi:"attribute" json:"refresh-only"`
	ReplaceAddrs           []string                `jsonapi:"attribute" json:"replace-addrs,omitempty"`
	Source                 string                  `jsonapi:"attribute" json:"source"`
	Status                 string                  `jsonapi:"attribute" json:"status"`
	StatusTimestamps       *TFERunStatusTimestamps `jsonapi:"attribute" json:"status-timestamps"`
	TargetAddrs            []string                `jsonapi:"attribute" json:"target-addrs,omitempty"`
	TerraformVersion       string                  `jsonapi:"attribute" json:"terraform-version"`
	Variables              []TFERunVariable        `jsonapi:"attribute" json:"variables"`

	// Relations
	Apply                *TFEApply                              `jsonapi:"relationship" json:"apply"`
	ConfigurationVersion *configversion.TFEConfigurationVersion `jsonapi:"relationship" json:"configuration-version"`
	CostEstimate         *types.CostEstimate                    `jsonapi:"relationship" json:"cost-estimate"`
	CreatedBy            *user.TFEUser                          `jsonapi:"relationship" json:"created-by"`
	Plan                 *TFEPlan                               `jsonapi:"relationship" json:"plan"`
	Workspace            *TFEWorkspace                          `jsonapi:"relationship" json:"workspace"`
}

type TFERunActions struct {
	IsCancelable      bool `json:"is-cancelable"`
	IsConfirmable     bool `json:"is-confirmable"`
	IsDiscardable     bool `json:"is-discardable"`
	IsForceCancelable bool `json:"is-force-cancelable"`
}

type TFERunCreateOptions struct {
	// Type is a public field utilized by JSON:API to set the resource type via
	// the field tag.  It is not a user-defined value and does not need to be
	// set.  https://jsonapi.org/format/#crud-creating
	Type string `jsonapi:"primary,runs"`

	// AllowEmptyApply specifies whether Terraform can apply the run even when the plan contains no changes.
	// Often used to upgrade state after upgrading a workspace to a new terraform version.
	AllowEmptyApply *bool `jsonapi:"attribute" json:"allow-empty-apply,omitempty"`

	// TerraformVersion specifies the Terraform version to use in this run.
	// Only valid for plan-only runs; must be a valid Terraform version available to the organization.
	TerraformVersion *string `jsonapi:"attribute" json:"terraform-version,omitempty"`

	// PlanOnly specifies if this is a speculative, plan-only run that Terraform cannot apply.
	PlanOnly *bool `jsonapi:"attribute" json:"plan-only,omitempty"`

	// Specifies if this plan is a destroy plan, which will destroy all
	// provisioned resources.
	IsDestroy *bool `jsonapi:"attribute" json:"is-destroy,omitempty"`

	// Refresh determines if the run should
	// update the state prior to checking for differences
	Refresh *bool `jsonapi:"attribute" json:"refresh,omitempty"`

	// RefreshOnly determines whether the run should ignore config changes
	// and refresh the state only
	RefreshOnly *bool `jsonapi:"attribute" json:"refresh-only,omitempty"`

	// Specifies the message to be associated with this run.
	Message *string `jsonapi:"attribute" json:"message,omitempty"`

	// Specifies the configuration version to use for this run. If the
	// configuration version object is omitted, the run will be created using the
	// workspace's latest configuration version.
	ConfigurationVersion *configversion.TFEConfigurationVersion `jsonapi:"relationship" json:"configuration-version"`

	// Specifies the workspace where the run will be executed.
	Workspace *workspace.TFEWorkspace `jsonapi:"relationship" json:"workspace"`

	// If non-empty, requests that Terraform should create a plan including
	// actions only for the given objects (specified using resource address
	// syntax) and the objects they depend on.
	//
	// This capability is provided for exceptional circumstances only, such as
	// recovering from mistakes or working around existing Terraform
	// limitations. Terraform will generally mention the -target command line
	// option in its error messages describing situations where setting this
	// argument may be appropriate. This argument should not be used as part
	// of routine workflow and Terraform will emit warnings reminding about
	// this whenever this property is set.
	TargetAddrs []string `jsonapi:"attribute" json:"target-addrs,omitempty"`

	// If non-empty, requests that Terraform create a plan that replaces
	// (destroys and then re-creates) the objects specified by the given
	// resource addresses.
	ReplaceAddrs []string `jsonapi:"attribute" json:"replace-addrs,omitempty"`

	// AutoApply determines if the run should be applied automatically without
	// user confirmation. It defaults to the Workspace.AutoApply setting.
	AutoApply *bool `jsonapi:"attribute" json:"auto-apply,omitempty"`

	// Variables allows you to specify terraform input variables for
	// a particular run, prioritized over variables defined on the workspace.
	Variables []*TFERunVariable `jsonapi:"attribute" json:"variables,omitempty"`
}

type TFERunEvent struct {
	ID          resource.TfeID `jsonapi:"primary,run-events"`
	Action      string         `jsonapi:"attr,action"`
	CreatedAt   time.Time      `jsonapi:"attr,created-at,iso8601"`
	Description string         `jsonapi:"attr,description"`

	// Relations - Note that `target` is not supported yet
	Actor *user.TFEUser `jsonapi:"relation,actor"`
}

type TFERunEventList struct {
	// Pagination is not supported by the API
	*types.Pagination
	Items []*TFERunEvent
}

type TFERunList struct {
	*types.Pagination
	Items []*Run
}

type TFERunListOptions struct {
	types.ListOptions

	Organization *organization.Name `schema:"organization_name,omitempty"`

	WorkspaceID *resource.TfeID `schema:"workspace_id,omitempty"`

	// Optional: Searches runs that matches the supplied VCS username.
	User *string `schema:"search[user],omitempty"`

	// Optional: Searches runs that matches the supplied commit sha.
	Commit *string `schema:"search[commit],omitempty"`

	// Optional: Searches runs that matches the supplied VCS username, commit sha, run_id, and run message.
	// The presence of search[commit] or search[user] takes priority over this parameter and will be omitted.
	Search string `schema:"search[basic],omitempty"`

	// Optional: Comma-separated list of acceptable run statuses.
	// Options are listed at https://developer.hashicorp.com/terraform/cloud-docs/api-docs/run#run-states,
	// or as constants with the RunStatus string type.
	Status string `schema:"filter[status],omitempty"`

	// Optional: Comma-separated list of acceptable run sources.
	// Options are listed at https://developer.hashicorp.com/terraform/cloud-docs/api-docs/run#run-sources,
	// or as constants with the RunSource string type.
	Source string `schema:"filter[source],omitempty"`

	// Optional: Comma-separated list of acceptable run operation types.
	// Options are listed at https://developer.hashicorp.com/terraform/cloud-docs/api-docs/run#run-operations,
	// or as constants with the RunOperation string type.
	Operation string `schema:"filter[operation],omitempty"`

	// Optional: A list of relations to include. See available resources:
	// https://developer.hashicorp.com/terraform/cloud-docs/api-docs/run#available-related-resources
	Include []string `schema:"include,omitempty"`
}

type TFERunOperation string

type TFERunPermissions struct {
	CanApply        bool `json:"can-apply"`
	CanCancel       bool `json:"can-cancel"`
	CanDiscard      bool `json:"can-discard"`
	CanForceCancel  bool `json:"can-force-cancel"`
	CanForceExecute bool `json:"can-force-execute"`
}

type TFERunStatusTimestamps struct {
	AppliedAt            *time.Time `json:"applied-at,omitempty"`
	ApplyQueuedAt        *time.Time `json:"apply-queued-at,omitempty"`
	ApplyingAt           *time.Time `json:"applying-at,omitempty"`
	CanceledAt           *time.Time `json:"canceled-at,omitempty"`
	ConfirmedAt          *time.Time `json:"confirmed-at,omitempty"`
	CostEstimatedAt      *time.Time `json:"cost-estimated-at,omitempty"`
	CostEstimatingAt     *time.Time `json:"cost-estimating-at,omitempty"`
	DiscardedAt          *time.Time `json:"discarded-at,omitempty"`
	ErroredAt            *time.Time `json:"errored-at,omitempty"`
	ForceCanceledAt      *time.Time `json:"force-canceled-at,omitempty"`
	PlanQueueableAt      *time.Time `json:"plan-queueable-at,omitempty"`
	PlanQueuedAt         *time.Time `json:"plan-queued-at,omitempty"`
	PlannedAndFinishedAt *time.Time `json:"planned-and-finished-at,omitempty"`
	PlannedAt            *time.Time `json:"planned-at,omitempty"`
	PlanningAt           *time.Time `json:"planning-at,omitempty"`
	PolicyCheckedAt      *time.Time `json:"policy-checked-at,omitempty"`
	PolicySoftFailedAt   *time.Time `json:"policy-soft-failed-at,omitempty"`
}

type TFERunVariable struct {
	Key   string `json:"key"`
	Value string `json:"value"`
}

type TFEWorkspace struct {
	ID         resource.TfeID `jsonapi:"primary,workspaces"`
	CurrentRun *TFERun        `jsonapi:"relationship" json:"current-run"`
}

type TailOptions struct {
	RunID  resource.TfeID `schema:"run_id,required"`
	Phase  PhaseType      `schema:"phase,required"`
	Offset int            `schema:"offset"` // position in overall data to seek from.
}

type Timeout struct {
	logr.Logger

	OverrideCheckInterval time.Duration
	PlanningTimeout       time.Duration
	ApplyingTimeout       time.Duration
	Runs                  timeoutRunClient
}

type VCSProviderService vcs.Service

type Variable struct {
	Key   string
	Value string
}

type WatchOptions struct {
	Organization *organization.Name `schema:"organization_name,omitempty"` // filter by organization name
	WorkspaceID  *resource.TfeID    `schema:"workspace_id,omitempty"`      // filter by workspace ID; mutually exclusive with organization filter
}