@pulumi/pulumi 3.163.0-alpha.xdc88586 → 3.163.0-alpha.xe7c1e4f

package/provider/server.js

@@ -12,15 +12,6 @@
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 var __importStar = (this && this.__importStar) || function (mod) {
     if (mod && mod.__esModule) return mod;
     var result = {};
@@ -127,187 +118,173 @@ class Server {
         resp.setAcceptoutputs(true);
         callback(undefined, resp);
     }
-    parameterize(call, callback) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let res = null;
-            if (call.request.hasArgs()) {
-                if (!this.provider.parameterizeArgs) {
-                    callback(new Error("parameterizeArgs not implemented"), undefined);
-                    return;
-                }
-                res = yield this.provider.parameterizeArgs(call.request.getArgs().getArgsList());
+    async parameterize(call, callback) {
+        let res = null;
+        if (call.request.hasArgs()) {
+            if (!this.provider.parameterizeArgs) {
+                callback(new Error("parameterizeArgs not implemented"), undefined);
+                return;
             }
-            else {
-                if (!this.provider.parameterizeValue) {
-                    callback(new Error("parameterizeValue not implemented"), undefined);
-                    return;
-                }
-                const b64 = call.request.getValue().getValue_asB64();
-                res = yield this.provider.parameterizeValue(call.request.getValue().getName(), call.request.getValue().getVersion(), Buffer.from(b64, "base64").toString("utf-8"));
+            res = await this.provider.parameterizeArgs(call.request.getArgs().getArgsList());
+        }
+        else {
+            if (!this.provider.parameterizeValue) {
+                callback(new Error("parameterizeValue not implemented"), undefined);
+                return;
             }
-            const resp = new provproto.ParameterizeResponse();
-            resp.setName(res.name);
-            resp.setVersion(res.version);
-            callback(undefined, resp);
-        });
+            const b64 = call.request.getValue().getValue_asB64();
+            res = await this.provider.parameterizeValue(call.request.getValue().getName(), call.request.getValue().getVersion(), Buffer.from(b64, "base64").toString("utf-8"));
+        }
+        const resp = new provproto.ParameterizeResponse();
+        resp.setName(res.name);
+        resp.setVersion(res.version);
+        callback(undefined, resp);
     }
     // CRUD resource methods
-    check(call, callback) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const req = call.request;
-                const resp = new provproto.CheckResponse();
-                const olds = req.getOlds().toJavaScript();
-                const news = req.getNews().toJavaScript();
-                let inputs = news;
-                let failures = [];
-                if (this.provider.check) {
-                    const result = yield this.provider.check(req.getUrn(), olds, news);
-                    if (result.inputs) {
-                        inputs = result.inputs;
-                    }
-                    if (result.failures) {
-                        failures = result.failures;
-                    }
+    async check(call, callback) {
+        try {
+            const req = call.request;
+            const resp = new provproto.CheckResponse();
+            const olds = req.getOlds().toJavaScript();
+            const news = req.getNews().toJavaScript();
+            let inputs = news;
+            let failures = [];
+            if (this.provider.check) {
+                const result = await this.provider.check(req.getUrn(), olds, news);
+                if (result.inputs) {
+                    inputs = result.inputs;
                 }
-                else {
-                    // If no check method was provided, propagate the new inputs as-is.
-                    inputs = news;
+                if (result.failures) {
+                    failures = result.failures;
                 }
-                resp.setInputs(structproto.Struct.fromJavaScript(inputs));
-                if (failures.length !== 0) {
-                    const failureList = [];
-                    for (const f of failures) {
-                        const failure = new provproto.CheckFailure();
-                        failure.setProperty(f.property);
-                        failure.setReason(f.reason);
-                        failureList.push(failure);
-                    }
-                    resp.setFailuresList(failureList);
-                }
-                callback(undefined, resp);
             }
-            catch (e) {
-                console.error(`${e}: ${e.stack}`);
-                callback(e, undefined);
+            else {
+                // If no check method was provided, propagate the new inputs as-is.
+                inputs = news;
             }
-        });
-    }
-    diff(call, callback) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const req = call.request;
-                const resp = new provproto.DiffResponse();
-                const olds = req.getOlds().toJavaScript();
-                const news = req.getNews().toJavaScript();
-                if (this.provider.diff) {
-                    const result = yield this.provider.diff(req.getId(), req.getUrn(), olds, news);
-                    if (result.changes === true) {
-                        resp.setChanges(provproto.DiffResponse.DiffChanges.DIFF_SOME);
-                    }
-                    else if (result.changes === false) {
-                        resp.setChanges(provproto.DiffResponse.DiffChanges.DIFF_NONE);
-                    }
-                    else {
-                        resp.setChanges(provproto.DiffResponse.DiffChanges.DIFF_UNKNOWN);
-                    }
-                    if (result.replaces && result.replaces.length !== 0) {
-                        resp.setReplacesList(result.replaces);
-                    }
-                    if (result.deleteBeforeReplace) {
-                        resp.setDeletebeforereplace(result.deleteBeforeReplace);
-                    }
+            resp.setInputs(structproto.Struct.fromJavaScript(inputs));
+            if (failures.length !== 0) {
+                const failureList = [];
+                for (const f of failures) {
+                    const failure = new provproto.CheckFailure();
+                    failure.setProperty(f.property);
+                    failure.setReason(f.reason);
+                    failureList.push(failure);
                 }
-                callback(undefined, resp);
-            }
-            catch (e) {
-                console.error(`${e}: ${e.stack}`);
-                callback(e, undefined);
+                resp.setFailuresList(failureList);
             }
-        });
+            callback(undefined, resp);
+        }
+        catch (e) {
+            console.error(`${e}: ${e.stack}`);
+            callback(e, undefined);
+        }
     }
