Module runtime




function _setQueryMode

_setQueryMode(val: boolean): void

function allConfig

allConfig(): {[key: string]: string}

allConfig returns a copy of the full config map.

function debuggablePromise

debuggablePromise<T>(p: Promise<T>, ctx: any): Promise<T>

debuggablePromise optionally wraps a promise with some goo to make it easier to debug common problems.

function deserializeProperties

deserializeProperties(outputsStruct: any): any

deserializeProperties fetches the raw outputs and deserializes them from a gRPC call result.

function deserializeProperty

deserializeProperty(prop: any): any

deserializeProperty unpacks some special types, reversing the above process.

function disconnect

disconnect(): void

disconnect permanently disconnects from the server, closing the connections. It waits for the existing RPC queue to drain. If any RPCs come in afterwards, however, they will crash the process.

function disconnectSync

disconnectSync(): void

disconnectSync permanently disconnects from the server, closing the connections. Unlike disconnect. it does not wait for the existing RPC queue to drain. Any RPCs that come in after this call will crash the process.

function errorString

errorString(err: Error): string

errorString produces a string from an error, conditionally including additional diagnostics.

let excessiveDebugOutput

let excessiveDebugOutput: boolean = false;

excessiveDebugOutput enables, well, pretty excessive debug output pertaining to resources and properties.

function getConfig

getConfig(k: string): string | undefined

getConfig returns a configuration variable’s value or undefined if it is unset.

function getEngine

getEngine(): Object | undefined

getEngine returns the current engine, if any, for RPC communications back to the resource engine.

function getMonitor

getMonitor(): Object | undefined

getMonitor returns the current resource monitoring service client for RPC communications.

function getProject

getProject(): string

Get the project being run by the current update.

function getRootResource

getRootResource(): Promise<URN | undefined>

getRootResource returns a root resource URN that will automatically become the default parent of all resources. This can be used to ensure that all resources without explicit parents are parented to a common parent resource.

function getStack

getStack(): string

Get the stack being targeted by the current update.

function hasMonitor

hasMonitor(): boolean

hasMonitor returns true if we are currently connected to a resource monitoring service.

function invoke

invoke(tok: string, props: Inputs, opts?: InvokeOptions): Promise<any>

invoke dynamically invokes the function, tok, which is offered by a provider plugin. The inputs can be a bag of computed values (Ts or Promises), and the result is a Promise that resolves when the invoke finishes.

function isDryRun

isDryRun(): boolean

Returns true if we’re currently performing a dry-run, or false if this is a true update. Note that we always consider executions in test mode to be “dry-runs”, since we will never actually carry out an update, and therefore certain output properties will never be resolved.

function isLegacyApplyEnabled

isLegacyApplyEnabled(): boolean

Returns true if we will resolve missing outputs to inputs during preview (PULUMI_ENABLE_LEGACY_APPLY).

function isQueryMode

isQueryMode(): boolean

Returns true if query mode is enabled.

function isTestModeEnabled

isTestModeEnabled(): boolean

Returns true if test mode is enabled (PULUMI_TEST_MODE).

function listResourceOutputs

listResourceOutputs<U>(typeFilter?: undefined | (o: any) => boolean, stackName?: undefined | string): query.AsyncQueryable<ResolvedResource<U>>

listResourceOutputs returns the resource outputs (if any) for a stack, or an error if the stack cannot be found. Resources are retrieved from the latest stack snapshot, which may include ongoing updates.

function monitorSupportsSecrets

monitorSupportsSecrets(): Promise<boolean>

monitorSupportsSecrets returns a promise that when resolved tells you if the resource monitor we are connected to is able to support secrets across it’s RPC interface. When it does, we marshal outputs marked with the secret bit in a special way.

interface Options

interface Options

Options is a bag of settings that controls the behavior of previews and deployments

property dryRun

dryRun?: undefined | false | true;

property engineAddr

engineAddr?: undefined | string;

property legacyApply

legacyApply?: undefined | false | true;

property monitorAddr

monitorAddr?: undefined | string;

property parallel

parallel?: undefined | number;

property project

project?: undefined | string;

property queryMode

queryMode?: undefined | false | true;

property stack

stack?: undefined | string;

property testModeEnabled

testModeEnabled?: undefined | false | true;

type OutputResolvers

type OutputResolvers = Record<string, (value: any, isStable: boolean, isSecret: boolean) => void>;

function readResource

readResource(res: Resource, t: string, name: string, props: Inputs, opts: ResourceOptions): void

Reads an existing custom resource’s state from the resource monitor. Note that resources read in this way will not be part of the resulting stack’s state, as they are presumed to belong to another.

function registerResource

registerResource(res: Resource, t: string, name: string, custom: boolean, props: Inputs, opts: ResourceOptions): void

