Configuration

VarMQ is configured with functions you pass when you create something: a worker, a job, a queue or a topic. This page lists all of them in one table, then explains how they combine. Each row links to the guide that covers the option in full.

Tick options in the scene below and it builds the call. A result list says what the worker gets.

Where each option goes

Every option

A Default* function sets the default of the matching worker option for workers created after the call. Its default is the same as the option’s. How the Default* functions work is below the table.

That is every exported With and Default function in the package. The methods that bind a source to a worker, such as WithQueue and WithTopic, are not options and are not in the table. A few details it leaves out:

• Not setting the idle ratio is not the same as setting it to 1. Without it, the worker keeps one idle goroutine. WithMinIdleWorkerRatio(1) keeps 1% of the limit, rounded down, and never fewer than one, so with a limit of 200 it keeps two.
• WithName and a string argument do the same thing. See below.
• A queue option reaches only a queue that can use it. WithQueueCapacity takes effect only on a queue that implements CapacitySetter. The built-in queues implement it. See queues.

Options and positional arguments

NewWorker, NewErrWorker and NewResultWorker take config ...any after the worker function. They read each argument by its type:

Only a value of type int sets the concurrency. A value of another integer type, such as int64 or uint, matches the last row and is ignored.

// 4 is the concurrency and "mailer" is the name.
worker := varmq.NewErrWorker(send, 4, "mailer", varmq.WithAutoRun(false))

The arguments are applied from left to right, over the defaults, so the last one that sets a value wins. varmq.NewWorker(f, 2, varmq.WithConcurrency(8)) runs 8 at once. A string and WithName set the same name, so with both, the later one decides. Worker types lists the same arguments next to the three constructors.

A value below 1 for the concurrency means one per CPU wherever it is given: as an int, in WithConcurrency, in DefaultConcurrency and in TunePool. The number is the logical CPU count of the machine, so it differs between machines.

The Default* functions

Each Default* function sets the default of one worker option. A worker copies the defaults when you create it. So a call changes only the workers created after it, not the ones that exist. An option or a positional argument for a worker still overrides the default.

func main() {
	// Defaults for the workers created below.
	varmq.DefaultConcurrency(8)
	varmq.DefaultErrHandler(func(w varmq.Worker, err error) {
		log.Printf("%s: %v", w.Name(), err)
	})

	emails := varmq.NewErrWorker(send, "emails")                                  // 8 at once, the handler above
	reports := varmq.NewResultWorker(build, 2, "reports", varmq.WithAutoRun(false)) // 2 at once, the handler above
}

• They write a package-level value with no locking. Call them once at start-up, before any goroutine creates a worker. Calling one while another goroutine creates a worker is a data race.
• DefaultJobIdGenerator(nil) and DefaultErrHandler(nil) do nothing, like their With twins. The other Default* functions have no such check. DefaultCtx(nil) goes back to no context.
• Some options have no Default* function: WithAutoRun, WithName, and the job, queue and topic options.