package proxy

Import Path
	golang.org/x/pkgsite/internal/proxy (on go.dev)

Dependency Relation
	imports 26 packages, and imported by 6 packages

Involved Source Files

	   d➜ client.go
		Package proxy provides a client for interacting with a proxy.

	      module.go
	      server.go
	      test_helper.go
Package-Level Type Names (total 4, all are exported)

	/* sort exporteds by: alphabet | popularity */
	 type Client (struct)
		A Client is used by the fetch service to communicate with a module
		proxy. It handles all methods defined by go help goproxy.

		Fields (total 7, none are exported)
			/* 7 unexporteds ... *//* 7 unexporteds: */
			disableFetch bool
				Whether fetch should be disabled.

			httpClient *http.Client
				Client used for HTTP requests. It is mutable for testing purposes.

			lastZipModulePath string
			lastZipReader *zip.Reader
			lastZipVersion string
			rememberLastZip bool
				One-element zip cache, to avoid a double download.
				See TestFetchAndUpdateStateCacheZip in internal/worker/fetch_test.go.
				Not thread-safe; should be used by only a single request goroutine.

			url string
				URL of the module proxy web server

		Methods (total 11, in which 8 are exported)
			(*T) FetchDisabled() bool
				FetchDisabled reports whether proxy fetch is disabled.

			(*T) Info(ctx context.Context, modulePath, requestedVersion string) (_ *VersionInfo, err error)
				Info makes a request to $GOPROXY/<module>/@v/<requestedVersion>.info and
				transforms that data into a *VersionInfo.
				If requestedVersion is internal.LatestVersion, it uses the proxy's @latest
				endpoint instead.

			(*T) Mod(ctx context.Context, modulePath, resolvedVersion string) (_ []byte, err error)
				Mod makes a request to $GOPROXY/<module>/@v/<resolvedVersion>.mod and returns the raw data.

			(*T) Versions(ctx context.Context, modulePath string) (_ []string, err error)
				Versions makes a request to $GOPROXY/<path>/@v/list and returns the
				resulting version strings.

			(*T) WithFetchDisabled() *Client
				WithFetchDisabled returns a new client that sets the Disable-Module-Fetch
				header so that the proxy does not fetch a module it doesn't already know
				about.

			(*T) WithZipCache() *Client
				WithZipCache returns a new client that caches the last zip
				it downloads (not thread-safely).

			(*T) Zip(ctx context.Context, modulePath, resolvedVersion string) (_ *zip.Reader, err error)
				Zip makes a request to $GOPROXY/<modulePath>/@v/<resolvedVersion>.zip and
				transforms that data into a *zip.Reader. <resolvedVersion> must have already
				been resolved by first making a request to
				$GOPROXY/<modulePath>/@v/<requestedVersion>.info to obtained the valid
				semantic version.

			(*T) ZipSize(ctx context.Context, modulePath, resolvedVersion string) (_ int64, err error)
				ZipSize gets the size in bytes of the zip from the proxy, without downloading it.
				The version must be resolved, as by a call to Client.Info.

			/* 3 unexporteds ... *//* 3 unexporteds: */
			(*T) escapedURL(modulePath, requestedVersion, suffix string) (_ string, err error)
			(*T) executeRequest(ctx context.Context, u string, bodyFunc func(body io.Reader) error) (err error)
				executeRequest executes an HTTP GET request for u, then calls the bodyFunc
				on the response body, if no error occurred.

			(*T) readBody(ctx context.Context, modulePath, requestedVersion, suffix string) (_ []byte, err error)
		As Outputs Of (at least 5, all are exported)
			func New(u string) (_ *Client, err error)
			func NewClientForServer(s *Server) (*Client, func(), error)
			func SetupTestClient(t *testing.T, modules []*Module) (*Client, func())
			func (*Client).WithFetchDisabled() *Client
			func (*Client).WithZipCache() *Client
		As Inputs Of (at least 12, in which 7 are exported)
			func golang.org/x/pkgsite/internal/fetch.FetchModule(ctx context.Context, modulePath, requestedVersion string, proxyClient *Client, sourceClient *source.Client) (fr *fetch.FetchResult)
			func golang.org/x/pkgsite/internal/fetch.GetInfo(ctx context.Context, modulePath, requestedVersion string, proxyClient *Client) (_ *VersionInfo, err error)
			func golang.org/x/pkgsite/internal/fetch.LatestModuleVersions(ctx context.Context, modulePath string, prox *Client, hasGoMod func(v string) (bool, error)) (info *internal.LatestModuleVersions, err error)
			func golang.org/x/pkgsite/internal/frontend.FetchAndUpdateState(ctx context.Context, modulePath, requestedVersion string, proxyClient *Client, sourceClient *source.Client, db *postgres.DB) (_ int, err error)
			func golang.org/x/pkgsite/internal/proxydatasource.New(proxyClient *Client) *proxydatasource.DataSource
			func golang.org/x/pkgsite/internal/proxydatasource.NewBypassingLicenseCheck(c *Client) *proxydatasource.DataSource
			func golang.org/x/pkgsite/internal/proxydatasource.NewForTesting(proxyClient *Client) *proxydatasource.DataSource
			/* 5+ unexporteds ... *//* 5+ unexporteds: */
			func golang.org/x/pkgsite/internal/fetch.fetchModule(ctx context.Context, fr *fetch.FetchResult, proxyClient *Client, sourceClient *source.Client) (*fetch.FetchInfo, error)
			func golang.org/x/pkgsite/internal/fetch.getGoModPath(ctx context.Context, modulePath, resolvedVersion string, proxyClient *Client) (string, []byte, error)
			func golang.org/x/pkgsite/internal/fetch.getZipSize(ctx context.Context, modulePath, resolvedVersion string, proxyClient *Client) (_ int64, err error)
			func golang.org/x/pkgsite/internal/proxydatasource.newDataSource(proxyClient *Client, sourceClient *source.Client) *proxydatasource.DataSource
			func golang.org/x/pkgsite/internal/worker.resolvedVersion(ctx context.Context, modulePath, requestedVersion string, proxyClient *Client) string

	 type Module (struct)
		Module represents a module version used by the proxy server.

		Fields (total 5, in which 4 are exported)
			Files map[string]string
			ModulePath string
			NotCached bool
				// if true, behaves like it's uncached

			Version string
			/* one unexported ... *//* one unexported: */
			zip []byte
		Methods (total 6, in which 5 are exported)
			(*T) AddFile(filename, contents string) *Module
				AddFile returns a copy of m with an additional file. It
				panics if the filename is already present.

			(*T) ChangePath(modulePath string) *Module
				ChangePath returns a copy of m with a different module path.

			(*T) ChangeVersion(version string) *Module
				ChangeVersion returns a copy of m with a different version.

			(*T) DeleteFile(filename string) *Module
				DeleteFile returns a copy of m with filename removed.
				It panics if filename is not present.

			(*T) ReplaceFile(filename, contents string) *Module
				ReplaceFile returns a copy of m with different contents for filename.
				It panics if filename is not present.

			/* one unexported ... *//* one unexported: */
			(*T) setFile(filename string, contents *string, mustExist bool) *Module
		As Outputs Of (at least 10, in which 7 are exported)
			func FindModule(mods []*Module, path, version string) *Module
			func LoadTestModules(dir string) []*Module
			func (*Module).AddFile(filename, contents string) *Module
			func (*Module).ChangePath(modulePath string) *Module
			func (*Module).ChangeVersion(version string) *Module
			func (*Module).DeleteFile(filename string) *Module
			func (*Module).ReplaceFile(filename, contents string) *Module
			/* 3+ unexporteds ... *//* 3+ unexporteds: */
			func cleanModule(m *Module) *Module
			func readTxtarModule(filename string) (*Module, error)
			func (*Module).setFile(filename string, contents *string, mustExist bool) *Module
		As Inputs Of (at least 9, in which 5 are exported)
			func FindModule(mods []*Module, path, version string) *Module
			func NewServer(modules []*Module) *Server
			func SetupTestClient(t *testing.T, modules []*Module) (*Client, func())
			func (*Server).AddModule(m *Module)
			func (*Server).AddModuleNoVersions(m *Module)
			/* 4+ unexporteds ... *//* 4+ unexporteds: */
			func cleanModule(m *Module) *Module
			func (*Server).addModule(m *Module, hasVersions bool)
			func (*Server).handleMod(m *Module)
			func (*Server).handleZip(m *Module)

	 type Server (struct)
		Server represents a proxy server containing the specified modules.

		Fields (total 4, none are exported)
			/* 4 unexporteds ... *//* 4 unexporteds: */
			modules map[string][]*Module
			mu sync.Mutex
			mux *http.ServeMux
			zipRequests int
				// number of .zip endpoint requests, for testing

		Methods (total 10, in which 4 are exported)
			(*T) AddModule(m *Module)
				AddModule adds an additional module to the server.

			(*T) AddModuleNoVersions(m *Module)
				AddModuleNoLatest adds a module to the server, but the @v/list endpoint will
				return nothing and @latest endpoint will serve a 410.
				For testing the unusual case where a module exists but there is no version information.

			(*T) AddRoute(route string, fn func(w http.ResponseWriter, r *http.Request))
				AddRoute adds an additional handler to the server.

			(*T) ZipRequests() int
			/* 6 unexporteds ... *//* 6 unexporteds: */
			(*T) addModule(m *Module, hasVersions bool)
			(*T) handleInfo(modulePath, resolvedVersion string, uncached bool)
				handleInfo creates an info endpoint for the specified module version.

			(*T) handleLatest(modulePath, urlPath string)
				handleLatest creates an info endpoint for the specified module at the latest
				version.

			(*T) handleList(modulePath string)
				handleList creates a list endpoint for the specified modulePath.

			(*T) handleMod(m *Module)
				handleMod creates a mod endpoint for the specified module version.

			(*T) handleZip(m *Module)
				handleZip creates a zip endpoint for the specified module version.

		As Outputs Of (at least one exported)
			func NewServer(modules []*Module) *Server
		As Inputs Of (at least one exported)
			func NewClientForServer(s *Server) (*Client, func(), error)

	 type VersionInfo (struct)
		A VersionInfo contains metadata about a given version of a module.

		Fields (total 2, both are exported)
			Time time.Time
			Version string
		As Outputs Of (at least 3, in which 2 are exported)
			func (*Client).Info(ctx context.Context, modulePath, requestedVersion string) (_ *VersionInfo, err error)
			func golang.org/x/pkgsite/internal/fetch.GetInfo(ctx context.Context, modulePath, requestedVersion string, proxyClient *Client) (_ *VersionInfo, err error)
			/* at least one unexported ... *//* at least one unexported: */
			func golang.org/x/pkgsite/internal/proxydatasource.(*DataSource).findModule(ctx context.Context, pkgPath string, version string) (_ string, _ *VersionInfo, err error)