-    create(call, callback) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const req = call.request;
-                if (!this.provider.create) {
-                    callback(new Error(`unknown resource type ${req.getUrn()}`), undefined);
-                    return;
+    async diff(call, callback) {
+        try {
+            const req = call.request;
+            const resp = new provproto.DiffResponse();
+            const olds = req.getOlds().toJavaScript();
+            const news = req.getNews().toJavaScript();
+            if (this.provider.diff) {
+                const result = await this.provider.diff(req.getId(), req.getUrn(), olds, news);
+                if (result.changes === true) {
+                    resp.setChanges(provproto.DiffResponse.DiffChanges.DIFF_SOME);
                 }
-                const resp = new provproto.CreateResponse();
-                const props = req.getProperties().toJavaScript();
-                const result = yield this.provider.create(req.getUrn(), props);
-                resp.setId(result.id);
-                resp.setProperties(structproto.Struct.fromJavaScript(result.outs));
-                callback(undefined, resp);
-            }
-            catch (e) {
-                const response = grpcResponseFromError(e);
-                return callback(/*err:*/ response, /*value:*/ null, /*metadata:*/ response.metadata);
-            }
-        });
-    }
-    read(call, callback) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const req = call.request;
-                const resp = new provproto.ReadResponse();
-                const id = req.getId();
-                const props = req.getProperties().toJavaScript();
-                if (this.provider.read) {
-                    const result = yield this.provider.read(id, req.getUrn(), props);
-                    resp.setId(result.id);
-                    resp.setProperties(structproto.Struct.fromJavaScript(result.props));
-                    resp.setInputs(result.inputs === undefined ? undefined : structproto.Struct.fromJavaScript(result.inputs));
+                else if (result.changes === false) {
+                    resp.setChanges(provproto.DiffResponse.DiffChanges.DIFF_NONE);
                 }
                 else {
-                    // In the event of a missing read, simply return back the input state.
-                    resp.setId(id);
-                    resp.setProperties(req.getProperties());
+                    resp.setChanges(provproto.DiffResponse.DiffChanges.DIFF_UNKNOWN);
+                }
+                if (result.replaces && result.replaces.length !== 0) {
+                    resp.setReplacesList(result.replaces);
+                }
+                if (result.deleteBeforeReplace) {
+                    resp.setDeletebeforereplace(result.deleteBeforeReplace);
                 }
-                callback(undefined, resp);
             }
