package queue

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

Dependency Relation
	imports 19 packages, and imported by 4 packages

Involved Source Files

	   d➜ queue.go
		Package queue provides queue implementations that can be used for
		asynchronous scheduling of fetch actions.
Package-Level Type Names (total 5, in which 3 are exported)

	/* sort exporteds by: alphabet | popularity */
	 type GCP (struct)
		GCP provides a Queue implementation backed by the Google Cloud Tasks
		API.

		Fields (total 4, none are exported)
			/* 4 unexporteds ... *//* 4 unexporteds: */
			client *cloudtasks.Client
			queueName string
				// full GCP name of the queue

			queueURL string
				// non-AppEngine URL to post tasks to

			token *taskspb.HttpRequest_OidcToken
				token holds information that lets the task queue construct an authorized request to the worker.
				Since the worker sits behind the IAP, the queue needs an identity token that includes the
				identity of a service account that has access, and the client ID for the IAP.
				We use the service account of the current process.

		Methods (total 2, in which 1 are exported)
			(*T) ScheduleFetch(ctx context.Context, modulePath, version, suffix string, disableProxyFetch bool) (enqueued bool, err error)
				ScheduleFetch enqueues a task on GCP to fetch the given modulePath and
				version. It returns an error if there was an error hashing the task name, or
				an error pushing the task to GCP. If the task was a duplicate, it returns (false, nil).

			/* one unexported ... *//* one unexported: */
			(*T) newTaskRequest(modulePath, version, suffix string, disableProxyFetch bool) *taskspb.CreateTaskRequest
		Implements (at least one exported)
			*T : Queue
		As Outputs Of (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			func newGCP(cfg *config.Config, client *cloudtasks.Client, queueID string) (_ *GCP, err error)

	 type InMemory (struct)
		InMemory is a Queue implementation that schedules in-process fetch
		operations. Unlike the GCP task queue, it will not automatically retry tasks
		on failure.

		This should only be used for local development.

		Fields (total 3, none are exported)
			/* 3 unexporteds ... *//* 3 unexporteds: */
			experiments []string
			queue chan moduleVersion
			sem chan struct{}
		Methods (total 2, both are exported)
			(*T) ScheduleFetch(ctx context.Context, modulePath, version, _ string, _ bool) (bool, error)
				ScheduleFetch pushes a fetch task into the local queue to be processed
				asynchronously.

			( T) WaitForTesting(ctx context.Context)
				WaitForTesting waits for all queued requests to finish. It should only be
				used by test code.

		Implements (at least one exported)
			*T : Queue
		As Outputs Of (at least one exported)
			func NewInMemory(ctx context.Context, workerCount int, experiments []string, processFunc inMemoryProcessFunc) *InMemory

	 type Queue (interface)
		A Queue provides an interface for asynchronous scheduling of fetch actions.

		Methods (only one, which is exported)
			( T) ScheduleFetch(ctx context.Context, modulePath, version, suffix string, disableProxyFetch bool) (bool, error)
		Implemented By (at least 2, both are exported)
			*GCP
			*InMemory
		As Outputs Of (at least one exported)
			func New(ctx context.Context, cfg *config.Config, queueName string, numWorkers int, expGetter middleware.ExperimentGetter, processFunc inMemoryProcessFunc) (Queue, error)

	/* 2 unexporteds ... *//* 2 unexporteds: */
	 type inMemoryProcessFunc (func)

		As Inputs Of (at least 2, both are exported)
			func New(ctx context.Context, cfg *config.Config, queueName string, numWorkers int, expGetter middleware.ExperimentGetter, processFunc inMemoryProcessFunc) (Queue, error)
			func NewInMemory(ctx context.Context, workerCount int, experiments []string, processFunc inMemoryProcessFunc) *InMemory

	 type moduleVersion (struct)

		Fields (total 2, neither is exported)
			/* 2 unexporteds ... *//* 2 unexporteds: */
			modulePath string
			version string


Package-Level Functions (total 4, in which 2 are exported)

	 func New(ctx context.Context, cfg *config.Config, queueName string, numWorkers int, expGetter middleware.ExperimentGetter, processFunc inMemoryProcessFunc) (Queue, error)
		New creates a new Queue with name queueName based on the configuration
		in cfg. When running locally, Queue uses numWorkers concurrent workers.

	 func NewInMemory(ctx context.Context, workerCount int, experiments []string, processFunc inMemoryProcessFunc) *InMemory
		NewInMemory creates a new InMemory that asynchronously fetches
		from proxyClient and stores in db. It uses workerCount parallelism to
		execute these fetches.

	/* 2 unexporteds ... *//* 2 unexporteds: */
	 func newGCP(cfg *config.Config, client *cloudtasks.Client, queueID string) (_ *GCP, err error)
		NewGCP returns a new Queue that can be used to enqueue tasks using the
		cloud tasks API.  The given queueID should be the name of the queue in the
		cloud tasks console.

	 func newTaskID(modulePath, version string) string
		Create a task ID for the given module path and version.
		Task IDs can contain only letters ([A-Za-z]), numbers ([0-9]), hyphens (-), or underscores (_).


Package-Level Constants (total 3, in which 2 are exported)

	const DisableProxyFetchParam = "proxyfetch"
	const DisableProxyFetchValue = "off"
	/* one unexported ... *//* one unexported: */
	const maxCloudTasksTimeout time.Duration = 1800000000000
		Maximum timeout for HTTP tasks.
		See https://cloud.google.com/tasks/docs/creating-http-target-tasks.

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.