Module runtime

@pulumi/pulumi > runtime

Index ▾

runtime/closure/createClosure.ts runtime/closure/parseFunction.ts runtime/closure/rewriteSuper.ts runtime/closure/serializeClosure.ts runtime/closure/v8.ts runtime/config.ts runtime/debuggable.ts runtime/invoke.ts runtime/resource.ts runtime/rpc.ts runtime/settings.ts runtime/stack.ts

const getFunctionLocationAsync

const getFunctionLocationAsync: getFunctionLocationAsync =  versionSpecificV8Module.getFunctionLocationAsync;

Given a function, returns the file, line and column number in the file where this function was defined. Returns { “”, 0, 0 } if the location cannot be found or if the given function has no Script.

const lookupCapturedVariableValueAsync

const lookupCapturedVariableValueAsync: lookupCapturedVariableValueAsync =  versionSpecificV8Module.lookupCapturedVariableValueAsync;

Given a function and a free variable name, lookupCapturedVariableValue looks up the value of that free variable in the scope chain of the provided function. If the free variable is not found, throwOnFailure indicates whether or not this function should throw or return `undefined.

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

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.

const unknownValue

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

Unknown values are encoded as a distinguished string value.

function allConfig

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

allConfig returns a copy of the full config map.

function createFunctionInfoAsync

createFunctionInfoAsync(func: Function, serialize: (o: any) => boolean, logResource: resource.Resource | undefined): Promise<FunctionInfo>

createFunctionInfo serializes a function and its closure environment into a form that is amenable to persistence as simple JSON. Like toString, it includes the full text of the function’s source code, suitable for execution. Unlike toString, it actually includes information about the captured environment.

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.

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

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

function getProject

getProject(): string | undefined

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 | undefined

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.

function parseFunction

parseFunction(funcString: string): [, string, ParsedFunction]

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) => 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.

function rewriteSuperReferences

rewriteSuperReferences(code: string, isStatic: boolean): string

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 serializeFunction

serializeFunction(func: Function, args: SerializeFunctionArgs): Promise<SerializedFunction>

serializeFunction serializes a JavaScript function into a text form that can be loaded in another execution context, for example as part of a function callback associated with an AWS Lambda. The function serialization captures any variables captured by the function body and serializes those values into the generated text along with the function body. This process is recursive, so that functions referenced by the body of the serialized function will themselves be serialized as well. This process also deeply serializes captured object values, including prototype chains and property descriptors, such that the semantics of the function when deserialized should match the original function.

There are several known limitations:

  • If a native function is captured either directly or indirectly, closure serialization will return an error.
  • Captured values will be serialized based on their values at the time that serializeFunction is called. Mutations to these values after that (but before the deserialized function is used) will not be observed by the deserialized function.

function serializeFunctionAsync

serializeFunctionAsync(func: Function, serialize?: undefined | (o: any) => boolean): Promise<string>

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<Object>

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 setIsDryRun

setIsDryRun(val: boolean): void

function setRootResource

setRootResource(res: ComponentResource): Promise<void>

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

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’.

interface CapturedPropertyChain

interface CapturedPropertyInfo

interface CapturedVariables

interface Entry

Entry is the environment slot for a named lexically captured variable.

property array

array?: Entry[];

property expr

expr?: undefined | string;

property function

function?: FunctionInfo;

property json

json?: any;

property module

module?: undefined | string;

property object

object?: ObjectInfo;

property output

output?: Entry;

property promise

promise?: Entry;

property regexp

regexp?: undefined | {
    flags: string;
    source: string;

interface FunctionInfo

interface ObjectInfo

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 monitorAddr

monitorAddr?: undefined | string;

property parallel

parallel?: undefined | number;

property project

project?: undefined | string;

property stack

stack?: undefined | string;

interface ParsedFunction

interface ParsedFunctionCode

property funcExprWithName

funcExprWithName?: undefined | string;

property funcExprWithoutName

funcExprWithoutName: string;

property functionDeclarationName

functionDeclarationName?: undefined | string;

property isArrowFunction

isArrowFunction: boolean;

interface PropertyInfo

property configurable

configurable?: undefined | false | true;

property enumerable

enumerable?: undefined | false | true;

property get

get?: Entry;

property hasValue

hasValue: boolean;

property set

set?: Entry;

property writable

writable?: undefined | false | true;

interface PropertyInfoAndValue

interface PropertyMap

extends Map<Entry, PropertyInfoAndValue>

method __@iterator

__@iterator(): IterableIterator<[, Entry, PropertyInfoAndValue]>

Returns an iterable of entries in the map.

method clear

clear(): void

method delete

delete(key: Entry): boolean

method entries

entries(): IterableIterator<[, Entry, PropertyInfoAndValue]>

Returns an iterable of key, value pairs for every entry in the map.

method forEach

forEach(callbackfn: (value: PropertyInfoAndValue, key: Entry, map: Map<Entry, PropertyInfoAndValue>) => void, thisArg?: any): void

method get

method has

has(key: Entry): boolean

method keys

keys(): IterableIterator<Entry>

Returns an iterable of keys in the map

method set

set(key: Entry, value: PropertyInfoAndValue): this

method values

values(): IterableIterator<PropertyInfoAndValue>

Returns an iterable of values in the map

property Map

Map: MapConstructor;

property __@toStringTag

__@toStringTag: "Map";

property size

size: number;

interface SerializeFunctionArgs

SerializeFunctionArgs are arguments used to serialize a JavaScript function

property exportName

exportName?: undefined | string;

The name to export from the module defined by the generated module text. Defaults to ‘handler’.

property isFactoryFunction

isFactoryFunction?: undefined | false | true;

If this is a function which, when invoked, will produce the actual entrypoint function. Useful for when serializing a function that has high startup cost that only wants to be run once. The signature of this function should be: () => (provider_handler_args…) => provider_result

This will then be emitted as: exports.[exportName] = serialized_func_name();

In other words, the function will be invoked (once) and the resulting inner function will be what is exported.

property logResource

logResource?: Resource;

The resource to log any errors we encounter against.

property serialize

serialize?: undefined | (o: any) => boolean;

A function to prevent serialization of certain objects captured during the serialization. Primarily used to prevent potential cycles.

interface SerializedFunction

SerializeFunction is a representation of a serialized JavaScript function.

property exportName

exportName: string;

The name of the exported module member.

property text

text: string;

The text of a JavaScript module which exports a single name bound to an appropriate value. In the case of a normal function, this value will just be serialized function. In the case of a factory function this value will be the result of invoking the factory function.

let excessiveDebugOutput

let excessiveDebugOutput: boolean = false;

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

type CapturedVariableMap

type CapturedVariableMap = Map<string, CapturedPropertyChain[]>;

type OutputResolvers

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