provisioners

type Diagnosable ¶

type Diagnosable interface {
	Diagnose(ctx context.Context, stackName string) (string, error)
}

Diagnosable defines the interface for a diagnosable provisioner.

type FileProvisioner ¶

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

FileProvisioner is a provisioner that reads JSON files from a filesystem.

func NewFileProvisioner(id string, fs fs.FS) *FileProvisioner

func (fp *FileProvisioner) Destroy(context.Context, string, io.Writer) error

func (fp *FileProvisioner) ID() string

func (fp *FileProvisioner) Provision(context.Context, string, io.Writer) (RawResources, error)

type Provisioner ¶

type Provisioner interface {
	ID() string
	Destroy(context.Context, string, io.Writer) error
}

Provisioner defines the interface for a provisioner.

type ProvisionerMap ¶

type ProvisionerMap map[string]Provisioner

ProvisionerMap is a map of provisioners.

func CopyProvisioners(in ProvisionerMap) ProvisionerMap

type PulumiEnvRunFunc ¶

type PulumiEnvRunFunc[Env any] func(ctx *pulumi.Context, env *Env) error

PulumiEnvRunFunc is a function that runs a Pulumi program with a given environment.

type PulumiProvisioner ¶

type PulumiProvisioner[Env any] struct {
	// contains filtered or unexported fields
}

PulumiProvisioner is a provisioner based on Pulumi with binding to an environment.

func NewTypedPulumiProvisioner[Env any](id string, runFunc PulumiEnvRunFunc[Env], configMap runner.ConfigMap) *PulumiProvisioner[Env]

func NewUntypedPulumiProvisioner(id string, runFunc pulumi.RunFunc, configMap runner.ConfigMap) *PulumiProvisioner[any]

func (pp *PulumiProvisioner[Env]) Destroy(ctx context.Context, stackName string, logger io.Writer) error

func (pp *PulumiProvisioner[Env]) Diagnose(ctx context.Context, stackName string) (string, error)

func (pp *PulumiProvisioner[Env]) ID() string

func (pp *PulumiProvisioner[Env]) Provision(ctx context.Context, stackName string, logger io.Writer) (RawResources, error)

func (pp *PulumiProvisioner[Env]) ProvisionEnv(ctx context.Context, stackName string, logger io.Writer, env *Env) (RawResources, error)

func (pp *PulumiProvisioner[Env]) SetDiagnoseFunc(diagnoseFunc func(ctx context.Context, stackName string) (string, error))

type RawResources ¶

type RawResources map[string][]byte

RawResources is the common types returned by provisioners

func (rr RawResources) Merge(in RawResources)

type StaticStackProvisioner ¶ added in v0.84.0

type StaticStackProvisioner[Env any] struct {
	// contains filtered or unexported fields
}

StaticStackProvisioner is a provisioner that reads a single JSON file and populates a typed environment directly.

JSON file format ¶

The file must be a JSON object whose top-level keys are resource names. Each value is the raw JSON payload for that resource. Keys prefixed with "_" are treated as metadata and are ignored.

{
  "_source": "pulumi-stack-my-stack",
  "kubernetesCluster": { "clusterName": "my-cluster", "kubeConfig": "…" },
  "fakeIntake":        { "host": "localhost", "port": 8080 },
  "agent":             { "version": "7.x" }
}

Field naming and key resolution ¶

For each exported pointer field in *Env that implements components.Importable, the provisioner derives a resource key using the following priority order:

1. The value of the `import` struct tag, when present.
2. The field name with its first letter lowercased (lowerCamelCase).

The derived key is then looked up in the JSON object:

• Match found: components.Importable.SetKey is called so that [environments.BuildEnvFromResources] can unmarshal the payload into the field.
• No match: the field is set to nil and silently skipped.

Naming convention ¶

For the provisioner to wire a field automatically, the corresponding JSON key must equal the lowerCamelCase form of the Go field name — unless the field carries an explicit `import` tag that overrides it.

Given this environment struct:

type MyEnv struct {
    KubernetesCluster *components.KubernetesCluster `import:"kubernetesCluster"` // explicit tag
    FakeIntake        *components.FakeIntake                                      // → key "fakeIntake"
    Agent             *components.KubernetesAgent                                 // → key "agent"
}

The expected JSON keys are "kubernetesCluster", "fakeIntake", and "agent". A field whose JSON key is absent from the file is set to nil (not an error); a JSON key that has no matching field is silently ignored.

Use the `import` tag when the field name and the JSON key diverge — for example when a legacy snapshot uses a different naming convention, or when two fields of the same type would otherwise produce duplicate keys.

Embedded structs and nesting ¶

The provisioner inspects only the direct fields of *Env — it does not recurse into embedded structs.

Value-embedded structs (e.g. CoverageBase in environments.Host) are silently skipped because they have kind Struct, not Ptr. This is harmless as long as those helpers carry no components.Importable fields themselves.

// OK — CoverageBase is a value embed with no Importable fields.
// wireEnv skips it and still finds RemoteHost, FakeIntake, Agent, Updater.
type Host struct {
    CoverageBase                      // skipped (Struct, not Ptr)
    RemoteHost *components.RemoteHost // → key "remoteHost"
    FakeIntake *components.FakeIntake // → key "fakeIntake"
    Agent      *components.RemoteHostAgent  // → key "agent"
    Updater    *components.RemoteHostUpdater // → key "updater"
}

Embedding another environment struct by value does NOT work: its component pointer fields are invisible to wireEnv because Go reflection reports only the direct (non-promoted) fields at the outermost level.

// NOT OK — RemoteHost, FakeIntake, Agent, Updater inside Host are never seen.
type ExtendedHost struct {
    Host                            // skipped (Struct, not Ptr); its fields are invisible
    ExtraComp *components.FakeIntake // → key "extraComp" (only this is wired)
}

If you need to extend an existing environment, declare all component pointer fields directly on the outer struct and use `import` tags where the JSON keys must match a specific name.

This design means no `import` struct tags need to be added to built-in environment types such as [environments.Kubernetes], and no Pulumi provisioner code needs to change.

func NewStaticStackProvisioner[Env any](id string, filePath string) *StaticStackProvisioner[Env]

func (fp *StaticStackProvisioner[Env]) Destroy(context.Context, string, io.Writer) error

func (fp *StaticStackProvisioner[Env]) ID() string

func (fp *StaticStackProvisioner[Env]) ProvisionEnv(_ context.Context, _ string, _ io.Writer, env *Env) (RawResources, error)

type TypedProvisioner ¶

type TypedProvisioner[Env any] interface {
	Provisioner
	ProvisionEnv(context.Context, string, io.Writer, *Env) (RawResources, error)
}

TypedProvisioner defines the interface for a provisioner with env binding

type UntypedProvisioner ¶

type UntypedProvisioner interface {
	Provisioner
	Provision(context.Context, string, io.Writer) (RawResources, error)
}

UntypedProvisioner defines the interface for a provisioner without env binding