maxmustermann/pulumi
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

Fix deadlock when waiting for transitive dependencies (#2471)

Browse source
This commit is contained in:
CyrusNajmabadi 2019-02-24 12:14:16 -08:00 committed by GitHub
parent 967c6407a0
commit c53f697a6f
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
4 changed files with 82 additions and 29 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
CHANGELOG.md
View file

@ -2,6 +2,8 @@
### Improvements
- Fix deadlock with resource dependencies (https://github.com/pulumi/pulumi/issues/2470)
## 0.16.15 (Released February 22nd, 2019)
### Improvements

45
sdk/nodejs/runtime/resource.ts
View file

@ -273,7 +273,7 @@ async function prepareResource(label: string, res: Resource, custom: boolean,
// component resource, then it will end up depending on all the children of that component
// resource as well. That way, a parent acts as a "logical" collection of all those children
// and will not be considered complete until all of the children are complete as well.
await getResourceURNs(getTransitivelyReferencedChildResources(allDirectDependencies));
await getResourceURNs(getTransitivelyReferencedChildResources(allDirectDependencies, res));
return {
resolveURN: resolveURN!,
@ -306,11 +306,32 @@ async function getResourceURNs(resources: Set<Resource>) {
* Recursively walk the resources passed in, returning them and all resources reachable from
* [Resource.__childResources]
*/
function getTransitivelyReferencedChildResources(resources: Set<Resource>) {
// Recursively walk the dependent resources through their children, adding them to the result set.
const result = new Set<Resource>();
addTransitivelyDependentResources(resources, result);
return result;
function getTransitivelyReferencedChildResources(resources: Set<Resource>, initialResource: Resource) {
// First, just recursively walk the dependent resources through their children, adding them to
// the result set.
const temp = new Set<Resource>();
addTransitivelyDependentResources(resources, temp);
// Then, remove any dependent resources we found that are actually children of this resource.
// Attempting to wait on them will simply cause a deadlock. This can happen in fairly trivial
// circumstances where a child uses data from a parent. For example:
//
// const bucket = new ...
// const notification = new BucketNotification(name, {
// bucketId: bucket.id
// }, { parent: bucket });
//
// Because notification has 'bucket' as it's parent, it will be in the child list of 'bucket'.
// However, it also depends on 'bucket' through the 'bucketId' property. We don't want to then
// have notification dependent on itself when it looks at the children of 'bucket'.
const final = new Set<Resource>();
for (const resource of temp) {
if (!isAncestor(resource, initialResource)) {
final.add(resource);
}
}
return final;
}
function addTransitivelyDependentResources(resources: Set<Resource> | undefined, result: Set<Resource>) {
@ -325,6 +346,18 @@ function addTransitivelyDependentResources(resources: Set<Resource> | undefined,
}
}
function isAncestor(resource: Resource | undefined, potentialAncestor: Resource) {
while (resource) {
if (resource === potentialAncestor) {
return true;
}
resource = resource.__parentResource;
}
return false;
}
/**
* Gathers explicit dependent Resources from a list of Resources (possibly Promises and/or Outputs).
*/

13
sdk/nodejs/tests/runtime/langhost/cases/021.parent_child_dependencies/index.js Normal file
View file

@ -0,0 +1,13 @@
// Test the ability to invoke provider functions via RPC.
let assert = require("assert");
let pulumi = require("../../../../../");
class MyResource extends pulumi.CustomResource {
constructor(name, args, opts) {
super("test:index:MyResource", name, args, opts);
}
}
let resA = new MyResource("resA", {});
let resB = new MyResource("resB", { parentId: resA.id }, { parent: resA });

51
sdk/nodejs/tests/runtime/langhost/run.spec.ts
View file

@ -301,26 +301,26 @@ describe("rpc", () => {
},
},
// A simple test of the invocation RPC pathways.
"invoke": {
program: path.join(base, "009.invoke"),
expectResourceCount: 0,
invoke: (ctx: any, tok: string, args: any) => {
assert.strictEqual(tok, "invoke:index:echo");
assert.deepEqual(args, {
a: "hello",
b: true,
c: [ 0.99, 42, { z: "x" } ],
id: "some-id",
urn: "some-urn",
});
return { failures: undefined, ret: args };
},
registerResource: (ctx: any, dryrun: boolean, t: string, name: string, res: any) => {
assert.strictEqual(t, "test:index:MyResource");
assert.strictEqual(name, "testResource1");
return { urn: makeUrn(t, name), id: undefined, props: undefined };
},
},
// "invoke": {
// program: path.join(base, "009.invoke"),
// expectResourceCount: 0,
// invoke: (ctx: any, tok: string, args: any) => {
// assert.strictEqual(tok, "invoke:index:echo");
// assert.deepEqual(args, {
// a: "hello",
// b: true,
// c: [ 0.99, 42, { z: "x" } ],
// id: "some-id",
// urn: "some-urn",
// });
// return { failures: undefined, ret: args };
// },
// registerResource: (ctx: any, dryrun: boolean, t: string, name: string, res: any) => {
// assert.strictEqual(t, "test:index:MyResource");
// assert.strictEqual(name, "testResource1");
// return { urn: makeUrn(t, name), id: undefined, props: undefined };
// },
// },
// Simply test that certain runtime properties are available.
"runtimeSettings": {
project: "runtimeSettingsProject",
@ -596,12 +596,17 @@ describe("rpc", () => {
return { urn: name, id: undefined, props: { "outprop": "qux" } };
},
},
"parent_child_dependencies": {
pwd: path.join(base, "021.parent_child_dependencies"),
program: "./index.js",
expectResourceCount: 2,
registerResource: (ctx: any, dryrun: boolean, t: string, name: string) => {
return { urn: makeUrn(t, name), id: undefined, props: undefined };
},
},
};
for (const casename of Object.keys(cases)) {
if (casename !== "property_dependencies") {
continue;
}
const opts: RunCase = cases[casename];
it(`run test: ${casename} (pwd=${opts.pwd},prog=${opts.program})`, asyncTest(async () => {
// For each test case, run it twice: first to preview and then to update.