-            catch (e) {
-                console.error(`${e}: ${e.stack}`);
-                callback(e, undefined);
+            callback(undefined, resp);
+        }
+        catch (e) {
+            console.error(`${e}: ${e.stack}`);
+            callback(e, undefined);
+        }
+    }
+    async create(call, callback) {
+        try {
+            const req = call.request;
+            if (!this.provider.create) {
+                callback(new Error(`unknown resource type ${req.getUrn()}`), undefined);
+                return;
             }
-        });
+            const resp = new provproto.CreateResponse();
+            const props = req.getProperties().toJavaScript();
+            const result = await this.provider.create(req.getUrn(), props);
+            resp.setId(result.id);
+            resp.setProperties(structproto.Struct.fromJavaScript(result.outs));
+            callback(undefined, resp);
+        }
+        catch (e) {
+            const response = grpcResponseFromError(e);
+            return callback(/*err:*/ response, /*value:*/ null, /*metadata:*/ response.metadata);
+        }
     }
-    update(call, callback) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const req = call.request;
-                const resp = new provproto.UpdateResponse();
-                const olds = req.getOlds().toJavaScript();
-                const news = req.getNews().toJavaScript();
-                let result = {};
-                if (this.provider.update) {
-                    result = (yield this.provider.update(req.getId(), req.getUrn(), olds, news)) || {};
-                }
-                resp.setProperties(structproto.Struct.fromJavaScript(result.outs));
-                callback(undefined, resp);
+    async read(call, callback) {
+        try {
+            const req = call.request;
+            const resp = new provproto.ReadResponse();
+            const id = req.getId();
+            const props = req.getProperties().toJavaScript();
+            if (this.provider.read) {
+                const result = await this.provider.read(id, req.getUrn(), props);
+                resp.setId(result.id);
+                resp.setProperties(structproto.Struct.fromJavaScript(result.props));
+                resp.setInputs(result.inputs === undefined ? undefined : structproto.Struct.fromJavaScript(result.inputs));
             }
-            catch (e) {
-                const response = grpcResponseFromError(e);
-                return callback(/*err:*/ response, /*value:*/ null, /*metadata:*/ response.metadata);
+            else {
+                // In the event of a missing read, simply return back the input state.
+                resp.setId(id);
+                resp.setProperties(req.getProperties());
             }
-        });
+            callback(undefined, resp);
+        }
+        catch (e) {
+            console.error(`${e}: ${e.stack}`);
+            callback(e, undefined);
+        }
     }
-    delete(call, callback) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const req = call.request;
-                const props = req.getProperties().toJavaScript();
-                if (this.provider.delete) {
-                    yield this.provider.delete(req.getId(), req.getUrn(), props);
-                }
-                callback(undefined, new emptyproto.Empty());
+    async update(call, callback) {
+        try {
+            const req = call.request;
+            const resp = new provproto.UpdateResponse();
+            const olds = req.getOlds().toJavaScript();
+            const news = req.getNews().toJavaScript();
+            let result = {};
+            if (this.provider.update) {
+                result = (await this.provider.update(req.getId(), req.getUrn(), olds, news)) || {};
             }
-            catch (e) {
-                console.error(`${e}: ${e.stack}`);
-                callback(e, undefined);
+            resp.setProperties(structproto.Struct.fromJavaScript(result.outs));
+            callback(undefined, resp);
+        }
+        catch (e) {
+            const response = grpcResponseFromError(e);
+            return callback(/*err:*/ response, /*value:*/ null, /*metadata:*/ response.metadata);
+        }
+    }
+    async delete(call, callback) {
+        try {
+            const req = call.request;
+            const props = req.getProperties().toJavaScript();
+            if (this.provider.delete) {
+                await this.provider.delete(req.getId(), req.getUrn(), props);
             }
-        });
+            callback(undefined, new emptyproto.Empty());
+        }
+        catch (e) {
+            console.error(`${e}: ${e.stack}`);
+            callback(e, undefined);
+        }
     }
     buildInvalidPropertiesError(message, errors) {
         const metadata = new grpc.Metadata();
@@ -336,154 +313,103 @@ class Server {
         };
         return error;
     }
