cloudiac

type AccountInfo struct {
	Region          string
	CompartmentOCID string
	Namespace       string
	Credential      CredentialHandle
}

type AccountResolver interface {
	ResolveAccount(ctx context.Context, name string) (AccountInfo, error)
}

type ApplyRequest struct {
	Spec     ModuleSpec
	Cred     CredentialHandle
	PlanHash string
	// ConfirmDestroy must be set to run a destroy plan.
	ConfirmDestroy bool
}

type BinaryEnsurer interface {
	Ensure(ctx context.Context) (string, error)
}

type BucketSpec struct {
	Name        string
	Namespace   string
	Unprotected bool
}

type Change struct {
	Address string
	Action  string
}

type CloudPlannerAdapter struct {
	Engine   DetailedPlanner
	Accounts AccountResolver
}

type ConnectionAccounts struct {
	Conns  ConnectionGetter
	Sealed cloudconn.SealedReader
}

type ConnectionGetter interface {
	Get(ctx context.Context, name string) (cloudconn.Connection, error)
}

type CostEstimate struct {
	MonthlyMicros int64
	Unpriced      []string
	AsOf          string
	Refusals      []Refusal
}

type CostPolicy struct {
	// MonthlyLimitMicros is the account limit. Zero means nothing billable is allowed.
	MonthlyLimitMicros int64
	// AllowUnpriced lets resources without a price through, not estimated.
	AllowUnpriced bool
}

type CredentialFile struct {
	// HostPath is a file on a host tmpfs, written for this step and removed after it.
	HostPath string
	// EnvName names the variable that tells the provider where the file is.
	EnvName string
}

type CredentialHandle struct {
	ID        string
	ExpiresAt int64
}

type DetailedPlanner interface {
	PlanDetailed(ctx context.Context, spec ModuleSpec, cred CredentialHandle) (PlanResult, error)
}

type Engine interface {
	Plan(ctx context.Context, spec ModuleSpec, cred CredentialHandle) (Result, error)
	Apply(ctx context.Context, req ApplyRequest) (Result, error)
	Destroy(ctx context.Context, req ApplyRequest) (Result, error)
}

type Error struct {
	Kind    ErrorKind
	Step    Step
	Message string
	Err     error
}

type ErrorKind string

type ExecRunner struct {
	// MaxBytes caps each stream; zero uses the env seeded default.
	MaxBytes int64
	// contains filtered or unexported fields
}

type FetchConfig struct {
	DataDir      string
	Version      string
	MaxBytes     int64
	MinFreeBytes int64
	Timeout      time.Duration
	// FreeBytes reports free space under DataDir; the caller supplies it per platform.
	FreeBytes  func(dir string) (int64, error)
	HTTPClient *http.Client
	BaseURL    string
	Verifier   SignatureVerifier
	// AllowChecksumOnly accepts a release without a signature check. Default off.
	AllowChecksumOnly bool
	GOOS, GOARCH      string
}

type FetchLimits struct {
	MaxMB, MinFreeMB, TimeoutSeconds int
	AllowChecksumOnly                bool
}

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

type InstanceSpec struct {
	Name               string
	Network            string
	Shape              string
	OCPUs              int
	MemoryGB           int
	AvailabilityDomain string
	ImageOCID          string
}

type KeyDeriver interface {
	DeriveKey(purpose string) []byte
}

type LiveFetcher struct {
	Base   FetchConfig
	Limits func() FetchLimits
	// contains filtered or unexported fields
}

type MaterialSource func(ctx context.Context, version string) (ReleaseMaterial, error)

type ModuleSpec struct {
	Name      string
	Provider  string
	Files     map[string][]byte
	Variables map[string]string
}

type Mount struct {
	Source    string
	Target    string
	ReadWrite bool
}

type NetworkPolicy struct {
	Network   string
	DenyCIDRs []string
}

type NetworkSpec struct {
	Name         string
	CIDR         string
	IngressPorts []int
}

type OCISpec struct {
	Name            string
	Region          string
	CompartmentOCID string
	Networks        []NetworkSpec
	Buckets         []BucketSpec
	Instances       []InstanceSpec
}

type OracleResolver interface {
	ResolveOracle(ctx context.Context, h CredentialHandle) (cloudconn.OracleCredential, error)
}

type PlanAttr struct {
	Path      string
	Old, New  string
	Sensitive bool
}

type PlanChange struct {
	Address string
	Type    string
	Action  string
	Attrs   []PlanAttr
}

type PlanResult struct {
	Changes  []PlanChange
	Cost     CostEstimate
	Warnings []string
	Hash     string
}

type Policy struct {
	// MaxDestroys is the number of destroys allowed without an override.
	MaxDestroys int
	// AllowProtectedDelete is the explicit opt in to delete data resources.
	AllowProtectedDelete bool
}

type PolicyAdapter struct {
	Policy func() Policy
}

type PriceTable interface {
	// Monthly returns the monthly price for one resource and whether it is priced.
	Monthly(resourceType string) (micros int64, ok bool)
	// AsOf names the table version date shown next to every estimate.
	AsOf() string
}

