2018-07-12 23:24:38 +02:00
|
|
|
// 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.
|
|
|
|
|
|
|
|
package deploy
|
|
|
|
|
|
|
|
import (
|
2019-08-11 09:39:03 +02:00
|
|
|
"path/filepath"
|
2019-07-31 18:39:07 +02:00
|
|
|
"strings"
|
|
|
|
|
Refine resource replacement logic for providers (#2767)
This commit touches an intersection of a few different provider-oriented
features that combined to cause a particularly severe bug that made it
impossible for users to upgrade provider versions without seeing
replacements with their resources.
For some context, Pulumi models all providers as resources and places
them in the snapshot like any other resource. Every resource has a
reference to the provider that created it. If a Pulumi program does not
specify a particular provider to use when performing a resource
operation, the Pulumi engine injects one automatically; these are called
"default providers" and are the most common ways that users end up with
providers in their snapshot. Default providers can be identified by
their name, which is always prefixed with "default".
Recently, in an effort to make the Pulumi engine more flexible with
provider versions, it was made possible for the engine to have multiple
default providers active for a provider of a particular type, which was
previously not possible. Because a provider is identified as a tuple of
package name and version, it was difficult to find a name for these
duplicate default providers that did not cause additional problems. The
provider versioning PR gave these default providers a name that was
derived from the version of the package. This proved to be a problem,
because when users upgraded from one version of a package to another,
this changed the name of their default provider which in turn caused all
of their resources created using that provider (read: everything) to be
replaced.
To combat this, this PR introduces a rule that the engine will apply
when diffing a resource to determine whether or not it needs to be
replaced: "If a resource's provider changes, and both old and new
providers are default providers whose properties do not require
replacement, proceed as if there were no diff." This allows the engine
to gracefully recognize and recover when a resource's default provider changes
names, as long as the provider's config has not changed.
2019-06-03 21:16:31 +02:00
|
|
|
"github.com/pkg/errors"
|
2019-06-11 00:20:44 +02:00
|
|
|
"github.com/pulumi/pulumi/pkg/apitype"
|
Refine resource replacement logic for providers (#2767)
This commit touches an intersection of a few different provider-oriented
features that combined to cause a particularly severe bug that made it
impossible for users to upgrade provider versions without seeing
replacements with their resources.
For some context, Pulumi models all providers as resources and places
them in the snapshot like any other resource. Every resource has a
reference to the provider that created it. If a Pulumi program does not
specify a particular provider to use when performing a resource
operation, the Pulumi engine injects one automatically; these are called
"default providers" and are the most common ways that users end up with
providers in their snapshot. Default providers can be identified by
their name, which is always prefixed with "default".
Recently, in an effort to make the Pulumi engine more flexible with
provider versions, it was made possible for the engine to have multiple
default providers active for a provider of a particular type, which was
previously not possible. Because a provider is identified as a tuple of
package name and version, it was difficult to find a name for these
duplicate default providers that did not cause additional problems. The
provider versioning PR gave these default providers a name that was
derived from the version of the package. This proved to be a problem,
because when users upgraded from one version of a package to another,
this changed the name of their default provider which in turn caused all
of their resources created using that provider (read: everything) to be
replaced.
To combat this, this PR introduces a rule that the engine will apply
when diffing a resource to determine whether or not it needs to be
replaced: "If a resource's provider changes, and both old and new
providers are default providers whose properties do not require
replacement, proceed as if there were no diff." This allows the engine
to gracefully recognize and recover when a resource's default provider changes
names, as long as the provider's config has not changed.
2019-06-03 21:16:31 +02:00
|
|
|
|
2018-07-12 23:24:38 +02:00
|
|
|
"github.com/pulumi/pulumi/pkg/diag"
|
|
|
|
"github.com/pulumi/pulumi/pkg/resource"
|
Implement first-class providers. (#1695)
### First-Class Providers
These changes implement support for first-class providers. First-class
providers are provider plugins that are exposed as resources via the
Pulumi programming model so that they may be explicitly and multiply
instantiated. Each instance of a provider resource may be configured
differently, and configuration parameters may be source from the
outputs of other resources.
### Provider Plugin Changes
In order to accommodate the need to verify and diff provider
configuration and configure providers without complete configuration
information, these changes adjust the high-level provider plugin
interface. Two new methods for validating a provider's configuration
and diffing changes to the same have been added (`CheckConfig` and
`DiffConfig`, respectively), and the type of the configuration bag
accepted by `Configure` has been changed to a `PropertyMap`.
These changes have not yet been reflected in the provider plugin gRPC
interface. We will do this in a set of follow-up changes. Until then,
these methods are implemented by adapters:
- `CheckConfig` validates that all configuration parameters are string
or unknown properties. This is necessary because existing plugins
only accept string-typed configuration values.
- `DiffConfig` either returns "never replace" if all configuration
values are known or "must replace" if any configuration value is
unknown. The justification for this behavior is given
[here](https://github.com/pulumi/pulumi/pull/1695/files#diff-a6cd5c7f337665f5bb22e92ca5f07537R106)
- `Configure` converts the config bag to a legacy config map and
configures the provider plugin if all config values are known. If any
config value is unknown, the underlying plugin is not configured and
the provider may only perform `Check`, `Read`, and `Invoke`, all of
which return empty results. We justify this behavior becuase it is
only possible during a preview and provides the best experience we
can manage with the existing gRPC interface.
### Resource Model Changes
Providers are now exposed as resources that participate in a stack's
dependency graph. Like other resources, they are explicitly created,
may have multiple instances, and may have dependencies on other
resources. Providers are referred to using provider references, which
are a combination of the provider's URN and its ID. This design
addresses the need during a preview to refer to providers that have not
yet been physically created and therefore have no ID.
All custom resources that are not themselves providers must specify a
single provider via a provider reference. The named provider will be
used to manage that resource's CRUD operations. If a resource's
provider reference changes, the resource must be replaced. Though its
URN is not present in the resource's dependency list, the provider
should be treated as a dependency of the resource when topologically
sorting the dependency graph.
Finally, `Invoke` operations must now specify a provider to use for the
invocation via a provider reference.
### Engine Changes
First-class providers support requires a few changes to the engine:
- The engine must have some way to map from provider references to
provider plugins. It must be possible to add providers from a stack's
checkpoint to this map and to register new/updated providers during
the execution of a plan in response to CRUD operations on provider
resources.
- In order to support updating existing stacks using existing Pulumi
programs that may not explicitly instantiate providers, the engine
must be able to manage the "default" providers for each package
referenced by a checkpoint or Pulumi program. The configuration for
a "default" provider is taken from the stack's configuration data.
The former need is addressed by adding a provider registry type that is
responsible for managing all of the plugins required by a plan. In
addition to loading plugins froma checkpoint and providing the ability
to map from a provider reference to a provider plugin, this type serves
as the provider plugin for providers themselves (i.e. it is the
"provider provider").
The latter need is solved via two relatively self-contained changes to
plan setup and the eval source.
During plan setup, the old checkpoint is scanned for custom resources
that do not have a provider reference in order to compute the set of
packages that require a default provider. Once this set has been
computed, the required default provider definitions are conjured and
prepended to the checkpoint's resource list. Each resource that
requires a default provider is then updated to refer to the default
provider for its package.
While an eval source is running, each custom resource registration,
resource read, and invoke that does not name a provider is trapped
before being returned by the source iterator. If no default provider
for the appropriate package has been registered, the eval source
synthesizes an appropriate registration, waits for it to complete, and
records the registered provider's reference. This reference is injected
into the original request, which is then processed as usual. If a
default provider was already registered, the recorded reference is
used and no new registration occurs.
### SDK Changes
These changes only expose first-class providers from the Node.JS SDK.
- A new abstract class, `ProviderResource`, can be subclassed and used
to instantiate first-class providers.
- A new field in `ResourceOptions`, `provider`, can be used to supply
a particular provider instance to manage a `CustomResource`'s CRUD
operations.
- A new type, `InvokeOptions`, can be used to specify options that
control the behavior of a call to `pulumi.runtime.invoke`. This type
includes a `provider` field that is analogous to
`ResourceOptions.provider`.
2018-08-07 02:50:29 +02:00
|
|
|
"github.com/pulumi/pulumi/pkg/resource/deploy/providers"
|
2018-09-28 00:49:08 +02:00
|
|
|
"github.com/pulumi/pulumi/pkg/resource/graph"
|
2018-07-12 23:24:38 +02:00
|
|
|
"github.com/pulumi/pulumi/pkg/resource/plugin"
|
Implement more precise delete-before-replace semantics. (#2369)
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.
2019-01-28 18:46:30 +01:00
|
|
|
"github.com/pulumi/pulumi/pkg/tokens"
|
2018-07-12 23:24:38 +02:00
|
|
|
"github.com/pulumi/pulumi/pkg/util/contract"
|
|
|
|
"github.com/pulumi/pulumi/pkg/util/logging"
|
2018-09-06 00:08:09 +02:00
|
|
|
"github.com/pulumi/pulumi/pkg/util/result"
|
2018-07-12 23:24:38 +02:00
|
|
|
)
|
|
|
|
|
|
|
|
// stepGenerator is responsible for turning resource events into steps that
|
|
|
|
// can be fed to the plan executor. It does this by consulting the plan
|
|
|
|
// and calculating the appropriate step action based on the requested goal
|
|
|
|
// state and the existing state of the world.
|
|
|
|
type stepGenerator struct {
|
|
|
|
plan *Plan // the plan to which this step generator belongs
|
|
|
|
opts Options // options for this step generator
|
|
|
|
|
2019-07-23 02:25:25 +02:00
|
|
|
// signals that one or more PolicyViolationEvents have been reported to the user, and the plan
|
|
|
|
// should terminate in error. This primarily allows `preview` to aggregate many policy violation
|
|
|
|
// events and report them all at once.
|
|
|
|
hasPolicyViolations bool
|
|
|
|
|
Refine resource replacement logic for providers (#2767)
This commit touches an intersection of a few different provider-oriented
features that combined to cause a particularly severe bug that made it
impossible for users to upgrade provider versions without seeing
replacements with their resources.
For some context, Pulumi models all providers as resources and places
them in the snapshot like any other resource. Every resource has a
reference to the provider that created it. If a Pulumi program does not
specify a particular provider to use when performing a resource
operation, the Pulumi engine injects one automatically; these are called
"default providers" and are the most common ways that users end up with
providers in their snapshot. Default providers can be identified by
their name, which is always prefixed with "default".
Recently, in an effort to make the Pulumi engine more flexible with
provider versions, it was made possible for the engine to have multiple
default providers active for a provider of a particular type, which was
previously not possible. Because a provider is identified as a tuple of
package name and version, it was difficult to find a name for these
duplicate default providers that did not cause additional problems. The
provider versioning PR gave these default providers a name that was
derived from the version of the package. This proved to be a problem,
because when users upgraded from one version of a package to another,
this changed the name of their default provider which in turn caused all
of their resources created using that provider (read: everything) to be
replaced.
To combat this, this PR introduces a rule that the engine will apply
when diffing a resource to determine whether or not it needs to be
replaced: "If a resource's provider changes, and both old and new
providers are default providers whose properties do not require
replacement, proceed as if there were no diff." This allows the engine
to gracefully recognize and recover when a resource's default provider changes
names, as long as the provider's config has not changed.
2019-06-03 21:16:31 +02:00
|
|
|
urns map[resource.URN]bool // set of URNs discovered for this plan
|
|
|
|
reads map[resource.URN]bool // set of URNs read for this plan
|
|
|
|
deletes map[resource.URN]bool // set of URNs deleted in this plan
|
|
|
|
replaces map[resource.URN]bool // set of URNs replaced in this plan
|
|
|
|
updates map[resource.URN]bool // set of URNs updated in this plan
|
|
|
|
creates map[resource.URN]bool // set of URNs created in this plan
|
|
|
|
sames map[resource.URN]bool // set of URNs that were not changed in this plan
|
|
|
|
pendingDeletes map[*resource.State]bool // set of resources (not URNs!) that are pending deletion
|
|
|
|
providers map[resource.URN]*resource.State // URN map of providers that we have seen so far.
|
Implement more precise delete-before-replace semantics. (#2369)
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.
2019-01-28 18:46:30 +01:00
|
|
|
// a map from URN to a list of property keys that caused the replacement of a dependent resource during a
|
|
|
|
// delete-before-replace.
|
|
|
|
dependentReplaceKeys map[resource.URN][]resource.PropertyKey
|
2019-06-01 08:01:01 +02:00
|
|
|
// a map from old names (aliased URNs) to the new URN that aliased to them.
|
|
|
|
aliased map[resource.URN]resource.URN
|
2018-07-12 23:24:38 +02:00
|
|
|
}
|
|
|
|
|
2018-08-03 23:06:00 +02:00
|
|
|
// GenerateReadSteps is responsible for producing one or more steps required to service
|
|
|
|
// a ReadResourceEvent coming from the language host.
|
2019-03-19 20:40:10 +01:00
|
|
|
func (sg *stepGenerator) GenerateReadSteps(event ReadResourceEvent) ([]Step, result.Result) {
|
Implement first-class providers. (#1695)
### First-Class Providers
These changes implement support for first-class providers. First-class
providers are provider plugins that are exposed as resources via the
Pulumi programming model so that they may be explicitly and multiply
instantiated. Each instance of a provider resource may be configured
differently, and configuration parameters may be source from the
outputs of other resources.
### Provider Plugin Changes
In order to accommodate the need to verify and diff provider
configuration and configure providers without complete configuration
information, these changes adjust the high-level provider plugin
interface. Two new methods for validating a provider's configuration
and diffing changes to the same have been added (`CheckConfig` and
`DiffConfig`, respectively), and the type of the configuration bag
accepted by `Configure` has been changed to a `PropertyMap`.
These changes have not yet been reflected in the provider plugin gRPC
interface. We will do this in a set of follow-up changes. Until then,
these methods are implemented by adapters:
- `CheckConfig` validates that all configuration parameters are string
or unknown properties. This is necessary because existing plugins
only accept string-typed configuration values.
- `DiffConfig` either returns "never replace" if all configuration
values are known or "must replace" if any configuration value is
unknown. The justification for this behavior is given
[here](https://github.com/pulumi/pulumi/pull/1695/files#diff-a6cd5c7f337665f5bb22e92ca5f07537R106)
- `Configure` converts the config bag to a legacy config map and
configures the provider plugin if all config values are known. If any
config value is unknown, the underlying plugin is not configured and
the provider may only perform `Check`, `Read`, and `Invoke`, all of
which return empty results. We justify this behavior becuase it is
only possible during a preview and provides the best experience we
can manage with the existing gRPC interface.
### Resource Model Changes
Providers are now exposed as resources that participate in a stack's
dependency graph. Like other resources, they are explicitly created,
may have multiple instances, and may have dependencies on other
resources. Providers are referred to using provider references, which
are a combination of the provider's URN and its ID. This design
addresses the need during a preview to refer to providers that have not
yet been physically created and therefore have no ID.
All custom resources that are not themselves providers must specify a
single provider via a provider reference. The named provider will be
used to manage that resource's CRUD operations. If a resource's
provider reference changes, the resource must be replaced. Though its
URN is not present in the resource's dependency list, the provider
should be treated as a dependency of the resource when topologically
sorting the dependency graph.
Finally, `Invoke` operations must now specify a provider to use for the
invocation via a provider reference.
### Engine Changes
First-class providers support requires a few changes to the engine:
- The engine must have some way to map from provider references to
provider plugins. It must be possible to add providers from a stack's
checkpoint to this map and to register new/updated providers during
the execution of a plan in response to CRUD operations on provider
resources.
- In order to support updating existing stacks using existing Pulumi
programs that may not explicitly instantiate providers, the engine
must be able to manage the "default" providers for each package
referenced by a checkpoint or Pulumi program. The configuration for
a "default" provider is taken from the stack's configuration data.
The former need is addressed by adding a provider registry type that is
responsible for managing all of the plugins required by a plan. In
addition to loading plugins froma checkpoint and providing the ability
to map from a provider reference to a provider plugin, this type serves
as the provider plugin for providers themselves (i.e. it is the
"provider provider").
The latter need is solved via two relatively self-contained changes to
plan setup and the eval source.
During plan setup, the old checkpoint is scanned for custom resources
that do not have a provider reference in order to compute the set of
packages that require a default provider. Once this set has been
computed, the required default provider definitions are conjured and
prepended to the checkpoint's resource list. Each resource that
requires a default provider is then updated to refer to the default
provider for its package.
While an eval source is running, each custom resource registration,
resource read, and invoke that does not name a provider is trapped
before being returned by the source iterator. If no default provider
for the appropriate package has been registered, the eval source
synthesizes an appropriate registration, waits for it to complete, and
records the registered provider's reference. This reference is injected
into the original request, which is then processed as usual. If a
default provider was already registered, the recorded reference is
used and no new registration occurs.
### SDK Changes
These changes only expose first-class providers from the Node.JS SDK.
- A new abstract class, `ProviderResource`, can be subclassed and used
to instantiate first-class providers.
- A new field in `ResourceOptions`, `provider`, can be used to supply
a particular provider instance to manage a `CustomResource`'s CRUD
operations.
- A new type, `InvokeOptions`, can be used to specify options that
control the behavior of a call to `pulumi.runtime.invoke`. This type
includes a `provider` field that is analogous to
`ResourceOptions.provider`.
2018-08-07 02:50:29 +02:00
|
|
|
urn := sg.plan.generateURN(event.Parent(), event.Type(), event.Name())
|
2018-08-03 23:06:00 +02:00
|
|
|
newState := resource.NewState(event.Type(),
|
|
|
|
urn,
|
|
|
|
true, /*custom*/
|
|
|
|
false, /*delete*/
|
|
|
|
event.ID(),
|
|
|
|
event.Properties(),
|
|
|
|
make(resource.PropertyMap), /* outputs */
|
|
|
|
event.Parent(),
|
|
|
|
false, /*protect*/
|
|
|
|
true, /*external*/
|
|
|
|
event.Dependencies(),
|
Implement first-class providers. (#1695)
### First-Class Providers
These changes implement support for first-class providers. First-class
providers are provider plugins that are exposed as resources via the
Pulumi programming model so that they may be explicitly and multiply
instantiated. Each instance of a provider resource may be configured
differently, and configuration parameters may be source from the
outputs of other resources.
### Provider Plugin Changes
In order to accommodate the need to verify and diff provider
configuration and configure providers without complete configuration
information, these changes adjust the high-level provider plugin
interface. Two new methods for validating a provider's configuration
and diffing changes to the same have been added (`CheckConfig` and
`DiffConfig`, respectively), and the type of the configuration bag
accepted by `Configure` has been changed to a `PropertyMap`.
These changes have not yet been reflected in the provider plugin gRPC
interface. We will do this in a set of follow-up changes. Until then,
these methods are implemented by adapters:
- `CheckConfig` validates that all configuration parameters are string
or unknown properties. This is necessary because existing plugins
only accept string-typed configuration values.
- `DiffConfig` either returns "never replace" if all configuration
values are known or "must replace" if any configuration value is
unknown. The justification for this behavior is given
[here](https://github.com/pulumi/pulumi/pull/1695/files#diff-a6cd5c7f337665f5bb22e92ca5f07537R106)
- `Configure` converts the config bag to a legacy config map and
configures the provider plugin if all config values are known. If any
config value is unknown, the underlying plugin is not configured and
the provider may only perform `Check`, `Read`, and `Invoke`, all of
which return empty results. We justify this behavior becuase it is
only possible during a preview and provides the best experience we
can manage with the existing gRPC interface.
### Resource Model Changes
Providers are now exposed as resources that participate in a stack's
dependency graph. Like other resources, they are explicitly created,
may have multiple instances, and may have dependencies on other
resources. Providers are referred to using provider references, which
are a combination of the provider's URN and its ID. This design
addresses the need during a preview to refer to providers that have not
yet been physically created and therefore have no ID.
All custom resources that are not themselves providers must specify a
single provider via a provider reference. The named provider will be
used to manage that resource's CRUD operations. If a resource's
provider reference changes, the resource must be replaced. Though its
URN is not present in the resource's dependency list, the provider
should be treated as a dependency of the resource when topologically
sorting the dependency graph.
Finally, `Invoke` operations must now specify a provider to use for the
invocation via a provider reference.
### Engine Changes
First-class providers support requires a few changes to the engine:
- The engine must have some way to map from provider references to
provider plugins. It must be possible to add providers from a stack's
checkpoint to this map and to register new/updated providers during
the execution of a plan in response to CRUD operations on provider
resources.
- In order to support updating existing stacks using existing Pulumi
programs that may not explicitly instantiate providers, the engine
must be able to manage the "default" providers for each package
referenced by a checkpoint or Pulumi program. The configuration for
a "default" provider is taken from the stack's configuration data.
The former need is addressed by adding a provider registry type that is
responsible for managing all of the plugins required by a plan. In
addition to loading plugins froma checkpoint and providing the ability
to map from a provider reference to a provider plugin, this type serves
as the provider plugin for providers themselves (i.e. it is the
"provider provider").
The latter need is solved via two relatively self-contained changes to
plan setup and the eval source.
During plan setup, the old checkpoint is scanned for custom resources
that do not have a provider reference in order to compute the set of
packages that require a default provider. Once this set has been
computed, the required default provider definitions are conjured and
prepended to the checkpoint's resource list. Each resource that
requires a default provider is then updated to refer to the default
provider for its package.
While an eval source is running, each custom resource registration,
resource read, and invoke that does not name a provider is trapped
before being returned by the source iterator. If no default provider
for the appropriate package has been registered, the eval source
synthesizes an appropriate registration, waits for it to complete, and
records the registered provider's reference. This reference is injected
into the original request, which is then processed as usual. If a
default provider was already registered, the recorded reference is
used and no new registration occurs.
### SDK Changes
These changes only expose first-class providers from the Node.JS SDK.
- A new abstract class, `ProviderResource`, can be subclassed and used
to instantiate first-class providers.
- A new field in `ResourceOptions`, `provider`, can be used to supply
a particular provider instance to manage a `CustomResource`'s CRUD
operations.
- A new type, `InvokeOptions`, can be used to specify options that
control the behavior of a call to `pulumi.runtime.invoke`. This type
includes a `provider` field that is analogous to
`ResourceOptions.provider`.
2018-08-07 02:50:29 +02:00
|
|
|
nil, /* initErrors */
|
Implement more precise delete-before-replace semantics. (#2369)
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.
2019-01-28 18:46:30 +01:00
|
|
|
event.Provider(),
|
2019-04-23 02:45:26 +02:00
|
|
|
nil, /* propertyDependencies */
|
|
|
|
false, /* deleteBeforeCreate */
|
2019-06-01 08:01:01 +02:00
|
|
|
event.AdditionalSecretOutputs(),
|
|
|
|
nil, /* aliases */
|
Addition of Custom Timeouts (#2885)
* Plumbing the custom timeouts from the engine to the providers
* Plumbing the CustomTimeouts through to the engine and adding test to show this
* Change the provider proto to include individual timeouts
* Plumbing the CustomTimeouts from the engine through to the Provider RPC interface
* Change how the CustomTimeouts are sent across RPC
These errors were spotted in testing. We can now see that the timeout
information is arriving in the RegisterResourceRequest
```
req=&pulumirpc.RegisterResourceRequest{
Type: "aws:s3/bucket:Bucket",
Name: "my-bucket",
Parent: "urn:pulumi:dev::aws-vpc::pulumi:pulumi:Stack::aws-vpc-dev",
Custom: true,
Object: &structpb.Struct{},
Protect: false,
Dependencies: nil,
Provider: "",
PropertyDependencies: {},
DeleteBeforeReplace: false,
Version: "",
IgnoreChanges: nil,
AcceptSecrets: true,
AdditionalSecretOutputs: nil,
Aliases: nil,
CustomTimeouts: &pulumirpc.RegisterResourceRequest_CustomTimeouts{
Create: 300,
Update: 400,
Delete: 500,
XXX_NoUnkeyedLiteral: struct {}{},
XXX_unrecognized: nil,
XXX_sizecache: 0,
},
XXX_NoUnkeyedLiteral: struct {}{},
XXX_unrecognized: nil,
XXX_sizecache: 0,
}
```
* Changing the design to use strings
* CHANGELOG entry to include the CustomTimeouts work
* Changing custom timeouts to be passed around the engine as converted value
We don't want to pass around strings - the user can provide it but we want
to make the engine aware of the timeout in seconds as a float64
2019-07-15 23:26:28 +02:00
|
|
|
nil, /* customTimeouts */
|
2019-06-01 08:01:01 +02:00
|
|
|
)
|
2018-08-03 23:06:00 +02:00
|
|
|
old, hasOld := sg.plan.Olds()[urn]
|
|
|
|
|
|
|
|
// If the snapshot has an old resource for this URN and it's not external, we're going
|
|
|
|
// to have to delete the old resource and conceptually replace it with the resource we
|
|
|
|
// are about to read.
|
|
|
|
//
|
|
|
|
// We accomplish this through the "read-replacement" step, which atomically reads a resource
|
|
|
|
// and marks the resource it is replacing as pending deletion.
|
|
|
|
//
|
|
|
|
// In the event that the new "read" resource's ID matches the existing resource,
|
|
|
|
// we do not need to delete the resource - we know exactly what resource we are going
|
|
|
|
// to get from the read.
|
|
|
|
//
|
|
|
|
// This operation is tenatively called "relinquish" - it semantically represents the
|
|
|
|
// release of a resource from the management of Pulumi.
|
|
|
|
if hasOld && !old.External && old.ID != event.ID() {
|
|
|
|
logging.V(7).Infof(
|
|
|
|
"stepGenerator.GenerateReadSteps(...): replacing existing resource %s, ids don't match", urn)
|
|
|
|
sg.replaces[urn] = true
|
|
|
|
return []Step{
|
|
|
|
NewReadReplacementStep(sg.plan, event, old, newState),
|
2019-07-01 21:34:19 +02:00
|
|
|
NewReplaceStep(sg.plan, old, newState, nil, nil, nil, true),
|
2018-08-03 23:06:00 +02:00
|
|
|
}, nil
|
|
|
|
}
|
|
|
|
|
2018-08-23 02:52:46 +02:00
|
|
|
if bool(logging.V(7)) && hasOld && old.ID == event.ID() {
|
2018-08-03 23:06:00 +02:00
|
|
|
logging.V(7).Infof("stepGenerator.GenerateReadSteps(...): recognized relinquish of resource %s", urn)
|
|
|
|
}
|
|
|
|
|
|
|
|
sg.reads[urn] = true
|
|
|
|
return []Step{
|
|
|
|
NewReadStep(sg.plan, event, old, newState),
|
|
|
|
}, nil
|
|
|
|
}
|
|
|
|
|
2018-07-12 23:24:38 +02:00
|
|
|
// GenerateSteps produces one or more steps required to achieve the goal state
|
|
|
|
// specified by the incoming RegisterResourceEvent.
|
|
|
|
//
|
|
|
|
// If the given resource is a custom resource, the step generator will invoke Diff
|
|
|
|
// and Check on the provider associated with that resource. If those fail, an error
|
|
|
|
// is returned.
|
2019-03-19 20:40:10 +01:00
|
|
|
func (sg *stepGenerator) GenerateSteps(event RegisterResourceEvent) ([]Step, result.Result) {
|
2018-07-12 23:24:38 +02:00
|
|
|
var invalid bool // will be set to true if this object fails validation.
|
|
|
|
|
|
|
|
goal := event.Goal()
|
|
|
|
// generate an URN for this new resource.
|
Implement first-class providers. (#1695)
### First-Class Providers
These changes implement support for first-class providers. First-class
providers are provider plugins that are exposed as resources via the
Pulumi programming model so that they may be explicitly and multiply
instantiated. Each instance of a provider resource may be configured
differently, and configuration parameters may be source from the
outputs of other resources.
### Provider Plugin Changes
In order to accommodate the need to verify and diff provider
configuration and configure providers without complete configuration
information, these changes adjust the high-level provider plugin
interface. Two new methods for validating a provider's configuration
and diffing changes to the same have been added (`CheckConfig` and
`DiffConfig`, respectively), and the type of the configuration bag
accepted by `Configure` has been changed to a `PropertyMap`.
These changes have not yet been reflected in the provider plugin gRPC
interface. We will do this in a set of follow-up changes. Until then,
these methods are implemented by adapters:
- `CheckConfig` validates that all configuration parameters are string
or unknown properties. This is necessary because existing plugins
only accept string-typed configuration values.
- `DiffConfig` either returns "never replace" if all configuration
values are known or "must replace" if any configuration value is
unknown. The justification for this behavior is given
[here](https://github.com/pulumi/pulumi/pull/1695/files#diff-a6cd5c7f337665f5bb22e92ca5f07537R106)
- `Configure` converts the config bag to a legacy config map and
configures the provider plugin if all config values are known. If any
config value is unknown, the underlying plugin is not configured and
the provider may only perform `Check`, `Read`, and `Invoke`, all of
which return empty results. We justify this behavior becuase it is
only possible during a preview and provides the best experience we
can manage with the existing gRPC interface.
### Resource Model Changes
Providers are now exposed as resources that participate in a stack's
dependency graph. Like other resources, they are explicitly created,
may have multiple instances, and may have dependencies on other
resources. Providers are referred to using provider references, which
are a combination of the provider's URN and its ID. This design
addresses the need during a preview to refer to providers that have not
yet been physically created and therefore have no ID.
All custom resources that are not themselves providers must specify a
single provider via a provider reference. The named provider will be
used to manage that resource's CRUD operations. If a resource's
provider reference changes, the resource must be replaced. Though its
URN is not present in the resource's dependency list, the provider
should be treated as a dependency of the resource when topologically
sorting the dependency graph.
Finally, `Invoke` operations must now specify a provider to use for the
invocation via a provider reference.
### Engine Changes
First-class providers support requires a few changes to the engine:
- The engine must have some way to map from provider references to
provider plugins. It must be possible to add providers from a stack's
checkpoint to this map and to register new/updated providers during
the execution of a plan in response to CRUD operations on provider
resources.
- In order to support updating existing stacks using existing Pulumi
programs that may not explicitly instantiate providers, the engine
must be able to manage the "default" providers for each package
referenced by a checkpoint or Pulumi program. The configuration for
a "default" provider is taken from the stack's configuration data.
The former need is addressed by adding a provider registry type that is
responsible for managing all of the plugins required by a plan. In
addition to loading plugins froma checkpoint and providing the ability
to map from a provider reference to a provider plugin, this type serves
as the provider plugin for providers themselves (i.e. it is the
"provider provider").
The latter need is solved via two relatively self-contained changes to
plan setup and the eval source.
During plan setup, the old checkpoint is scanned for custom resources
that do not have a provider reference in order to compute the set of
packages that require a default provider. Once this set has been
computed, the required default provider definitions are conjured and
prepended to the checkpoint's resource list. Each resource that
requires a default provider is then updated to refer to the default
provider for its package.
While an eval source is running, each custom resource registration,
resource read, and invoke that does not name a provider is trapped
before being returned by the source iterator. If no default provider
for the appropriate package has been registered, the eval source
synthesizes an appropriate registration, waits for it to complete, and
records the registered provider's reference. This reference is injected
into the original request, which is then processed as usual. If a
default provider was already registered, the recorded reference is
used and no new registration occurs.
### SDK Changes
These changes only expose first-class providers from the Node.JS SDK.
- A new abstract class, `ProviderResource`, can be subclassed and used
to instantiate first-class providers.
- A new field in `ResourceOptions`, `provider`, can be used to supply
a particular provider instance to manage a `CustomResource`'s CRUD
operations.
- A new type, `InvokeOptions`, can be used to specify options that
control the behavior of a call to `pulumi.runtime.invoke`. This type
includes a `provider` field that is analogous to
`ResourceOptions.provider`.
2018-08-07 02:50:29 +02:00
|
|
|
urn := sg.plan.generateURN(goal.Parent, goal.Type, goal.Name)
|
2018-07-12 23:24:38 +02:00
|
|
|
if sg.urns[urn] {
|
|
|
|
invalid = true
|
|
|
|
// TODO[pulumi/pulumi-framework#19]: improve this error message!
|
2018-08-31 21:33:01 +02:00
|
|
|
sg.plan.Diag().Errorf(diag.GetDuplicateResourceURNError(urn), urn)
|
2018-07-12 23:24:38 +02:00
|
|
|
}
|
2018-08-02 06:32:29 +02:00
|
|
|
sg.urns[urn] = true
|
2018-07-12 23:24:38 +02:00
|
|
|
|
2019-06-01 08:01:01 +02:00
|
|
|
// Check for an old resource so that we can figure out if this is a create, delete, etc., and/or to diff. We look
|
|
|
|
// up first by URN and then by any provided aliases. If it is found using an alias, record that alias so that we do
|
|
|
|
// not delete the aliased resource later.
|
2018-07-12 23:24:38 +02:00
|
|
|
var oldInputs resource.PropertyMap
|
|
|
|
var oldOutputs resource.PropertyMap
|
2019-06-01 08:01:01 +02:00
|
|
|
var old *resource.State
|
|
|
|
var hasOld bool
|
|
|
|
for _, urnOrAlias := range append([]resource.URN{urn}, goal.Aliases...) {
|
|
|
|
old, hasOld = sg.plan.Olds()[urnOrAlias]
|
|
|
|
if hasOld {
|
|
|
|
oldInputs = old.Inputs
|
|
|
|
oldOutputs = old.Outputs
|
|
|
|
if urnOrAlias != urn {
|
|
|
|
if previousAliasURN, alreadyAliased := sg.aliased[urnOrAlias]; alreadyAliased {
|
|
|
|
invalid = true
|
|
|
|
sg.plan.Diag().Errorf(diag.GetDuplicateResourceAliasError(urn), urnOrAlias, urn, previousAliasURN)
|
|
|
|
}
|
|
|
|
sg.aliased[urnOrAlias] = urn
|
|
|
|
}
|
|
|
|
break
|
|
|
|
}
|
2018-07-12 23:24:38 +02:00
|
|
|
}
|
|
|
|
|
2019-04-22 22:54:48 +02:00
|
|
|
// Create the desired inputs from the goal state
|
|
|
|
inputs := goal.Properties
|
|
|
|
if hasOld {
|
|
|
|
// Set inputs back to their old values (if any) for any "ignored" properties
|
2019-07-31 18:39:07 +02:00
|
|
|
processedInputs, res := processIgnoreChanges(inputs, oldInputs, goal.IgnoreChanges)
|
|
|
|
if res != nil {
|
|
|
|
return nil, res
|
|
|
|
}
|
|
|
|
inputs = processedInputs
|
2019-04-22 22:54:48 +02:00
|
|
|
}
|
|
|
|
|
2018-07-12 23:24:38 +02:00
|
|
|
// Produce a new state object that we'll build up as operations are performed. Ultimately, this is what will
|
2018-08-23 02:52:46 +02:00
|
|
|
// get serialized into the checkpoint file.
|
|
|
|
new := resource.NewState(goal.Type, urn, goal.Custom, false, "", inputs, nil, goal.Parent, goal.Protect, false,
|
2019-06-01 08:01:01 +02:00
|
|
|
goal.Dependencies, goal.InitErrors, goal.Provider, goal.PropertyDependencies, false,
|
Addition of Custom Timeouts (#2885)
* Plumbing the custom timeouts from the engine to the providers
* Plumbing the CustomTimeouts through to the engine and adding test to show this
* Change the provider proto to include individual timeouts
* Plumbing the CustomTimeouts from the engine through to the Provider RPC interface
* Change how the CustomTimeouts are sent across RPC
These errors were spotted in testing. We can now see that the timeout
information is arriving in the RegisterResourceRequest
```
req=&pulumirpc.RegisterResourceRequest{
Type: "aws:s3/bucket:Bucket",
Name: "my-bucket",
Parent: "urn:pulumi:dev::aws-vpc::pulumi:pulumi:Stack::aws-vpc-dev",
Custom: true,
Object: &structpb.Struct{},
Protect: false,
Dependencies: nil,
Provider: "",
PropertyDependencies: {},
DeleteBeforeReplace: false,
Version: "",
IgnoreChanges: nil,
AcceptSecrets: true,
AdditionalSecretOutputs: nil,
Aliases: nil,
CustomTimeouts: &pulumirpc.RegisterResourceRequest_CustomTimeouts{
Create: 300,
Update: 400,
Delete: 500,
XXX_NoUnkeyedLiteral: struct {}{},
XXX_unrecognized: nil,
XXX_sizecache: 0,
},
XXX_NoUnkeyedLiteral: struct {}{},
XXX_unrecognized: nil,
XXX_sizecache: 0,
}
```
* Changing the design to use strings
* CHANGELOG entry to include the CustomTimeouts work
* Changing custom timeouts to be passed around the engine as converted value
We don't want to pass around strings - the user can provide it but we want
to make the engine aware of the timeout in seconds as a float64
2019-07-15 23:26:28 +02:00
|
|
|
goal.AdditionalSecretOutputs, goal.Aliases, &goal.CustomTimeouts)
|
Implement more precise delete-before-replace semantics. (#2369)
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.
2019-01-28 18:46:30 +01:00
|
|
|
|
Refine resource replacement logic for providers (#2767)
This commit touches an intersection of a few different provider-oriented
features that combined to cause a particularly severe bug that made it
impossible for users to upgrade provider versions without seeing
replacements with their resources.
For some context, Pulumi models all providers as resources and places
them in the snapshot like any other resource. Every resource has a
reference to the provider that created it. If a Pulumi program does not
specify a particular provider to use when performing a resource
operation, the Pulumi engine injects one automatically; these are called
"default providers" and are the most common ways that users end up with
providers in their snapshot. Default providers can be identified by
their name, which is always prefixed with "default".
Recently, in an effort to make the Pulumi engine more flexible with
provider versions, it was made possible for the engine to have multiple
default providers active for a provider of a particular type, which was
previously not possible. Because a provider is identified as a tuple of
package name and version, it was difficult to find a name for these
duplicate default providers that did not cause additional problems. The
provider versioning PR gave these default providers a name that was
derived from the version of the package. This proved to be a problem,
because when users upgraded from one version of a package to another,
this changed the name of their default provider which in turn caused all
of their resources created using that provider (read: everything) to be
replaced.
To combat this, this PR introduces a rule that the engine will apply
when diffing a resource to determine whether or not it needs to be
replaced: "If a resource's provider changes, and both old and new
providers are default providers whose properties do not require
replacement, proceed as if there were no diff." This allows the engine
to gracefully recognize and recover when a resource's default provider changes
names, as long as the provider's config has not changed.
2019-06-03 21:16:31 +02:00
|
|
|
// Is this thing a provider resource? If so, stash it - we might need it later when calculating replacement
|
|
|
|
// of resources that use this provider.
|
|
|
|
if providers.IsProviderType(goal.Type) {
|
|
|
|
sg.providers[urn] = new
|
|
|
|
}
|
|
|
|
|
Implement more precise delete-before-replace semantics. (#2369)
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.
2019-01-28 18:46:30 +01:00
|
|
|
// Fetch the provider for this resource.
|
2019-03-21 21:23:46 +01:00
|
|
|
prov, res := sg.loadResourceProvider(urn, goal.Custom, goal.Provider, goal.Type)
|
|
|
|
if res != nil {
|
|
|
|
return nil, res
|
2018-07-12 23:24:38 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
// We only allow unknown property values to be exposed to the provider if we are performing an update preview.
|
2018-08-23 02:52:46 +02:00
|
|
|
allowUnknowns := sg.plan.preview
|
2018-07-12 23:24:38 +02:00
|
|
|
|
|
|
|
// We may be re-creating this resource if it got deleted earlier in the execution of this plan.
|
|
|
|
_, recreating := sg.deletes[urn]
|
|
|
|
|
2018-08-03 23:06:00 +02:00
|
|
|
// We may be creating this resource if it previously existed in the snapshot as an External resource
|
|
|
|
wasExternal := hasOld && old.External
|
|
|
|
|
2019-07-12 20:12:01 +02:00
|
|
|
// If the goal contains an ID, this may be an import. An import occurs if there is no old resource or if the old
|
|
|
|
// resource's ID does not match the ID in the goal state.
|
|
|
|
isImport := goal.Custom && goal.ID != "" && (!hasOld || old.External || old.ID != goal.ID)
|
|
|
|
if isImport {
|
|
|
|
// Write the ID of the resource to import into the new state and return an ImportStep or an
|
|
|
|
// ImportReplacementStep
|
|
|
|
new.ID = goal.ID
|
|
|
|
if isReplace := hasOld && !recreating; isReplace {
|
|
|
|
return []Step{
|
2019-07-31 18:39:07 +02:00
|
|
|
NewImportReplacementStep(sg.plan, event, old, new, goal.IgnoreChanges),
|
2019-07-12 20:12:01 +02:00
|
|
|
NewReplaceStep(sg.plan, old, new, nil, nil, nil, true),
|
|
|
|
}, nil
|
|
|
|
}
|
2019-07-31 18:39:07 +02:00
|
|
|
return []Step{NewImportStep(sg.plan, event, new, goal.IgnoreChanges)}, nil
|
2019-07-12 20:12:01 +02:00
|
|
|
}
|
|
|
|
|
2018-08-23 02:52:46 +02:00
|
|
|
// Ensure the provider is okay with this resource and fetch the inputs to pass to subsequent methods.
|
2019-03-21 21:23:46 +01:00
|
|
|
var err error
|
2018-08-23 02:52:46 +02:00
|
|
|
if prov != nil {
|
2018-07-12 23:24:38 +02:00
|
|
|
var failures []plugin.CheckFailure
|
|
|
|
|
|
|
|
// If we are re-creating this resource because it was deleted earlier, the old inputs are now
|
2018-08-03 23:06:00 +02:00
|
|
|
// invalid (they got deleted) so don't consider them. Similarly, if the old resource was External,
|
|
|
|
// don't consider those inputs since Pulumi does not own them.
|
|
|
|
if recreating || wasExternal {
|
2018-07-12 23:24:38 +02:00
|
|
|
inputs, failures, err = prov.Check(urn, nil, goal.Properties, allowUnknowns)
|
|
|
|
} else {
|
|
|
|
inputs, failures, err = prov.Check(urn, oldInputs, inputs, allowUnknowns)
|
|
|
|
}
|
|
|
|
|
|
|
|
if err != nil {
|
2018-09-06 00:08:09 +02:00
|
|
|
return nil, result.FromError(err)
|
2019-07-12 20:12:01 +02:00
|
|
|
} else if issueCheckErrors(sg.plan, new, urn, failures) {
|
2018-07-12 23:24:38 +02:00
|
|
|
invalid = true
|
|
|
|
}
|
|
|
|
new.Inputs = inputs
|
|
|
|
}
|
|
|
|
|
2019-08-11 09:39:03 +02:00
|
|
|
// Load all policy packs into the plugin host.
|
|
|
|
for _, path := range sg.plan.localPolicyPackPaths {
|
|
|
|
abs, err := filepath.Abs(path)
|
|
|
|
if err != nil {
|
|
|
|
return nil, result.FromError(err)
|
|
|
|
}
|
|
|
|
|
2018-07-12 23:24:38 +02:00
|
|
|
var analyzer plugin.Analyzer
|
2019-08-11 09:39:03 +02:00
|
|
|
analyzer, err = sg.plan.ctx.Host.PolicyAnalyzer(tokens.QName(abs), path)
|
2018-07-12 23:24:38 +02:00
|
|
|
if err != nil {
|
2018-09-06 00:08:09 +02:00
|
|
|
return nil, result.FromError(err)
|
2018-07-12 23:24:38 +02:00
|
|
|
} else if analyzer == nil {
|
2019-08-11 09:39:03 +02:00
|
|
|
return nil, result.Errorf("analyzer could not be loaded from path '%s'", path)
|
2018-07-12 23:24:38 +02:00
|
|
|
}
|
2019-07-01 01:34:39 +02:00
|
|
|
}
|
|
|
|
|
2019-08-11 09:39:03 +02:00
|
|
|
// Get the final list of policy packs.
|
|
|
|
analyzers := sg.plan.ctx.Host.ListAnalyzers()
|
|
|
|
|
2019-07-01 01:34:39 +02:00
|
|
|
for _, analyzer := range analyzers {
|
2019-06-11 00:20:44 +02:00
|
|
|
var diagnostics []plugin.AnalyzeDiagnostic
|
|
|
|
diagnostics, err = analyzer.Analyze(new.Type, inputs)
|
2018-07-12 23:24:38 +02:00
|
|
|
if err != nil {
|
2018-09-06 00:08:09 +02:00
|
|
|
return nil, result.FromError(err)
|
2018-07-12 23:24:38 +02:00
|
|
|
}
|
2019-06-11 00:20:44 +02:00
|
|
|
for _, d := range diagnostics {
|
|
|
|
// TODO(hausdorff): Batch up failures and report them all at once during preview. This
|
|
|
|
// will cause them to fail eagerly.
|
|
|
|
if d.EnforcementLevel == apitype.Mandatory {
|
2019-07-23 02:25:25 +02:00
|
|
|
if !sg.plan.preview {
|
|
|
|
invalid = true
|
|
|
|
}
|
|
|
|
sg.hasPolicyViolations = true
|
2019-06-11 00:20:44 +02:00
|
|
|
}
|
|
|
|
sg.opts.Events.OnPolicyViolation(new.URN, d)
|
2018-07-12 23:24:38 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// If the resource isn't valid, don't proceed any further.
|
|
|
|
if invalid {
|
2018-09-06 00:08:09 +02:00
|
|
|
return nil, result.Bail()
|
2018-07-12 23:24:38 +02:00
|
|
|
}
|
|
|
|
|
2018-08-03 23:06:00 +02:00
|
|
|
// There are four cases we need to consider when figuring out what to do with this resource.
|
2018-07-12 23:24:38 +02:00
|
|
|
//
|
|
|
|
// Case 1: recreating
|
|
|
|
// In this case, we have seen a resource with this URN before and we have already issued a
|
|
|
|
// delete step for it. This happens when the engine has to delete a resource before it has
|
|
|
|
// enough information about whether that resource still exists. A concrete example is
|
|
|
|
// when a resource depends on a resource that is delete-before-replace: the engine must first
|
|
|
|
// delete the dependent resource before depending the DBR resource, but the engine can't know
|
|
|
|
// yet whether the dependent resource is being replaced or deleted.
|
|
|
|
//
|
|
|
|
// In this case, we are seeing the resource again after deleting it, so it must be a replacement.
|
|
|
|
//
|
|
|
|
// Logically, recreating implies hasOld, since in order to delete something it must have
|
|
|
|
// already existed.
|
|
|
|
contract.Assert(!recreating || hasOld)
|
|
|
|
if recreating {
|
|
|
|
logging.V(7).Infof("Planner decided to re-create replaced resource '%v' deleted due to dependent DBR", urn)
|
|
|
|
|
|
|
|
// Unmark this resource as deleted, we now know it's being replaced instead.
|
|
|
|
delete(sg.deletes, urn)
|
|
|
|
sg.replaces[urn] = true
|
Implement more precise delete-before-replace semantics. (#2369)
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.
2019-01-28 18:46:30 +01:00
|
|
|
keys := sg.dependentReplaceKeys[urn]
|
2018-07-12 23:24:38 +02:00
|
|
|
return []Step{
|
2019-07-01 21:34:19 +02:00
|
|
|
NewReplaceStep(sg.plan, old, new, nil, nil, nil, false),
|
|
|
|
NewCreateReplacementStep(sg.plan, event, old, new, keys, nil, nil, false),
|
2018-07-12 23:24:38 +02:00
|
|
|
}, nil
|
|
|
|
}
|
|
|
|
|
2018-08-03 23:06:00 +02:00
|
|
|
// Case 2: wasExternal
|
|
|
|
// In this case, the resource we are operating upon exists in the old snapshot, but it
|
|
|
|
// was "external" - Pulumi does not own its lifecycle. Conceptually, this operation is
|
|
|
|
// akin to "taking ownership" of a resource that we did not previously control.
|
|
|
|
//
|
|
|
|
// Since we are not allowed to manipulate the existing resource, we must create a resource
|
|
|
|
// to take its place. Since this is technically a replacement operation, we pend deletion of
|
|
|
|
// read until the end of the plan.
|
|
|
|
if wasExternal {
|
|
|
|
logging.V(7).Infof("Planner recognized '%s' as old external resource, creating instead", urn)
|
|
|
|
sg.creates[urn] = true
|
|
|
|
if err != nil {
|
2018-09-06 00:08:09 +02:00
|
|
|
return nil, result.FromError(err)
|
2018-08-03 23:06:00 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return []Step{
|
2019-07-01 21:34:19 +02:00
|
|
|
NewCreateReplacementStep(sg.plan, event, old, new, nil, nil, nil, true),
|
|
|
|
NewReplaceStep(sg.plan, old, new, nil, nil, nil, true),
|
2018-08-03 23:06:00 +02:00
|
|
|
}, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// Case 3: hasOld
|
2018-07-12 23:24:38 +02:00
|
|
|
// In this case, the resource we are operating upon now exists in the old snapshot.
|
Implement first-class providers. (#1695)
### First-Class Providers
These changes implement support for first-class providers. First-class
providers are provider plugins that are exposed as resources via the
Pulumi programming model so that they may be explicitly and multiply
instantiated. Each instance of a provider resource may be configured
differently, and configuration parameters may be source from the
outputs of other resources.
### Provider Plugin Changes
In order to accommodate the need to verify and diff provider
configuration and configure providers without complete configuration
information, these changes adjust the high-level provider plugin
interface. Two new methods for validating a provider's configuration
and diffing changes to the same have been added (`CheckConfig` and
`DiffConfig`, respectively), and the type of the configuration bag
accepted by `Configure` has been changed to a `PropertyMap`.
These changes have not yet been reflected in the provider plugin gRPC
interface. We will do this in a set of follow-up changes. Until then,
these methods are implemented by adapters:
- `CheckConfig` validates that all configuration parameters are string
or unknown properties. This is necessary because existing plugins
only accept string-typed configuration values.
- `DiffConfig` either returns "never replace" if all configuration
values are known or "must replace" if any configuration value is
unknown. The justification for this behavior is given
[here](https://github.com/pulumi/pulumi/pull/1695/files#diff-a6cd5c7f337665f5bb22e92ca5f07537R106)
- `Configure` converts the config bag to a legacy config map and
configures the provider plugin if all config values are known. If any
config value is unknown, the underlying plugin is not configured and
the provider may only perform `Check`, `Read`, and `Invoke`, all of
which return empty results. We justify this behavior becuase it is
only possible during a preview and provides the best experience we
can manage with the existing gRPC interface.
### Resource Model Changes
Providers are now exposed as resources that participate in a stack's
dependency graph. Like other resources, they are explicitly created,
may have multiple instances, and may have dependencies on other
resources. Providers are referred to using provider references, which
are a combination of the provider's URN and its ID. This design
addresses the need during a preview to refer to providers that have not
yet been physically created and therefore have no ID.
All custom resources that are not themselves providers must specify a
single provider via a provider reference. The named provider will be
used to manage that resource's CRUD operations. If a resource's
provider reference changes, the resource must be replaced. Though its
URN is not present in the resource's dependency list, the provider
should be treated as a dependency of the resource when topologically
sorting the dependency graph.
Finally, `Invoke` operations must now specify a provider to use for the
invocation via a provider reference.
### Engine Changes
First-class providers support requires a few changes to the engine:
- The engine must have some way to map from provider references to
provider plugins. It must be possible to add providers from a stack's
checkpoint to this map and to register new/updated providers during
the execution of a plan in response to CRUD operations on provider
resources.
- In order to support updating existing stacks using existing Pulumi
programs that may not explicitly instantiate providers, the engine
must be able to manage the "default" providers for each package
referenced by a checkpoint or Pulumi program. The configuration for
a "default" provider is taken from the stack's configuration data.
The former need is addressed by adding a provider registry type that is
responsible for managing all of the plugins required by a plan. In
addition to loading plugins froma checkpoint and providing the ability
to map from a provider reference to a provider plugin, this type serves
as the provider plugin for providers themselves (i.e. it is the
"provider provider").
The latter need is solved via two relatively self-contained changes to
plan setup and the eval source.
During plan setup, the old checkpoint is scanned for custom resources
that do not have a provider reference in order to compute the set of
packages that require a default provider. Once this set has been
computed, the required default provider definitions are conjured and
prepended to the checkpoint's resource list. Each resource that
requires a default provider is then updated to refer to the default
provider for its package.
While an eval source is running, each custom resource registration,
resource read, and invoke that does not name a provider is trapped
before being returned by the source iterator. If no default provider
for the appropriate package has been registered, the eval source
synthesizes an appropriate registration, waits for it to complete, and
records the registered provider's reference. This reference is injected
into the original request, which is then processed as usual. If a
default provider was already registered, the recorded reference is
used and no new registration occurs.
### SDK Changes
These changes only expose first-class providers from the Node.JS SDK.
- A new abstract class, `ProviderResource`, can be subclassed and used
to instantiate first-class providers.
- A new field in `ResourceOptions`, `provider`, can be used to supply
a particular provider instance to manage a `CustomResource`'s CRUD
operations.
- A new type, `InvokeOptions`, can be used to specify options that
control the behavior of a call to `pulumi.runtime.invoke`. This type
includes a `provider` field that is analogous to
`ResourceOptions.provider`.
2018-08-07 02:50:29 +02:00
|
|
|
// It must be an update or a replace. Which operation we do depends on the the specific change made to the
|
|
|
|
// resource's properties:
|
|
|
|
// - If the resource's provider reference changed, the resource must be replaced. This behavior is founded upon
|
|
|
|
// the assumption that providers are recreated iff their configuration changed in such a way that they are no
|
|
|
|
// longer able to manage existing resources.
|
|
|
|
// - Otherwise, we invoke the resource's provider's `Diff` method. If this method indicates that the resource must
|
|
|
|
// be replaced, we do so. If it does not, we update the resource in place.
|
2018-07-12 23:24:38 +02:00
|
|
|
if hasOld {
|
2019-06-01 08:01:01 +02:00
|
|
|
contract.Assert(old != nil)
|
2019-07-31 18:39:07 +02:00
|
|
|
diff, err := sg.diff(urn, old, new, oldInputs, oldOutputs, inputs, prov, allowUnknowns, goal.IgnoreChanges)
|
Refine resource replacement logic for providers (#2767)
This commit touches an intersection of a few different provider-oriented
features that combined to cause a particularly severe bug that made it
impossible for users to upgrade provider versions without seeing
replacements with their resources.
For some context, Pulumi models all providers as resources and places
them in the snapshot like any other resource. Every resource has a
reference to the provider that created it. If a Pulumi program does not
specify a particular provider to use when performing a resource
operation, the Pulumi engine injects one automatically; these are called
"default providers" and are the most common ways that users end up with
providers in their snapshot. Default providers can be identified by
their name, which is always prefixed with "default".
Recently, in an effort to make the Pulumi engine more flexible with
provider versions, it was made possible for the engine to have multiple
default providers active for a provider of a particular type, which was
previously not possible. Because a provider is identified as a tuple of
package name and version, it was difficult to find a name for these
duplicate default providers that did not cause additional problems. The
provider versioning PR gave these default providers a name that was
derived from the version of the package. This proved to be a problem,
because when users upgraded from one version of a package to another,
this changed the name of their default provider which in turn caused all
of their resources created using that provider (read: everything) to be
replaced.
To combat this, this PR introduces a rule that the engine will apply
when diffing a resource to determine whether or not it needs to be
replaced: "If a resource's provider changes, and both old and new
providers are default providers whose properties do not require
replacement, proceed as if there were no diff." This allows the engine
to gracefully recognize and recover when a resource's default provider changes
names, as long as the provider's config has not changed.
2019-06-03 21:16:31 +02:00
|
|
|
if err != nil {
|
|
|
|
// If the plugin indicated that the diff is unavailable, assume that the resource will be updated and
|
|
|
|
// report the message contained in the error.
|
|
|
|
if _, ok := err.(plugin.DiffUnavailableError); ok {
|
|
|
|
diff = plugin.DiffResult{Changes: plugin.DiffSome}
|
|
|
|
sg.plan.ctx.Diag.Warningf(diag.RawMessage(urn, err.Error()))
|
|
|
|
} else {
|
|
|
|
return nil, result.FromError(err)
|
Implement first-class providers. (#1695)
### First-Class Providers
These changes implement support for first-class providers. First-class
providers are provider plugins that are exposed as resources via the
Pulumi programming model so that they may be explicitly and multiply
instantiated. Each instance of a provider resource may be configured
differently, and configuration parameters may be source from the
outputs of other resources.
### Provider Plugin Changes
In order to accommodate the need to verify and diff provider
configuration and configure providers without complete configuration
information, these changes adjust the high-level provider plugin
interface. Two new methods for validating a provider's configuration
and diffing changes to the same have been added (`CheckConfig` and
`DiffConfig`, respectively), and the type of the configuration bag
accepted by `Configure` has been changed to a `PropertyMap`.
These changes have not yet been reflected in the provider plugin gRPC
interface. We will do this in a set of follow-up changes. Until then,
these methods are implemented by adapters:
- `CheckConfig` validates that all configuration parameters are string
or unknown properties. This is necessary because existing plugins
only accept string-typed configuration values.
- `DiffConfig` either returns "never replace" if all configuration
values are known or "must replace" if any configuration value is
unknown. The justification for this behavior is given
[here](https://github.com/pulumi/pulumi/pull/1695/files#diff-a6cd5c7f337665f5bb22e92ca5f07537R106)
- `Configure` converts the config bag to a legacy config map and
configures the provider plugin if all config values are known. If any
config value is unknown, the underlying plugin is not configured and
the provider may only perform `Check`, `Read`, and `Invoke`, all of
which return empty results. We justify this behavior becuase it is
only possible during a preview and provides the best experience we
can manage with the existing gRPC interface.
### Resource Model Changes
Providers are now exposed as resources that participate in a stack's
dependency graph. Like other resources, they are explicitly created,
may have multiple instances, and may have dependencies on other
resources. Providers are referred to using provider references, which
are a combination of the provider's URN and its ID. This design
addresses the need during a preview to refer to providers that have not
yet been physically created and therefore have no ID.
All custom resources that are not themselves providers must specify a
single provider via a provider reference. The named provider will be
used to manage that resource's CRUD operations. If a resource's
provider reference changes, the resource must be replaced. Though its
URN is not present in the resource's dependency list, the provider
should be treated as a dependency of the resource when topologically
sorting the dependency graph.
Finally, `Invoke` operations must now specify a provider to use for the
invocation via a provider reference.
### Engine Changes
First-class providers support requires a few changes to the engine:
- The engine must have some way to map from provider references to
provider plugins. It must be possible to add providers from a stack's
checkpoint to this map and to register new/updated providers during
the execution of a plan in response to CRUD operations on provider
resources.
- In order to support updating existing stacks using existing Pulumi
programs that may not explicitly instantiate providers, the engine
must be able to manage the "default" providers for each package
referenced by a checkpoint or Pulumi program. The configuration for
a "default" provider is taken from the stack's configuration data.
The former need is addressed by adding a provider registry type that is
responsible for managing all of the plugins required by a plan. In
addition to loading plugins froma checkpoint and providing the ability
to map from a provider reference to a provider plugin, this type serves
as the provider plugin for providers themselves (i.e. it is the
"provider provider").
The latter need is solved via two relatively self-contained changes to
plan setup and the eval source.
During plan setup, the old checkpoint is scanned for custom resources
that do not have a provider reference in order to compute the set of
packages that require a default provider. Once this set has been
computed, the required default provider definitions are conjured and
prepended to the checkpoint's resource list. Each resource that
requires a default provider is then updated to refer to the default
provider for its package.
While an eval source is running, each custom resource registration,
resource read, and invoke that does not name a provider is trapped
before being returned by the source iterator. If no default provider
for the appropriate package has been registered, the eval source
synthesizes an appropriate registration, waits for it to complete, and
records the registered provider's reference. This reference is injected
into the original request, which is then processed as usual. If a
default provider was already registered, the recorded reference is
used and no new registration occurs.
### SDK Changes
These changes only expose first-class providers from the Node.JS SDK.
- A new abstract class, `ProviderResource`, can be subclassed and used
to instantiate first-class providers.
- A new field in `ResourceOptions`, `provider`, can be used to supply
a particular provider instance to manage a `CustomResource`'s CRUD
operations.
- A new type, `InvokeOptions`, can be used to specify options that
control the behavior of a call to `pulumi.runtime.invoke`. This type
includes a `provider` field that is analogous to
`ResourceOptions.provider`.
2018-08-07 02:50:29 +02:00
|
|
|
}
|
2018-07-12 23:24:38 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
// Ensure that we received a sensible response.
|
|
|
|
if diff.Changes != plugin.DiffNone && diff.Changes != plugin.DiffSome {
|
2018-09-06 00:08:09 +02:00
|
|
|
return nil, result.Errorf(
|
2018-07-12 23:24:38 +02:00
|
|
|
"unrecognized diff state for %s: %d", urn, diff.Changes)
|
|
|
|
}
|
|
|
|
|
|
|
|
// If there were changes, check for a replacement vs. an in-place update.
|
|
|
|
if diff.Changes == plugin.DiffSome {
|
|
|
|
if diff.Replace() {
|
2019-07-12 20:12:01 +02:00
|
|
|
// If the goal state specified an ID, issue an error: the replacement will change the ID, and is
|
|
|
|
// therefore incompatible with the goal state.
|
|
|
|
if goal.ID != "" {
|
|
|
|
const message = "previously-imported resources that still specify an ID may not be replaced; " +
|
|
|
|
"please remove the `import` declaration from your program"
|
|
|
|
if sg.plan.preview {
|
|
|
|
sg.plan.ctx.Diag.Warningf(diag.StreamMessage(urn, message, 0))
|
|
|
|
} else {
|
|
|
|
return nil, result.Errorf(message)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-07-12 23:24:38 +02:00
|
|
|
sg.replaces[urn] = true
|
|
|
|
|
|
|
|
// If we are going to perform a replacement, we need to recompute the default values. The above logic
|
|
|
|
// had assumed that we were going to carry them over from the old resource, which is no longer true.
|
2018-08-23 02:52:46 +02:00
|
|
|
if prov != nil {
|
2018-07-12 23:24:38 +02:00
|
|
|
var failures []plugin.CheckFailure
|
|
|
|
inputs, failures, err = prov.Check(urn, nil, goal.Properties, allowUnknowns)
|
|
|
|
if err != nil {
|
2018-09-06 00:08:09 +02:00
|
|
|
return nil, result.FromError(err)
|
2019-07-12 20:12:01 +02:00
|
|
|
} else if issueCheckErrors(sg.plan, new, urn, failures) {
|
2018-09-06 00:08:09 +02:00
|
|
|
return nil, result.Bail()
|
2018-07-12 23:24:38 +02:00
|
|
|
}
|
|
|
|
new.Inputs = inputs
|
|
|
|
}
|
|
|
|
|
|
|
|
if logging.V(7) {
|
|
|
|
logging.V(7).Infof("Planner decided to replace '%v' (oldprops=%v inputs=%v)",
|
|
|
|
urn, oldInputs, new.Inputs)
|
|
|
|
}
|
|
|
|
|
|
|
|
// We have two approaches to performing replacements:
|
|
|
|
//
|
|
|
|
// * CreateBeforeDelete: the default mode first creates a new instance of the resource, then
|
|
|
|
// updates all dependent resources to point to the new one, and finally after all of that,
|
|
|
|
// deletes the old resource. This ensures minimal downtime.
|
|
|
|
//
|
|
|
|
// * DeleteBeforeCreate: this mode can be used for resources that cannot be tolerate having
|
|
|
|
// side-by-side old and new instances alive at once. This first deletes the resource and
|
|
|
|
// then creates the new one. This may result in downtime, so is less preferred. Note that
|
|
|
|
// until pulumi/pulumi#624 is resolved, we cannot safely perform this operation on resources
|
|
|
|
// that have dependent resources (we try to delete the resource while they refer to it).
|
|
|
|
//
|
2019-08-21 00:51:02 +02:00
|
|
|
// The provider is responsible for requesting which of these two modes to use. The user can override
|
|
|
|
// the provider's decision by setting the `deleteBeforeReplace` field of `ResourceOptions` to either
|
|
|
|
// `true` or `false`.
|
|
|
|
deleteBeforeReplace := diff.DeleteBeforeReplace
|
|
|
|
if goal.DeleteBeforeReplace != nil {
|
|
|
|
deleteBeforeReplace = *goal.DeleteBeforeReplace
|
|
|
|
}
|
|
|
|
if deleteBeforeReplace {
|
2018-07-12 23:24:38 +02:00
|
|
|
logging.V(7).Infof("Planner decided to delete-before-replacement for resource '%v'", urn)
|
|
|
|
contract.Assert(sg.plan.depGraph != nil)
|
|
|
|
|
|
|
|
// DeleteBeforeCreate implies that we must immediately delete the resource. For correctness,
|
|
|
|
// we must also eagerly delete all resources that depend directly or indirectly on the resource
|
Implement more precise delete-before-replace semantics. (#2369)
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.
2019-01-28 18:46:30 +01:00
|
|
|
// being replaced and would be replaced by a change to the relevant dependency.
|
2018-07-12 23:24:38 +02:00
|
|
|
//
|
2018-09-28 00:49:08 +02:00
|
|
|
// To do this, we'll utilize the dependency information contained in the snapshot if it is
|
|
|
|
// trustworthy, which is interpreted by the DependencyGraph type.
|
2018-07-12 23:24:38 +02:00
|
|
|
var steps []Step
|
2018-09-28 00:49:08 +02:00
|
|
|
if sg.opts.TrustDependencies {
|
2019-03-21 21:23:46 +01:00
|
|
|
toReplace, res := sg.calculateDependentReplacements(old)
|
|
|
|
if res != nil {
|
|
|
|
return nil, res
|
Implement more precise delete-before-replace semantics. (#2369)
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.
2019-01-28 18:46:30 +01:00
|
|
|
}
|
2018-09-28 00:49:08 +02:00
|
|
|
|
|
|
|
// Deletions must occur in reverse dependency order, and `deps` is returned in dependency
|
|
|
|
// order, so we iterate in reverse.
|
Implement more precise delete-before-replace semantics. (#2369)
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.
2019-01-28 18:46:30 +01:00
|
|
|
for i := len(toReplace) - 1; i >= 0; i-- {
|
|
|
|
dependentResource := toReplace[i].res
|
2018-09-28 00:49:08 +02:00
|
|
|
|
|
|
|
// If we already deleted this resource due to some other DBR, don't do it again.
|
Implement more precise delete-before-replace semantics. (#2369)
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.
2019-01-28 18:46:30 +01:00
|
|
|
if sg.deletes[dependentResource.URN] {
|
2018-09-28 00:49:08 +02:00
|
|
|
continue
|
|
|
|
}
|
|
|
|
|
Implement more precise delete-before-replace semantics. (#2369)
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.
2019-01-28 18:46:30 +01:00
|
|
|
sg.dependentReplaceKeys[dependentResource.URN] = toReplace[i].keys
|
|
|
|
|
2018-09-28 00:49:08 +02:00
|
|
|
logging.V(7).Infof("Planner decided to delete '%v' due to dependence on condemned resource '%v'",
|
|
|
|
dependentResource.URN, urn)
|
|
|
|
|
Implement more precise delete-before-replace semantics. (#2369)
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.
2019-01-28 18:46:30 +01:00
|
|
|
steps = append(steps, NewDeleteReplacementStep(sg.plan, dependentResource, true))
|
2018-09-28 00:49:08 +02:00
|
|
|
// Mark the condemned resource as deleted. We won't know until later in the plan whether
|
|
|
|
// or not we're going to be replacing this resource.
|
|
|
|
sg.deletes[dependentResource.URN] = true
|
2018-07-12 23:24:38 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return append(steps,
|
Implement more precise delete-before-replace semantics. (#2369)
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.
2019-01-28 18:46:30 +01:00
|
|
|
NewDeleteReplacementStep(sg.plan, old, true),
|
2019-07-01 21:34:19 +02:00
|
|
|
NewReplaceStep(sg.plan, old, new, diff.ReplaceKeys, diff.ChangedKeys, diff.DetailedDiff, false),
|
|
|
|
NewCreateReplacementStep(
|
|
|
|
sg.plan, event, old, new, diff.ReplaceKeys, diff.ChangedKeys, diff.DetailedDiff, false),
|
2018-07-12 23:24:38 +02:00
|
|
|
), nil
|
|
|
|
}
|
|
|
|
|
|
|
|
return []Step{
|
2019-07-01 21:34:19 +02:00
|
|
|
NewCreateReplacementStep(
|
|
|
|
sg.plan, event, old, new, diff.ReplaceKeys, diff.ChangedKeys, diff.DetailedDiff, true),
|
|
|
|
NewReplaceStep(sg.plan, old, new, diff.ReplaceKeys, diff.ChangedKeys, diff.DetailedDiff, true),
|
2018-07-12 23:24:38 +02:00
|
|
|
// note that the delete step is generated "later" on, after all creates/updates finish.
|
|
|
|
}, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// If we fell through, it's an update.
|
|
|
|
sg.updates[urn] = true
|
|
|
|
if logging.V(7) {
|
|
|
|
logging.V(7).Infof("Planner decided to update '%v' (oldprops=%v inputs=%v", urn, oldInputs, new.Inputs)
|
|
|
|
}
|
2019-07-01 21:34:19 +02:00
|
|
|
return []Step{
|
2019-07-31 18:39:07 +02:00
|
|
|
NewUpdateStep(sg.plan, event, old, new, diff.StableKeys, diff.ChangedKeys, diff.DetailedDiff,
|
|
|
|
goal.IgnoreChanges),
|
2019-07-01 21:34:19 +02:00
|
|
|
}, nil
|
2018-07-12 23:24:38 +02:00
|
|
|
}
|
|
|
|
|
Generate empty update steps for partial failures
This commit will greatly improve the experience of dealing with partial
failures by simply re-trying to initialize the relevant resources on
every subsequent `pulumi up`, instead of printing a list of reasons the
resource had previously failed to initialize.
As motivation, consider our behavior in the following common, painful
scenario:
* The user creates a `Service` and a `Deployment`.
* The `Pod`s in the `Deployment` fail to become live. This causes the
`Service` to fail, since it does not target any live `Pod`s.
* The user fixes the `Deployment`. A run of `pulumi up` sees the
`Pod`s successfully initialize.
* Users will expect that the `Service` is now in a state of success,
as the `Pod`s it targets are alive. But, because we don't update the
`Service` by default, it perpetually exists in a state of error.
* The user is now required to change some trivial feature of the
`Service` just to trigger an update, so that we can see it succeed.
There are many situations like this. Another very common one is waiting
for test `Pod`s that are meant to successfully complete when some object
becomes live.
By triggering an empty update step for all resources that have any
initialization errors, we avoid all problems like this.
This commit will implement this empty-update semantics for partial
failures, as well as fix the display UX to correctly render the diff in
these cases.
2018-08-28 23:23:31 +02:00
|
|
|
// If resource was unchanged, but there were initialization errors, generate an empty update
|
|
|
|
// step to attempt to "continue" awaiting initialization.
|
|
|
|
if len(old.InitErrors) > 0 {
|
|
|
|
sg.updates[urn] = true
|
2019-07-31 18:39:07 +02:00
|
|
|
return []Step{NewUpdateStep(sg.plan, event, old, new, diff.StableKeys, nil, nil, nil)}, nil
|
Generate empty update steps for partial failures
This commit will greatly improve the experience of dealing with partial
failures by simply re-trying to initialize the relevant resources on
every subsequent `pulumi up`, instead of printing a list of reasons the
resource had previously failed to initialize.
As motivation, consider our behavior in the following common, painful
scenario:
* The user creates a `Service` and a `Deployment`.
* The `Pod`s in the `Deployment` fail to become live. This causes the
`Service` to fail, since it does not target any live `Pod`s.
* The user fixes the `Deployment`. A run of `pulumi up` sees the
`Pod`s successfully initialize.
* Users will expect that the `Service` is now in a state of success,
as the `Pod`s it targets are alive. But, because we don't update the
`Service` by default, it perpetually exists in a state of error.
* The user is now required to change some trivial feature of the
`Service` just to trigger an update, so that we can see it succeed.
There are many situations like this. Another very common one is waiting
for test `Pod`s that are meant to successfully complete when some object
becomes live.
By triggering an empty update step for all resources that have any
initialization errors, we avoid all problems like this.
This commit will implement this empty-update semantics for partial
failures, as well as fix the display UX to correctly render the diff in
these cases.
2018-08-28 23:23:31 +02:00
|
|
|
}
|
|
|
|
|
2018-07-12 23:24:38 +02:00
|
|
|
// No need to update anything, the properties didn't change.
|
|
|
|
sg.sames[urn] = true
|
|
|
|
if logging.V(7) {
|
|
|
|
logging.V(7).Infof("Planner decided not to update '%v' (same) (inputs=%v)", urn, new.Inputs)
|
|
|
|
}
|
|
|
|
return []Step{NewSameStep(sg.plan, event, old, new)}, nil
|
|
|
|
}
|
|
|
|
|
2018-08-03 23:06:00 +02:00
|
|
|
// Case 4: Not Case 1, 2, or 3
|
2018-07-12 23:24:38 +02:00
|
|
|
// If a resource isn't being recreated and it's not being updated or replaced,
|
|
|
|
// it's just being created.
|
|
|
|
sg.creates[urn] = true
|
|
|
|
logging.V(7).Infof("Planner decided to create '%v' (inputs=%v)", urn, new.Inputs)
|
|
|
|
return []Step{NewCreateStep(sg.plan, event, new)}, nil
|
|
|
|
}
|
|
|
|
|
2019-09-20 04:28:14 +02:00
|
|
|
func (sg *stepGenerator) GenerateDeletes(targets []resource.URN) ([]Step, result.Result) {
|
2018-07-12 23:24:38 +02:00
|
|
|
// To compute the deletion list, we must walk the list of old resources *backwards*. This is because the list is
|
|
|
|
// stored in dependency order, and earlier elements are possibly leaf nodes for later elements. We must not delete
|
|
|
|
// dependencies prior to their dependent nodes.
|
|
|
|
var dels []Step
|
|
|
|
if prev := sg.plan.prev; prev != nil {
|
|
|
|
for i := len(prev.Resources) - 1; i >= 0; i-- {
|
|
|
|
// If this resource is explicitly marked for deletion or wasn't seen at all, delete it.
|
|
|
|
res := prev.Resources[i]
|
|
|
|
if res.Delete {
|
2018-07-19 00:48:55 +02:00
|
|
|
// The below assert is commented-out because it's believed to be wrong.
|
|
|
|
//
|
|
|
|
// The original justification for this assert is that the author (swgillespie) believed that
|
|
|
|
// it was impossible for a single URN to be deleted multiple times in the same program.
|
|
|
|
// This has empirically been proven to be false - it is possible using today engine to construct
|
|
|
|
// a series of actions that puts arbitrarily many pending delete resources with the same URN in
|
|
|
|
// the snapshot.
|
|
|
|
//
|
|
|
|
// It is not clear whether or not this is OK. I (swgillespie), the author of this comment, have
|
|
|
|
// seen no evidence that it is *not* OK. However, concerns were raised about what this means for
|
|
|
|
// structural resources, and so until that question is answered, I am leaving this comment and
|
|
|
|
// assert in the code.
|
|
|
|
//
|
|
|
|
// Regardless, it is better to admit strange behavior in corner cases than it is to crash the CLI
|
|
|
|
// whenever we see multiple deletes for the same URN.
|
|
|
|
// contract.Assert(!sg.deletes[res.URN])
|
2018-09-11 01:48:14 +02:00
|
|
|
if sg.pendingDeletes[res] {
|
|
|
|
logging.V(7).Infof(
|
|
|
|
"Planner ignoring pending-delete resource (%v, %v) that was already deleted", res.URN, res.ID)
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
|
2018-07-19 00:48:55 +02:00
|
|
|
if sg.deletes[res.URN] {
|
|
|
|
logging.V(7).Infof(
|
|
|
|
"Planner is deleting pending-delete urn '%v' that has already been deleted", res.URN)
|
|
|
|
}
|
2018-09-11 01:48:14 +02:00
|
|
|
|
|
|
|
logging.V(7).Infof("Planner decided to delete '%v' due to replacement", res.URN)
|
2018-07-12 23:24:38 +02:00
|
|
|
sg.deletes[res.URN] = true
|
Implement more precise delete-before-replace semantics. (#2369)
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.
2019-01-28 18:46:30 +01:00
|
|
|
dels = append(dels, NewDeleteReplacementStep(sg.plan, res, false))
|
2019-06-01 08:01:01 +02:00
|
|
|
} else if _, aliased := sg.aliased[res.URN]; !sg.sames[res.URN] && !sg.updates[res.URN] && !sg.replaces[res.URN] &&
|
|
|
|
!sg.reads[res.URN] && !aliased {
|
2018-08-07 20:01:08 +02:00
|
|
|
// NOTE: we deliberately do not check sg.deletes here, as it is possible for us to issue multiple
|
|
|
|
// delete steps for the same URN if the old checkpoint contained pending deletes.
|
2018-07-12 23:24:38 +02:00
|
|
|
logging.V(7).Infof("Planner decided to delete '%v'", res.URN)
|
|
|
|
sg.deletes[res.URN] = true
|
Implement more precise delete-before-replace semantics. (#2369)
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.
2019-01-28 18:46:30 +01:00
|
|
|
if !res.PendingReplacement {
|
|
|
|
dels = append(dels, NewDeleteStep(sg.plan, res))
|
|
|
|
} else {
|
|
|
|
dels = append(dels, NewRemovePendingReplaceStep(sg.plan, res))
|
|
|
|
}
|
2018-07-12 23:24:38 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2019-09-20 04:28:14 +02:00
|
|
|
|
|
|
|
if len(targets) > 0 {
|
|
|
|
logging.V(7).Infof("Planner was asked to only delete '%v'", targets)
|
|
|
|
|
|
|
|
resourcesToDelete := make(map[resource.URN]bool)
|
|
|
|
|
|
|
|
// Do an initial pass first to ensure that all the targets mentioned are ones we know about.
|
|
|
|
hasUnknownTarget := false
|
|
|
|
for _, target := range targets {
|
|
|
|
if _, has := sg.plan.olds[target]; !has {
|
|
|
|
hasUnknownTarget = true
|
|
|
|
logging.V(7).Infof("Resource to delete (%v) could not be found in the stack.", target)
|
|
|
|
if strings.Contains(string(target), "$") {
|
|
|
|
sg.plan.Diag().Errorf(diag.GetResourceToDeleteCouldNotBeFoundError(), target)
|
|
|
|
} else {
|
|
|
|
sg.plan.Diag().Errorf(diag.GetResourceToDeleteCouldNotBeFoundDidYouForgetError(), target)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if hasUnknownTarget {
|
|
|
|
return nil, result.Bail()
|
|
|
|
}
|
|
|
|
|
|
|
|
// Now actually use all the requested targets to figure out the exact set to delete.
|
|
|
|
for _, target := range targets {
|
|
|
|
current := sg.plan.olds[target]
|
|
|
|
resourcesToDelete[target] = true
|
|
|
|
|
|
|
|
// the item the user is asking to destroy may cause downstream replacements. Clean those up
|
|
|
|
// as well. Use the standard delete-before-replace computation to determine the minimal
|
|
|
|
// set of downstream resources that are affected.
|
|
|
|
deps, res := sg.calculateDependentReplacements(current)
|
|
|
|
if res != nil {
|
|
|
|
return nil, res
|
|
|
|
}
|
|
|
|
|
|
|
|
for _, dep := range deps {
|
|
|
|
logging.V(7).Infof("GenerateDeletes(...): Adding dependent: %v", dep.res.URN)
|
|
|
|
resourcesToDelete[dep.res.URN] = true
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Also see if any resources have a resource we're deleting as a parent. If so, we'll block
|
|
|
|
// the delete. It's a little painful. But can be worked around by explicitly deleting
|
|
|
|
// children before parents. Note: in almost all cases, people will want to delete children,
|
|
|
|
// so this restriction should not be too onerous.
|
|
|
|
for _, res := range sg.plan.prev.Resources {
|
|
|
|
if res.Parent != "" {
|
|
|
|
if _, has := resourcesToDelete[res.URN]; has {
|
|
|
|
// already deleting this sibling
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
|
|
|
|
if _, has := resourcesToDelete[res.Parent]; has {
|
|
|
|
sg.plan.Diag().Errorf(diag.GetCannotDeleteParentResourceWithoutAlsoDeletingChildError(),
|
|
|
|
res.Parent, res.URN)
|
|
|
|
return nil, result.Bail()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if logging.V(7) {
|
|
|
|
keys := []resource.URN{}
|
|
|
|
for k := range resourcesToDelete {
|
|
|
|
keys = append(keys, k)
|
|
|
|
}
|
|
|
|
|
|
|
|
logging.V(7).Infof("Planner will delete all of '%v'", keys)
|
|
|
|
}
|
|
|
|
|
|
|
|
filtered := []Step{}
|
|
|
|
for _, step := range dels {
|
|
|
|
if _, has := resourcesToDelete[step.URN()]; has {
|
|
|
|
filtered = append(filtered, step)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
dels = filtered
|
|
|
|
}
|
|
|
|
|
|
|
|
return dels, nil
|
2018-07-12 23:24:38 +02:00
|
|
|
}
|
|
|
|
|
2018-09-11 01:48:14 +02:00
|
|
|
// GeneratePendingDeletes generates delete steps for all resources that are pending deletion. This function should be
|
|
|
|
// called at the start of a plan in order to find all resources that are pending deletion from the prevous plan.
|
|
|
|
func (sg *stepGenerator) GeneratePendingDeletes() []Step {
|
|
|
|
var dels []Step
|
|
|
|
if prev := sg.plan.prev; prev != nil {
|
|
|
|
logging.V(7).Infof("stepGenerator.GeneratePendingDeletes(): scanning previous snapshot for pending deletes")
|
|
|
|
for i := len(prev.Resources) - 1; i >= 0; i-- {
|
|
|
|
res := prev.Resources[i]
|
|
|
|
if res.Delete {
|
|
|
|
logging.V(7).Infof(
|
|
|
|
"stepGenerator.GeneratePendingDeletes(): resource (%v, %v) is pending deletion", res.URN, res.ID)
|
|
|
|
sg.pendingDeletes[res] = true
|
|
|
|
dels = append(dels, NewDeleteStep(sg.plan, res))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return dels
|
|
|
|
}
|
|
|
|
|
2018-09-28 00:49:08 +02:00
|
|
|
// scheduleDeletes takes a list of steps that will delete resources and "schedules" them by producing a list of list of
|
|
|
|
// steps, where each list can be executed in parallel but a previous list must be executed to completion before advacing
|
|
|
|
// to the next list.
|
|
|
|
//
|
|
|
|
// In lieu of tracking per-step dependencies and orienting the step executor around these dependencies, this function
|
|
|
|
// provides a conservative approximation of what deletions can safely occur in parallel. The insight here is that the
|
|
|
|
// resource dependency graph is a partially-ordered set and all partially-ordered sets can be easily decomposed into
|
|
|
|
// antichains - subsets of the set that are all not comparable to one another. (In this definition, "not comparable"
|
|
|
|
// means "do not depend on one another").
|
|
|
|
//
|
|
|
|
// The algorithm for decomposing a poset into antichains is:
|
|
|
|
// 1. While there exist elements in the poset,
|
|
|
|
// 1a. There must exist at least one "maximal" element of the poset. Let E_max be those elements.
|
|
|
|
// 2a. Remove all elements E_max from the poset. E_max is an antichain.
|
|
|
|
// 3a. Goto 1.
|
|
|
|
//
|
|
|
|
// Translated to our dependency graph:
|
|
|
|
// 1. While the set of condemned resources is not empty:
|
|
|
|
// 1a. Remove all resources with no outgoing edges from the graph and add them to the current antichain.
|
|
|
|
// 2a. Goto 1.
|
|
|
|
//
|
|
|
|
// The resulting list of antichains is a list of list of steps that can be safely executed in parallel. Since we must
|
|
|
|
// process deletes in reverse (so we don't delete resources upon which other resources depend), we reverse the list and
|
|
|
|
// hand it back to the plan executor for safe execution.
|
|
|
|
func (sg *stepGenerator) ScheduleDeletes(deleteSteps []Step) []antichain {
|
|
|
|
var antichains []antichain // the list of parallelizable steps we intend to return.
|
|
|
|
dg := sg.plan.depGraph // the current plan's dependency graph.
|
|
|
|
condemned := make(graph.ResourceSet) // the set of condemned resources.
|
|
|
|
stepMap := make(map[*resource.State]Step) // a map from resource states to the steps that delete them.
|
|
|
|
|
|
|
|
// If we don't trust the dependency graph we've been given, we must be conservative and delete everything serially.
|
|
|
|
if !sg.opts.TrustDependencies {
|
|
|
|
logging.V(7).Infof("Planner does not trust dependency graph, scheduling deletions serially")
|
|
|
|
for _, step := range deleteSteps {
|
|
|
|
antichains = append(antichains, antichain{step})
|
|
|
|
}
|
|
|
|
|
|
|
|
return antichains
|
|
|
|
}
|
|
|
|
|
|
|
|
logging.V(7).Infof("Planner trusts dependency graph, scheduling deletions in parallel")
|
|
|
|
|
|
|
|
// For every step we've been given, record it as condemned and save the step that will be used to delete it. We'll
|
|
|
|
// iteratively place these steps into antichains as we remove elements from the condemned set.
|
|
|
|
for _, step := range deleteSteps {
|
|
|
|
condemned[step.Res()] = true
|
|
|
|
stepMap[step.Res()] = step
|
|
|
|
}
|
|
|
|
|
|
|
|
for len(condemned) > 0 {
|
|
|
|
var steps antichain
|
|
|
|
logging.V(7).Infof("Planner beginning schedule of new deletion antichain")
|
|
|
|
for res := range condemned {
|
|
|
|
// Does res have any outgoing edges to resources that haven't already been removed from the graph?
|
|
|
|
condemnedDependencies := dg.DependenciesOf(res).Intersect(condemned)
|
|
|
|
if len(condemnedDependencies) == 0 {
|
|
|
|
// If not, it's safe to delete res at this stage.
|
|
|
|
logging.V(7).Infof("Planner scheduling deletion of '%v'", res.URN)
|
|
|
|
steps = append(steps, stepMap[res])
|
|
|
|
}
|
|
|
|
|
|
|
|
// If one of this resource's dependencies or this resource's parent hasn't been removed from the graph yet,
|
|
|
|
// it can't be deleted this round.
|
|
|
|
}
|
|
|
|
|
|
|
|
// For all reosurces that are to be deleted in this round, remove them from the graph.
|
|
|
|
for _, step := range steps {
|
|
|
|
delete(condemned, step.Res())
|
|
|
|
}
|
|
|
|
|
|
|
|
antichains = append(antichains, steps)
|
|
|
|
}
|
|
|
|
|
|
|
|
// Up until this point, all logic has been "backwards" - we're scheduling resources for deletion when all of their
|
|
|
|
// dependencies finish deletion, but that's exactly the opposite of what we need to do. We can only delete a
|
|
|
|
// resource when all *resources that depend on it* complete deletion. Our solution is still correct, though, it's
|
|
|
|
// just backwards.
|
|
|
|
//
|
|
|
|
// All we have to do here is reverse the list and then our solution is correct.
|
|
|
|
for i := len(antichains)/2 - 1; i >= 0; i-- {
|
|
|
|
opp := len(antichains) - 1 - i
|
|
|
|
antichains[i], antichains[opp] = antichains[opp], antichains[i]
|
|
|
|
}
|
|
|
|
|
|
|
|
return antichains
|
|
|
|
}
|
|
|
|
|
Refine resource replacement logic for providers (#2767)
This commit touches an intersection of a few different provider-oriented
features that combined to cause a particularly severe bug that made it
impossible for users to upgrade provider versions without seeing
replacements with their resources.
For some context, Pulumi models all providers as resources and places
them in the snapshot like any other resource. Every resource has a
reference to the provider that created it. If a Pulumi program does not
specify a particular provider to use when performing a resource
operation, the Pulumi engine injects one automatically; these are called
"default providers" and are the most common ways that users end up with
providers in their snapshot. Default providers can be identified by
their name, which is always prefixed with "default".
Recently, in an effort to make the Pulumi engine more flexible with
provider versions, it was made possible for the engine to have multiple
default providers active for a provider of a particular type, which was
previously not possible. Because a provider is identified as a tuple of
package name and version, it was difficult to find a name for these
duplicate default providers that did not cause additional problems. The
provider versioning PR gave these default providers a name that was
derived from the version of the package. This proved to be a problem,
because when users upgraded from one version of a package to another,
this changed the name of their default provider which in turn caused all
of their resources created using that provider (read: everything) to be
replaced.
To combat this, this PR introduces a rule that the engine will apply
when diffing a resource to determine whether or not it needs to be
replaced: "If a resource's provider changes, and both old and new
providers are default providers whose properties do not require
replacement, proceed as if there were no diff." This allows the engine
to gracefully recognize and recover when a resource's default provider changes
names, as long as the provider's config has not changed.
2019-06-03 21:16:31 +02:00
|
|
|
// providerChanged diffs the Provider field of old and new resources, returning true if the rest of the step generator
|
|
|
|
// should consider there to be a diff between these two resources.
|
|
|
|
func (sg *stepGenerator) providerChanged(urn resource.URN, old, new *resource.State) (bool, error) {
|
|
|
|
// If a resource's Provider field has changed, we may need to show a diff and we may not. This is subtle. See
|
|
|
|
// pulumi/pulumi#2753 for more details.
|
|
|
|
//
|
|
|
|
// Recent versions of Pulumi allow for language hosts to pass a plugin version to the engine. The purpose of this is
|
|
|
|
// to ensure that the plugin that the engine uses for a particular resource is *exactly equal* to the version of the
|
|
|
|
// SDK that the language host used to produce the resource registration. This is critical for correct versioning
|
|
|
|
// semantics; it is generally an error for a language SDK to produce a registration that is serviced by a
|
|
|
|
// differently versioned plugin, since the two version in complete lockstep and there is no guarantee that the two
|
|
|
|
// will work correctly together when not the same version.
|
|
|
|
|
|
|
|
if old.Provider == new.Provider {
|
|
|
|
return false, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
logging.V(stepExecutorLogLevel).Infof("sg.diffProvider(%s, ...): observed provider diff", urn)
|
|
|
|
logging.V(stepExecutorLogLevel).Infof("sg.diffProvider(%s, ...): %s => %s", urn, old.Provider, new.Provider)
|
|
|
|
|
|
|
|
oldRef, err := providers.ParseReference(old.Provider)
|
|
|
|
if err != nil {
|
|
|
|
return false, err
|
|
|
|
}
|
|
|
|
newRef, err := providers.ParseReference(new.Provider)
|
|
|
|
if err != nil {
|
|
|
|
return false, err
|
|
|
|
}
|
|
|
|
|
|
|
|
// If one or both of these providers are not default providers, we will need to accept the diff and replace
|
|
|
|
// everything. This might not be strictly necessary, but it is conservatively correct.
|
|
|
|
if !providers.IsDefaultProvider(oldRef.URN()) || !providers.IsDefaultProvider(newRef.URN()) {
|
|
|
|
logging.V(stepExecutorLogLevel).Infof(
|
|
|
|
"sg.diffProvider(%s, ...): reporting provider diff due to change in default provider status", urn)
|
|
|
|
logging.V(stepExecutorLogLevel).Infof(
|
|
|
|
"sg.diffProvider(%s, ...): old provider %q is default: %v",
|
|
|
|
urn, oldRef.URN(), providers.IsDefaultProvider(oldRef.URN()))
|
|
|
|
logging.V(stepExecutorLogLevel).Infof(
|
|
|
|
"sg.diffProvider(%s, ...): new provider %q is default: %v",
|
|
|
|
urn, newRef.URN(), providers.IsDefaultProvider(newRef.URN()))
|
|
|
|
return true, err
|
|
|
|
}
|
|
|
|
|
|
|
|
// If both of these providers are default providers, use the *new provider* to diff the config and determine if
|
|
|
|
// this provider requires replacement.
|
|
|
|
//
|
|
|
|
// Note that, if we have many resources managed by the same provider that is getting replaced in this manner,
|
|
|
|
// this will call DiffConfig repeatedly with the same arguments for every resource. If this becomes a
|
|
|
|
// performance problem, this result can be cached.
|
|
|
|
newProv, ok := sg.plan.providers.GetProvider(newRef)
|
|
|
|
if !ok {
|
|
|
|
return false, errors.Errorf("failed to resolve provider reference: %q", oldRef.String())
|
|
|
|
}
|
|
|
|
|
|
|
|
oldRes, ok := sg.plan.olds[oldRef.URN()]
|
|
|
|
contract.Assertf(ok, "old state didn't have provider, despite resource using it?")
|
|
|
|
newRes, ok := sg.providers[newRef.URN()]
|
|
|
|
contract.Assertf(ok, "new plan didn't have provider, despite resource using it?")
|
|
|
|
|
2019-07-31 18:39:07 +02:00
|
|
|
diff, err := newProv.DiffConfig(newRef.URN(), oldRes.Inputs, newRes.Inputs, true, nil)
|
Refine resource replacement logic for providers (#2767)
This commit touches an intersection of a few different provider-oriented
features that combined to cause a particularly severe bug that made it
impossible for users to upgrade provider versions without seeing
replacements with their resources.
For some context, Pulumi models all providers as resources and places
them in the snapshot like any other resource. Every resource has a
reference to the provider that created it. If a Pulumi program does not
specify a particular provider to use when performing a resource
operation, the Pulumi engine injects one automatically; these are called
"default providers" and are the most common ways that users end up with
providers in their snapshot. Default providers can be identified by
their name, which is always prefixed with "default".
Recently, in an effort to make the Pulumi engine more flexible with
provider versions, it was made possible for the engine to have multiple
default providers active for a provider of a particular type, which was
previously not possible. Because a provider is identified as a tuple of
package name and version, it was difficult to find a name for these
duplicate default providers that did not cause additional problems. The
provider versioning PR gave these default providers a name that was
derived from the version of the package. This proved to be a problem,
because when users upgraded from one version of a package to another,
this changed the name of their default provider which in turn caused all
of their resources created using that provider (read: everything) to be
replaced.
To combat this, this PR introduces a rule that the engine will apply
when diffing a resource to determine whether or not it needs to be
replaced: "If a resource's provider changes, and both old and new
providers are default providers whose properties do not require
replacement, proceed as if there were no diff." This allows the engine
to gracefully recognize and recover when a resource's default provider changes
names, as long as the provider's config has not changed.
2019-06-03 21:16:31 +02:00
|
|
|
if err != nil {
|
|
|
|
return false, err
|
|
|
|
}
|
|
|
|
|
|
|
|
// If there is a replacement diff, we must also replace this resource.
|
|
|
|
if diff.Replace() {
|
|
|
|
logging.V(stepExecutorLogLevel).Infof(
|
|
|
|
"sg.diffProvider(%s, ...): new provider's DiffConfig reported replacement", urn)
|
|
|
|
return true, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// Otherwise, it's safe to allow this new provider to replace our old one.
|
|
|
|
logging.V(stepExecutorLogLevel).Infof(
|
|
|
|
"sg.diffProvider(%s, ...): both providers are default, proceeding with resource diff", urn)
|
|
|
|
return false, nil
|
|
|
|
}
|
|
|
|
|
2018-07-12 23:24:38 +02:00
|
|
|
// diff returns a DiffResult for the given resource.
|
Refine resource replacement logic for providers (#2767)
This commit touches an intersection of a few different provider-oriented
features that combined to cause a particularly severe bug that made it
impossible for users to upgrade provider versions without seeing
replacements with their resources.
For some context, Pulumi models all providers as resources and places
them in the snapshot like any other resource. Every resource has a
reference to the provider that created it. If a Pulumi program does not
specify a particular provider to use when performing a resource
operation, the Pulumi engine injects one automatically; these are called
"default providers" and are the most common ways that users end up with
providers in their snapshot. Default providers can be identified by
their name, which is always prefixed with "default".
Recently, in an effort to make the Pulumi engine more flexible with
provider versions, it was made possible for the engine to have multiple
default providers active for a provider of a particular type, which was
previously not possible. Because a provider is identified as a tuple of
package name and version, it was difficult to find a name for these
duplicate default providers that did not cause additional problems. The
provider versioning PR gave these default providers a name that was
derived from the version of the package. This proved to be a problem,
because when users upgraded from one version of a package to another,
this changed the name of their default provider which in turn caused all
of their resources created using that provider (read: everything) to be
replaced.
To combat this, this PR introduces a rule that the engine will apply
when diffing a resource to determine whether or not it needs to be
replaced: "If a resource's provider changes, and both old and new
providers are default providers whose properties do not require
replacement, proceed as if there were no diff." This allows the engine
to gracefully recognize and recover when a resource's default provider changes
names, as long as the provider's config has not changed.
2019-06-03 21:16:31 +02:00
|
|
|
func (sg *stepGenerator) diff(urn resource.URN, old, new *resource.State, oldInputs, oldOutputs,
|
2019-07-31 18:39:07 +02:00
|
|
|
newInputs resource.PropertyMap, prov plugin.Provider, allowUnknowns bool,
|
|
|
|
ignoreChanges []string) (plugin.DiffResult, error) {
|
Refine resource replacement logic for providers (#2767)
This commit touches an intersection of a few different provider-oriented
features that combined to cause a particularly severe bug that made it
impossible for users to upgrade provider versions without seeing
replacements with their resources.
For some context, Pulumi models all providers as resources and places
them in the snapshot like any other resource. Every resource has a
reference to the provider that created it. If a Pulumi program does not
specify a particular provider to use when performing a resource
operation, the Pulumi engine injects one automatically; these are called
"default providers" and are the most common ways that users end up with
providers in their snapshot. Default providers can be identified by
their name, which is always prefixed with "default".
Recently, in an effort to make the Pulumi engine more flexible with
provider versions, it was made possible for the engine to have multiple
default providers active for a provider of a particular type, which was
previously not possible. Because a provider is identified as a tuple of
package name and version, it was difficult to find a name for these
duplicate default providers that did not cause additional problems. The
provider versioning PR gave these default providers a name that was
derived from the version of the package. This proved to be a problem,
because when users upgraded from one version of a package to another,
this changed the name of their default provider which in turn caused all
of their resources created using that provider (read: everything) to be
replaced.
To combat this, this PR introduces a rule that the engine will apply
when diffing a resource to determine whether or not it needs to be
replaced: "If a resource's provider changes, and both old and new
providers are default providers whose properties do not require
replacement, proceed as if there were no diff." This allows the engine
to gracefully recognize and recover when a resource's default provider changes
names, as long as the provider's config has not changed.
2019-06-03 21:16:31 +02:00
|
|
|
|
|
|
|
// Before diffing the resource, diff the provider field. If the provider field changes, we may or may
|
|
|
|
// not need to replace the resource.
|
|
|
|
providerChanged, err := sg.providerChanged(urn, old, new)
|
|
|
|
if err != nil {
|
|
|
|
return plugin.DiffResult{}, err
|
|
|
|
} else if providerChanged {
|
|
|
|
return plugin.DiffResult{Changes: plugin.DiffSome, ReplaceKeys: []resource.PropertyKey{"provider"}}, nil
|
|
|
|
}
|
2018-07-12 23:24:38 +02:00
|
|
|
|
2019-07-01 21:34:19 +02:00
|
|
|
// Apply legacy diffing behavior if requested. In this mode, if the provider-calculated inputs for a resource did
|
|
|
|
// not change, then the resource is considered to have no diff between its desired and actual state.
|
|
|
|
if sg.opts.UseLegacyDiff && oldInputs.DeepEquals(newInputs) {
|
2018-07-12 23:24:38 +02:00
|
|
|
return plugin.DiffResult{Changes: plugin.DiffNone}, nil
|
|
|
|
}
|
|
|
|
|
2019-07-01 21:34:19 +02:00
|
|
|
// If there is no provider for this resource (which should only happen for component resources), simply return a
|
|
|
|
// "diffs exist" result.
|
2018-07-12 23:24:38 +02:00
|
|
|
if prov == nil {
|
2019-07-01 21:34:19 +02:00
|
|
|
if oldInputs.DeepEquals(newInputs) {
|
|
|
|
return plugin.DiffResult{Changes: plugin.DiffNone}, nil
|
|
|
|
}
|
2018-07-12 23:24:38 +02:00
|
|
|
return plugin.DiffResult{Changes: plugin.DiffSome}, nil
|
|
|
|
}
|
|
|
|
|
2019-07-31 18:39:07 +02:00
|
|
|
return diffResource(urn, old.ID, oldInputs, oldOutputs, newInputs, prov, allowUnknowns, ignoreChanges)
|
2019-07-12 20:12:01 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
// diffResource invokes the Diff function for the given custom resource's provider and returns the result.
|
|
|
|
func diffResource(urn resource.URN, id resource.ID, oldInputs, oldOutputs,
|
2019-07-31 18:39:07 +02:00
|
|
|
newInputs resource.PropertyMap, prov plugin.Provider, allowUnknowns bool,
|
|
|
|
ignoreChanges []string) (plugin.DiffResult, error) {
|
2019-07-12 20:12:01 +02:00
|
|
|
|
|
|
|
contract.Require(prov != nil, "prov != nil")
|
|
|
|
|
2018-07-12 23:24:38 +02:00
|
|
|
// Grab the diff from the provider. At this point we know that there were changes to the Pulumi inputs, so if the
|
|
|
|
// provider returns an "unknown" diff result, pretend it returned "diffs exist".
|
2019-07-31 18:39:07 +02:00
|
|
|
diff, err := prov.Diff(urn, id, oldOutputs, newInputs, allowUnknowns, ignoreChanges)
|
2018-07-12 23:24:38 +02:00
|
|
|
if err != nil {
|
2018-11-22 01:53:29 +01:00
|
|
|
return diff, err
|
2018-07-12 23:24:38 +02:00
|
|
|
}
|
|
|
|
if diff.Changes == plugin.DiffUnknown {
|
2019-07-01 21:34:19 +02:00
|
|
|
if oldInputs.DeepEquals(newInputs) {
|
|
|
|
diff.Changes = plugin.DiffNone
|
|
|
|
} else {
|
|
|
|
diff.Changes = plugin.DiffSome
|
|
|
|
}
|
2018-07-12 23:24:38 +02:00
|
|
|
}
|
|
|
|
return diff, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// issueCheckErrors prints any check errors to the diagnostics sink.
|
2019-07-12 20:12:01 +02:00
|
|
|
func issueCheckErrors(plan *Plan, new *resource.State, urn resource.URN, failures []plugin.CheckFailure) bool {
|
2018-07-12 23:24:38 +02:00
|
|
|
if len(failures) == 0 {
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
inputs := new.Inputs
|
|
|
|
for _, failure := range failures {
|
|
|
|
if failure.Property != "" {
|
2019-07-12 20:12:01 +02:00
|
|
|
plan.Diag().Errorf(diag.GetResourcePropertyInvalidValueError(urn),
|
2018-07-12 23:24:38 +02:00
|
|
|
new.Type, urn.Name(), failure.Property, inputs[failure.Property], failure.Reason)
|
|
|
|
} else {
|
2019-07-12 20:12:01 +02:00
|
|
|
plan.Diag().Errorf(
|
2018-08-31 21:33:01 +02:00
|
|
|
diag.GetResourceInvalidError(urn), new.Type, urn.Name(), failure.Reason)
|
2018-07-12 23:24:38 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
|
2019-04-22 22:54:48 +02:00
|
|
|
// processIgnoreChanges sets the value for each ignoreChanges property in inputs to the value from oldInputs. This has
|
|
|
|
// the effect of ensuring that no changes will be made for the corresponding property.
|
2019-07-31 18:39:07 +02:00
|
|
|
func processIgnoreChanges(inputs, oldInputs resource.PropertyMap,
|
|
|
|
ignoreChanges []string) (resource.PropertyMap, result.Result) {
|
2019-04-22 22:54:48 +02:00
|
|
|
|
2019-07-31 18:39:07 +02:00
|
|
|
ignoredInputs := resource.NewObjectProperty(inputs.Copy())
|
|
|
|
var invalidPaths []string
|
2019-04-22 22:54:48 +02:00
|
|
|
for _, ignoreChange := range ignoreChanges {
|
2019-07-31 18:39:07 +02:00
|
|
|
path, err := resource.ParsePropertyPath(ignoreChange)
|
|
|
|
if err != nil {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
|
|
|
|
oldValue, hasOld := path.Get(resource.NewObjectProperty(oldInputs))
|
|
|
|
_, hasNew := path.Get(resource.NewObjectProperty(inputs))
|
|
|
|
|
|
|
|
var ok bool
|
|
|
|
switch {
|
|
|
|
case hasOld && hasNew:
|
|
|
|
ok = path.Set(ignoredInputs, oldValue)
|
|
|
|
contract.Assert(ok)
|
|
|
|
case hasOld && !hasNew:
|
|
|
|
ok = path.Set(ignoredInputs, oldValue)
|
|
|
|
case !hasOld && hasNew:
|
|
|
|
ok = path.Delete(ignoredInputs)
|
|
|
|
default:
|
|
|
|
ok = true
|
2019-04-22 22:54:48 +02:00
|
|
|
}
|
2019-07-31 18:39:07 +02:00
|
|
|
if !ok {
|
|
|
|
invalidPaths = append(invalidPaths, ignoreChange)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if len(invalidPaths) != 0 {
|
|
|
|
return nil, result.Errorf("cannot ignore changes to the following properties because one or more elements of "+
|
|
|
|
"the path are missing: %q", strings.Join(invalidPaths, ", "))
|
2019-04-22 22:54:48 +02:00
|
|
|
}
|
2019-07-31 18:39:07 +02:00
|
|
|
return ignoredInputs.ObjectValue(), nil
|
2019-04-22 22:54:48 +02:00
|
|
|
}
|
|
|
|
|
2019-03-21 21:23:46 +01:00
|
|
|
func (sg *stepGenerator) loadResourceProvider(
|
|
|
|
urn resource.URN, custom bool, provider string, typ tokens.Type) (plugin.Provider, result.Result) {
|
Implement more precise delete-before-replace semantics. (#2369)
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.
2019-01-28 18:46:30 +01:00
|
|
|
|
|
|
|
// If this is not a custom resource, then it has no provider by definition.
|
|
|
|
if !custom {
|
|
|
|
return nil, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// If this resource is a provider resource, use the plan's provider registry for its CRUD operations.
|
|
|
|
// Otherwise, resolve the the resource's provider reference.
|
|
|
|
if providers.IsProviderType(typ) {
|
|
|
|
return sg.plan.providers, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
contract.Assert(provider != "")
|
|
|
|
ref, refErr := providers.ParseReference(provider)
|
|
|
|
if refErr != nil {
|
2019-03-21 21:23:46 +01:00
|
|
|
sg.plan.Diag().Errorf(diag.GetBadProviderError(urn), provider, urn, refErr)
|
|
|
|
return nil, result.Bail()
|
Implement more precise delete-before-replace semantics. (#2369)
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.
2019-01-28 18:46:30 +01:00
|
|
|
}
|
|
|
|
p, ok := sg.plan.GetProvider(ref)
|
|
|
|
if !ok {
|
2019-03-21 21:23:46 +01:00
|
|
|
sg.plan.Diag().Errorf(diag.GetUnknownProviderError(urn), provider, urn, refErr)
|
|
|
|
return nil, result.Bail()
|
Implement more precise delete-before-replace semantics. (#2369)
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.
2019-01-28 18:46:30 +01:00
|
|
|
}
|
|
|
|
return p, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
type dependentReplace struct {
|
|
|
|
res *resource.State
|
|
|
|
keys []resource.PropertyKey
|
|
|
|
}
|
|
|
|
|
2019-03-21 21:23:46 +01:00
|
|
|
func (sg *stepGenerator) calculateDependentReplacements(root *resource.State) ([]dependentReplace, result.Result) {
|
2019-09-18 18:49:13 +02:00
|
|
|
// 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.
|
Implement more precise delete-before-replace semantics. (#2369)
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.
2019-01-28 18:46:30 +01:00
|
|
|
//
|
|
|
|
// This is perhaps clearer when described by example. Consider the following dependency graph:
|
|
|
|
//
|
|
|
|
// A
|
|
|
|
// __|__
|
|
|
|
// B C
|
|
|
|
// | _|_
|
|
|
|
// D E F
|
|
|
|
//
|
2019-09-18 18:49:13 +02:00
|
|
|
// 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. More commonly, the edge from B to A may
|
|
|
|
// be due to a property from A being used as the input to a property of B that does not require
|
|
|
|
// B to be replaced upon a change. In these cases, neither B nor D would need to be deleted
|
|
|
|
// before A could be deleted.
|
Implement more precise delete-before-replace semantics. (#2369)
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.
2019-01-28 18:46:30 +01:00
|
|
|
var toReplace []dependentReplace
|
|
|
|
replaceSet := map[resource.URN]bool{root.URN: true}
|
|
|
|
|
2019-03-21 21:23:46 +01:00
|
|
|
requiresReplacement := func(r *resource.State) (bool, []resource.PropertyKey, result.Result) {
|
Implement more precise delete-before-replace semantics. (#2369)
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.
2019-01-28 18:46:30 +01:00
|
|
|
// Neither component nor external resources require replacement.
|
|
|
|
if !r.Custom || r.External {
|
|
|
|
return false, nil, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// If the resource's provider is in the replace set, we mustreplace this resource.
|
|
|
|
if r.Provider != "" {
|
|
|
|
ref, err := providers.ParseReference(r.Provider)
|
|
|
|
if err != nil {
|
2019-03-21 21:23:46 +01:00
|
|
|
return false, nil, result.FromError(err)
|
Implement more precise delete-before-replace semantics. (#2369)
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.
2019-01-28 18:46:30 +01:00
|
|
|
}
|
|
|
|
if replaceSet[ref.URN()] {
|
|
|
|
return true, nil, nil
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Scan the properties of this resource in order to determine whether or not any of them depend on a resource
|
|
|
|
// that requires replacement and build a set of input properties for the provider diff.
|
|
|
|
hasDependencyInReplaceSet, inputsForDiff := false, resource.PropertyMap{}
|
|
|
|
for pk, pv := range r.Inputs {
|
|
|
|
for _, propertyDep := range r.PropertyDependencies[pk] {
|
|
|
|
if replaceSet[propertyDep] {
|
|
|
|
hasDependencyInReplaceSet = true
|
|
|
|
pv = resource.MakeComputed(resource.NewStringProperty("<unknown>"))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
inputsForDiff[pk] = pv
|
|
|
|
}
|
|
|
|
|
|
|
|
// If none of this resource's properties depend on a resource in the replace set, then none of the properties
|
|
|
|
// may change and this resource does not need to be replaced.
|
|
|
|
if !hasDependencyInReplaceSet {
|
|
|
|
return false, nil, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// Otherwise, fetch the resource's provider. Since we have filtered out component resources, this resource must
|
|
|
|
// have a provider.
|
2019-03-21 21:23:46 +01:00
|
|
|
prov, res := sg.loadResourceProvider(r.URN, r.Custom, r.Provider, r.Type)
|
|
|
|
if res != nil {
|
|
|
|
return false, nil, res
|
Implement more precise delete-before-replace semantics. (#2369)
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.
2019-01-28 18:46:30 +01:00
|
|
|
}
|
|
|
|
contract.Assert(prov != nil)
|
|
|
|
|
|
|
|
// Call the provider's `Diff` method and return.
|
2019-07-31 18:39:07 +02:00
|
|
|
diff, err := prov.Diff(r.URN, r.ID, r.Outputs, inputsForDiff, true, nil)
|
Implement more precise delete-before-replace semantics. (#2369)
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.
2019-01-28 18:46:30 +01:00
|
|
|
if err != nil {
|
2019-03-21 21:23:46 +01:00
|
|
|
return false, nil, result.FromError(err)
|
Implement more precise delete-before-replace semantics. (#2369)
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.
2019-01-28 18:46:30 +01:00
|
|
|
}
|
|
|
|
return diff.Replace(), diff.ReplaceKeys, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// Walk the root resource's dependents in order and build up the set of resources that require replacement.
|
|
|
|
for _, d := range sg.plan.depGraph.DependingOn(root) {
|
2019-03-21 21:23:46 +01:00
|
|
|
replace, keys, res := requiresReplacement(d)
|
|
|
|
if res != nil {
|
|
|
|
return nil, res
|
Implement more precise delete-before-replace semantics. (#2369)
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.
2019-01-28 18:46:30 +01:00
|
|
|
}
|
|
|
|
if replace {
|
|
|
|
toReplace, replaceSet[d.URN] = append(toReplace, dependentReplace{res: d, keys: keys}), true
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Return the list of resources to replace.
|
|
|
|
return toReplace, nil
|
|
|
|
}
|
|
|
|
|
2018-07-12 23:24:38 +02:00
|
|
|
// newStepGenerator creates a new step generator that operates on the given plan.
|
|
|
|
func newStepGenerator(plan *Plan, opts Options) *stepGenerator {
|
|
|
|
return &stepGenerator{
|
Implement more precise delete-before-replace semantics. (#2369)
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.
2019-01-28 18:46:30 +01:00
|
|
|
plan: plan,
|
|
|
|
opts: opts,
|
|
|
|
urns: make(map[resource.URN]bool),
|
|
|
|
reads: make(map[resource.URN]bool),
|
|
|
|
creates: make(map[resource.URN]bool),
|
|
|
|
sames: make(map[resource.URN]bool),
|
|
|
|
replaces: make(map[resource.URN]bool),
|
|
|
|
updates: make(map[resource.URN]bool),
|
|
|
|
deletes: make(map[resource.URN]bool),
|
|
|
|
pendingDeletes: make(map[*resource.State]bool),
|
Refine resource replacement logic for providers (#2767)
This commit touches an intersection of a few different provider-oriented
features that combined to cause a particularly severe bug that made it
impossible for users to upgrade provider versions without seeing
replacements with their resources.
For some context, Pulumi models all providers as resources and places
them in the snapshot like any other resource. Every resource has a
reference to the provider that created it. If a Pulumi program does not
specify a particular provider to use when performing a resource
operation, the Pulumi engine injects one automatically; these are called
"default providers" and are the most common ways that users end up with
providers in their snapshot. Default providers can be identified by
their name, which is always prefixed with "default".
Recently, in an effort to make the Pulumi engine more flexible with
provider versions, it was made possible for the engine to have multiple
default providers active for a provider of a particular type, which was
previously not possible. Because a provider is identified as a tuple of
package name and version, it was difficult to find a name for these
duplicate default providers that did not cause additional problems. The
provider versioning PR gave these default providers a name that was
derived from the version of the package. This proved to be a problem,
because when users upgraded from one version of a package to another,
this changed the name of their default provider which in turn caused all
of their resources created using that provider (read: everything) to be
replaced.
To combat this, this PR introduces a rule that the engine will apply
when diffing a resource to determine whether or not it needs to be
replaced: "If a resource's provider changes, and both old and new
providers are default providers whose properties do not require
replacement, proceed as if there were no diff." This allows the engine
to gracefully recognize and recover when a resource's default provider changes
names, as long as the provider's config has not changed.
2019-06-03 21:16:31 +02:00
|
|
|
providers: make(map[resource.URN]*resource.State),
|
Implement more precise delete-before-replace semantics. (#2369)
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.
2019-01-28 18:46:30 +01:00
|
|
|
dependentReplaceKeys: make(map[resource.URN][]resource.PropertyKey),
|
2019-06-01 08:01:01 +02:00
|
|
|
aliased: make(map[resource.URN]resource.URN),
|
2018-07-12 23:24:38 +02:00
|
|
|
}
|
|
|
|
}
|