-    construct(call, callback) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // 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);
-                }
-                catch (e) {
-                    if (errors_1.InputPropertiesError.isInstance(e)) {
-                        const error = this.buildInvalidPropertiesError(e.message, e.errors);
-                        callback(error, undefined);
-                        return;
-                    }
-                    else if (errors_1.InputPropertyError.isInstance(e)) {
-                        const error = this.buildInvalidPropertiesError("", [
-                            { propertyPath: e.propertyPath, reason: e.reason },
-                        ]);
-                        callback(error, undefined);
-                        return;
-                    }
-                    callback(e, undefined);
+    async construct(call, callback) {
+        // Setup a new async state store for this run
+        const store = new localState.LocalStore();
+        return localState.asyncLocalStorage.run(store, async () => {
+            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;
                 }
-                finally {
-                    // remove the gRPC callback context from the map of in-flight callbacks
-                    this._callbacks.delete(callbackId);
+                await configureRuntime(req, this.engineAddr);
+                const inputs = await deserializeInputs(req.getInputs(), req.getInputdependenciesMap());
+                // Rebuild the resource options.
+                const dependsOn = [];
+                for (const urn of req.getDependenciesList()) {
+                    dependsOn.push(new resource.DependencyResource(urn));
                 }
-            }));
-        });
-    }
-    call(call, callback) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // 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));
+                const providers = {};
+                const rpcProviders = req.getProvidersMap();
+                if (rpcProviders) {
+                    for (const [pkg, ref] of rpcProviders.entries()) {
+                        providers[pkg] = createProviderResource(ref);
                     }
-                    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) {
-                    if (errors_1.InputPropertiesError.isInstance(e)) {
-                        const error = this.buildInvalidPropertiesError(e.message, e.errors);
-                        callback(error, undefined);
-                        return;
-                    }
-                    else if (errors_1.InputPropertyError.isInstance(e)) {
-                        const error = this.buildInvalidPropertiesError("", [
-                            { propertyPath: e.propertyPath, reason: e.reason },
-                        ]);
-                        callback(error, undefined);
-                        return;
-                    }
-                    callback(e, undefined);
+                const opts = {
+                    aliases: req.getAliasesList(),
+                    dependsOn: dependsOn,
+                    protect: req.getProtect(),
+                    providers: providers,
+                    parent: req.getParent() ? new resource.DependencyResource(req.getParent()) : undefined,
+                };
+                const result = await this.provider.construct(name, type, inputs, opts);
+                const resp = new provproto.ConstructResponse();
+                resp.setUrn(await output_1.output(result.urn).promise());
+                const [state, stateDependencies] = await 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(await 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.
+                await settings.waitForRPCs();
+                callback(undefined, resp);
+            }
+            catch (e) {
+                if (errors_1.InputPropertiesError.isInstance(e)) {
+                    const error = this.buildInvalidPropertiesError(e.message, e.errors);
+                    callback(error, undefined);
+                    return;
                 }
-                finally {
-                    // remove the gRPC callback context from the map of in-flight callbacks
-                    this._callbacks.delete(callbackId);
+                else if (errors_1.InputPropertyError.isInstance(e)) {
+                    const error = this.buildInvalidPropertiesError("", [
+                        { propertyPath: e.propertyPath, reason: e.reason },
+                    ]);
+                    callback(error, undefined);
+                    return;
                 }
-            }));
+                callback(e, undefined);
+            }
+            finally {
+                // remove the gRPC callback context from the map of in-flight callbacks
+                this._callbacks.delete(callbackId);
+            }
         });
     }
