You're Invited:Meet the Socket Team at BlackHat and DEF CON in Las Vegas, Aug 7-8.RSVP →
Socket
Socket
Sign inDemoInstall

@pulumi/pulumi

Package Overview
Dependencies
Maintainers
0
Versions
4281
Alerts
File Explorer

Advanced tools

npm Scripts
License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

Comparing version 3.121.1-alpha.xd64448e to 3.121.1-alpha.xdd7e21c

2

package.json
{
"name": "@pulumi/pulumi",
"version": "3.121.1-alpha.xd64448e",
"version": "3.121.1-alpha.xdd7e21c",
"description": "Pulumi's Node.js SDK",

@@ -5,0 +5,0 @@ "license": "Apache-2.0",

28

proto/resource_grpc_pb.d.ts

@@ -25,3 +25,3 @@ // package: pulumirpc

registerStackTransform: IResourceMonitorService_IRegisterStackTransform;
registerProvider: IResourceMonitorService_IRegisterProvider;
registerPackage: IResourceMonitorService_IRegisterPackage;
}

@@ -101,10 +101,10 @@

}
interface IResourceMonitorService_IRegisterProvider extends grpc.MethodDefinition<pulumi_resource_pb.RegisterProviderRequest, pulumi_resource_pb.RegisterProviderResponse> {
path: "/pulumirpc.ResourceMonitor/RegisterProvider";
interface IResourceMonitorService_IRegisterPackage extends grpc.MethodDefinition<pulumi_resource_pb.RegisterPackageRequest, pulumi_resource_pb.RegisterPackageResponse> {
path: "/pulumirpc.ResourceMonitor/RegisterPackage";
requestStream: false;
responseStream: false;
requestSerialize: grpc.serialize<pulumi_resource_pb.RegisterProviderRequest>;
requestDeserialize: grpc.deserialize<pulumi_resource_pb.RegisterProviderRequest>;
responseSerialize: grpc.serialize<pulumi_resource_pb.RegisterProviderResponse>;
responseDeserialize: grpc.deserialize<pulumi_resource_pb.RegisterProviderResponse>;
requestSerialize: grpc.serialize<pulumi_resource_pb.RegisterPackageRequest>;
requestDeserialize: grpc.deserialize<pulumi_resource_pb.RegisterPackageRequest>;
responseSerialize: grpc.serialize<pulumi_resource_pb.RegisterPackageResponse>;
responseDeserialize: grpc.deserialize<pulumi_resource_pb.RegisterPackageResponse>;
}

@@ -123,3 +123,3 @@

registerStackTransform: grpc.handleUnaryCall<pulumi_callback_pb.Callback, google_protobuf_empty_pb.Empty>;
registerProvider: grpc.handleUnaryCall<pulumi_resource_pb.RegisterProviderRequest, pulumi_resource_pb.RegisterProviderResponse>;
registerPackage: grpc.handleUnaryCall<pulumi_resource_pb.RegisterPackageRequest, pulumi_resource_pb.RegisterPackageResponse>;
}

@@ -151,5 +151,5 @@

registerStackTransform(request: pulumi_callback_pb.Callback, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: google_protobuf_empty_pb.Empty) => void): grpc.ClientUnaryCall;
registerProvider(request: pulumi_resource_pb.RegisterProviderRequest, callback: (error: grpc.ServiceError | null, response: pulumi_resource_pb.RegisterProviderResponse) => void): grpc.ClientUnaryCall;
registerProvider(request: pulumi_resource_pb.RegisterProviderRequest, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: pulumi_resource_pb.RegisterProviderResponse) => void): grpc.ClientUnaryCall;
registerProvider(request: pulumi_resource_pb.RegisterProviderRequest, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: pulumi_resource_pb.RegisterProviderResponse) => void): grpc.ClientUnaryCall;
registerPackage(request: pulumi_resource_pb.RegisterPackageRequest, callback: (error: grpc.ServiceError | null, response: pulumi_resource_pb.RegisterPackageResponse) => void): grpc.ClientUnaryCall;
registerPackage(request: pulumi_resource_pb.RegisterPackageRequest, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: pulumi_resource_pb.RegisterPackageResponse) => void): grpc.ClientUnaryCall;
registerPackage(request: pulumi_resource_pb.RegisterPackageRequest, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: pulumi_resource_pb.RegisterPackageResponse) => void): grpc.ClientUnaryCall;
}

@@ -182,5 +182,5 @@

