modules

type BaseCredentialSet ¶

type BaseCredentialSet struct {
	Token string
	Host  string
}

BaseCredentialSet are the underlying credentials that CredentialsSource will use if no other credentials can be found for a given host.

type Cache ¶

type Cache struct {
	// contains filtered or unexported fields
}

Cache is a cache of modules that can be used to lookup modules to check if they've already been loaded.

This only works with modules that have the same identifier. It doesn't cache modules that are used multiple times with different identifiers. That is done separately by the PackageFetcher and only caches per-run of C3X, so if you add the same module to your Terraform code it will redownload that module. We could optimize it by moving the package fetching cache logic into here, but it would be inconsistent with how terraform init works.

func NewCache(disco *Disco, logger zerolog.Logger) *Cache

type ConditionalTransport ¶

type ConditionalTransport struct {
	ProxyHosts []string
	ProxyURL   string
	Inner      http.RoundTripper
}

func (t *ConditionalTransport) RoundTrip(req *http.Request) (*http.Response, error)

type CredentialsSource ¶

type CredentialsSource struct {
	BaseCredentialSet BaseCredentialSet
	FetchToken        FetchTokenFunc
}

CredentialsSource is an object that may be able to provide credentials for a given module source.

func NewTerraformCredentialsSource(creds BaseCredentialSet) (*CredentialsSource, error)

func (s *CredentialsSource) ForHost(host svchost.Hostname) (auth.HostCredentials, error)

func (s *CredentialsSource) ForgetForHost(host svchost.Hostname) error

func (s *CredentialsSource) StoreForHost(host svchost.Hostname, credentials auth.HostCredentialsWritable) error

type CustomGitGetter ¶

type CustomGitGetter struct {
	*getter.GitGetter
}

CustomGitGetter extends the standard GitGetter and normalizes SSH and HTTPS URLs so it can attempt to use the Git credentials on the host machine to resolve the Get before falling back to the original method. SSH URLs are transformed to their HTTPS equivalent before attempting a Get. HTTPS URLS are stripped of any credentials.

func (g *CustomGitGetter) Get(ctx context.Context, dst string, u *url.URL) error

type Disco ¶

type Disco struct {
	// contains filtered or unexported fields
}

Disco allows discovery on given hostnames. It tries to resolve a module source based on a set of discovery rules. It caches the results by hostname to avoid repeated requests for the same information. Therefore, it is advisable to use Disco per project and pass it to all required clients.

func NewDisco(credentialsSource auth.CredentialsSource, logger zerolog.Logger) *Disco

func (d *Disco) DownloadLocation(moduleURL RegistryURL, version string) (string, error)

func (d *Disco) ModuleLocation(source string) (RegistryURL, bool, error)

type FetchTokenFunc ¶

type FetchTokenFunc func(key string) string

FetchTokenFunc defines a function that returns a token for a given key. This can be an environment key, a header key, whatever the CredentialsSource requires.

type HostCredentials ¶

type HostCredentials struct {
	// contains filtered or unexported fields
}

func (c HostCredentials) PrepareRequest(req *http.Request)

func (c HostCredentials) Token() string

type HttpPublicModuleChecker ¶

type HttpPublicModuleChecker struct {
	// contains filtered or unexported fields
}

func NewHttpPublicModuleChecker() *HttpPublicModuleChecker

func (h *HttpPublicModuleChecker) IsPublicModule(moduleAddr string) (bool, error)

type Manifest ¶

type Manifest struct {
	Path    string            `json:"Path"`
	Version string            `json:"Version"`
	Modules []*ManifestModule `json:"Modules"`
	// contains filtered or unexported fields
}

Manifest is a struct that represents the JSON found in the manifest.json file in the .c3x dir It is used for caching the modules that have already been downloaded. It uses the same format as the .terraform/modules/modules.json file

func (m Manifest) Get(key string) ManifestModule

type ManifestModule ¶

type ManifestModule struct {
	Key            string `json:"Key"`
	Source         string `json:"Source"`
	Version        string `json:"Version,omitempty"`
	Dir            string `json:"Dir"`
	DownloadURL    string
	IsSourceMapped bool `json:"-"`
}

ManifestModule represents a single module in the manifest.json file

func (m ManifestModule) URL() string

type ModuleLoader ¶

type ModuleLoader struct {
	// contains filtered or unexported fields
}

