/
resource.go
883 lines (750 loc) 路 27.3 KB
/
resource.go
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
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
// Copyright 2016-2021, 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.
package pulumi
import (
"context"
"fmt"
"reflect"
"sort"
"sync"
"github.com/pulumi/pulumi/sdk/v3/go/common/resource"
"github.com/pulumi/pulumi/sdk/v3/go/common/util/contract"
)
type (
// ID is a unique identifier assigned by a resource provider to a resource.
ID string
// URN is an automatically generated logical URN, used to stably identify resources.
URN string
)
var (
resourceStateType = reflect.TypeOf(ResourceState{})
customResourceStateType = reflect.TypeOf(CustomResourceState{})
providerResourceStateType = reflect.TypeOf(ProviderResourceState{})
)
// ResourceState is the base
type ResourceState struct {
m sync.RWMutex
urn URNOutput `pulumi:"urn"`
rawOutputs Output
children resourceSet
providers map[string]ProviderResource
provider ProviderResource
version string
pluginDownloadURL string
aliases []URNOutput
name string
transformations []ResourceTransformation
keepDep bool
}
func (s *ResourceState) URN() URNOutput {
return s.urn
}
func (s *ResourceState) GetProvider(token string) ProviderResource {
return s.providers[getPackage(token)]
}
// This is an internal method and future versions of the sdk may not support this API.
//
// InternalGetRawOutputs obtains the full PropertyMap returned during resource registration,
// allowing a caller of RegisterResource to obtain directly information about the outputs and their
// known and secret attributes.
func InternalGetRawOutputs(res *ResourceState) Output {
return res.rawOutputs
}
func (s *ResourceState) getChildren() []Resource {
s.m.RLock()
defer s.m.RUnlock()
var children []Resource
if len(s.children) != 0 {
children = make([]Resource, 0, len(s.children))
for r := range s.children {
children = append(children, r)
}
}
return children
}
func (s *ResourceState) addChild(r Resource) {
s.m.Lock()
defer s.m.Unlock()
if s.children == nil {
s.children = resourceSet{}
}
s.children.add(r)
}
func (s *ResourceState) getProviders() map[string]ProviderResource {
return s.providers
}
func (s *ResourceState) getProvider() ProviderResource {
return s.provider
}
func (s *ResourceState) getVersion() string {
return s.version
}
func (s *ResourceState) getPluginDownloadURL() string {
return s.pluginDownloadURL
}
func (s *ResourceState) getAliases() []URNOutput {
return s.aliases
}
func (s *ResourceState) getName() string {
return s.name
}
func (s *ResourceState) getTransformations() []ResourceTransformation {
return s.transformations
}
func (s *ResourceState) addTransformation(t ResourceTransformation) {
s.transformations = append(s.transformations, t)
}
func (s *ResourceState) setKeepDependency() {
s.keepDep = true
}
func (s *ResourceState) keepDependency() bool {
return s.keepDep
}
func (*ResourceState) isResource() {}
func (ctx *Context) newDependencyResource(urn URN) Resource {
var res ResourceState
res.urn.OutputState = ctx.newOutputState(res.urn.ElementType(), &res)
res.urn.resolve(urn, true, false, nil)
res.keepDep = true
return &res
}
type CustomResourceState struct {
ResourceState
id IDOutput `pulumi:"id"`
}
func (s *CustomResourceState) ID() IDOutput {
return s.id
}
func (*CustomResourceState) isCustomResource() {}
func (ctx *Context) newDependencyCustomResource(urn URN, id ID) CustomResource {
var res CustomResourceState
res.urn.OutputState = ctx.newOutputState(res.urn.ElementType(), &res)
res.urn.resolve(urn, true, false, nil)
res.id.OutputState = ctx.newOutputState(res.id.ElementType(), &res)
res.id.resolve(id, id != "", false, nil)
return &res
}
type ProviderResourceState struct {
CustomResourceState
pkg string
}
func (s *ProviderResourceState) getPackage() string {
return s.pkg
}
func (ctx *Context) newDependencyProviderResource(urn URN, id ID) ProviderResource {
var res ProviderResourceState
res.urn.OutputState = ctx.newOutputState(res.urn.ElementType(), &res)
res.id.OutputState = ctx.newOutputState(res.id.ElementType(), &res)
res.urn.resolve(urn, true, false, nil)
res.id.resolve(id, id != "", false, nil)
res.pkg = string(resource.URN(urn).Type().Name())
return &res
}
// Resource represents a cloud resource managed by Pulumi.
type Resource interface {
// URN is this resource's stable logical URN used to distinctly address it before, during, and after deployments.
URN() URNOutput
// getChildren returns the resource's children.
getChildren() []Resource
// addChild adds a child to the resource.
addChild(r Resource)
// getProviders returns the provider map for this resource.
getProviders() map[string]ProviderResource
// getProvider returns the provider for the resource.
getProvider() ProviderResource
// getVersion returns the version for the resource.
getVersion() string
// getPluginDownloadURL returns the provider plugin download url
getPluginDownloadURL() string
// getAliases returns the list of aliases for this resource
getAliases() []URNOutput
// getName returns the name of the resource
getName() string
// isResource() is a marker method used to ensure that all Resource types embed a ResourceState.
isResource()
// getTransformations returns the transformations for the resource.
getTransformations() []ResourceTransformation
// addTransformation adds a single transformation to the resource.
addTransformation(t ResourceTransformation)
// setKeepDependency marks this resource as a resource that should be kept as a dependency.
// This is done for remote component resources, dependency resources, and rehydrated component resources.
setKeepDependency()
// keepDependency returns true if the resource should be kept as a dependency, which is the case for
// remote component resources, dependency resources, and rehydrated component resources.
keepDependency() bool
}
// CustomResource is a cloud resource whose create, read, update, and delete (CRUD) operations are managed by performing
// external operations on some physical entity. The engine understands how to diff and perform partial updates of them,
// and these CRUD operations are implemented in a dynamically loaded plugin for the defining package.
type CustomResource interface {
Resource
// ID is the provider-assigned unique identifier for this managed resource. It is set during deployments,
// but might be missing ("") during planning phases.
ID() IDOutput
isCustomResource()
}
// ComponentResource is a resource that aggregates one or more other child resources into a higher level abstraction.
// The component resource itself is a resource, but does not require custom CRUD operations for provisioning.
type ComponentResource interface {
Resource
}
// ProviderResource is a resource that represents a configured instance of a particular package's provider plugin.
// These resources are supply the implementations of their package's CRUD operations. A specific provider instance can
// be used for a given resource by passing it in ResourceOpt.Provider.
type ProviderResource interface {
CustomResource
getPackage() string
}
// CustomTimeouts specifies timeouts for resource provisioning operations.
// Use it with the [Timeouts] option when creating new resources
// to override default timeouts.
//
// Each timeout is specified as a duration string such as,
// "5ms" (5 milliseconds), "40s" (40 seconds),
// and "1m30s" (1 minute, 30 seconds).
//
// The following units are accepted.
//
// - ns: nanoseconds
// - us: microseconds
// - 碌s: microseconds
// - ms: milliseconds
// - s: seconds
// - m: minutes
// - h: hours
type CustomTimeouts struct {
Create string
Update string
Delete string
}
// ResourceOptions is a snapshot of one or more [ResourceOption]s.
//
// It provides a preview of the collective effect of options
// passed to a resource.
//
// See https://www.pulumi.com/docs/intro/concepts/resources/options/
// for more details on individual options.
type ResourceOptions struct {
// AdditionalSecretOutputs lists output properties
// that must be encrypted as secrets.
AdditionalSecretOutputs []string
// Aliases lists aliases for this resource
// that are used to find and use existing resources.
Aliases []Alias
// CustomTimeouts, if set, overrides the default timeouts
// for resource CRUD operations.
CustomTimeouts *CustomTimeouts
// DeleteBeforeReplace specifies that resources being replaced
// should be deleted before creating the replacement
// instead of Pulumi's default behavior of creating the replacement
// before performing deletion.
DeleteBeforeReplace bool
// DependsOn lists additional explicit dependencies for the resource
// in addition to those tracked automatically by Pulumi.
DependsOn []Resource
// DependsOnInputs holds explicit dependencies for the resource
// that may not be fully known yet.
DependsOnInputs []ResourceArrayInput
// IgnoreChanges lists properties changes to which should be ignored.
IgnoreChanges []string
// Import specifies that the provider for this resource
// should import its state from a cloud resource with the given ID.
Import IDInput
// Parent is the parent resource for the resource being created,
// or nil if this resource does not have a parent.
Parent Resource
// Protect prevents this resource from being deleted.
Protect bool
// Provider is the provider resource to use for this resource's CRUD operations.
// It's nil if the default provider should be used.
Provider ProviderResource
// Providers is a bag of providers available
// to instantiate resources of various types.
// These are used for a type when a provider for that type
// was not explicitly supplied.
Providers []ProviderResource
// ReplaceOnChanges lists properties that, when modified,
// force a replacement of the resource.
// The list may include '*' to indicate that all properties trigger
// replacements.
ReplaceOnChanges []string
// Transformations is a list of functions that transform
// the resource's properties during construction.
Transformations []ResourceTransformation
// URN is the URN of a previously-registered resource of this type.
URN string
// Version changes the version of the provider plugin that should be used
// when operating on this resource.
// This will be blank if the version was automatically inferred.
Version string
// PluginDownloadURL specifies the URL from which the provider plugin
// should be downloaded.
// This will be blank if the URL was inferred automatically.
PluginDownloadURL string
// RetainOnDelete specifies that the resource should not be deleted
// in the cloud provider, even if it's deleted from Pulumi.
RetainOnDelete bool
// DeletedWith holds a container resource that, if deleted,
// also deletes this resource.
DeletedWith Resource
}
// NewResourceOptions builds a preview of the effect of the provided options.
//
// Use this to get a read-only snapshot of a list of options
// inside mocks and component resources.
func NewResourceOptions(opts ...ResourceOption) (*ResourceOptions, error) {
// The error return is currently unused,
// but it's foreseeable that we'll need it
// if we begin doing option validation at option merge time.
return resourceOptionsSnapshot(merge(opts...)), nil
}
// resourceOptions is the internal representation of the effect of
// [ResourceOption]s.
type resourceOptions struct {
AdditionalSecretOutputs []string
Aliases []Alias
CustomTimeouts *CustomTimeouts
DeleteBeforeReplace bool
DependsOn []dependencySet
IgnoreChanges []string
Import IDInput
Parent Resource
Protect bool
Provider ProviderResource
Providers map[string]ProviderResource
ReplaceOnChanges []string
Transformations []ResourceTransformation
URN string
Version string
PluginDownloadURL string
RetainOnDelete bool
DeletedWith Resource
}
func resourceOptionsSnapshot(ro *resourceOptions) *ResourceOptions {
var (
dependsOn []Resource
dependsOnInputs []ResourceArrayInput
)
for _, d := range ro.DependsOn {
switch d := d.(type) {
case urnDependencySet:
// There is no user-facing option
// to specify URN dependencies directly.
// This is only used internally,
// so omit this from the snapshot.
case resourceDependencySet:
dependsOn = append(dependsOn, []Resource(d)...)
case *resourceArrayInputDependencySet:
dependsOnInputs = append(dependsOnInputs, d.input)
default:
// Unreachable.
// We control all implementations of dependencySet.
contract.Failf("Unknown dependencySet %T", d)
}
}
sort.Slice(dependsOn, func(i, j int) bool {
return dependsOn[i].getName() < dependsOn[j].getName()
})
var providers []ProviderResource
if len(ro.Providers) > 0 {
providers = make([]ProviderResource, 0, len(ro.Providers))
for _, p := range ro.Providers {
providers = append(providers, p)
}
sort.Slice(providers, func(i, j int) bool {
return providers[i].getPackage() < providers[j].getPackage()
})
}
return &ResourceOptions{
AdditionalSecretOutputs: ro.AdditionalSecretOutputs,
Aliases: ro.Aliases,
CustomTimeouts: ro.CustomTimeouts,
DeleteBeforeReplace: ro.DeleteBeforeReplace,
DependsOn: dependsOn,
DependsOnInputs: dependsOnInputs,
IgnoreChanges: ro.IgnoreChanges,
Import: ro.Import,
Parent: ro.Parent,
Protect: ro.Protect,
Provider: ro.Provider,
Providers: providers,
ReplaceOnChanges: ro.ReplaceOnChanges,
Transformations: ro.Transformations,
URN: ro.URN,
Version: ro.Version,
PluginDownloadURL: ro.PluginDownloadURL,
RetainOnDelete: ro.RetainOnDelete,
DeletedWith: ro.DeletedWith,
}
}
// InvokeOptions is a snapshot of one or more [InvokeOption]s.
type InvokeOptions struct {
// Parent is the parent resource for this operation.
// It may be used to determine the provider to use.
Parent Resource
// Provider specifies the provider to use for this operation.
// This is nil if the default provider should be used.
Provider ProviderResource
// Version is the version of the provider plugin that should be used.
// This will be blank if the version was automatically inferred.
Version string
// PluginDownloadURL is the URL from which the provider plugin
// should be downloaded.
// This will be blank if the URL was inferred automatically.
PluginDownloadURL string
}
// NOTE:
// InvokeOptions is part of the public API.
// If you introduce a new option,
// consider what its "snapshot" should look like,
// not the internal representation.
// For example, a list of resources should be []Resource,
// even if it's stored as a map[string]Resource.
// If the snapshot representation diverges from the internal,
// mirror this struct into a private invokeOptions struct.
// See resourceOptions for an example.
// NewInvokeOptions builds a preview of the effect of the provided options.
//
// Use this to get a read-only snapshot of the collective effect
// of a list of [InvokeOption]s.
func NewInvokeOptions(opts ...InvokeOption) (*InvokeOptions, error) {
var options InvokeOptions
for _, o := range opts {
if o != nil {
o.applyInvokeOption(&options)
}
}
// The error return is currently unused,
// but it's foreseeable that we'll need it
// if we begin doing option validation at option merge time.
return &options, nil
}
type ResourceOption interface {
applyResourceOption(*resourceOptions)
}
type InvokeOption interface {
applyInvokeOption(*InvokeOptions)
}
type ResourceOrInvokeOption interface {
ResourceOption
InvokeOption
}
type resourceOption func(*resourceOptions)
func (o resourceOption) applyResourceOption(opts *resourceOptions) {
o(opts)
}
type invokeOption func(*InvokeOptions)
func (o invokeOption) applyInvokeOption(opts *InvokeOptions) {
o(opts)
}
type resourceOrInvokeOption func(ro *resourceOptions, io *InvokeOptions)
func (o resourceOrInvokeOption) applyResourceOption(opts *resourceOptions) {
o(opts, nil)
}
func (o resourceOrInvokeOption) applyInvokeOption(opts *InvokeOptions) {
o(nil, opts)
}
// merging is handled by each functional options call
// properties that are arrays/maps are always appended/merged together
// last value wins for non-array/map values and for conflicting map values (bool, struct, etc)
func merge(opts ...ResourceOption) *resourceOptions {
options := &resourceOptions{}
for _, o := range opts {
if o != nil {
o.applyResourceOption(options)
}
}
return options
}
// AdditionalSecretOutputs specifies a list of output properties to mark as secret.
func AdditionalSecretOutputs(o []string) ResourceOption {
return resourceOption(func(ro *resourceOptions) {
ro.AdditionalSecretOutputs = append(ro.AdditionalSecretOutputs, o...)
})
}
// Aliases applies a list of identifiers to find and use existing resources.
func Aliases(o []Alias) ResourceOption {
return resourceOption(func(ro *resourceOptions) {
ro.Aliases = append(ro.Aliases, o...)
})
}
// DeleteBeforeReplace, when set to true, ensures that this resource is deleted prior to replacement.
func DeleteBeforeReplace(o bool) ResourceOption {
return resourceOption(func(ro *resourceOptions) {
ro.DeleteBeforeReplace = o
})
}
// Composite is a resource option that contains other resource options.
func Composite(opts ...ResourceOption) ResourceOption {
return resourceOption(func(ro *resourceOptions) {
for _, o := range opts {
o.applyResourceOption(ro)
}
})
}
// CompositeInvoke is an invoke option that contains other invoke options.
func CompositeInvoke(opts ...InvokeOption) InvokeOption {
return invokeOption(func(ro *InvokeOptions) {
for _, o := range opts {
o.applyInvokeOption(ro)
}
})
}
// dependencySet unifies types that can provide dependencies for a
// resource.
type dependencySet interface {
// Adds URNs for addURNs from this set
// into the given urnSet.
addURNs(context.Context, urnSet) error
}
// urnDependencySet is a dependencySet built from a constant set of URNs.
type urnDependencySet urnSet
var _ dependencySet = (urnDependencySet)(nil)
func (us urnDependencySet) addURNs(ctx context.Context, urns urnSet) error {
urns.union(urnSet(us))
return nil
}
// DependsOn is an optional array of explicit dependencies on other resources.
func DependsOn(o []Resource) ResourceOption {
return resourceOption(func(ro *resourceOptions) {
ro.DependsOn = append(ro.DependsOn, resourceDependencySet(o))
})
}
// resourceDependencySet is a dependencySet comprised of references to
// resources.
type resourceDependencySet []Resource
var _ dependencySet = (resourceDependencySet)(nil)
func (rs resourceDependencySet) addURNs(ctx context.Context, urns urnSet) error {
for _, r := range rs {
if err := addDependency(ctx, urns, r); err != nil {
return err
}
}
return nil
}
// Declares explicit dependencies on other resources. Similar to
// `DependsOn`, but also admits resource inputs and outputs:
//
// var r Resource
// var ri ResourceInput
// var ro ResourceOutput
// allDeps := NewResourceArrayOutput(NewResourceOutput(r), ri.ToResourceOutput(), ro)
// DependsOnInputs(allDeps)
func DependsOnInputs(o ResourceArrayInput) ResourceOption {
return resourceOption(func(ro *resourceOptions) {
ro.DependsOn = append(ro.DependsOn, &resourceArrayInputDependencySet{o})
})
}
// resourceArrayInputDependencySet is a dependencySet built from
// collections of resources that are not yet known.
type resourceArrayInputDependencySet struct{ input ResourceArrayInput }
var _ dependencySet = (*resourceArrayInputDependencySet)(nil)
func (ra *resourceArrayInputDependencySet) addURNs(ctx context.Context, urns urnSet) error {
out := ra.input.ToResourceArrayOutput()
value, known, _ /* secret */, _ /* deps */, err := out.await(ctx)
if err != nil || !known {
return err
}
resources, ok := value.([]Resource)
if !ok {
return fmt.Errorf("ResourceArrayInput resolved to a value of unexpected type %v, expected []Resource",
reflect.TypeOf(value))
}
// For some reason, deps returned above are incorrect; instead:
toplevelDeps := out.dependencies()
for _, r := range append(resources, toplevelDeps...) {
if err := addDependency(ctx, urns, r); err != nil {
return err
}
}
return nil
}
// Ignore changes to any of the specified properties.
func IgnoreChanges(o []string) ResourceOption {
return resourceOption(func(ro *resourceOptions) {
ro.IgnoreChanges = append(ro.IgnoreChanges, o...)
})
}
// Import, when provided with a resource ID, indicates that this resource's provider should import its state from
// the cloud resource with the given ID. The inputs to the resource's constructor must align with the resource's
// current state. Once a resource has been imported, the import property must be removed from the resource's
// options.
func Import(o IDInput) ResourceOption {
return resourceOption(func(ro *resourceOptions) {
ro.Import = o
})
}
// Parent sets the parent resource to which this resource or invoke belongs.
func Parent(r Resource) ResourceOrInvokeOption {
return resourceOrInvokeOption(func(ro *resourceOptions, io *InvokeOptions) {
switch {
case ro != nil:
ro.Parent = r
case io != nil:
io.Parent = r
}
})
}
// Protect, when set to true, ensures that this resource cannot be deleted (without first setting it to false).
func Protect(o bool) ResourceOption {
return resourceOption(func(ro *resourceOptions) {
ro.Protect = o
})
}
////////////////////////////////////////////////////////////////////////
// NOTE(Provider and Providers)
//
// For Provider vs Providers, there's a bit of complexity.
//
// # Background
//
// First, here's the desired behavior across languages,
// as standardized in #8796:
//
// - Providers is a bag of providers available to a resource.
// These are used by the resource and its children.
// - Provider passed to a resource indicates that that specific resource
// MUST use this provider over all else,
// and it should add it to the bag of providers for use by its children.
//
// One discrepancy from the above is that originally, for the Provider option,
// mismatch between the provider package and resource type was an error.
// However, this appears to have been relaxed over time.
// In such a case, the provider is added to the bag of providers
// and used by the children of the resource.
// This is necessary, for example, for resources to inherit a provider
// passed to a component resource via the Provider option.
//
// # Go-specific difference
//
// In other languages, the Provider and Providers options can be provided at
// most once per resource.
// In Go, because we use functional options, we allow multiple calls to
// the Provider and Providers options.
// This has allowed for the following to be equivalen in Go:
//
// NewFoo(..., Provider(p1), Provider(p2), Provider(p3))
// NewFoo(..., Providers(p1, p2, p3))
//
// To support this while still having the Provider option take precedence,
// we need to do the following:
//
// 1. All providers (whether passed with Provider or Providers)
// are merged into a single map.
// Last provider for a given package wins.
// 2. For the Provider option, we additionally track the last
// passed value in a separate field.
// If this provider handles the current resource,
// it takes precedence over the map.
////////////////////////////////////////////////////////////////////////
// Provider sets the provider resource to use for a resource's CRUD operations or an invoke's call.
func Provider(r ProviderResource) ResourceOrInvokeOption {
return resourceOrInvokeOption(func(ro *resourceOptions, io *InvokeOptions) {
switch {
case ro != nil:
ro.Provider = r
Providers(r).applyResourceOption(ro)
case io != nil:
io.Provider = r
}
})
}
// ProviderMap is an optional map of package to provider resource for a component resource.
func ProviderMap(o map[string]ProviderResource) ResourceOption {
return resourceOption(func(ro *resourceOptions) {
if o != nil {
if ro.Providers == nil {
ro.Providers = make(map[string]ProviderResource)
}
for k, v := range o {
ro.Providers[k] = v
}
}
})
}
// Providers is an optional list of providers to use for a resource's children.
func Providers(o ...ProviderResource) ResourceOption {
m := map[string]ProviderResource{}
for _, p := range o {
m[p.getPackage()] = p
}
return ProviderMap(m)
}
// ReplaceOnChanges will force a replacement when any of these property paths are set. If this list includes `"*"`,
// changes to any properties will force a replacement. Initialization errors from previous deployments will
// require replacement instead of update only if `"*"` is passed.
func ReplaceOnChanges(o []string) ResourceOption {
return resourceOption(func(ro *resourceOptions) {
ro.ReplaceOnChanges = append(ro.ReplaceOnChanges, o...)
})
}
// Timeouts is an optional configuration block used for CRUD operations
func Timeouts(o *CustomTimeouts) ResourceOption {
return resourceOption(func(ro *resourceOptions) {
ro.CustomTimeouts = o
})
}
// Transformations is an optional list of transformations to be applied to the resource.
func Transformations(o []ResourceTransformation) ResourceOption {
return resourceOption(func(ro *resourceOptions) {
ro.Transformations = append(ro.Transformations, o...)
})
}
// URN_ is an optional URN of a previously-registered resource of this type to read from the engine.
//
//nolint:revive
func URN_(o string) ResourceOption {
return resourceOption(func(ro *resourceOptions) {
ro.URN = o
})
}
// Version is an optional version, corresponding to the version of the provider plugin that should be used when
// operating on this resource. This version overrides the version information inferred from the current package and
// should rarely be used.
func Version(o string) ResourceOrInvokeOption {
return resourceOrInvokeOption(func(ro *resourceOptions, io *InvokeOptions) {
switch {
case ro != nil:
ro.Version = o
case io != nil:
io.Version = o
}
})
}
// PluginDownloadURL is an optional url, corresponding to the download url of the provider plugin
// that should be used when operating on this resource. This url overrides the url information
// inferred from the current package and should rarely be used.
func PluginDownloadURL(o string) ResourceOrInvokeOption {
return resourceOrInvokeOption(func(ro *resourceOptions, io *InvokeOptions) {
switch {
case ro != nil:
ro.PluginDownloadURL = o
case io != nil:
io.PluginDownloadURL = o
}
})
}
// If set to True, the providers Delete method will not be called for this resource.
func RetainOnDelete(b bool) ResourceOption {
return resourceOption(func(ro *resourceOptions) {
ro.RetainOnDelete = b
})
}
// If set, the providers Delete method will not be called for this resource
// if specified resource is being deleted as well.
func DeletedWith(r Resource) ResourceOption {
return resourceOption(func(ro *resourceOptions) {
ro.DeletedWith = r
})
}