flags.go

// Running goworker
//
// After building your workers, you will have an
// executable that you can run which will
// automatically poll a Redis server and call
// your workers as jobs arrive.
//
// Flags
//
// There are several flags which control the
// operation of the goworker client.
//
// -queues="comma,delimited,queues"
// — This is the only required flag. The
// recommended practice is to separate your
// Resque workers from your goworkers with
// different queues. Otherwise, Resque worker
// classes that have no goworker analog will
// cause the goworker process to fail the jobs.
// Because of this, there is no default queue,
// nor is there a way to select all queues (à la
// Resque's * queue). Queues are processed in
// the order they are specififed.
// If you have multiple queues you can assign
// them weights. A queue with a weight of 2 will
// be checked twice as often as a queue with a
// weight of 1: -queues='high=2,low=1'.
//
// -interval=5.0
// — Specifies the wait period between polling if
// no job was in the queue the last time one was
// requested.
//
// -concurrency=25
// — Specifies the number of concurrently
// executing workers. This number can be as low
// as 1 or rather comfortably as high as 100,000,
// and should be tuned to your workflow and the
// availability of outside resources.
//
// -connections=2
// — Specifies the maximum number of Redis
// connections that goworker will consume between
// the poller and all workers. There is not much
// performance gain over two and a slight penalty
// when using only one. This is configurable in
// case you need to keep connection counts low
// for cloud Redis providers who limit plans on
// maxclients.
//
// -uri=redis://localhost:6379/
// — Specifies the URI of the Redis database from
// which goworker polls for jobs. Accepts URIs of
// the format redis://user:pass@host:port/db or
// unix:///path/to/redis.sock. The flag may also
// be set by the environment variable
// $($REDIS_PROVIDER) or $REDIS_URL. E.g. set
// $REDIS_PROVIDER to REDISTOGO_URL on Heroku to
// let the Redis To Go add-on configure the Redis
// database.
//
// -namespace=resque:
// — Specifies the namespace from which goworker
// retrieves jobs and stores stats on workers.
//
// -exit-on-complete=false
// — Exits goworker when there are no jobs left
// in the queue. This is helpful in conjunction
// with the time command to benchmark different
// configurations.
//
// You can also configure your own flags for use
// within your workers. Be sure to set them
// before calling goworker.Main(). It is okay to
// call flags.Parse() before calling
// goworker.Main() if you need to do additional
// processing on your flags.
package goworker

import (
	"flag"
	"strconv"
	"strings"
)

var (
	queuesString   string
	queues         queuesFlag
	intervalFloat  float64
	interval       intervalFlag
	concurrency    int
	connections    int
	uri            string
	namespace      string
	exitOnComplete bool
	isStrict       bool
)

func Config(values map[string]string) {
	var err error

	if x, ok := values["queues"]; ok {
		queuesString = x
	}

	if x, ok := values["interval"]; ok {
		if intervalFloat, err = strconv.ParseFloat(x, 64); err != nil {
			panic(err)
		}
	}

	if x, ok := values["concurrency"]; ok {
		if concurrency, err = strconv.Atoi(x); err != nil {
			panic(err)
		}
	}

	if x, ok := values["connections"]; ok {
		if connections, err = strconv.Atoi(x); err != nil {
			panic(err)
		}
	}

	if x, ok := values["uri"]; ok {
		uri = x
	}

	if x, ok := values["namespace"]; ok {
		namespace = x
	}

	if x, ok := values["exitOnComplete"]; ok {
		if exitOnComplete, err = strconv.ParseBool(x); err != nil {
			panic(err)
		}
	}
}

func init() {
	queuesString = ""
	intervalFloat = 5.0
	concurrency = 25
	connections = 2
	uri = "redis://localhost:6379/"
	namespace = "resque:"
	exitOnComplete = false
}

func flags() error {
	if !flag.Parsed() {
		flag.Parse()
	}
	if err := queues.Set(queuesString); err != nil {
		return err
	}
	if err := interval.SetFloat(intervalFloat); err != nil {
		return err
	}
	isStrict = strings.IndexRune(queuesString, '=') == -1
	return nil
}