ModuleLoader handles the loading of Terraform modules. It supports local, registry and other remote modules.

The path should be the root directory of the Terraform project. We use a distinct module loader per Terraform project, because at the moment the cache is per project. The cache reads the manifest.json file from the path's .c3x/terraform_modules directory. We could implement a global cache in the future, but for now have decided to go with the same approach as Terraform.

func NewModuleLoader(opts ModuleLoaderOptions) *ModuleLoader

func (m *ModuleLoader) Load(path string) (man *Manifest, err error)

func (m *ModuleLoader) MapSourceWithRegex(source string) (SourceMapResult, error)

type ModuleLoaderOptions ¶

type ModuleLoaderOptions struct {
	CachePath           string
	HCLParser           *SharedHCLParser
	CredentialsSource   *CredentialsSource
	SourceMap           settings.TerraformSourceMap
	SourceMapRegex      settings.TerraformSourceMapRegex
	Logger              zerolog.Logger
	ModuleSync          *intSync.KeyMutex
	RemoteCache         RemoteCache
	PublicModuleChecker PublicModuleChecker
}

type PackageFetcher ¶

type PackageFetcher struct {
	// contains filtered or unexported fields
}

PackageFetcher downloads modules from a remote source to the given destination This supports all the non-local and non-Terraform registry sources listed here: https://www.terraform.io/language/modules/sources

func NewPackageFetcher(remoteCache RemoteCache, logger zerolog.Logger, opts ...PackageFetcherOpts) *PackageFetcher

func (p *PackageFetcher) Fetch(moduleAddr string, dest string) error

type PackageFetcherOpts ¶

type PackageFetcherOpts func(*PackageFetcher)

func WithGetters(getters map[string]getter.Getter) PackageFetcherOpts

func WithPublicModuleChecker(publicModuleChecker PublicModuleChecker) PackageFetcherOpts

type PublicModuleChecker ¶

type PublicModuleChecker interface {
	IsPublicModule(moduleAddr string) (bool, error)
}

PublicModuleChecker is an interface that defines the method for checking if a module is public.

type RegistryLoader ¶

type RegistryLoader struct {
	// contains filtered or unexported fields
}

RegistryLoader is a loader that can lookup modules from a Terraform Registry and download them to the given destination

func NewRegistryLoader(packageFetcher *PackageFetcher, disco *Disco, logger zerolog.Logger) *RegistryLoader

func (r *RegistryLoader) DownloadLocation(moduleURL RegistryURL, version string) (string, error)

type RegistryLookupResult ¶

type RegistryLookupResult struct {
	OK        bool
	ModuleURL RegistryURL
	Version   string
}

RegistryLookupResult is returned when looking up the module to check if it exists in the registry and has a matching version

type RegistryURL ¶

type RegistryURL struct {
	RawSource   string
	Host        string
	Location    string
	Credentials auth.HostCredentials
}

RegistryURL contains given URL information for a module source. This can be used to build http requests to download the module or check versions of the module.

type RemoteCache ¶

type RemoteCache interface {
	Exists(key string, public bool) (bool, error)
	Get(key string, dest string, public bool) error
	Put(key string, src string, ttl time.Duration, public bool) error
}

RemoteCache is an interface that defines the methods for a remote cache, i.e. an S3 bucket.

type S3Cache ¶

type S3Cache struct {
	// contains filtered or unexported fields
}

func NewS3Cache(region, bucketName, prefix string, cachePrivate bool) (*S3Cache, error)

func (cache *S3Cache) Exists(key string, public bool) (bool, error)

func (cache *S3Cache) Get(key, destPath string, public bool) error

func (cache *S3Cache) Put(key, srcPath string, ttl time.Duration, public bool) error

type SharedHCLParser ¶

type SharedHCLParser struct {
	// contains filtered or unexported fields
}

func NewSharedHCLParser() *SharedHCLParser

func (p *SharedHCLParser) ParseHCLFile(filename string) (*hcl.File, hcl.Diagnostics)

func (p *SharedHCLParser) ParseJSONFile(filename string) (*hcl.File, hcl.Diagnostics)

type SourceMapResult ¶

type SourceMapResult struct {
	Source   string
	Version  string
	RawQuery string
}

func MapSource(sourceMap settings.TerraformSourceMap, source string) (SourceMapResult, error)