public registerStackTransform(request: pulumi_callback_pb.Callback, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: google_protobuf_empty_pb.Empty) => void): grpc.ClientUnaryCall;
public registerProvider(request: pulumi_resource_pb.RegisterProviderRequest, callback: (error: grpc.ServiceError | null, response: pulumi_resource_pb.RegisterProviderResponse) => void): grpc.ClientUnaryCall;
public registerProvider(request: pulumi_resource_pb.RegisterProviderRequest, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: pulumi_resource_pb.RegisterProviderResponse) => void): grpc.ClientUnaryCall;
public registerProvider(request: pulumi_resource_pb.RegisterProviderRequest, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: pulumi_resource_pb.RegisterProviderResponse) => void): grpc.ClientUnaryCall;
public registerPackage(request: pulumi_resource_pb.RegisterPackageRequest, callback: (error: grpc.ServiceError | null, response: pulumi_resource_pb.RegisterPackageResponse) => void): grpc.ClientUnaryCall;
public registerPackage(request: pulumi_resource_pb.RegisterPackageRequest, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: pulumi_resource_pb.RegisterPackageResponse) => void): grpc.ClientUnaryCall;
public registerPackage(request: pulumi_resource_pb.RegisterPackageRequest, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: pulumi_resource_pb.RegisterPackageResponse) => void): grpc.ClientUnaryCall;
}

36

proto/resource_grpc_pb.js

@@ -94,5 +94,5 @@ // GENERATED CODE -- DO NOT EDIT!

