mirror of
https://github.com/opentffoundation/opentf.git
synced 2025-12-23 03:34:30 -05:00
bcdadc80ee
Previously we treated PackageLocation only as pure data, describing a location from which something could be retrieved. Unexported functions in package providercache then treated PackageLocation values as a closed union dispatched using a type switch. That strategy has been okay for our relatively-generic package locations so far, but in a future commit we intend to add a new kind of package location referring to a manifest in an OCI distribution repository, and installing from _that_ will require a nontrivial amount of OCI-distribution-specific logic that will be more tightly coupled to the getproviders.Source that will return such locations, and so we're switching to a model where _the location object itself_ is responsible for knowing how to install a provider package from its location, as a method of PackageLocation. The implementation of installing from each location type now moves from package providercache to package getproviders, which is arguably a better thematic home for that functionality anyway. For now these remain tested only indirectly through the tests in package providercache, since we didn't previously have any independent tests for these unexported functions. We might want to add more tightly-scoped unit tests for these to package getproviders in future, but for now this is not materially worse than it was before. Signed-off-by: Martin Atkins <mart@degeneration.co.uk>
102 lines
4.1 KiB
Go
102 lines
4.1 KiB
Go
// Copyright (c) The OpenTofu Authors
|
|
// SPDX-License-Identifier: MPL-2.0
|
|
// Copyright (c) 2023 HashiCorp, Inc.
|
|
// SPDX-License-Identifier: MPL-2.0
|
|
|
|
package providercache
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"log"
|
|
|
|
"github.com/opentofu/opentofu/internal/getproviders"
|
|
)
|
|
|
|
// InstallPackage takes a metadata object describing a package available for
|
|
// installation, retrieves that package, and installs it into the receiving
|
|
// cache directory.
|
|
//
|
|
// If the allowedHashes set has non-zero length then at least one of the hashes
|
|
// in the set must match the package that "entry" refers to. If none of the
|
|
// hashes match then the returned error message assumes that the hashes came
|
|
// from a lock file.
|
|
func (d *Dir) InstallPackage(ctx context.Context, meta getproviders.PackageMeta, allowedHashes []getproviders.Hash) (*getproviders.PackageAuthenticationResult, error) {
|
|
if meta.TargetPlatform != d.targetPlatform {
|
|
return nil, fmt.Errorf("can't install %s package into cache directory expecting %s", meta.TargetPlatform, d.targetPlatform)
|
|
}
|
|
newPath := getproviders.UnpackedDirectoryPathForPackage(
|
|
d.baseDir, meta.Provider, meta.Version, d.targetPlatform,
|
|
)
|
|
|
|
// Invalidate our metaCache so that subsequent read calls will re-scan to
|
|
// incorporate any changes we make here.
|
|
d.metaCache = nil
|
|
|
|
log.Printf("[TRACE] providercache.Dir.InstallPackage: installing %s v%s from %s", meta.Provider, meta.Version, meta.Location)
|
|
return meta.Location.InstallProviderPackage(ctx, meta, newPath, allowedHashes)
|
|
}
|
|
|
|
// LinkFromOtherCache takes a CachedProvider value produced from another Dir
|
|
// and links it into the cache represented by the receiver Dir.
|
|
//
|
|
// This is used to implement tiered caching, where new providers are first
|
|
// populated into a system-wide shared cache and then linked from there into
|
|
// a configuration-specific local cache.
|
|
//
|
|
// It's invalid to link a CachedProvider from a particular Dir into that same
|
|
// Dir, because that would otherwise potentially replace a real package
|
|
// directory with a circular link back to itself.
|
|
//
|
|
// If the allowedHashes set has non-zero length then at least one of the hashes
|
|
// in the set must match the package that "entry" refers to. If none of the
|
|
// hashes match then the returned error message assumes that the hashes came
|
|
// from a lock file.
|
|
func (d *Dir) LinkFromOtherCache(entry *CachedProvider, allowedHashes []getproviders.Hash) error {
|
|
if len(allowedHashes) > 0 {
|
|
if matches, err := entry.MatchesAnyHash(allowedHashes); err != nil {
|
|
return fmt.Errorf(
|
|
"failed to calculate checksum for cached copy of %s %s in %s: %w",
|
|
entry.Provider, entry.Version, d.baseDir, err,
|
|
)
|
|
} else if !matches {
|
|
return fmt.Errorf(
|
|
"the provider cache at %s has a copy of %s %s that doesn't match any of the checksums recorded in the dependency lock file",
|
|
d.baseDir, entry.Provider, entry.Version,
|
|
)
|
|
}
|
|
}
|
|
|
|
newPath := getproviders.UnpackedDirectoryPathForPackage(
|
|
d.baseDir, entry.Provider, entry.Version, d.targetPlatform,
|
|
)
|
|
currentPath := entry.PackageDir
|
|
log.Printf("[TRACE] providercache.Dir.LinkFromOtherCache: linking %s v%s from existing cache %s to %s", entry.Provider, entry.Version, currentPath, newPath)
|
|
|
|
// Invalidate our metaCache so that subsequent read calls will re-scan to
|
|
// incorporate any changes we make here.
|
|
d.metaCache = nil
|
|
|
|
// We re-use the process of installing from a local directory here, because
|
|
// the two operations are fundamentally the same: symlink if possible,
|
|
// deep-copy otherwise.
|
|
meta := getproviders.PackageMeta{
|
|
Provider: entry.Provider,
|
|
Version: entry.Version,
|
|
|
|
// FIXME: How do we populate this?
|
|
ProtocolVersions: nil,
|
|
TargetPlatform: d.targetPlatform,
|
|
|
|
// Because this is already unpacked, the filename is synthetic
|
|
// based on the standard naming scheme.
|
|
Filename: fmt.Sprintf("terraform-provider-%s_%s_%s.zip",
|
|
entry.Provider.Type, entry.Version, d.targetPlatform),
|
|
Location: getproviders.PackageLocalDir(currentPath),
|
|
}
|
|
// No further hash check here because we already checked the hash
|
|
// of the source directory above.
|
|
_, err := meta.Location.InstallProviderPackage(context.TODO(), meta, newPath, nil)
|
|
return err
|
|
}
|