2019-12-20 02:24:14 +01:00
|
|
|
package getproviders
|
|
|
|
|
|
|
|
import (
|
2020-02-21 02:57:15 +01:00
|
|
|
"fmt"
|
2019-12-20 02:24:14 +01:00
|
|
|
"runtime"
|
2020-02-21 02:57:15 +01:00
|
|
|
"sort"
|
|
|
|
"strings"
|
2019-12-20 02:24:14 +01:00
|
|
|
|
|
|
|
"github.com/apparentlymart/go-versions/versions"
|
2020-03-13 01:48:30 +01:00
|
|
|
"github.com/apparentlymart/go-versions/versions/constraints"
|
|
|
|
|
2020-02-21 02:57:15 +01:00
|
|
|
"github.com/hashicorp/terraform/addrs"
|
2019-12-20 02:24:14 +01:00
|
|
|
)
|
|
|
|
|
|
|
|
// Version represents a particular single version of a provider.
|
|
|
|
type Version = versions.Version
|
|
|
|
|
2020-05-11 19:49:12 +02:00
|
|
|
// UnspecifiedVersion is the zero value of Version, representing the absense
|
|
|
|
// of a version number.
|
|
|
|
var UnspecifiedVersion Version = versions.Unspecified
|
|
|
|
|
2019-12-20 02:24:14 +01:00
|
|
|
// VersionList represents a list of versions. It is a []Version with some
|
|
|
|
// extra methods for convenient filtering.
|
|
|
|
type VersionList = versions.List
|
|
|
|
|
2020-03-12 03:11:52 +01:00
|
|
|
// VersionSet represents a set of versions, usually describing the acceptable
|
|
|
|
// versions that can be selected under a particular version constraint provided
|
|
|
|
// by the end-user.
|
|
|
|
type VersionSet = versions.Set
|
|
|
|
|
2020-03-13 01:48:30 +01:00
|
|
|
// VersionConstraints represents a set of version constraints, which can
|
|
|
|
// define the membership of a VersionSet by exclusion.
|
|
|
|
type VersionConstraints = constraints.IntersectionSpec
|
|
|
|
|
2020-06-25 16:49:48 +02:00
|
|
|
// Warnings represents a list of warnings returned by a Registry source.
|
|
|
|
type Warnings = []string
|
|
|
|
|
2020-03-26 20:04:48 +01:00
|
|
|
// Requirements gathers together requirements for many different providers
|
|
|
|
// into a single data structure, as a convenient way to represent the full
|
|
|
|
// set of requirements for a particular configuration or state or both.
|
|
|
|
//
|
|
|
|
// If an entry in a Requirements has a zero-length VersionConstraints then
|
|
|
|
// that indicates that the provider is required but that any version is
|
|
|
|
// acceptable. That's different than a provider being absent from the map
|
|
|
|
// altogether, which means that it is not required at all.
|
|
|
|
type Requirements map[addrs.Provider]VersionConstraints
|
|
|
|
|
|
|
|
// Merge takes the requirements in the receiever and the requirements in the
|
|
|
|
// other given value and produces a new set of requirements that combines
|
|
|
|
// all of the requirements of both.
|
|
|
|
//
|
|
|
|
// The resulting requirements will permit only selections that both of the
|
|
|
|
// source requirements would've allowed.
|
|
|
|
func (r Requirements) Merge(other Requirements) Requirements {
|
|
|
|
ret := make(Requirements)
|
|
|
|
for addr, constraints := range r {
|
|
|
|
ret[addr] = constraints
|
|
|
|
}
|
|
|
|
for addr, constraints := range other {
|
|
|
|
ret[addr] = append(ret[addr], constraints...)
|
|
|
|
}
|
|
|
|
return ret
|
|
|
|
}
|
|
|
|
|
|
|
|
// Selections gathers together version selections for many different providers.
|
|
|
|
//
|
|
|
|
// This is the result of provider installation: a specific version selected
|
|
|
|
// for each provider given in the requested Requirements, selected based on
|
|
|
|
// the given version constraints.
|
|
|
|
type Selections map[addrs.Provider]Version
|
|
|
|
|
2019-12-20 02:24:14 +01:00
|
|
|
// ParseVersion parses a "semver"-style version string into a Version value,
|
|
|
|
// which is the version syntax we use for provider versions.
|
|
|
|
func ParseVersion(str string) (Version, error) {
|
|
|
|
return versions.ParseVersion(str)
|
|
|
|
}
|
|
|
|
|
2020-03-26 20:04:48 +01:00
|
|
|
// MustParseVersion is a variant of ParseVersion that panics if it encounters
|
|
|
|
// an error while parsing.
|
|
|
|
func MustParseVersion(str string) Version {
|
|
|
|
ret, err := ParseVersion(str)
|
|
|
|
if err != nil {
|
|
|
|
panic(err)
|
|
|
|
}
|
|
|
|
return ret
|
|
|
|
}
|
|
|
|
|
2020-03-13 19:22:24 +01:00
|
|
|
// ParseVersionConstraints parses a "Ruby-like" version constraint string
|
|
|
|
// into a VersionConstraints value.
|
|
|
|
func ParseVersionConstraints(str string) (VersionConstraints, error) {
|
|
|
|
return constraints.ParseRubyStyleMulti(str)
|
|
|
|
}
|
|
|
|
|
2020-03-26 20:04:48 +01:00
|
|
|
// MustParseVersionConstraints is a variant of ParseVersionConstraints that
|
|
|
|
// panics if it encounters an error while parsing.
|
|
|
|
func MustParseVersionConstraints(str string) VersionConstraints {
|
|
|
|
ret, err := ParseVersionConstraints(str)
|
|
|
|
if err != nil {
|
|
|
|
panic(err)
|
|
|
|
}
|
|
|
|
return ret
|
|
|
|
}
|
|
|
|
|
2020-05-11 19:49:12 +02:00
|
|
|
// MeetingConstraints returns a version set that contains all of the versions
|
|
|
|
// that meet the given constraints, specified using the Spec type from the
|
|
|
|
// constraints package.
|
|
|
|
func MeetingConstraints(vc VersionConstraints) VersionSet {
|
|
|
|
return versions.MeetingConstraints(vc)
|
|
|
|
}
|
|
|
|
|
2019-12-20 02:24:14 +01:00
|
|
|
// Platform represents a target platform that a provider is or might be
|
|
|
|
// available for.
|
|
|
|
type Platform struct {
|
|
|
|
OS, Arch string
|
|
|
|
}
|
|
|
|
|
|
|
|
func (p Platform) String() string {
|
|
|
|
return p.OS + "_" + p.Arch
|
|
|
|
}
|
|
|
|
|
2020-02-21 02:57:15 +01:00
|
|
|
// LessThan returns true if the receiver should sort before the other given
|
|
|
|
// Platform in an ordered list of platforms.
|
|
|
|
//
|
|
|
|
// The ordering is lexical first by OS and then by Architecture.
|
|
|
|
// This ordering is primarily just to ensure that results of
|
|
|
|
// functions in this package will be deterministic. The ordering is not
|
|
|
|
// intended to have any semantic meaning and is subject to change in future.
|
|
|
|
func (p Platform) LessThan(other Platform) bool {
|
|
|
|
switch {
|
|
|
|
case p.OS != other.OS:
|
|
|
|
return p.OS < other.OS
|
|
|
|
default:
|
|
|
|
return p.Arch < other.Arch
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-02-21 02:54:35 +01:00
|
|
|
// ParsePlatform parses a string representation of a platform, like
|
|
|
|
// "linux_amd64", or returns an error if the string is not valid.
|
|
|
|
func ParsePlatform(str string) (Platform, error) {
|
|
|
|
underPos := strings.Index(str, "_")
|
|
|
|
if underPos < 1 || underPos >= len(str)-2 {
|
|
|
|
return Platform{}, fmt.Errorf("must be two words separated by an underscore")
|
|
|
|
}
|
|
|
|
|
|
|
|
os, arch := str[:underPos], str[underPos+1:]
|
|
|
|
if strings.ContainsAny(os, " \t\n\r") {
|
|
|
|
return Platform{}, fmt.Errorf("OS portion must not contain whitespace")
|
|
|
|
}
|
|
|
|
if strings.ContainsAny(arch, " \t\n\r") {
|
|
|
|
return Platform{}, fmt.Errorf("architecture portion must not contain whitespace")
|
|
|
|
}
|
|
|
|
|
|
|
|
return Platform{
|
|
|
|
OS: os,
|
|
|
|
Arch: arch,
|
|
|
|
}, nil
|
|
|
|
}
|
|
|
|
|
2019-12-20 02:24:14 +01:00
|
|
|
// CurrentPlatform is the platform where the current program is running.
|
|
|
|
//
|
|
|
|
// If attempting to install providers for use on the same system where the
|
|
|
|
// installation process is running, this is the right platform to use.
|
|
|
|
var CurrentPlatform = Platform{
|
|
|
|
OS: runtime.GOOS,
|
|
|
|
Arch: runtime.GOARCH,
|
|
|
|
}
|
|
|
|
|
|
|
|
// PackageMeta represents the metadata related to a particular downloadable
|
|
|
|
// provider package targeting a single platform.
|
|
|
|
//
|
|
|
|
// Package findproviders does no signature verification or protocol version
|
|
|
|
// compatibility checking of its own. A caller receving a PackageMeta must
|
|
|
|
// verify that it has a correct signature and supports a protocol version
|
|
|
|
// accepted by the current version of Terraform before trying to use the
|
|
|
|
// described package.
|
|
|
|
type PackageMeta struct {
|
2020-02-21 02:53:11 +01:00
|
|
|
Provider addrs.Provider
|
|
|
|
Version Version
|
|
|
|
|
2019-12-20 02:24:14 +01:00
|
|
|
ProtocolVersions VersionList
|
|
|
|
TargetPlatform Platform
|
|
|
|
|
2020-02-21 03:01:29 +01:00
|
|
|
Filename string
|
|
|
|
Location PackageLocation
|
|
|
|
|
2020-04-03 21:11:57 +02:00
|
|
|
// Authentication, if non-nil, is a request from the source that produced
|
|
|
|
// this meta for verification of the target package after it has been
|
|
|
|
// retrieved from the indicated Location.
|
|
|
|
//
|
|
|
|
// Different sources will support different authentication strategies --
|
|
|
|
// or possibly no strategies at all -- depending on what metadata they
|
|
|
|
// have available to them, such as checksums provided out-of-band by the
|
|
|
|
// original package author, expected signing keys, etc.
|
|
|
|
//
|
|
|
|
// If Authentication is non-nil then no authentication is requested.
|
|
|
|
// This is likely appropriate only for packages that are already available
|
|
|
|
// on the local system.
|
|
|
|
Authentication PackageAuthentication
|
2019-12-20 02:24:14 +01:00
|
|
|
}
|
2020-01-09 01:24:41 +01:00
|
|
|
|
2020-02-21 02:57:15 +01:00
|
|
|
// LessThan returns true if the receiver should sort before the given other
|
|
|
|
// PackageMeta in a sorted list of PackageMeta.
|
|
|
|
//
|
|
|
|
// Sorting preference is given first to the provider address, then to the
|
|
|
|
// taget platform, and the to the version number (using semver precedence).
|
|
|
|
// Packages that differ only in semver build metadata have no defined
|
|
|
|
// precedence and so will always return false.
|
|
|
|
//
|
|
|
|
// This ordering is primarily just to maximize the chance that results of
|
|
|
|
// functions in this package will be deterministic. The ordering is not
|
|
|
|
// intended to have any semantic meaning and is subject to change in future.
|
|
|
|
func (m PackageMeta) LessThan(other PackageMeta) bool {
|
|
|
|
switch {
|
|
|
|
case m.Provider != other.Provider:
|
|
|
|
return m.Provider.LessThan(other.Provider)
|
|
|
|
case m.TargetPlatform != other.TargetPlatform:
|
|
|
|
return m.TargetPlatform.LessThan(other.TargetPlatform)
|
|
|
|
case m.Version != other.Version:
|
|
|
|
return m.Version.LessThan(other.Version)
|
|
|
|
default:
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-03-12 01:53:19 +01:00
|
|
|
// UnpackedDirectoryPath determines the path under the given base
|
|
|
|
// directory where SearchLocalDirectory or the FilesystemMirrorSource would
|
|
|
|
// expect to find an unpacked copy of the receiving PackageMeta.
|
|
|
|
//
|
|
|
|
// The result always uses forward slashes as path separator, even on Windows,
|
|
|
|
// to produce a consistent result on all platforms. Windows accepts both
|
|
|
|
// direction of slash as long as each individual path string is self-consistent.
|
|
|
|
func (m PackageMeta) UnpackedDirectoryPath(baseDir string) string {
|
|
|
|
return UnpackedDirectoryPathForPackage(baseDir, m.Provider, m.Version, m.TargetPlatform)
|
|
|
|
}
|
|
|
|
|
2020-04-24 03:12:01 +02:00
|
|
|
// PackedFilePath determines the path under the given base
|
|
|
|
// directory where SearchLocalDirectory or the FilesystemMirrorSource would
|
|
|
|
// expect to find packed copy (a .zip archive) of the receiving PackageMeta.
|
|
|
|
//
|
|
|
|
// The result always uses forward slashes as path separator, even on Windows,
|
|
|
|
// to produce a consistent result on all platforms. Windows accepts both
|
|
|
|
// direction of slash as long as each individual path string is self-consistent.
|
|
|
|
func (m PackageMeta) PackedFilePath(baseDir string) string {
|
|
|
|
return PackedFilePathForPackage(baseDir, m.Provider, m.Version, m.TargetPlatform)
|
|
|
|
}
|
|
|
|
|
2020-09-24 01:23:00 +02:00
|
|
|
// AcceptableHashes returns a set of hashes that could be recorded for
|
|
|
|
// comparison to future results for the same provider version, to implement a
|
|
|
|
// "trust on first use" scheme.
|
|
|
|
//
|
|
|
|
// The AcceptableHashes result is a platform-agnostic set of hashes, with the
|
|
|
|
// intent that in most cases it will be used as an additional cross-check in
|
|
|
|
// addition to a platform-specific hash check made during installation. However,
|
|
|
|
// there are some situations (such as verifying an already-installed package
|
|
|
|
// that's on local disk) where Terraform would check only against the results
|
|
|
|
// of this function, meaning that it would in principle accept another
|
|
|
|
// platform's package as a substitute for the correct platform. That's a
|
|
|
|
// pragmatic compromise to allow lock files derived from the result of this
|
|
|
|
// method to be portable across platforms.
|
2020-09-09 01:44:55 +02:00
|
|
|
//
|
|
|
|
// Callers of this method should typically also verify the package using the
|
|
|
|
// object in the Authentication field, and consider how much trust to give
|
|
|
|
// the result of this method depending on the authentication result: an
|
|
|
|
// unauthenticated result or one that only verified a checksum could be
|
|
|
|
// considered less trustworthy than one that checked the package against
|
|
|
|
// a signature provided by the origin registry.
|
|
|
|
//
|
|
|
|
// The AcceptableHashes result is actually provided by the object in the
|
|
|
|
// Authentication field. AcceptableHashes therefore returns an empty result
|
|
|
|
// for a PackageMeta that has no authentication object, or has one that does
|
|
|
|
// not make use of hashes.
|
2020-09-24 01:23:00 +02:00
|
|
|
func (m PackageMeta) AcceptableHashes() []Hash {
|
2020-09-09 01:44:55 +02:00
|
|
|
auth, ok := m.Authentication.(PackageAuthenticationHashes)
|
|
|
|
if !ok {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
return auth.AcceptableHashes()
|
|
|
|
}
|
|
|
|
|
2020-01-09 01:24:41 +01:00
|
|
|
// PackageLocation represents a location where a provider distribution package
|
2020-01-10 02:54:16 +01:00
|
|
|
// can be obtained. A value of this type contains one of the following
|
|
|
|
// concrete types: PackageLocalArchive, PackageLocalDir, or PackageHTTPURL.
|
2020-01-09 01:24:41 +01:00
|
|
|
type PackageLocation interface {
|
|
|
|
packageLocation()
|
internal: Verify provider signatures on install
Providers installed from the registry are accompanied by a list of
checksums (the "SHA256SUMS" file), which is cryptographically signed to
allow package authentication. The process of verifying this has multiple
steps:
- First we must verify that the SHA256 hash of the package archive
matches the expected hash. This could be done for local installations
too, in the future.
- Next we ensure that the expected hash returned as part of the registry
API response matches an entry in the checksum list.
- Finally we verify the cryptographic signature of the checksum list,
using the public keys provided by the registry.
Each of these steps is implemented as a separate PackageAuthentication
type. The local archive installation mechanism uses only the archive
checksum authenticator, and the HTTP installation uses all three in the
order given.
The package authentication system now also returns a result value, which
is used by command/init to display the result of the authentication
process.
There are three tiers of signature, each of which is presented
differently to the user:
- Signatures from the embedded HashiCorp public key indicate that the
provider is officially supported by HashiCorp;
- If the signing key is not from HashiCorp, it may have an associated
trust signature, which indicates that the provider is from one of
HashiCorp's trusted partners;
- Otherwise, if the signature is valid, this is a community provider.
2020-04-08 22:22:07 +02:00
|
|
|
String() string
|
2020-01-09 01:24:41 +01:00
|
|
|
}
|
|
|
|
|
2020-01-10 02:54:16 +01:00
|
|
|
// PackageLocalArchive is the location of a provider distribution archive file
|
|
|
|
// in the local filesystem. Its value is a local filesystem path using the
|
|
|
|
// syntax understood by Go's standard path/filepath package on the operating
|
|
|
|
// system where Terraform is running.
|
|
|
|
type PackageLocalArchive string
|
2020-01-09 01:24:41 +01:00
|
|
|
|
2020-01-10 02:54:16 +01:00
|
|
|
func (p PackageLocalArchive) packageLocation() {}
|
internal: Verify provider signatures on install
Providers installed from the registry are accompanied by a list of
checksums (the "SHA256SUMS" file), which is cryptographically signed to
allow package authentication. The process of verifying this has multiple
steps:
- First we must verify that the SHA256 hash of the package archive
matches the expected hash. This could be done for local installations
too, in the future.
- Next we ensure that the expected hash returned as part of the registry
API response matches an entry in the checksum list.
- Finally we verify the cryptographic signature of the checksum list,
using the public keys provided by the registry.
Each of these steps is implemented as a separate PackageAuthentication
type. The local archive installation mechanism uses only the archive
checksum authenticator, and the HTTP installation uses all three in the
order given.
The package authentication system now also returns a result value, which
is used by command/init to display the result of the authentication
process.
There are three tiers of signature, each of which is presented
differently to the user:
- Signatures from the embedded HashiCorp public key indicate that the
provider is officially supported by HashiCorp;
- If the signing key is not from HashiCorp, it may have an associated
trust signature, which indicates that the provider is from one of
HashiCorp's trusted partners;
- Otherwise, if the signature is valid, this is a community provider.
2020-04-08 22:22:07 +02:00
|
|
|
func (p PackageLocalArchive) String() string { return string(p) }
|
2020-01-10 02:54:16 +01:00
|
|
|
|
|
|
|
// PackageLocalDir is the location of a directory containing an unpacked
|
|
|
|
// provider distribution archive in the local filesystem. Its value is a local
|
|
|
|
// filesystem path using the syntax understood by Go's standard path/filepath
|
|
|
|
// package on the operating system where Terraform is running.
|
|
|
|
type PackageLocalDir string
|
|
|
|
|
|
|
|
func (p PackageLocalDir) packageLocation() {}
|
internal: Verify provider signatures on install
Providers installed from the registry are accompanied by a list of
checksums (the "SHA256SUMS" file), which is cryptographically signed to
allow package authentication. The process of verifying this has multiple
steps:
- First we must verify that the SHA256 hash of the package archive
matches the expected hash. This could be done for local installations
too, in the future.
- Next we ensure that the expected hash returned as part of the registry
API response matches an entry in the checksum list.
- Finally we verify the cryptographic signature of the checksum list,
using the public keys provided by the registry.
Each of these steps is implemented as a separate PackageAuthentication
type. The local archive installation mechanism uses only the archive
checksum authenticator, and the HTTP installation uses all three in the
order given.
The package authentication system now also returns a result value, which
is used by command/init to display the result of the authentication
process.
There are three tiers of signature, each of which is presented
differently to the user:
- Signatures from the embedded HashiCorp public key indicate that the
provider is officially supported by HashiCorp;
- If the signing key is not from HashiCorp, it may have an associated
trust signature, which indicates that the provider is from one of
HashiCorp's trusted partners;
- Otherwise, if the signature is valid, this is a community provider.
2020-04-08 22:22:07 +02:00
|
|
|
func (p PackageLocalDir) String() string { return string(p) }
|
2020-01-09 01:24:41 +01:00
|
|
|
|
|
|
|
// PackageHTTPURL is a provider package location accessible via HTTP.
|
|
|
|
// Its value is a URL string using either the http: scheme or the https: scheme.
|
|
|
|
type PackageHTTPURL string
|
|
|
|
|
|
|
|
func (p PackageHTTPURL) packageLocation() {}
|
internal: Verify provider signatures on install
Providers installed from the registry are accompanied by a list of
checksums (the "SHA256SUMS" file), which is cryptographically signed to
allow package authentication. The process of verifying this has multiple
steps:
- First we must verify that the SHA256 hash of the package archive
matches the expected hash. This could be done for local installations
too, in the future.
- Next we ensure that the expected hash returned as part of the registry
API response matches an entry in the checksum list.
- Finally we verify the cryptographic signature of the checksum list,
using the public keys provided by the registry.
Each of these steps is implemented as a separate PackageAuthentication
type. The local archive installation mechanism uses only the archive
checksum authenticator, and the HTTP installation uses all three in the
order given.
The package authentication system now also returns a result value, which
is used by command/init to display the result of the authentication
process.
There are three tiers of signature, each of which is presented
differently to the user:
- Signatures from the embedded HashiCorp public key indicate that the
provider is officially supported by HashiCorp;
- If the signing key is not from HashiCorp, it may have an associated
trust signature, which indicates that the provider is from one of
HashiCorp's trusted partners;
- Otherwise, if the signature is valid, this is a community provider.
2020-04-08 22:22:07 +02:00
|
|
|
func (p PackageHTTPURL) String() string { return string(p) }
|
2020-02-21 02:57:15 +01:00
|
|
|
|
|
|
|
// PackageMetaList is a list of PackageMeta. It's just []PackageMeta with
|
|
|
|
// some methods for convenient sorting and filtering.
|
|
|
|
type PackageMetaList []PackageMeta
|
|
|
|
|
|
|
|
func (l PackageMetaList) Len() int {
|
|
|
|
return len(l)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (l PackageMetaList) Less(i, j int) bool {
|
|
|
|
return l[i].LessThan(l[j])
|
|
|
|
}
|
|
|
|
|
|
|
|
func (l PackageMetaList) Swap(i, j int) {
|
|
|
|
l[i], l[j] = l[j], l[i]
|
|
|
|
}
|
|
|
|
|
|
|
|
// Sort performs an in-place, stable sort on the contents of the list, using
|
|
|
|
// the ordering given by method Less. This ordering is primarily to help
|
|
|
|
// encourage deterministic results from functions and does not have any
|
|
|
|
// semantic meaning.
|
|
|
|
func (l PackageMetaList) Sort() {
|
|
|
|
sort.Stable(l)
|
|
|
|
}
|
|
|
|
|
|
|
|
// FilterPlatform constructs a new PackageMetaList that contains only the
|
|
|
|
// elements of the receiver that are for the given target platform.
|
|
|
|
//
|
|
|
|
// Pass CurrentPlatform to filter only for packages targeting the platform
|
|
|
|
// where this code is running.
|
|
|
|
func (l PackageMetaList) FilterPlatform(target Platform) PackageMetaList {
|
|
|
|
var ret PackageMetaList
|
|
|
|
for _, m := range l {
|
|
|
|
if m.TargetPlatform == target {
|
|
|
|
ret = append(ret, m)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return ret
|
|
|
|
}
|
|
|
|
|
|
|
|
// FilterProviderExactVersion constructs a new PackageMetaList that contains
|
|
|
|
// only the elements of the receiver that relate to the given provider address
|
|
|
|
// and exact version.
|
|
|
|
//
|
|
|
|
// The version matching for this function is exact, including matching on
|
|
|
|
// semver build metadata, because it's intended for handling a single exact
|
|
|
|
// version selected by the caller from a set of available versions.
|
|
|
|
func (l PackageMetaList) FilterProviderExactVersion(provider addrs.Provider, version Version) PackageMetaList {
|
|
|
|
var ret PackageMetaList
|
|
|
|
for _, m := range l {
|
|
|
|
if m.Provider == provider && m.Version == version {
|
|
|
|
ret = append(ret, m)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return ret
|
|
|
|
}
|
|
|
|
|
|
|
|
// FilterProviderPlatformExactVersion is a combination of both
|
|
|
|
// FilterPlatform and FilterProviderExactVersion that filters by all three
|
|
|
|
// criteria at once.
|
|
|
|
func (l PackageMetaList) FilterProviderPlatformExactVersion(provider addrs.Provider, platform Platform, version Version) PackageMetaList {
|
|
|
|
var ret PackageMetaList
|
|
|
|
for _, m := range l {
|
|
|
|
if m.Provider == provider && m.Version == version && m.TargetPlatform == platform {
|
|
|
|
ret = append(ret, m)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return ret
|
|
|
|
}
|
2020-03-13 01:48:30 +01:00
|
|
|
|
2020-09-04 03:35:31 +02:00
|
|
|
// VersionConstraintsString returns a canonical string representation of
|
2020-03-13 01:48:30 +01:00
|
|
|
// a VersionConstraints value.
|
|
|
|
func VersionConstraintsString(spec VersionConstraints) string {
|
|
|
|
// (we have our own function for this because the upstream versions
|
|
|
|
// library prefers to use npm/cargo-style constraint syntax, but
|
|
|
|
// Terraform prefers Ruby-like. Maybe we can upstream a "RubyLikeString")
|
|
|
|
// function to do this later, but having this in here avoids blocking on
|
|
|
|
// that and this is the sort of thing that is unlikely to need ongoing
|
|
|
|
// maintenance because the version constraint syntax is unlikely to change.)
|
2020-09-04 03:35:31 +02:00
|
|
|
//
|
|
|
|
// ParseVersionConstraints allows some variations for convenience, but the
|
|
|
|
// return value from this function serves as the normalized form of a
|
|
|
|
// particular version constraint, which is the form we require in dependency
|
|
|
|
// lock files. Therefore the canonical forms produced here are a compatibility
|
|
|
|
// constraint for the dependency lock file parser.
|
2020-03-13 01:48:30 +01:00
|
|
|
|
|
|
|
var b strings.Builder
|
|
|
|
for i, sel := range spec {
|
|
|
|
if i > 0 {
|
|
|
|
b.WriteString(", ")
|
|
|
|
}
|
|
|
|
switch sel.Operator {
|
|
|
|
case constraints.OpGreaterThan:
|
|
|
|
b.WriteString("> ")
|
|
|
|
case constraints.OpLessThan:
|
|
|
|
b.WriteString("< ")
|
|
|
|
case constraints.OpGreaterThanOrEqual:
|
|
|
|
b.WriteString(">= ")
|
|
|
|
case constraints.OpGreaterThanOrEqualPatchOnly, constraints.OpGreaterThanOrEqualMinorOnly:
|
|
|
|
// These two differ in how the version is written, not in the symbol.
|
|
|
|
b.WriteString("~> ")
|
|
|
|
case constraints.OpLessThanOrEqual:
|
|
|
|
b.WriteString("<= ")
|
|
|
|
case constraints.OpEqual:
|
|
|
|
b.WriteString("")
|
|
|
|
case constraints.OpNotEqual:
|
|
|
|
b.WriteString("!= ")
|
|
|
|
default:
|
|
|
|
// The above covers all of the operators we support during
|
|
|
|
// parsing, so we should not get here.
|
|
|
|
b.WriteString("??? ")
|
|
|
|
}
|
|
|
|
|
2020-10-19 22:37:00 +02:00
|
|
|
// The parser allows writing abbreviated version (such as 2) which
|
|
|
|
// end up being represented in memory with trailing unconstrained parts
|
|
|
|
// (for example 2.*.*). For the purpose of serialization with Ruby
|
|
|
|
// style syntax, these unconstrained parts can all be represented as 0
|
|
|
|
// with no loss of meaning, so we make that conversion here.
|
|
|
|
//
|
|
|
|
// This is possible because we use a different constraint operator to
|
|
|
|
// distinguish between the two types of pessimistic constraint:
|
|
|
|
// minor-only and patch-only. For minor-only constraints, we always
|
|
|
|
// want to display only the major and minor version components, so we
|
|
|
|
// special-case that operator below.
|
|
|
|
//
|
|
|
|
// One final edge case is a minor-only constraint specified with only
|
|
|
|
// the major version, such as ~> 2. We treat this the same as ~> 2.0,
|
|
|
|
// because a major-only pessimistic constraint does not exist: it is
|
|
|
|
// logically identical to >= 2.0.0.
|
|
|
|
boundary := sel.Boundary.ConstrainToZero()
|
2020-03-13 01:48:30 +01:00
|
|
|
if sel.Operator == constraints.OpGreaterThanOrEqualMinorOnly {
|
|
|
|
// The minor-pessimistic syntax uses only two version components.
|
2020-10-19 22:37:00 +02:00
|
|
|
fmt.Fprintf(&b, "%s.%s", boundary.Major, boundary.Minor)
|
2020-03-13 01:48:30 +01:00
|
|
|
} else {
|
2020-10-19 22:37:00 +02:00
|
|
|
fmt.Fprintf(&b, "%s.%s.%s", boundary.Major, boundary.Minor, boundary.Patch)
|
2020-03-13 01:48:30 +01:00
|
|
|
}
|
|
|
|
if sel.Boundary.Prerelease != "" {
|
2020-10-19 22:37:00 +02:00
|
|
|
b.WriteString("-" + boundary.Prerelease)
|
2020-03-13 01:48:30 +01:00
|
|
|
}
|
|
|
|
if sel.Boundary.Metadata != "" {
|
2020-10-19 22:37:00 +02:00
|
|
|
b.WriteString("+" + boundary.Metadata)
|
2020-03-13 01:48:30 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return b.String()
|
|
|
|
}
|