152 lines
6.5 KiB
Go
152 lines
6.5 KiB
Go
package providercache
|
|
|
|
import (
|
|
"fmt"
|
|
"io/ioutil"
|
|
"path/filepath"
|
|
"strings"
|
|
|
|
"github.com/hashicorp/terraform/internal/addrs"
|
|
"github.com/hashicorp/terraform/internal/getproviders"
|
|
)
|
|
|
|
// CachedProvider represents a provider package in a cache directory.
|
|
type CachedProvider struct {
|
|
// Provider and Version together identify the specific provider version
|
|
// this cache entry represents.
|
|
Provider addrs.Provider
|
|
Version getproviders.Version
|
|
|
|
// PackageDir is the local filesystem path to the root directory where
|
|
// the provider's distribution archive was unpacked.
|
|
//
|
|
// The path always uses slashes as path separators, even on Windows, so
|
|
// that the results are consistent between platforms. Windows accepts
|
|
// both slashes and backslashes as long as the separators are consistent
|
|
// within a particular path string.
|
|
PackageDir string
|
|
}
|
|
|
|
// PackageLocation returns the package directory given in the PackageDir field
|
|
// as a getproviders.PackageLocation implementation.
|
|
//
|
|
// Because cached providers are always in the unpacked structure, the result is
|
|
// always of the concrete type getproviders.PackageLocalDir.
|
|
func (cp *CachedProvider) PackageLocation() getproviders.PackageLocalDir {
|
|
return getproviders.PackageLocalDir(cp.PackageDir)
|
|
}
|
|
|
|
// Hash computes a hash of the contents of the package directory associated
|
|
// with the receiving cached provider, using whichever hash algorithm is
|
|
// the current default.
|
|
//
|
|
// If you need a specific version of hash rather than just whichever one is
|
|
// current default, call that version's corresponding method (e.g. HashV1)
|
|
// directly instead.
|
|
func (cp *CachedProvider) Hash() (getproviders.Hash, error) {
|
|
return getproviders.PackageHash(cp.PackageLocation())
|
|
}
|
|
|
|
// MatchesHash returns true if the package on disk matches the given hash,
|
|
// or false otherwise. If it cannot traverse the package directory and read
|
|
// all of the files in it, or if the hash is in an unsupported format,
|
|
// MatchesHash returns an error.
|
|
//
|
|
// MatchesHash may accept hashes in a number of different formats. Over time
|
|
// the set of supported formats may grow and shrink.
|
|
func (cp *CachedProvider) MatchesHash(want getproviders.Hash) (bool, error) {
|
|
return getproviders.PackageMatchesHash(cp.PackageLocation(), want)
|
|
}
|
|
|
|
// MatchesAnyHash returns true if the package on disk matches the given hash,
|
|
// or false otherwise. If it cannot traverse the package directory and read
|
|
// all of the files in it, MatchesAnyHash returns an error.
|
|
//
|
|
// Unlike the singular MatchesHash, MatchesAnyHash considers unsupported hash
|
|
// formats as successfully non-matching, rather than returning an error.
|
|
func (cp *CachedProvider) MatchesAnyHash(allowed []getproviders.Hash) (bool, error) {
|
|
return getproviders.PackageMatchesAnyHash(cp.PackageLocation(), allowed)
|
|
}
|
|
|
|
// HashV1 computes a hash of the contents of the package directory associated
|
|
// with the receiving cached provider using hash algorithm 1.
|
|
//
|
|
// The hash covers the paths to files in the directory and the contents of
|
|
// those files. It does not cover other metadata about the files, such as
|
|
// permissions.
|
|
//
|
|
// This function is named "HashV1" in anticipation of other hashing algorithms
|
|
// being added (in a backward-compatible way) in future. The result from
|
|
// HashV1 always begins with the prefix "h1:" so that callers can distinguish
|
|
// the results of potentially multiple different hash algorithms in future.
|
|
func (cp *CachedProvider) HashV1() (getproviders.Hash, error) {
|
|
return getproviders.PackageHashV1(cp.PackageLocation())
|
|
}
|
|
|
|
// ExecutableFile inspects the cached provider's unpacked package directory for
|
|
// something that looks like it's intended to be the executable file for the
|
|
// plugin.
|
|
//
|
|
// This is a bit messy and heuristic-y because historically Terraform used the
|
|
// filename itself for local filesystem discovery, allowing some variance in
|
|
// the filenames to capture extra metadata, whereas now we're using the
|
|
// directory structure leading to the executable instead but need to remain
|
|
// compatible with the executable names bundled into existing provider packages.
|
|
//
|
|
// It will return an error if it can't find a file following the expected
|
|
// convention in the given directory.
|
|
//
|
|
// If found, the path always uses slashes as path separators, even on Windows,
|
|
// so that the results are consistent between platforms. Windows accepts both
|
|
// slashes and backslashes as long as the separators are consistent within a
|
|
// particular path string.
|
|
func (cp *CachedProvider) ExecutableFile() (string, error) {
|
|
infos, err := ioutil.ReadDir(cp.PackageDir)
|
|
if err != nil {
|
|
// If the directory itself doesn't exist or isn't readable then we
|
|
// can't access an executable in it.
|
|
return "", fmt.Errorf("could not read package directory: %s", err)
|
|
}
|
|
|
|
// For a provider named e.g. tf.example.com/awesomecorp/happycloud, we
|
|
// expect an executable file whose name starts with
|
|
// "terraform-provider-happycloud", followed by zero or more additional
|
|
// characters. If there _are_ additional characters then the first one
|
|
// must be an underscore or a period, like in thse examples:
|
|
// - terraform-provider-happycloud_v1.0.0
|
|
// - terraform-provider-happycloud.exe
|
|
//
|
|
// We don't require the version in the filename to match because the
|
|
// executable's name is no longer authoritative, but packages of "official"
|
|
// providers may continue to use versioned executable names for backward
|
|
// compatibility with Terraform 0.12.
|
|
//
|
|
// We also presume that providers packaged for Windows will include the
|
|
// necessary .exe extension on their filenames but do not explicitly check
|
|
// for that. If there's a provider package for Windows that has a file
|
|
// without that suffix then it will be detected as an executable but then
|
|
// we'll presumably fail later trying to run it.
|
|
wantPrefix := "terraform-provider-" + cp.Provider.Type
|
|
|
|
// We'll visit all of the directory entries and take the first (in
|
|
// name-lexical order) that looks like a plausible provider executable
|
|
// name. A package with multiple files meeting these criteria is degenerate
|
|
// but we will tolerate it by ignoring the subsequent entries.
|
|
for _, info := range infos {
|
|
if info.IsDir() {
|
|
continue // A directory can never be an executable
|
|
}
|
|
name := info.Name()
|
|
if !strings.HasPrefix(name, wantPrefix) {
|
|
continue
|
|
}
|
|
remainder := name[len(wantPrefix):]
|
|
if len(remainder) > 0 && (remainder[0] != '_' && remainder[0] != '.') {
|
|
continue // subsequent characters must be delimited by _ or .
|
|
}
|
|
return filepath.ToSlash(filepath.Join(cp.PackageDir, name)), nil
|
|
}
|
|
|
|
return "", fmt.Errorf("could not find executable file starting with %s", wantPrefix)
|
|
}
|