mirror of
https://github.com/opentofu/opentofu.git
synced 2024-12-25 16:31:10 -06:00
104 lines
3.5 KiB
Go
104 lines
3.5 KiB
Go
package config
|
|
|
|
import "github.com/blang/semver"
|
|
|
|
// ProviderVersionConstraint presents a constraint for a particular
|
|
// provider, identified by its full name.
|
|
type ProviderVersionConstraint struct {
|
|
Constraint string
|
|
ProviderType string
|
|
}
|
|
|
|
// ProviderVersionConstraints is a map from provider full name to its associated
|
|
// ProviderVersionConstraint, as produced by Config.RequiredProviders.
|
|
type ProviderVersionConstraints map[string]ProviderVersionConstraint
|
|
|
|
// RequiredProviders returns the ProviderVersionConstraints for this
|
|
// module.
|
|
//
|
|
// This includes both providers that are explicitly requested by provider
|
|
// blocks and those that are used implicitly by instantiating one of their
|
|
// resource types. In the latter case, the returned semver Range will
|
|
// accept any version of the provider.
|
|
func (c *Config) RequiredProviders() ProviderVersionConstraints {
|
|
ret := make(ProviderVersionConstraints, len(c.ProviderConfigs))
|
|
|
|
configs := c.ProviderConfigsByFullName()
|
|
|
|
// In order to find the *implied* dependencies (those without explicit
|
|
// "provider" blocks) we need to walk over all of the resources and
|
|
// cross-reference with the provider configs.
|
|
for _, rc := range c.Resources {
|
|
providerName := rc.ProviderFullName()
|
|
var providerType string
|
|
|
|
// Default to (effectively) no constraint whatsoever, but we might
|
|
// override if there's an explicit constraint in config.
|
|
constraint := ">=0.0.0"
|
|
|
|
config, ok := configs[providerName]
|
|
if ok {
|
|
if config.Version != "" {
|
|
constraint = config.Version
|
|
}
|
|
providerType = config.Name
|
|
} else {
|
|
providerType = providerName
|
|
}
|
|
|
|
ret[providerName] = ProviderVersionConstraint{
|
|
ProviderType: providerType,
|
|
Constraint: constraint,
|
|
}
|
|
}
|
|
|
|
return ret
|
|
}
|
|
|
|
// RequiredRanges returns a semver.Range for each distinct provider type in
|
|
// the constraint map. If the same provider type appears more than once
|
|
// (e.g. because aliases are in use) then their respective constraints are
|
|
// combined such that they must *all* apply.
|
|
//
|
|
// The result of this method can be passed to the
|
|
// PluginMetaSet.ConstrainVersions method within the plugin/discovery
|
|
// package in order to filter down the available plugins to those which
|
|
// satisfy the given constraints.
|
|
//
|
|
// This function will panic if any of the constraints within cannot be
|
|
// parsed as semver ranges. This is guaranteed to never happen for a
|
|
// constraint set that was built from a configuration that passed validation.
|
|
func (cons ProviderVersionConstraints) RequiredRanges() map[string]semver.Range {
|
|
ret := make(map[string]semver.Range, len(cons))
|
|
|
|
for _, con := range cons {
|
|
spec := semver.MustParseRange(con.Constraint)
|
|
if existing, exists := ret[con.ProviderType]; exists {
|
|
ret[con.ProviderType] = existing.AND(spec)
|
|
} else {
|
|
ret[con.ProviderType] = spec
|
|
}
|
|
}
|
|
|
|
return ret
|
|
}
|
|
|
|
// ProviderConfigsByFullName returns a map from provider full names (as
|
|
// returned by ProviderConfig.FullName()) to the corresponding provider
|
|
// configs.
|
|
//
|
|
// This function returns no new information than what's already in
|
|
// c.ProviderConfigs, but returns it in a more convenient shape. If there
|
|
// is more than one provider config with the same full name then the result
|
|
// is undefined, but that is guaranteed not to happen for any config that
|
|
// has passed validation.
|
|
func (c *Config) ProviderConfigsByFullName() map[string]*ProviderConfig {
|
|
ret := make(map[string]*ProviderConfig, len(c.ProviderConfigs))
|
|
|
|
for _, pc := range c.ProviderConfigs {
|
|
ret[pc.FullName()] = pc
|
|
}
|
|
|
|
return ret
|
|
}
|