type Refusal struct {
	Code    string
	Address string
	Type    string
	Message string
}

type ReleaseMaterial struct {
	Sums   []byte
	Entity verify.SignedEntity
}

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

type ResourceChange struct {
	Address string
	Type    string
	Action  string
}

type Result struct {
	Step    Step
	Changes []Change
	Outputs map[string]string
	Log     string
	// PlanHash names the saved plan a plan produced or an apply ran.
	PlanHash string
	// StateVersion is the stored state version after the step.
	StateVersion int64
	// Partial means the apply failed but the state it reached was stored.
	Partial bool
	// Diverged means the new state could not be stored under the fence.
	Diverged bool
}

type RunDir struct {
	Root    string
	OnTmpfs bool
}

type RunOutput struct {
	Stdout    []byte
	Stderr    []byte
	Truncated bool
}

type Runner interface {
	Run(ctx context.Context, spec SandboxSpec) (RunOutput, error)
}

type SandboxInput struct {
	Runtime   string
	Image     string
	User      string
	Name      string
	Step      Step
	ModuleDir string
	// RunDir is the private per-run host directory; its work and state subdirs are shared by every step.
	RunDir     string
	TofuBinary string
	PluginDir  string
	Credential CredentialFile
	Network    NetworkPolicy
	Limits     SandboxLimits
	Env        map[string]string
}

type SandboxLimits struct {
	MemoryMB   int
	CPUs       float64
	Pids       int
	WorkTmpMB  int
	StateTmpMB int
}

type SandboxSpec struct {
	Runtime      string
	Image        string
	Name         string
	User         string
	ReadOnlyRoot bool
	CapDrop      []string
	SecurityOpt  []string
	PidsLimit    int
	MemoryMB     int
	CPUs         string
	NetworkFlags []string
	Mounts       []Mount
	Tmpfs        []Tmpfs
	Env          []string
	Workdir      string
	Entrypoint   string
	Args         []string
}

type SavedPlan struct {
	Hash         string           `json:"-"`
	Plan         []byte           `json:"plan"`
	Changes      []ResourceChange `json:"changes"`
	StateVersion int64            `json:"state_version"`
	Destroy      bool             `json:"destroy"`
	CreatedAt    time.Time        `json:"-"`
}

type SavedPlanRunner interface {
	Apply(ctx context.Context, req ApplyRequest) (Result, error)
	Destroy(ctx context.Context, req ApplyRequest) (Result, error)
}

type SettingsReader interface {
	Int(ctx context.Context, key string) int
	Bool(ctx context.Context, key string) bool
}

type SignatureVerifier interface {
	Verify(ctx context.Context, archiveName, archivePath string) error
}

type StateDB interface {
	GetCloudState(ctx context.Context, account, stack string) (store.CloudState, error)
	PutCloudState(ctx context.Context, lock store.CloudStateLock, expectVersion int64, sealed []byte, now time.Time) (int64, error)
	PutCloudPlan(ctx context.Context, p store.CloudPlan) error
	GetCloudPlan(ctx context.Context, account, stack string) (store.CloudPlan, error)
	DeleteCloudPlan(ctx context.Context, account, stack, hash string) error
	InsertCloudStateQuarantine(ctx context.Context, q store.CloudStateQuarantine) (int64, error)
	ListCloudStateQuarantine(ctx context.Context, account, stack string) ([]store.CloudStateQuarantine, error)
}

type StateLocker interface {
	AcquireCloudStateLock(ctx context.Context, account, stack, holder string, ttl time.Duration, now time.Time) (store.CloudStateLock, error)
	ReleaseCloudStateLock(ctx context.Context, lock store.CloudStateLock) error
}

type StateQuarantine struct{ ID int64 }

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

type StaticPrices struct {
	Date   string
	Prices map[string]int64
}

type Step string

type StringSettings interface {
	String(ctx context.Context, key string) string
}

type Tmpfs struct {
	Target  string
	Options string
}

type TofuConfig struct {
	Runtime   string
	Image     string
	User      string
	PluginDir string
	// WorkBase holds the private run dirs; prefer a tmpfs, since the plaintext state and plan
	// sit there for the run. A disk backed base is allowed but reported as a plan warning.
	WorkBase string
	// Live refreshes the sandbox knobs from runtime settings at the start of every run.
	Live    func(TofuConfig) TofuConfig
	Holder  string
	Network NetworkPolicy
	Limits  SandboxLimits
	Timeout func() time.Duration
	// PlanMaxAge caps how old a saved plan may be when it is applied; zero refuses every apply.
	PlanMaxAge func() time.Duration
	Policy     func() Policy
	Cost       func() CostPolicy
	Prices     PriceTable
	// ExistingSpend reports the account's current monthly micros; nil means zero.
	ExistingSpend func(ctx context.Context, account string) int64
}

type TofuDeps struct {
	Runner Runner
	Binary BinaryEnsurer
	Locks  StateLocker
	State  *StateStore
	Creds  OracleResolver
}

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