Package-Level Functions (total 10, in which 6 are exported)

	 func FindModule(mods []*Module, path, version string) *Module
		FindModule returns the module in mods with the given path and version, or nil
		if there isn't one. An empty version argument matches any version.

	 func LoadTestModules(dir string) []*Module
		LoadTestModules reads the modules in the given directory. Each file in that
		directory with a .txtar extension should be named "path@version" and should
		be in txtar format (golang.org/x/tools/txtar). The path part of the filename
		will be preceded by "example.com/" and colons will be replaced by slashes to
		form a full module path. The file contents are used verbatim except that some
		variables beginning with "$" are substituted with predefined strings.

		LoadTestModules panics if there is an error reading any of the files.

	 func New(u string) (_ *Client, err error)
		New constructs a *Client using the provided url, which is expected to
		be an absolute URI that can be directly passed to http.Get.

	 func NewClientForServer(s *Server) (*Client, func(), error)
		NewClientForServer starts serving proxyMux locally. It returns a client to the
		server and a function to shut down the server.

	 func NewServer(modules []*Module) *Server
		NewServer returns a proxy Server that serves the provided modules.

	 func SetupTestClient(t *testing.T, modules []*Module) (*Client, func())
		SetupTestClient creates a fake module proxy for testing using the given test
		version information.

		It returns a function for tearing down the proxy after the test is completed
		and a Client for interacting with the test proxy.

	/* 4 unexporteds ... *//* 4 unexporteds: */
	 func cleanModule(m *Module) *Module
	 func defaultInfo(resolvedVersion string) *strings.Reader
	 func readTxtarModule(filename string) (*Module, error)
	 func responseError(r *http.Response, fetchDisabled bool) error
		responseError translates the response status code to an appropriate error.


Package-Level Variables (only one, which is unexported)

	/* one unexported ... *//* one unexported: */
	  var testModuleReplacer *strings.Replacer
Package-Level Constants (total 2, neither is exported)

	/* 2 unexporteds ... *//* 2 unexporteds: */
	const disableFetchHeader = "Disable-Module-Fetch"
		Setting this header to true prevents the proxy from fetching uncached
		modules.

	const versionTime = "2019-01-30T00:00:00Z"

The pages are generated with Golds v0.3.2-preview. (GOOS=darwin GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @Go100and1 (reachable from the left QR code) to get the latest news of Golds.