The Automation API is now available. No CLI. No human-in-the-loop. Just your code. Learn More

Module runtime




function allConfig

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

allConfig returns a copy of the full config map.

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(): Promise<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.

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 getStackResource

getStackResource(): Stack | undefined

function hasEngine

hasEngine(): boolean

hasEngine returns true if we are currently connected to an engine.

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. invoke behaves differently in the case that options contains {async:true} or not.

In the case where {async:true} is present in the options bag:

  1. the result of invoke will be a Promise resolved to the result value of the provider plugin.
  2. the props inputs can be a bag of computed values (including, Ts, Promise<T>s, Output<T>s etc.).

In the case where {async:true} is not present in the options bag:

  1. the result of invoke will be a Promise resolved to the result value of the provider call. However, that Promise will also have the respective values of the Provider result exposed directly on it as properties.

  2. The inputs must be a bag of simple values, and the result is the result that the Provider produced.

Simple values are: 1. undefined, null, string, number or boolean values. 2. arrays of simple values. 3. objects containing only simple values.

Importantly, simple values do not include: 1. Promises 2. Outputs 3. Assets or Archives 4. Resources.

All of these contain async values that would prevent `invoke from being able to operate synchronously.

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 isRpcSecret

isRpcSecret(obj: any): boolean

isRpcSecret returns true if obj is a wrapped secret value (i.e. it’s an object with the special key set).

function isTestModeEnabled

isTestModeEnabled(): boolean

Returns true if test mode is enabled (PULUMI_TEST_MODE).

function leakedPromises

leakedPromises(): [, Set<Promise<any>>, string]

function listResourceOutputs

listResourceOutputs<U>(typeFilter?: undefined | (o: any) => boolean, stackName?: undefined | string): 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.

const maxRPCMessageSize

const maxRPCMessageSize: number =  1024 * 1024 * 400;

class MockMonitor

class MockMonitor


new MockMonitor(mocks: Mocks)

method invoke

public invoke(req: any, callback: (err: any, innerResponse: any) => void): Promise<void>

method readResource

public readResource(req: any, callback: (err: any, innterResponse: any) => void): Promise<void>

method registerResource

public registerResource(req: any, callback: (err: any, innerResponse: any) => void): Promise<void>

method registerResourceOutputs

public registerResourceOutputs(req: any, callback: (err: any, innerResponse: any) => void): void

method supportsFeature

public supportsFeature(req: any, callback: (err: any, innerResponse: any) => void): void

property mocks

mocks: Mocks;

interface Mocks

interface Mocks

Mocks is an abstract class that allows subclasses to replace operations normally implemented by the Pulumi engine with their own implementations. This can be used during testing to ensure that calls to provider functions and resource constructors return predictable values.

method call

call(token: string, args: any, provider?: undefined | string): Record<string, any>

call mocks provider-implemented function calls (e.g. aws.get_availability_zones).

method newResource

newResource(type: string, name: string, inputs: any, provider?: undefined | string, id?: undefined | string): {
    id: string;
    state: Record<string, any>;

new_resource mocks resource construction calls. This function should return the physical identifier and the output properties for the resource being constructed.

function monitorSupportsFeature

monitorSupportsFeature(feature: string): Promise<boolean>

monitorSupportsFeature returns a promise that when resolved tells you if the resource monitor we are connected to is able to support a particular feature.

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 its 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 syncDir

syncDir?: undefined | string;

Directory containing the send/receive files for making synchronous invokes to the engine.

property testModeEnabled

testModeEnabled?: undefined | false | true;

type OutputResolvers

type OutputResolvers = Record<string, (value: any, isStable: boolean, isSecret: boolean, deps?: Resource[], err?: Error) => void>;

function promiseDebugString

promiseDebugString(p: Promise<any>): string

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, remote: boolean, newDependency: (urn: URN) => Resource, 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 registerStackTransformation

registerStackTransformation(t: ResourceTransformation): void

Add a transformation to all future resources constructed in this Pulumi stack.

function resetOptions

resetOptions(project: string, stack: string, parallel: number, engineAddr: string, monitorAddr: string, preview: boolean): void

function resolveProperties

resolveProperties(res: Resource, resolvers: Record<string, (v: any, isKnown: boolean, isSecret: boolean, deps?: Resource[], err?: Error) => void>, t: string, name: string, allProps: any, deps: Record<string, Resource[]>, err?: Error): 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: () => Promise<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 setAllConfig

setAllConfig(c: {[key: string]: string}): void

setAllConfig overwrites the config map.

function setConfig

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

setConfig sets a configuration variable.

function setMockOptions

setMockOptions(mockMonitor: any, project?: undefined | string, stack?: undefined | string, preview?: undefined | false | true): void

function setMocks

setMocks(mocks: Mocks, project?: undefined | string, stack?: undefined | string, preview?: undefined | false | true): void

setMocks configures the Pulumi runtime to use the given mocks for testing.

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 streamInvoke

streamInvoke(tok: string, props: Inputs, opts: InvokeOptions): Promise<StreamInvokeResponse<any>>

class StreamInvokeResponse

 implements AsyncIterable<T>


new StreamInvokeResponse(source: AsyncIterable<T>, cancelSource: () => void)

method __@asyncIterator

__@asyncIterator(): AsyncIterator<T>

method cancel

public cancel(): void

function suppressUnhandledGrpcRejections

suppressUnhandledGrpcRejections<T>(p: Promise<T>): Promise<T>

suppressUnhandledGrpcRejections silences any unhandled promise rejections that occur due to gRPC errors. The input promise may still be rejected.

function terminateRpcs

terminateRpcs(): void

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.

function unwrapRpcSecret

unwrapRpcSecret(obj: any): any

unwrapRpcSecret returns the underlying value for a secret, or the value itself if it was not a secret.