/
index.ts
233 lines (207 loc) 路 7.8 KB
/
index.ts
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
// Copyright 2016-2022, 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.
import { Inputs, Input, Output } from "../output";
import * as resource from "../resource";
import * as settings from "../runtime/settings";
import * as serializeClosure from "../runtime/closure/serializeClosure";
/**
* CheckResult represents the results of a call to `ResourceProvider.check`.
*/
export interface CheckResult<Inputs = any> {
/**
* The inputs to use, if any.
*/
readonly inputs?: Inputs;
/**
* Any validation failures that occurred.
*/
readonly failures?: CheckFailure[];
}
/**
* CheckFailure represents a single failure in the results of a call to `ResourceProvider.check`
*/
export interface CheckFailure {
/**
* The property that failed validation.
*/
readonly property: string;
/**
* The reason that the property failed validation.
*/
readonly reason: string;
}
/**
* DiffResult represents the results of a call to `ResourceProvider.diff`.
*/
export interface DiffResult {
/**
* If true, this diff detected changes and suggests an update.
*/
readonly changes?: boolean;
/**
* If this update requires a replacement, the set of properties triggering it.
*/
readonly replaces?: string[];
/**
* An optional list of properties that will not ever change.
*/
readonly stables?: string[];
/**
* If true, and a replacement occurs, the resource will first be deleted before being recreated. This is to
* void potential side-by-side issues with the default create before delete behavior.
*/
readonly deleteBeforeReplace?: boolean;
}
/**
* CreateResult represents the results of a call to `ResourceProvider.create`.
*/
export interface CreateResult<Outputs = any> {
/**
* The ID of the created resource.
*/
readonly id: resource.ID;
/**
* Any properties that were computed during creation.
*/
readonly outs?: Outputs;
}
export interface ReadResult<Outputs = any> {
/**
* The ID of the resource ready back (or blank if missing).
*/
readonly id?: resource.ID;
/**
* The current property state read from the live environment.
*/
readonly props?: Outputs;
}
/**
* UpdateResult represents the results of a call to `ResourceProvider.update`.
*/
export interface UpdateResult<Outputs = any> {
/**
* Any properties that were computed during updating.
*/
readonly outs?: Outputs;
}
/**
* ResourceProvider represents an object that provides CRUD operations for a particular type of resource.
*/
export interface ResourceProvider<Inputs = any, Outputs = any> {
/**
* Check validates that the given property bag is valid for a resource of the given type.
*
* @param olds The old input properties to use for validation.
* @param news The new input properties to use for validation.
*/
check?: (olds: Inputs, news: Inputs) => Promise<CheckResult<Inputs>>;
/**
* Diff checks what impacts a hypothetical update will have on the resource's properties.
*
* @param id The ID of the resource to diff.
* @param olds The old values of properties to diff.
* @param news The new values of properties to diff.
*/
diff?: (id: resource.ID, olds: Outputs, news: Inputs) => Promise<DiffResult>;
/**
* Create allocates a new instance of the provided resource and returns its unique ID afterwards.
* If this call fails, the resource must not have been created (i.e., it is "transactional").
*
* @param inputs The properties to set during creation.
*/
create: (inputs: Inputs) => Promise<CreateResult<Outputs>>;
/**
* Reads the current live state associated with a resource. Enough state must be included in the inputs to uniquely
* identify the resource; this is typically just the resource ID, but it may also include some properties.
*/
read?: (id: resource.ID, props?: Outputs) => Promise<ReadResult<Outputs>>;
/**
* Update updates an existing resource with new values.
*
* @param id The ID of the resource to update.
* @param olds The old values of properties to update.
* @param news The new values of properties to update.
*/
update?: (id: resource.ID, olds: Outputs, news: Inputs) => Promise<UpdateResult<Outputs>>;
/**
* Delete tears down an existing resource with the given ID. If it fails, the resource is assumed to still exist.
*
* @param id The ID of the resource to delete.
* @param props The current properties on the resource.
*/
delete?: (id: resource.ID, props: Outputs) => Promise<void>;
}
const providerCache = new WeakMap<ResourceProvider, Input<string>>();
function serializeProvider(provider: ResourceProvider): Input<string> {
let result: Input<string>;
// caching is enabled by default as of 3.0
if (settings.cacheDynamicProviders()) {
const cachedProvider = providerCache.get(provider);
if (cachedProvider) {
result = cachedProvider;
} else {
result = serializeFunctionMaybeSecret(provider);
providerCache.set(provider, result);
}
} else {
result = serializeFunctionMaybeSecret(provider);
}
return result;
}
function serializeFunctionMaybeSecret(provider: ResourceProvider): Output<string> {
// Load runtime/closure on demand, as its dependencies are slow to load.
//
// See https://www.typescriptlang.org/docs/handbook/modules.html#optional-module-loading-and-other-advanced-loading-scenarios
const sc: typeof serializeClosure = require("../runtime/closure/serializeClosure");
const sfPromise = sc.serializeFunction(() => provider, { allowSecrets: true });
// Create an Output from the promise's text and containsSecrets properties. Uses the internal API since we don't provide a public interface for this.
return new Output(
[],
sfPromise.then((sf) => sf.text),
new Promise((resolve) => resolve(true)),
sfPromise.then((sf) => sf.containsSecrets),
new Promise((resolve) => resolve([])),
);
}
/**
* Resource represents a Pulumi Resource that incorporates an inline implementation of the Resource's CRUD operations.
*/
export abstract class Resource extends resource.CustomResource {
/**
* Creates a new dynamic resource.
*
* @param provider The implementation of the resource's CRUD operations.
* @param name The name of the resource.
* @param props The arguments to use to populate the new resource. Must not define the reserved
* property "__provider".
* @param opts A bag of options that control this resource's behavior.
* @param module The module of the resource.
* @param type The type of the resource.
*/
constructor(
provider: ResourceProvider,
name: string,
props: Inputs,
opts?: resource.CustomResourceOptions,
module?: string,
type: string = "Resource",
) {
const providerKey: string = "__provider";
if (props[providerKey]) {
throw new Error("A dynamic resource must not define the __provider key");
}
props[providerKey] = serializeProvider(provider);
super(`pulumi-nodejs:dynamic${module ? `/${module}` : ""}:${type}`, name, props, opts);
}
}