mirror of
https://github.com/opentofu/opentofu.git
synced 2024-12-28 01:41:48 -06:00
51b0aee36c
Previously we had a separation between ModuleSourceRemote and ModulePackage as a way to represent within the type system that there's an important difference between a module source address and a package address, because module packages often contain multiple modules and so a ModuleSourceRemote combines a ModulePackage with a subdirectory to represent one specific module. This commit applies that same strategy to ModuleSourceRegistry, creating a new type ModuleRegistryPackage to represent the different sort of package that we use for registry modules. Again, the main goal here is to try to reflect the conceptual modelling more directly in the type system so that we can more easily verify that uses of these different address types are correct. To make use of that, I've also lightly reworked initwd's module installer to use addrs.ModuleRegistryPackage directly, instead of a string representation thereof. This was in response to some earlier commits where I found myself accidentally mixing up package addresses and source addresses in the installRegistryModule method; with this new organization those bugs would've been caught at compile time, rather than only at unit and integration testing time. While in the area anyway, I also took this opportunity to fix some historical confusing names of fields in initwd.ModuleInstaller, to be clearer that they are only for registry packages and not for all module source address types.
90 lines
3.7 KiB
Go
90 lines
3.7 KiB
Go
package addrs
|
|
|
|
import (
|
|
"strings"
|
|
|
|
svchost "github.com/hashicorp/terraform-svchost"
|
|
)
|
|
|
|
// A ModulePackage represents a physical location where Terraform can retrieve
|
|
// a module package, which is an archive, repository, or other similar
|
|
// container which delivers the source code for one or more Terraform modules.
|
|
//
|
|
// A ModulePackage is a string in go-getter's address syntax. By convention,
|
|
// we use ModulePackage-typed values only for the result of successfully
|
|
// running the go-getter "detectors", which produces an address string which
|
|
// includes an explicit installation method prefix along with an address
|
|
// string in the format expected by that installation method.
|
|
//
|
|
// Note that although the "detector" phase of go-getter does do some simple
|
|
// normalization in certain cases, it isn't generally possible to compare
|
|
// two ModulePackage values to decide if they refer to the same package. Two
|
|
// equal ModulePackage values represent the same package, but there might be
|
|
// other non-equal ModulePackage values that also refer to that package, and
|
|
// there is no reliable way to determine that.
|
|
//
|
|
// Don't convert a user-provided string directly to ModulePackage. Instead,
|
|
// use ParseModuleSource with a remote module address and then access the
|
|
// ModulePackage value from the result, making sure to also handle the
|
|
// selected subdirectory if any. You should convert directly to ModulePackage
|
|
// only for a string that is hard-coded into the program (e.g. in a unit test)
|
|
// where you've ensured that it's already in the expected syntax.
|
|
type ModulePackage string
|
|
|
|
func (p ModulePackage) String() string {
|
|
return string(p)
|
|
}
|
|
|
|
// A ModuleRegistryPackage is an extra indirection over a ModulePackage where
|
|
// we use a module registry to translate a more symbolic address (and
|
|
// associated version constraint given out of band) into a physical source
|
|
// location.
|
|
//
|
|
// ModuleRegistryPackage is distinct from ModulePackage because they have
|
|
// disjoint use-cases: registry package addresses are only used to query a
|
|
// registry in order to find a real module package address. These being
|
|
// distinct is intended to help future maintainers more easily follow the
|
|
// series of steps in the module installer, with the help of the type checker.
|
|
type ModuleRegistryPackage struct {
|
|
Host svchost.Hostname
|
|
Namespace string
|
|
Name string
|
|
TargetSystem string
|
|
}
|
|
|
|
func (s ModuleRegistryPackage) String() string {
|
|
var buf strings.Builder
|
|
// Note: we're using the "display" form of the hostname here because
|
|
// for our service hostnames "for display" means something different:
|
|
// it means to render non-ASCII characters directly as Unicode
|
|
// characters, rather than using the "punycode" representation we
|
|
// use for internal processing, and so the "display" representation
|
|
// is actually what users would write in their configurations.
|
|
return s.Host.ForDisplay() + "/" + s.ForRegistryProtocol()
|
|
return buf.String()
|
|
}
|
|
|
|
func (s ModuleRegistryPackage) ForDisplay() string {
|
|
if s.Host == DefaultModuleRegistryHost {
|
|
return s.ForRegistryProtocol()
|
|
}
|
|
return s.Host.ForDisplay() + "/" + s.ForRegistryProtocol()
|
|
}
|
|
|
|
// ForRegistryProtocol returns a string representation of just the namespace,
|
|
// name, and target system portions of the address, always omitting the
|
|
// registry hostname and the subdirectory portion, if any.
|
|
//
|
|
// This is primarily intended for generating addresses to send to the
|
|
// registry in question via the registry protocol, since the protocol
|
|
// skips sending the registry its own hostname as part of identifiers.
|
|
func (s ModuleRegistryPackage) ForRegistryProtocol() string {
|
|
var buf strings.Builder
|
|
buf.WriteString(s.Namespace)
|
|
buf.WriteByte('/')
|
|
buf.WriteString(s.Name)
|
|
buf.WriteByte('/')
|
|
buf.WriteString(s.TargetSystem)
|
|
return buf.String()
|
|
}
|