function serialize_pulumirpc_RegisterProviderRequest(arg) {
if (!(arg instanceof pulumi_resource_pb.RegisterProviderRequest)) {
throw new Error('Expected argument of type pulumirpc.RegisterProviderRequest');
function serialize_pulumirpc_RegisterPackageRequest(arg) {
if (!(arg instanceof pulumi_resource_pb.RegisterPackageRequest)) {
throw new Error('Expected argument of type pulumirpc.RegisterPackageRequest');
}

@@ -102,9 +102,9 @@ return Buffer.from(arg.serializeBinary());

function deserialize_pulumirpc_RegisterProviderRequest(buffer_arg) {
return pulumi_resource_pb.RegisterProviderRequest.deserializeBinary(new Uint8Array(buffer_arg));
function deserialize_pulumirpc_RegisterPackageRequest(buffer_arg) {
return pulumi_resource_pb.RegisterPackageRequest.deserializeBinary(new Uint8Array(buffer_arg));
}
function serialize_pulumirpc_RegisterProviderResponse(arg) {
if (!(arg instanceof pulumi_resource_pb.RegisterProviderResponse)) {
throw new Error('Expected argument of type pulumirpc.RegisterProviderResponse');
function serialize_pulumirpc_RegisterPackageResponse(arg) {
if (!(arg instanceof pulumi_resource_pb.RegisterPackageResponse)) {
throw new Error('Expected argument of type pulumirpc.RegisterPackageResponse');
}

@@ -114,4 +114,4 @@ return Buffer.from(arg.serializeBinary());

function deserialize_pulumirpc_RegisterProviderResponse(buffer_arg) {
return pulumi_resource_pb.RegisterProviderResponse.deserializeBinary(new Uint8Array(buffer_arg));
function deserialize_pulumirpc_RegisterPackageResponse(buffer_arg) {
return pulumi_resource_pb.RegisterPackageResponse.deserializeBinary(new Uint8Array(buffer_arg));
}

@@ -287,12 +287,12 @@

},
registerProvider: {
path: '/pulumirpc.ResourceMonitor/RegisterProvider',
registerPackage: {
path: '/pulumirpc.ResourceMonitor/RegisterPackage',
requestStream: false,
responseStream: false,
requestType: pulumi_resource_pb.RegisterProviderRequest,
responseType: pulumi_resource_pb.RegisterProviderResponse,
requestSerialize: serialize_pulumirpc_RegisterProviderRequest,
requestDeserialize: deserialize_pulumirpc_RegisterProviderRequest,
responseSerialize: serialize_pulumirpc_RegisterProviderResponse,
responseDeserialize: deserialize_pulumirpc_RegisterProviderResponse,
requestType: pulumi_resource_pb.RegisterPackageRequest,
responseType: pulumi_resource_pb.RegisterPackageResponse,
requestSerialize: serialize_pulumirpc_RegisterPackageRequest,
requestDeserialize: deserialize_pulumirpc_RegisterPackageRequest,
responseSerialize: serialize_pulumirpc_RegisterPackageResponse,
responseDeserialize: deserialize_pulumirpc_RegisterPackageResponse,
},

@@ -299,0 +299,0 @@ };

65

proto/resource_pb.d.ts

@@ -243,2 +243,4 @@ // package: pulumirpc

setSupportsresultreporting(value: boolean): RegisterResourceRequest;
getPackage(): string;
setPackage(value: string): RegisterResourceRequest;

@@ -292,2 +294,3 @@ serializeBinary(): Uint8Array;

supportsresultreporting: boolean,
pb_package: string,
}

@@ -717,9 +720,9 @@

export class RegisterProviderRequest extends jspb.Message {
export class RegisterPackageRequest extends jspb.Message {
getName(): string;
setName(value: string): RegisterProviderRequest;
setName(value: string): RegisterPackageRequest;
getVersion(): string;
setVersion(value: string): RegisterProviderRequest;
setVersion(value: string): RegisterPackageRequest;
getPluginDownloadUrl(): string;
setPluginDownloadUrl(value: string): RegisterProviderRequest;
setPluginDownloadUrl(value: string): RegisterPackageRequest;

@@ -731,16 +734,16 @@ getPluginChecksumsMap(): jspb.Map<string, Uint8Array | string>;

clearParameter(): void;
getParameter(): ProviderParameter | undefined;
setParameter(value?: ProviderParameter): RegisterProviderRequest;
getParameter(): PackageParameter | undefined;
setParameter(value?: PackageParameter): RegisterPackageRequest;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): RegisterProviderRequest.AsObject;
static toObject(includeInstance: boolean, msg: RegisterProviderRequest): RegisterProviderRequest.AsObject;
toObject(includeInstance?: boolean): RegisterPackageRequest.AsObject;
static toObject(includeInstance: boolean, msg: RegisterPackageRequest): RegisterPackageRequest.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: RegisterProviderRequest, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): RegisterProviderRequest;
static deserializeBinaryFromReader(message: RegisterProviderRequest, reader: jspb.BinaryReader): RegisterProviderRequest;
static serializeBinaryToWriter(message: RegisterPackageRequest, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): RegisterPackageRequest;
static deserializeBinaryFromReader(message: RegisterPackageRequest, reader: jspb.BinaryReader): RegisterPackageRequest;
}
export namespace RegisterProviderRequest {
export namespace RegisterPackageRequest {
export type AsObject = {

@@ -752,21 +755,21 @@ name: string,

pluginChecksumsMap: Array<[string, Uint8Array | string]>,
parameter?: ProviderParameter.AsObject,
parameter?: PackageParameter.AsObject,
}
}
export class RegisterProviderResponse extends jspb.Message {
export class RegisterPackageResponse extends jspb.Message {
getRef(): string;
setRef(value: string): RegisterProviderResponse;
setRef(value: string): RegisterPackageResponse;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): RegisterProviderResponse.AsObject;
static toObject(includeInstance: boolean, msg: RegisterProviderResponse): RegisterProviderResponse.AsObject;
toObject(includeInstance?: boolean): RegisterPackageResponse.AsObject;
static toObject(includeInstance: boolean, msg: RegisterPackageResponse): RegisterPackageResponse.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: RegisterProviderResponse, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): RegisterProviderResponse;
static deserializeBinaryFromReader(message: RegisterProviderResponse, reader: jspb.BinaryReader): RegisterProviderResponse;
static serializeBinaryToWriter(message: RegisterPackageResponse, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): RegisterPackageResponse;
static deserializeBinaryFromReader(message: RegisterPackageResponse, reader: jspb.BinaryReader): RegisterPackageResponse;
}
export namespace RegisterProviderResponse {
export namespace RegisterPackageResponse {
export type AsObject = {

@@ -777,7 +780,7 @@ ref: string,

export class ProviderParameter extends jspb.Message {
export class PackageParameter extends jspb.Message {
getName(): string;
setName(value: string): ProviderParameter;
setName(value: string): PackageParameter;
getVersion(): string;
setVersion(value: string): ProviderParameter;
setVersion(value: string): PackageParameter;

@@ -787,15 +790,15 @@ hasValue(): boolean;

getValue(): google_protobuf_struct_pb.Value | undefined;
setValue(value?: google_protobuf_struct_pb.Value): ProviderParameter;
setValue(value?: google_protobuf_struct_pb.Value): PackageParameter;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): ProviderParameter.AsObject;
static toObject(includeInstance: boolean, msg: ProviderParameter): ProviderParameter.AsObject;
toObject(includeInstance?: boolean): PackageParameter.AsObject;
static toObject(includeInstance: boolean, msg: PackageParameter): PackageParameter.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: ProviderParameter, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): ProviderParameter;
static deserializeBinaryFromReader(message: ProviderParameter, reader: jspb.BinaryReader): ProviderParameter;
static serializeBinaryToWriter(message: PackageParameter, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): PackageParameter;
static deserializeBinaryFromReader(message: PackageParameter, reader: jspb.BinaryReader): PackageParameter;
}
export namespace ProviderParameter {
export namespace PackageParameter {
export type AsObject = {

@@ -802,0 +805,0 @@ name: string,

263

provider/server.js

@@ -39,2 +39,3 @@ "use strict";

const settings = __importStar(require("../runtime/settings"));
const localState = __importStar(require("../runtime/state"));
const internals_1 = require("./internals");

@@ -50,7 +51,19 @@ const anyproto = __importStar(require("google-protobuf/google/protobuf/any_pb"));

constructor(engineAddr, provider, uncaughtErrors) {
/** Queue of construct calls. */
this.constructCallQueue = Promise.resolve();
this._callbacks = new Map();
this.engineAddr = engineAddr;
this.provider = provider;
this.uncaughtErrors = uncaughtErrors;
// When we catch an uncaught error, we need to respond to the inflight call/construct gRPC requests
// with the error to avoid a hang.
const uncaughtHandler = (err) => {
if (!this.uncaughtErrors.has(err)) {
this.uncaughtErrors.add(err);
}
// terminate the outstanding gRPC requests.
this._callbacks.forEach((callback) => callback(err, undefined));
};
process.on("uncaughtException", uncaughtHandler);
// @ts-ignore 'unhandledRejection' will almost always invoke uncaughtHandler with an Error. so
// just suppress the TS strictness here.
process.on("unhandledRejection", uncaughtHandler);
}

@@ -261,83 +274,60 @@ // Misc. methods

return __awaiter(this, void 0, void 0, function* () {
// Serialize invocations of `construct` and `call` so that each call runs one after another, avoiding concurrent
// runs. We do this because `construct` and `call` modify global state to reset the SDK's runtime options.
// This is a short-term workaround to provide correctness, but likely isn't sustainable long-term due to the
// limits it places on parallelism. We will likely want to investigate if it's possible to run each invocation
// in its own context, possibly using Node's `createContext` API to avoid modifying global state:
// https://nodejs.org/api/vm.html#vm_vm_createcontext_contextobject_options
const res = this.constructCallQueue.then(() => this.constructImpl(call, callback));
/* eslint-disable no-empty,no-empty-function,@typescript-eslint/no-empty-function */
this.constructCallQueue = res.catch(() => { });
return res;
});
}
constructImpl(call, callback) {
return __awaiter(this, void 0, void 0, function* () {
// given that construct calls are serialized, we can attach an uncaught handler to pick up exceptions
// in underlying user code. When we catch the error, we need to respond to the gRPC request with the error
// to avoid a hang.
const uncaughtHandler = (err) => {
if (!this.uncaughtErrors.has(err)) {
this.uncaughtErrors.add(err);
// Setup a new async state store for this run
const store = new localState.LocalStore();
return localState.asyncLocalStorage.run(store, () => __awaiter(this, void 0, void 0, function* () {
const callbackId = Symbol("id");
this._callbacks.set(callbackId, callback);
try {
const req = call.request;
const type = req.getType();
const name = req.getName();
if (!this.provider.construct) {
callback(new Error(`unknown resource type ${type}`), undefined);
return;
}
yield configureRuntime(req, this.engineAddr);
const inputs = yield deserializeInputs(req.getInputs(), req.getInputdependenciesMap());
// Rebuild the resource options.
const dependsOn = [];
for (const urn of req.getDependenciesList()) {
dependsOn.push(new resource.DependencyResource(urn));
}
const providers = {};
const rpcProviders = req.getProvidersMap();
if (rpcProviders) {
for (const [pkg, ref] of rpcProviders.entries()) {
providers[pkg] = createProviderResource(ref);
}
}
const opts = {
aliases: req.getAliasesList(),
dependsOn: dependsOn,
protect: req.getProtect(),
providers: providers,
parent: req.getParent() ? new resource.DependencyResource(req.getParent()) : undefined,
};
const result = yield this.provider.construct(name, type, inputs, opts);
const resp = new provproto.ConstructResponse();
resp.setUrn(yield output_1.output(result.urn).promise());
const [state, stateDependencies] = yield rpc.serializeResourceProperties(`construct(${type}, ${name})`, result.state);
const stateDependenciesMap = resp.getStatedependenciesMap();
for (const [key, resources] of stateDependencies) {
const deps = new provproto.ConstructResponse.PropertyDependencies();
deps.setUrnsList(yield Promise.all(Array.from(resources).map((r) => r.urn.promise())));
stateDependenciesMap.set(key, deps);
}
resp.setState(structproto.Struct.fromJavaScript(state));
// Wait for RPC operations to complete.
yield settings.waitForRPCs();
callback(undefined, resp);
}
// bubble the uncaught error in the user code back and terminate the outstanding gRPC request.
callback(err, undefined);
};
process.on("uncaughtException", uncaughtHandler);
// @ts-ignore 'unhandledRejection' will almost always invoke uncaughtHandler with an Error. so
// just suppress the TS strictness here.
process.on("unhandledRejection", uncaughtHandler);
try {
const req = call.request;
const type = req.getType();
const name = req.getName();
if (!this.provider.construct) {
callback(new Error(`unknown resource type ${type}`), undefined);
return;
catch (e) {
console.error(`${e}: ${e.stack}`);
callback(e, undefined);
}
yield configureRuntime(req, this.engineAddr);
const inputs = yield deserializeInputs(req.getInputs(), req.getInputdependenciesMap());
// Rebuild the resource options.
const dependsOn = [];
for (const urn of req.getDependenciesList()) {
dependsOn.push(new resource.DependencyResource(urn));
finally {
// remove the gRPC callback context from the map of in-flight callbacks
this._callbacks.delete(callbackId);
}
const providers = {};
const rpcProviders = req.getProvidersMap();
if (rpcProviders) {
for (const [pkg, ref] of rpcProviders.entries()) {
providers[pkg] = createProviderResource(ref);
}
}
const opts = {
aliases: req.getAliasesList(),
dependsOn: dependsOn,
protect: req.getProtect(),
providers: providers,
parent: req.getParent() ? new resource.DependencyResource(req.getParent()) : undefined,
};
const result = yield this.provider.construct(name, type, inputs, opts);
const resp = new provproto.ConstructResponse();
resp.setUrn(yield output_1.output(result.urn).promise());
const [state, stateDependencies] = yield rpc.serializeResourceProperties(`construct(${type}, ${name})`, result.state);
const stateDependenciesMap = resp.getStatedependenciesMap();
for (const [key, resources] of stateDependencies) {
const deps = new provproto.ConstructResponse.PropertyDependencies();
deps.setUrnsList(yield Promise.all(Array.from(resources).map((r) => r.urn.promise())));
stateDependenciesMap.set(key, deps);
}
resp.setState(structproto.Struct.fromJavaScript(state));
// Wait for RPC operations to complete.
yield settings.waitForRPCs();
callback(undefined, resp);
}
catch (e) {
console.error(`${e}: ${e.stack}`);
callback(e, undefined);
}
finally {
// remove these uncaught handlers that are specific to this gRPC callback context
process.off("uncaughtException", uncaughtHandler);
process.off("unhandledRejection", uncaughtHandler);
}
}));
});

@@ -347,73 +337,50 @@ }

return __awaiter(this, void 0, void 0, function* () {
// Serialize invocations of `construct` and `call` so that each call runs one after another, avoiding concurrent
// runs. We do this because `construct` and `call` modify global state to reset the SDK's runtime options.
// This is a short-term workaround to provide correctness, but likely isn't sustainable long-term due to the
// limits it places on parallelism. We will likely want to investigate if it's possible to run each invocation
// in its own context, possibly using Node's `createContext` API to avoid modifying global state:
// https://nodejs.org/api/vm.html#vm_vm_createcontext_contextobject_options
const res = this.constructCallQueue.then(() => this.callImpl(call, callback));
/* eslint-disable no-empty, no-empty-function, @typescript-eslint/no-empty-function */
this.constructCallQueue = res.catch(() => { });
return res;
});
}
callImpl(call, callback) {
return __awaiter(this, void 0, void 0, function* () {
// given that call calls are serialized, we can attach an uncaught handler to pick up exceptions
// in underlying user code. When we catch the error, we need to respond to the gRPC request with the error
// to avoid a hang.
const uncaughtHandler = (err) => {
if (!this.uncaughtErrors.has(err)) {
this.uncaughtErrors.add(err);
// Setup a new async state store for this run
const store = new localState.LocalStore();
return localState.asyncLocalStorage.run(store, () => __awaiter(this, void 0, void 0, function* () {
const callbackId = Symbol("id");
this._callbacks.set(callbackId, callback);
try {
const req = call.request;
if (!this.provider.call) {
callback(new Error(`unknown function ${req.getTok()}`), undefined);
return;
}
yield configureRuntime(req, this.engineAddr);
const args = yield deserializeInputs(req.getArgs(), req.getArgdependenciesMap());
const result = yield this.provider.call(req.getTok(), args);
const resp = new provproto.CallResponse();
if (result.outputs) {
const [ret, retDependencies] = yield rpc.serializeResourceProperties(`call(${req.getTok()})`, result.outputs);
const returnDependenciesMap = resp.getReturndependenciesMap();
for (const [key, resources] of retDependencies) {
const deps = new provproto.CallResponse.ReturnDependencies();
deps.setUrnsList(yield Promise.all(Array.from(resources).map((r) => r.urn.promise())));
returnDependenciesMap.set(key, deps);
}
resp.setReturn(structproto.Struct.fromJavaScript(ret));
}
if ((result.failures || []).length !== 0) {
const failureList = [];
for (const f of result.failures) {
const failure = new provproto.CheckFailure();
failure.setProperty(f.property);
failure.setReason(f.reason);
failureList.push(failure);
}
resp.setFailuresList(failureList);
}
// Wait for RPC operations to complete.
yield settings.waitForRPCs();
callback(undefined, resp);
}
// bubble the uncaught error in the user code back and terminate the outstanding gRPC request.
callback(err, undefined);
};
process.on("uncaughtException", uncaughtHandler);
// @ts-ignore 'unhandledRejection' will almost always invoke uncaughtHandler with an Error. so
// just suppress the TS strictness here.
process.on("unhandledRejection", uncaughtHandler);
try {
const req = call.request;
if (!this.provider.call) {
callback(new Error(`unknown function ${req.getTok()}`), undefined);
return;
catch (e) {
console.error(`${e}: ${e.stack}`);
callback(e, undefined);
}
yield configureRuntime(req, this.engineAddr);
const args = yield deserializeInputs(req.getArgs(), req.getArgdependenciesMap());
const result = yield this.provider.call(req.getTok(), args);
const resp = new provproto.CallResponse();
if (result.outputs) {
const [ret, retDependencies] = yield rpc.serializeResourceProperties(`call(${req.getTok()})`, result.outputs);
const returnDependenciesMap = resp.getReturndependenciesMap();
for (const [key, resources] of retDependencies) {
const deps = new provproto.CallResponse.ReturnDependencies();
deps.setUrnsList(yield Promise.all(Array.from(resources).map((r) => r.urn.promise())));
returnDependenciesMap.set(key, deps);
}
resp.setReturn(structproto.Struct.fromJavaScript(ret));
finally {
// remove the gRPC callback context from the map of in-flight callbacks
this._callbacks.delete(callbackId);
}
if ((result.failures || []).length !== 0) {
const failureList = [];
for (const f of result.failures) {
const failure = new provproto.CheckFailure();
failure.setProperty(f.property);
failure.setReason(f.reason);
failureList.push(failure);
}
resp.setFailuresList(failureList);
}
// Wait for RPC operations to complete.
yield settings.waitForRPCs();
callback(undefined, resp);
}
catch (e) {
console.error(`${e}: ${e.stack}`);
callback(e, undefined);
}
finally {
// remove these uncaught handlers that are specific to this gRPC callback context
process.off("uncaughtException", uncaughtHandler);
process.off("unhandledRejection", uncaughtHandler);
}
}));
});

@@ -420,0 +387,0 @@ }

2

version.js

@@ -16,3 +16,3 @@ "use strict";

Object.defineProperty(exports, "__esModule", { value: true });
exports.version = "3.121.1-alpha.xd64448e";
exports.version = "3.121.1-alpha.xdd7e21c";
//# sourceMappingURL=version.js.map
proto/resource_pb.js

Sorry, the diff of this file is too big to display

provider/server.js.map

Sorry, the diff of this file is not supported yet

SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap
  • Changelog

About

Packages

Stay in touch

Get open source security insights delivered straight into your inbox.

  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc