1ecdc83a33
This implements the new algorithm for deciding which resources must be deleted due to a delete-before-replace operation. We need to compute the set of resources that may be replaced by a change to the resource under consideration. We do this by taking the complete set of transitive dependents on the resource under consideration and removing any resources that would not be replaced by changes to their dependencies. We determine whether or not a resource may be replaced by substituting unknowns for input properties that may change due to deletion of the resources their value depends on and calling the resource provider's Diff method. This is perhaps clearer when described by example. Consider the following dependency graph: A __|__ B C | _|_ D E F In this graph, all of B, C, D, E, and F transitively depend on A. It may be the case, however, that changes to the specific properties of any of those resources R that would occur if a resource on the path to A were deleted and recreated may not cause R to be replaced. For example, the edge from B to A may be a simple dependsOn edge such that a change to B does not actually influence any of B's input properties. In that case, neither B nor D would need to be deleted before A could be deleted. In order to make the above algorithm a reality, the resource monitor interface has been updated to include a map that associates an input property key with the list of resources that input property depends on. Older clients of the resource monitor will leave this map empty, in which case all input properties will be treated as depending on all dependencies of the resource. This is probably overly conservative, but it is less conservative than what we currently implement, and is certainly correct.
88 lines
5.1 KiB
Protocol Buffer
88 lines
5.1 KiB
Protocol Buffer
// Copyright 2016-2018, Pulumi Corporation.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// 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.
|
|
|
|
syntax = "proto3";
|
|
|
|
import "google/protobuf/empty.proto";
|
|
import "google/protobuf/struct.proto";
|
|
import "provider.proto";
|
|
|
|
package pulumirpc;
|
|
|
|
// ResourceMonitor is the interface a source uses to talk back to the planning monitor orchestrating the execution.
|
|
service ResourceMonitor {
|
|
rpc Invoke(InvokeRequest) returns (InvokeResponse) {}
|
|
rpc ReadResource(ReadResourceRequest) returns (ReadResourceResponse) {}
|
|
rpc RegisterResource(RegisterResourceRequest) returns (RegisterResourceResponse) {}
|
|
rpc RegisterResourceOutputs(RegisterResourceOutputsRequest) returns (google.protobuf.Empty) {}
|
|
}
|
|
|
|
// There is a clear distinction here between the "properties" bag sent across the wire as part of these RPCs and
|
|
// properties that exist on Pulumi resources as projected into the target language. It is important to call out that the
|
|
// properties here are in the format that a provider will expect. This is to say that they are usually in camel case.
|
|
// If a language wants to project properties in a format *other* than camel-case, it is the job of the language to
|
|
// ensure that the properties are translated into camel case before invoking an RPC.
|
|
|
|
// ReadResourceRequest contains enough information to uniquely qualify and read a resource's state.
|
|
message ReadResourceRequest {
|
|
string id = 1; // the ID of the resource to read.
|
|
string type = 2; // the type of the resource object.
|
|
string name = 3; // the name, for URN purposes, of the object.
|
|
string parent = 4; // an optional parent URN that this child resource belongs to.
|
|
google.protobuf.Struct properties = 5; // optional state sufficient to uniquely identify the resource.
|
|
repeated string dependencies = 6; // a list of URNs that this read depends on, as observed by the language host.
|
|
string provider = 7; // an optional reference to the provider to use for this read.
|
|
}
|
|
|
|
// ReadResourceResponse contains the result of reading a resource's state.
|
|
message ReadResourceResponse {
|
|
string urn = 1; // the URN for this resource.
|
|
google.protobuf.Struct properties = 2; // the state of the resource read from the live environment.
|
|
}
|
|
|
|
// RegisterResourceRequest contains information about a resource object that was newly allocated.
|
|
message RegisterResourceRequest {
|
|
// PropertyDependencies describes the resources that a particular property depends on.
|
|
message PropertyDependencies {
|
|
repeated string urns = 1; // A list of URNs this property depends on.
|
|
}
|
|
|
|
string type = 1; // the type of the object allocated.
|
|
string name = 2; // the name, for URN purposes, of the object.
|
|
string parent = 3; // an optional parent URN that this child resource belongs to.
|
|
bool custom = 4; // true if the resource is a custom, managed by a plugin's CRUD operations.
|
|
google.protobuf.Struct object = 5; // an object produced by the interpreter/source.
|
|
bool protect = 6; // true if the resource should be marked protected.
|
|
repeated string dependencies = 7; // a list of URNs that this resource depends on, as observed by the language host.
|
|
string provider = 8; // an optional reference to the provider to manage this resource's CRUD operations.
|
|
|
|
map<string, PropertyDependencies> propertyDependencies = 9; // a map from property keys to the dependencies of the property.
|
|
}
|
|
|
|
// RegisterResourceResponse is returned by the engine after a resource has finished being initialized. It includes the
|
|
// auto-assigned URN, the provider-assigned ID, and any other properties initialized by the engine.
|
|
message RegisterResourceResponse {
|
|
string urn = 1; // the URN assigned by the engine.
|
|
string id = 2; // the unique ID assigned by the provider.
|
|
google.protobuf.Struct object = 3; // the resulting object properties, including provider defaults.
|
|
bool stable = 4; // if true, the object's state is stable and may be trusted not to change.
|
|
repeated string stables = 5; // an optional list of guaranteed-stable properties.
|
|
}
|
|
|
|
// RegisterResourceOutputsRequest adds extra resource outputs created by the program after registration has occurred.
|
|
message RegisterResourceOutputsRequest {
|
|
string urn = 1; // the URN for the resource to attach output properties to.
|
|
google.protobuf.Struct outputs = 2; // additional output properties to add to the existing resource.
|
|
}
|