-    invoke(call, callback) {
-        return __awaiter(this, void 0, void 0, function* () {
+    async call(call, callback) {
+        // Setup a new async state store for this run
+        const store = new localState.LocalStore();
+        return localState.asyncLocalStorage.run(store, async () => {
+            const callbackId = Symbol("id");
+            this._callbacks.set(callbackId, callback);
             try {
                 const req = call.request;
-                if (!this.provider.invoke) {
+                if (!this.provider.call) {
                     callback(new Error(`unknown function ${req.getTok()}`), undefined);
                     return;
                 }
-                const args = req.getArgs().toJavaScript();
-                const result = yield this.provider.invoke(req.getTok(), args);
-                const resp = new provproto.InvokeResponse();
-                resp.setReturn(structproto.Struct.fromJavaScript(result.outputs));
+                await configureRuntime(req, this.engineAddr);
+                const args = await deserializeInputs(req.getArgs(), req.getArgdependenciesMap());
+                const result = await this.provider.call(req.getTok(), args);
+                const resp = new provproto.CallResponse();
+                if (result.outputs) {
+                    const [ret, retDependencies] = await 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(await 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) {
@@ -494,75 +420,113 @@ class Server {
                     }
                     resp.setFailuresList(failureList);
                 }
+                // Wait for RPC operations to complete.
+                await settings.waitForRPCs();
                 callback(undefined, resp);
             }
             catch (e) {
-                console.error(`${e}: ${e.stack}`);
+                if (errors_1.InputPropertiesError.isInstance(e)) {
+                    const error = this.buildInvalidPropertiesError(e.message, e.errors);
+                    callback(error, undefined);
+                    return;
+                }
+                else if (errors_1.InputPropertyError.isInstance(e)) {
+                    const error = this.buildInvalidPropertiesError("", [
+                        { propertyPath: e.propertyPath, reason: e.reason },
+                    ]);
+                    callback(error, undefined);
+                    return;
+                }
                 callback(e, undefined);
             }
+            finally {
+                // remove the gRPC callback context from the map of in-flight callbacks
+                this._callbacks.delete(callbackId);
+            }
         });
     }
-}
-function configureRuntime(req, engineAddr) {
-    return __awaiter(this, void 0, void 0, function* () {
-        // NOTE: these are globals! We should ensure that all settings are identical between calls, and eventually
-        // refactor so we can avoid the global state.
-        if (engineAddr === undefined) {
-            throw new Error("fatal: Missing <engine> address");
-        }
-        settings.resetOptions(req.getProject(), req.getStack(), req.getParallel(), engineAddr, req.getMonitorendpoint(), req.getDryrun(), req.getOrganization());
-        // resetOptions doesn't reset the saved features
-        yield settings.awaitFeatureSupport();
-        const pulumiConfig = {};
-        const rpcConfig = req.getConfigMap();
-        if (rpcConfig) {
-            for (const [k, v] of rpcConfig.entries()) {
-                pulumiConfig[k] = v;
+    async invoke(call, callback) {
+        try {
+            const req = call.request;
+            if (!this.provider.invoke) {
+                callback(new Error(`unknown function ${req.getTok()}`), undefined);
+                return;
             }
+            const args = req.getArgs().toJavaScript();
+            const result = await this.provider.invoke(req.getTok(), args);
+            const resp = new provproto.InvokeResponse();
+            resp.setReturn(structproto.Struct.fromJavaScript(result.outputs));
+            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);
+            }
+            callback(undefined, resp);
         }
-        config.setAllConfig(pulumiConfig, req.getConfigsecretkeysList());
-    });
+        catch (e) {
+            console.error(`${e}: ${e.stack}`);
+            callback(e, undefined);
+        }
+    }
+}
+async function configureRuntime(req, engineAddr) {
+    // NOTE: these are globals! We should ensure that all settings are identical between calls, and eventually
+    // refactor so we can avoid the global state.
+    if (engineAddr === undefined) {
+        throw new Error("fatal: Missing <engine> address");
+    }
+    settings.resetOptions(req.getProject(), req.getStack(), req.getParallel(), engineAddr, req.getMonitorendpoint(), req.getDryrun(), req.getOrganization());
+    // resetOptions doesn't reset the saved features
+    await settings.awaitFeatureSupport();
+    const pulumiConfig = {};
+    const rpcConfig = req.getConfigMap();
+    if (rpcConfig) {
+        for (const [k, v] of rpcConfig.entries()) {
+            pulumiConfig[k] = v;
+        }
+    }
+    config.setAllConfig(pulumiConfig, req.getConfigsecretkeysList());
 }
 /**
  * Deserializes the inputs struct and applies appropriate dependencies.
  *
  * @internal
  */
-function deserializeInputs(inputsStruct, inputDependencies) {
-    var _a, _b;
-    return __awaiter(this, void 0, void 0, function* () {
-        const result = {};
-        const deserializedInputs = rpc.deserializeProperties(inputsStruct);
-        for (const k of Object.keys(deserializedInputs)) {
-            const input = deserializedInputs[k];
-            const isSecret = rpc.isRpcSecret(input);
-            const depsUrns = (_b = (_a = inputDependencies.get(k)) === null || _a === void 0 ? void 0 : _a.getUrnsList()) !== null && _b !== void 0 ? _b : [];
-            if (!isSecret &&
-                (depsUrns.length === 0 || containsOutputs(input) || (yield isResourceReference(input, depsUrns)))) {
-                // If the input isn't a secret and either doesn't have any dependencies, already contains Outputs (from
-                // deserialized output values), or is a resource reference, then we can return it directly without
-                // wrapping it as an output.
-                result[k] = input;
-            }
-            else {
-                // Otherwise, wrap it in an output so we can handle secrets and/or track dependencies.
-                // Note: If the value is or contains an unknown value, the Output will mark its value as
-                // unknown automatically, so we just pass true for isKnown here.
-                const deps = depsUrns.map((depUrn) => new resource.DependencyResource(depUrn));
-                result[k] = new output_1.Output(deps, Promise.resolve(rpc.unwrapRpcSecret(input)), Promise.resolve(true), Promise.resolve(isSecret), Promise.resolve([]));
-            }
+async function deserializeInputs(inputsStruct, inputDependencies) {
+    const result = {};
+    const deserializedInputs = rpc.deserializeProperties(inputsStruct);
+    for (const k of Object.keys(deserializedInputs)) {
+        const input = deserializedInputs[k];
+        const isSecret = rpc.isRpcSecret(input);
+        const depsUrns = inputDependencies.get(k)?.getUrnsList() ?? [];
+        if (!isSecret &&
+            (depsUrns.length === 0 || containsOutputs(input) || (await isResourceReference(input, depsUrns)))) {
+            // If the input isn't a secret and either doesn't have any dependencies, already contains Outputs (from
+            // deserialized output values), or is a resource reference, then we can return it directly without
+            // wrapping it as an output.
+            result[k] = input;
         }
-        return result;
-    });
+        else {
+            // Otherwise, wrap it in an output so we can handle secrets and/or track dependencies.
+            // Note: If the value is or contains an unknown value, the Output will mark its value as
+            // unknown automatically, so we just pass true for isKnown here.
+            const deps = depsUrns.map((depUrn) => new resource.DependencyResource(depUrn));
+            result[k] = new output_1.Output(deps, Promise.resolve(rpc.unwrapRpcSecret(input)), Promise.resolve(true), Promise.resolve(isSecret), Promise.resolve([]));
+        }
+    }
+    return result;
 }
 exports.deserializeInputs = deserializeInputs;
 /**
  * Returns true if the input is a resource reference.
  */
-function isResourceReference(input, deps) {
-    return __awaiter(this, void 0, void 0, function* () {
-        return resource.Resource.isInstance(input) && deps.length === 1 && deps[0] === (yield input.urn.promise());
-    });
+async function isResourceReference(input, deps) {
+    return resource.Resource.isInstance(input) && deps.length === 1 && deps[0] === (await input.urn.promise());
 }
 /**
  * Returns true if the deserialized input contains outputs (deeply), excluding
@@ -636,58 +600,56 @@ function grpcResponseFromError(e) {
 }
 // Add a flag to track if main has already been called
 let isServing = false;
-function main(provider, args) {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (isServing) {
-            // If we're already serving, just return and don't start another server.
-            return Promise.resolve();
+async function main(provider, args) {
+    if (isServing) {
+        // If we're already serving, just return and don't start another server.
+        return Promise.resolve();
+    }
+    isServing = true;
+    require("source-map-support").install();
+    // We track all uncaught errors here.  If we have any, we will make sure we always have a non-0 exit
+    // code.
+    const uncaughtErrors = new Set();
+    const uncaughtHandler = (err) => {
+        if (!uncaughtErrors.has(err)) {
+            uncaughtErrors.add(err);
+            // Use `pulumi.log.error` here to tell the engine there was a fatal error, which should
+            // stop processing subsequent resource operations.
+            log.error(err.stack || err.message || "" + err);
         }
-        isServing = true;
-        require("source-map-support").install();
-        // We track all uncaught errors here.  If we have any, we will make sure we always have a non-0 exit
-        // code.
-        const uncaughtErrors = new Set();
-        const uncaughtHandler = (err) => {
-            if (!uncaughtErrors.has(err)) {
-                uncaughtErrors.add(err);
-                // Use `pulumi.log.error` here to tell the engine there was a fatal error, which should
-                // stop processing subsequent resource operations.
-                log.error(err.stack || err.message || "" + err);
+    };
+    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);
+    process.on("exit", (code) => {
+        // If there were any uncaught errors at all, we always want to exit with an error code.
+        if (code === 0 && uncaughtErrors.size > 0) {
+            process.exitCode = 1;
+        }
+    });
+    const parsedArgs = internals_1.parseArgs(args);
+    // Finally connect up the gRPC client/server and listen for incoming requests.
+    const server = new grpc.Server({
+        "grpc.max_receive_message_length": settings.maxRPCMessageSize,
+    });
+    // The program receives a single optional argument: the address of the RPC endpoint for the engine.  It
+    // optionally also takes a second argument, a reference back to the engine, but this may be missing.
+    const engineAddr = parsedArgs?.engineAddress;
+    server.addService(provrpc.ResourceProviderService, new Server(engineAddr, provider, uncaughtErrors));
+    const port = await new Promise((resolve, reject) => {
+        server.bindAsync(`127.0.0.1:0`, grpc.ServerCredentials.createInsecure(), (err, p) => {
+            if (err) {
+                reject(err);
             }
-        };
-        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);
-        process.on("exit", (code) => {
-            // If there were any uncaught errors at all, we always want to exit with an error code.
-            if (code === 0 && uncaughtErrors.size > 0) {
-                process.exitCode = 1;
+            else {
+                resolve(p);
             }
         });
-        const parsedArgs = internals_1.parseArgs(args);
-        // Finally connect up the gRPC client/server and listen for incoming requests.
-        const server = new grpc.Server({
-            "grpc.max_receive_message_length": settings.maxRPCMessageSize,
-        });
-        // The program receives a single optional argument: the address of the RPC endpoint for the engine.  It
-        // optionally also takes a second argument, a reference back to the engine, but this may be missing.
-        const engineAddr = parsedArgs === null || parsedArgs === void 0 ? void 0 : parsedArgs.engineAddress;
-        server.addService(provrpc.ResourceProviderService, new Server(engineAddr, provider, uncaughtErrors));
-        const port = yield new Promise((resolve, reject) => {
-            server.bindAsync(`127.0.0.1:0`, grpc.ServerCredentials.createInsecure(), (err, p) => {
-                if (err) {
-                    reject(err);
-                }
-                else {
-                    resolve(p);
-                }
-            });
-        });
-        // Emit the address so the monitor can read it to connect.  The gRPC server will keep the message loop alive.
-        // We explicitly convert the number to a string so that Node doesn't colorize the output.
-        console.log(port.toString());
     });
+    // Emit the address so the monitor can read it to connect.  The gRPC server will keep the message loop alive.
+    // We explicitly convert the number to a string so that Node doesn't colorize the output.
+    console.log(port.toString());
 }
 exports.main = main;
 /**