registerResource registers a new resource object with a given type t and name. It returns the auto-generated URN and the ID that will resolve after the deployment has completed. All properties will be initialized to property objects that the registration operation will resolve at the right time (or remain unresolved for deployments).

function registerResourceOutputs

registerResourceOutputs(res: Resource, outputs: Inputs | Promise<Inputs> | Output<Inputs>): void

registerResourceOutputs completes the resource registration, attaching an optional set of computed outputs.

function resolveProperties

resolveProperties(res: Resource, resolvers: Record<string, (v: any, isKnown: boolean, isSecret: boolean) => void>, t: string, name: string, allProps: any): void

resolveProperties takes as input a gRPC serialized and resolves all of the resource’s matching properties to the values inside.

NOTE: it is imperative that the properties in allProps were produced by deserializeProperties in order for output properties to work correctly w.r.t. knowns/unknowns: this function assumes that any undefined value in allPropsrepresents an unknown value that was returned by an engine operation.

const rootPulumiStackTypeName

const rootPulumiStackTypeName: "pulumi:pulumi:Stack" = "pulumi:pulumi:Stack";

rootPulumiStackTypeName is the type name that should be used to construct the root component in the tree of Pulumi resources allocated by a deployment. This must be kept up to date with

function rpcKeepAlive

rpcKeepAlive(): () => void

rpcKeepAlive registers a pending call to ensure that we don’t prematurely disconnect from the server. It returns a function that, when invoked, signals that the RPC has completed.

function runInPulumiStack

runInPulumiStack(init: () => any): Promise<Inputs | undefined>

runInPulumiStack creates a new Pulumi stack resource and executes the callback inside of it. Any outputs returned by the callback will be stored as output properties on this resulting Stack object.

function serialize

serialize(): boolean

serialize returns true if resource operations should be serialized.

function serializeProperties

serializeProperties(label: string, props: Inputs): Promise<{ ... }>

serializeProperties walks the props object passed in, awaiting all interior promises, creating a reasonable POJO object that can be remoted over to registerResource.

function serializeProperty

serializeProperty(ctx: string, prop: Input<any>, dependentResources: Set<Resource>): Promise<any>

serializeProperty serializes properties deeply. This understands how to wait on any unresolved promises, as appropriate, in addition to translating certain “special” values so that they are ready to go on the wire.

function serializeResourceProperties

serializeResourceProperties(label: string, props: Inputs): Promise<[, { ... }, Map<string, Set<Resource>>]>

serializeResourceProperties walks the props object passed in, awaiting all interior promises besides those for id and urn, creating a reasonable POJO object that can be remoted over to registerResource.

function setConfig

setConfig(k: string, v: string): void

setConfig sets a configuration variable.

function setRootResource

setRootResource(res: ComponentResource): Promise<void>

setRootResource registers a resource that will become the default parent for all resources without explicit parents.

const specialArchiveSig

const specialArchiveSig: "0def7320c3a5731c473e5ecbe6d01bc7" = "0def7320c3a5731c473e5ecbe6d01bc7";

specialArchiveSig is a randomly assigned hash used to identify archives in maps. See pkg/resource/asset.go.

const specialAssetSig

const specialAssetSig: "c44067f5952c0a294b673a41bacd8c17" = "c44067f5952c0a294b673a41bacd8c17";

specialAssetSig is a randomly assigned hash used to identify assets in maps. See pkg/resource/asset.go.

const specialSecretSig

const specialSecretSig: "1b47061264138c4ac30d75fd1eb44270" = "1b47061264138c4ac30d75fd1eb44270";

specialSecretSig is a randomly assigned hash used to identify secrets in maps. See pkg/resource/properties.go.

const specialSigKey

const specialSigKey: "4dabf18193072939515e22adb298388d" = "4dabf18193072939515e22adb298388d";

specialSigKey is sometimes used to encode type identity inside of a map. See pkg/resource/properties.go.

function transferProperties

transferProperties(onto: Resource, label: string, props: Inputs): OutputResolvers

transferProperties mutates the ‘onto’ resource so that it has Promise-valued properties for all the ‘props’ input/output props. Importantly all these promises are completely unresolved. This is because we don’t want anyone to observe the values of these properties until the rpc call to registerResource actually returns. This is because the registerResource call may actually override input values, and we only want people to see the final value.

The result of this call (beyond the stateful changes to ‘onto’) is the set of Promise resolvers that will be called post-RPC call. When the registerResource RPC call comes back, the values that the engine actualy produced will be used to resolve all the unresolved promised placed on ‘onto’.

const unknownValue

const unknownValue: "04da6b54-80e4-46f7-96ec-b56ff0331ba9" = "04da6b54-80e4-46f7-96ec-b56ff0331ba9";

Unknown values are encoded as a distinguished string value.