upstream

type DomainHeaderTransform ¶

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

A DomainHeaderTransform is used to set the header for a request. Typically one of these will be used to set the authentication key for https requests to an internal VCS system.

func (t *DomainHeaderTransform) Modify(r *Request) (*Request, error)

type DomainPathTransform ¶

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

A DomainPathTransform is used to generate or rewrite the URL path of the module archive that is to be fetched per the domain of desired module of the Request. Default path rewriting rules are provided for repositories ultimately hosted in github or gitlab. Additional path transformations should be defined for internally hosed VCSs.

e.g. github:

https://github.com/ELEM1/ELEM2/archive/VERSION.zip

e.g. gitlab:

https://gitlab.com/ELEM1/ELEM2/-/archive/VERSOIN/ELEM2-v2.0.1.zip

func (t *DomainPathTransform) Modify(r *Request) (*Request, error)

type DomainTransportTransform ¶

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

func (t *DomainTransportTransform) Modify(r *Request) (*Request, error)

type GoGetTransform ¶

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

The GoGetTransform triggers an http request to the domain to simply do a "?go-get=1" lookup for the real domain of where the module is being hosted.

Additional domains can be specified via configuration. The known go-get redirectors in the wild include: - golang.org - google.golang.org - cloud.google.com - gopkg.in - contrib.go.opencensus.io - go.uber.org

func (t *GoGetTransform) Modify(r *Request) (*Request, error)

type Namespace ¶

type Namespace []string

type Request ¶

type Request struct {
	Transport     string
	Domain        string
	Namespace     Namespace
	Version       string
	Path          string
	GoGetRedirect bool
	Headers       map[string]string
}

func NewRequest(mod coordinates.Module) (*Request, error)

func (r *Request) String() string

func (r *Request) URI() string

type Resolver ¶

type Resolver interface {
	// Resolve applies any underlying Transform operations
	// and returns the resulting Request, or an error if
	// one of the Transform operations does not work.
	Resolve(coordinates.Module) (*Request, error)
}

A Resolver is able to turn the globally unique identifier of a Go module (which includes a Source and a Version) and applies a set of Transform operations until a Request is created that can later be used to fetch the module from some source, which is typically a VCS host (e.g. github).

func NewResolver(transforms ...Transform) Resolver

type SetPathTransform ¶

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

A SetPathTransform is a collection of transforms which set the Path of a Request given a domain. Think of it as a map from a domain to a DomainPathTransform, which can be used in the general case rather than specifying an explicit list of DomainPathTransform.

func (t *SetPathTransform) Modify(r *Request) (*Request, error)

type StaticRedirectTransform ¶

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

A StaticRedirectTransform is used to directly convert one domain to another. For example, if your organization internally keeps packages organized like

${GOPATH}/company/...

but the internal VCS is only addressable in a way like

code.internal.company.net/...

then the StaticRedirectTransform can be used to automatically acquire modules prefixed with name "company/" from the internal VCS of the different domain name.

func (t *StaticRedirectTransform) Modify(r *Request) (*Request, error)

type Transform ¶

type Transform interface {
	Modify(*Request) (*Request, error)
}

A Transform is one operation that is applied to a Request, which creates a new Request with zero or more parameters of the input Request having been modified. A Transform can be used to handle things like static domain name redirection, indirect domain name redirect (i.e. accommodate go-get meta URIs), domain-based path rewriting, etc.

As time goes on, more and more Transform implementations will be added, to support additional use cases for enterprise environments which tend to have special needs.

func NewAutomaticGoGetTransform() Transform

func NewDomainHeaderTransform(domain string, headers map[string]string) Transform

func NewDomainPathTransform(pathFmt string) Transform

func NewDomainTransportTransform(domain, transport string) Transform

func NewGoGetTransform(domains []string) Transform

https://golang.ir/cmd/go/#hdr-Remote_import_paths

func NewSetPathTransform(customDomainPathTransforms map[string]Transform) Transform

func NewStaticRedirectTransform(original, substitution string) Transform