Change ErrorHandler function signature

The command converts all messages in redis to be compatible for asynq
v0.10.0

.github/FUNDING.yml

@@ -1,12 +0,0 @@
-# These are supported funding model platforms
-
-github: [hibiken] # Replace with up to 4 GitHub Sponsors-enabled usernames e.g., [user1, user2]
-patreon: # Replace with a single Patreon username
-open_collective: # Replace with a single Open Collective username
-ko_fi: # Replace with a single Ko-fi username
-tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
-community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
-liberapay: # Replace with a single Liberapay username
-issuehunt: # Replace with a single IssueHunt username
-otechie: # Replace with a single Otechie username
-custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']

.github/workflows/benchstat.yml

@@ -1,82 +0,0 @@
-# This workflow runs benchmarks against the current branch,
-# compares them to benchmarks against master,
-# and uploads the results as an artifact.
-
-name: benchstat
-
-on: [pull_request]
-
-jobs:
-  incoming:
-    runs-on: ubuntu-latest
-    services:
-      redis:
-        image: redis
-        ports:
-          - 6379:6379
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v2
-      - name: Set up Go
-        uses: actions/setup-go@v2
-        with:
-          go-version: 1.16.x
-      - name: Benchmark
-        run: go test -run=^$ -bench=. -count=5 -timeout=60m ./... | tee -a new.txt
-      - name: Upload Benchmark
-        uses: actions/upload-artifact@v2
-        with:
-          name: bench-incoming
-          path: new.txt
-
-  current:
-    runs-on: ubuntu-latest
-    services:
-      redis:
-        image: redis
-        ports:
-          - 6379:6379
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v2
-        with:
-          ref: master
-      - name: Set up Go
-        uses: actions/setup-go@v2
-        with:
-          go-version: 1.15.x
-      - name: Benchmark
-        run: go test -run=^$ -bench=. -count=5 -timeout=60m ./... | tee -a old.txt
-      - name: Upload Benchmark
-        uses: actions/upload-artifact@v2
-        with:
-          name: bench-current
-          path: old.txt
-
-  benchstat:
-    needs: [incoming, current]
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v2
-      - name: Set up Go
-        uses: actions/setup-go@v2
-        with:
-          go-version: 1.15.x
-      - name: Install benchstat
-        run: go get -u golang.org/x/perf/cmd/benchstat
-      - name: Download Incoming
-        uses: actions/download-artifact@v2
-        with:
-          name: bench-incoming
-      - name: Download Current
-        uses: actions/download-artifact@v2
-        with:
-          name: bench-current
-      - name: Benchstat Results
-        run: benchstat old.txt new.txt | tee -a benchstat.txt
-      - name: Upload benchstat results
-        uses: actions/upload-artifact@v2
-        with:
-          name: benchstat
-          path: benchstat.txt

.github/workflows/build.yml

@@ -1,35 +0,0 @@
-name: build
-
-on: [push, pull_request]
-
-jobs:
-  build:
-    strategy:
-      matrix:
-        os: [ubuntu-latest]
-        go-version: [1.14.x, 1.15.x, 1.16.x, 1.17.x]
-    runs-on: ${{ matrix.os }}
-    services:
-      redis:
-        image: redis
-        ports:
-          - 6379:6379
-    steps:
-      - uses: actions/checkout@v2
-
-      - name: Set up Go
-        uses: actions/setup-go@v2
-        with:
-          go-version: ${{ matrix.go-version }}
-
-      - name: Build
-        run: go build -v ./...
-
-      - name: Test
-        run: go test -race -v -coverprofile=coverage.txt -covermode=atomic ./...
-
-      - name: Benchmark Test
-        run: go test -run=^$ -bench=. -loglevel=debug ./...
-
-      - name: Upload coverage to Codecov
-        uses: codecov/codecov-action@v1

.gitignore

@@ -1,4 +1,3 @@
-vendor
 # Binaries for programs and plugins
 *.exe
 *.exe~
@@ -15,13 +14,8 @@ vendor
 # Ignore examples for now
 /examples
 
-# Ignore tool binaries
+# Ignore command binary
 /tools/asynq/asynq
-/tools/metrics_exporter/metrics_exporter
 
 # Ignore asynq config file
 .asynq.*
-
-# Ignore editor config files
-.vscode
-.idea

.travis.yml

@@ -0,0 +1,13 @@
+language: go
+go_import_path: github.com/hibiken/asynq
+git:
+  depth: 1
+go: [1.13.x, 1.14.x]
+script:
+  - go test -race -v -coverprofile=coverage.txt -covermode=atomic ./...
+  - go test -run=XXX -bench=. -loglevel=debug ./...
+services:
+  - redis-server
+after_success:
+  - bash ./.travis/benchcmp.sh
+  - bash <(curl -s https://codecov.io/bash)

.travis/benchcmp.sh

@@ -0,0 +1,18 @@
+if [ "${TRAVIS_PULL_REQUEST_BRANCH:-$TRAVIS_BRANCH}" != "master" ]; then
+    REMOTE_URL="$(git config --get remote.origin.url)";
+    cd ${TRAVIS_BUILD_DIR}/.. && \
+    git clone ${REMOTE_URL} "${TRAVIS_REPO_SLUG}-bench" && \
+    cd "${TRAVIS_REPO_SLUG}-bench" && \
+
+    # Benchmark master
+    git checkout master && \
+    go test -run=XXX -bench=. ./... > master.txt && \
+
+    # Benchmark feature branch
+    git checkout ${TRAVIS_COMMIT} && \
+    go test -run=XXX -bench=. ./... > feature.txt && \
+
+    # compare two benchmarks
+    go get -u golang.org/x/tools/cmd/benchcmp && \
+    benchcmp master.txt feature.txt;
+fi

CHANGELOG.md

@@ -7,293 +7,6 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
-## [0.21.0] - 2022-01-22
-
-### Added
-
-- `PeriodicTaskManager` is added. Prefer using this over `Scheduler` as it has better support for dynamic periodic tasks.
-- The `asynq stats` command now supports a `--json` option, making its output a JSON object
-- Introduced new configuration for `DelayedTaskCheckInterval`. See [godoc](https://godoc.org/github.com/hibiken/asynq) for more details.
-
-## [0.20.0] - 2021-12-19
-
-### Added
-
-- Package `x/metrics` is added.
-- Tool `tools/metrics_exporter` binary is added.
-- `ProcessedTotal` and `FailedTotal` fields were added to `QueueInfo` struct.
-
-## [0.19.1] - 2021-12-12
-
-### Added
-
-- `Latency` field is added to `QueueInfo`.
-- `EnqueueContext` method is added to `Client`.
-
-### Fixed
-
-- Fixed an error when user pass a duration less than 1s to `Unique` option
-
-## [0.19.0] - 2021-11-06
-
-### Changed
-
-- `NewTask` takes `Option` as variadic argument
-- Bumped minimum supported go version to 1.14 (i.e. go1.14 or higher is required).
-
-### Added
-
-- `Retention` option is added to allow user to specify task retention duration after completion.
-- `TaskID` option is added to allow user to specify task ID.
-- `ErrTaskIDConflict` sentinel error value is added.
-- `ResultWriter` type is added and provided through `Task.ResultWriter` method.
-- `TaskInfo` has new fields `CompletedAt`, `Result` and `Retention`.
-
-### Removed
-
-- `Client.SetDefaultOptions` is removed. Use `NewTask` instead to pass default options for tasks.
-
-## [0.18.6] - 2021-10-03
-
-### Changed
-
-- Updated `github.com/go-redis/redis` package to v8
-
-## [0.18.5] - 2021-09-01
-
-### Added
-
-- `IsFailure` config option is added to determine whether error returned from Handler counts as a failure.
-
-## [0.18.4] - 2021-08-17
-
-### Fixed
-
-- Scheduler methods are now thread-safe. It's now safe to call `Register` and `Unregister` concurrently.
-
-## [0.18.3] - 2021-08-09
-
-### Changed
-
-- `Client.Enqueue` no longer enqueues tasks with empty typename; Error message is returned.
-
-## [0.18.2] - 2021-07-15
-
-### Changed
-
-- Changed `Queue` function to not to convert the provided queue name to lowercase. Queue names are now case-sensitive.
-- `QueueInfo.MemoryUsage` is now an approximate usage value.
-
-### Fixed
-
-- Fixed latency issue around memory usage (see https://github.com/hibiken/asynq/issues/309).
-
-## [0.18.1] - 2021-07-04
-
-### Changed
-
-- Changed to execute task recovering logic when server starts up; Previously it needed to wait for a minute for task recovering logic to exeucte.
-
-### Fixed
-
-- Fixed task recovering logic to execute every minute
-
-## [0.18.0] - 2021-06-29
-
-### Changed
-
-- NewTask function now takes array of bytes as payload.
-- Task `Type` and `Payload` should be accessed by a method call.
-- `Server` API has changed. Renamed `Quiet` to `Stop`. Renamed `Stop` to `Shutdown`. _Note:_ As a result of this renaming, the behavior of `Stop` has changed. Please update the exising code to call `Shutdown` where it used to call `Stop`.
-- `Scheduler` API has changed. Renamed `Stop` to `Shutdown`.
-- Requires redis v4.0+ for multiple field/value pair support
-- `Client.Enqueue` now returns `TaskInfo`
-- `Inspector.RunTaskByKey` is replaced with `Inspector.RunTask`
-- `Inspector.DeleteTaskByKey` is replaced with `Inspector.DeleteTask`
-- `Inspector.ArchiveTaskByKey` is replaced with `Inspector.ArchiveTask`
-- `inspeq` package is removed. All types and functions from the package is moved to `asynq` package.
-- `WorkerInfo` field names have changed.
-- `Inspector.CancelActiveTask` is renamed to `Inspector.CancelProcessing`
-
-## [0.17.2] - 2021-06-06
-
-### Fixed
-
-- Free unique lock when task is deleted (https://github.com/hibiken/asynq/issues/275).
-
-## [0.17.1] - 2021-04-04
-
-### Fixed
-
-- Fix bug in internal `RDB.memoryUsage` method.
-
-## [0.17.0] - 2021-03-24
-
-### Added
-
-- `DialTimeout`, `ReadTimeout`, and `WriteTimeout` options are added to `RedisConnOpt`.
-
-## [0.16.1] - 2021-03-20
-
-### Fixed
-
-- Replace `KEYS` command with `SCAN` as recommended by [redis doc](https://redis.io/commands/KEYS).
-
-## [0.16.0] - 2021-03-10
-
-### Added
-
-- `Unregister` method is added to `Scheduler` to remove a registered entry.
-
-## [0.15.0] - 2021-01-31
-
-**IMPORTATNT**: All `Inspector` related code are moved to subpackage "github.com/hibiken/asynq/inspeq"
-
-### Changed
-
-- `Inspector` related code are moved to subpackage "github.com/hibken/asynq/inspeq".
-- `RedisConnOpt` interface has changed slightly. If you have been passing `RedisClientOpt`, `RedisFailoverClientOpt`, or `RedisClusterClientOpt` as a pointer,
-  update your code to pass as a value.
-- `ErrorMsg` field in `RetryTask` and `ArchivedTask` was renamed to `LastError`.
-
-### Added
-
-- `MaxRetry`, `Retried`, `LastError` fields were added to all task types returned from `Inspector`.
-- `MemoryUsage` field was added to `QueueStats`.
-- `DeleteAllPendingTasks`, `ArchiveAllPendingTasks` were added to `Inspector`
-- `DeleteTaskByKey` and `ArchiveTaskByKey` now supports deleting/archiving `PendingTask`.
-- asynq CLI now supports deleting/archiving pending tasks.
-
-## [0.14.1] - 2021-01-19
-
-### Fixed
-
-- `go.mod` file for CLI
-
-## [0.14.0] - 2021-01-14
-
-**IMPORTATNT**: Please run `asynq migrate` command to migrate from the previous versions.
-
-### Changed
-
-- Renamed `DeadTask` to `ArchivedTask`.
-- Renamed the operation `Kill` to `Archive` in `Inpsector`.
-- Print stack trace when Handler panics.
-- Include a file name and a line number in the error message when recovering from a panic.
-
-### Added
-
-- `DefaultRetryDelayFunc` is now a public API, which can be used in the custom `RetryDelayFunc`.
-- `SkipRetry` error is added to be used as a return value from `Handler`.
-- `Servers` method is added to `Inspector`
-- `CancelActiveTask` method is added to `Inspector`.
-- `ListSchedulerEnqueueEvents` method is added to `Inspector`.
-- `SchedulerEntries` method is added to `Inspector`.
-- `DeleteQueue` method is added to `Inspector`.
-
-## [0.13.1] - 2020-11-22
-
-### Fixed
-
-- Fixed processor to wait for specified time duration before forcefully shutdown workers.
-
-## [0.13.0] - 2020-10-13
-
-### Added
-
-- `Scheduler` type is added to enable periodic tasks. See the godoc for its APIs and [wiki](https://github.com/hibiken/asynq/wiki/Periodic-Tasks) for the getting-started guide.
-
-### Changed
-
-- interface `Option` has changed. See the godoc for the new interface.
-  This change would have no impact as long as you are using exported functions (e.g. `MaxRetry`, `Queue`, etc)
-  to create `Option`s.
-
-### Added
-
-- `Payload.String() string` method is added
-- `Payload.MarshalJSON() ([]byte, error)` method is added
-
-## [0.12.0] - 2020-09-12
-
-**IMPORTANT**: If you are upgrading from a previous version, please install the latest version of the CLI `go get -u github.com/hibiken/asynq/tools/asynq` and run `asynq migrate` command. No process should be writing to Redis while you run the migration command.
-
-## The semantics of queue have changed
-
-Previously, we called tasks that are ready to be processed _"Enqueued tasks"_, and other tasks that are scheduled to be processed in the future _"Scheduled tasks"_, etc.
-We changed the semantics of _"Enqueue"_ slightly; All tasks that client pushes to Redis are _Enqueued_ to a queue. Within a queue, tasks will transition from one state to another.
-Possible task states are:
-
-- `Pending`: task is ready to be processed (previously called "Enqueued")
-- `Active`: tasks is currently being processed (previously called "InProgress")
-- `Scheduled`: task is scheduled to be processed in the future
-- `Retry`: task failed to be processed and will be retried again in the future
-- `Dead`: task has exhausted all of its retries and stored for manual inspection purpose
-
-**These semantics change is reflected in the new `Inspector` API and CLI commands.**
-
----
-
-### Changed
-
-#### `Client`
-
-Use `ProcessIn` or `ProcessAt` option to schedule a task instead of `EnqueueIn` or `EnqueueAt`.
-
-| Previously                  | v0.12.0                                    |
-| --------------------------- | ------------------------------------------ |
-| `client.EnqueueAt(t, task)` | `client.Enqueue(task, asynq.ProcessAt(t))` |
-| `client.EnqueueIn(d, task)` | `client.Enqueue(task, asynq.ProcessIn(d))` |
-
-#### `Inspector`
-
-All Inspector methods are scoped to a queue, and the methods take `qname (string)` as the first argument.  
-`EnqueuedTask` is renamed to `PendingTask` and its corresponding methods.  
-`InProgressTask` is renamed to `ActiveTask` and its corresponding methods.  
-Command "Enqueue" is replaced by the verb "Run" (e.g. `EnqueueAllScheduledTasks` --> `RunAllScheduledTasks`)
-
-#### `CLI`
-
-CLI commands are restructured to use subcommands. Commands are organized into a few management commands:
-To view details on any command, use `asynq help <command> <subcommand>`.
-
-- `asynq stats`
-- `asynq queue [ls inspect history rm pause unpause]`
-- `asynq task [ls cancel delete kill run delete-all kill-all run-all]`
-- `asynq server [ls]`
-
-### Added
-
-#### `RedisConnOpt`
-
-- `RedisClusterClientOpt` is added to connect to Redis Cluster.
-- `Username` field is added to all `RedisConnOpt` types in order to authenticate connection when Redis ACLs are used.
-
-#### `Client`
-
-- `ProcessIn(d time.Duration) Option` and `ProcessAt(t time.Time) Option` are added to replace `EnqueueIn` and `EnqueueAt` functionality.
-
-#### `Inspector`
-
-- `Queues() ([]string, error)` method is added to get all queue names.
-- `ClusterKeySlot(qname string) (int64, error)` method is added to get queue's hash slot in Redis cluster.
-- `ClusterNodes(qname string) ([]ClusterNode, error)` method is added to get a list of Redis cluster nodes for the given queue.
-- `Close() error` method is added to close connection with redis.
-
-### `Handler`
-
-- `GetQueueName(ctx context.Context) (string, bool)` helper is added to extract queue name from a context.
-
-## [0.11.0] - 2020-07-28
-
-### Added
-
-- `Inspector` type was added to monitor and mutate state of queues and tasks.
-- `HealthCheckFunc` and `HealthCheckInterval` fields were added to `Config` to allow user to specify a callback
-  function to check for broker connection.
-
-## [0.10.0] - 2020-07-06
-
 ### Changed
 
 - All tasks now requires timeout or deadline. By default, timeout is set to 30 mins.
@@ -316,6 +29,7 @@ To view details on any command, use `asynq help <command> <subcommand>`.
 
 - Fixes the JSON number overflow issue (https://github.com/hibiken/asynq/issues/166).
 
+
 ## [0.9.2] - 2020-06-08
 
 ### Added

CODE_OF_CONDUCT.md

@@ -1,128 +0,0 @@
-# Contributor Covenant Code of Conduct
-
-## Our Pledge
-
-We as members, contributors, and leaders pledge to make participation in our
-community a harassment-free experience for everyone, regardless of age, body
-size, visible or invisible disability, ethnicity, sex characteristics, gender
-identity and expression, level of experience, education, socio-economic status,
-nationality, personal appearance, race, religion, or sexual identity
-and orientation.
-
-We pledge to act and interact in ways that contribute to an open, welcoming,
-diverse, inclusive, and healthy community.
-
-## Our Standards
-
-Examples of behavior that contributes to a positive environment for our
-community include:
-
-* Demonstrating empathy and kindness toward other people
-* Being respectful of differing opinions, viewpoints, and experiences
-* Giving and gracefully accepting constructive feedback
-* Accepting responsibility and apologizing to those affected by our mistakes,
-  and learning from the experience
-* Focusing on what is best not just for us as individuals, but for the
-  overall community
-
-Examples of unacceptable behavior include:
-
-* The use of sexualized language or imagery, and sexual attention or
-  advances of any kind
-* Trolling, insulting or derogatory comments, and personal or political attacks
-* Public or private harassment
-* Publishing others' private information, such as a physical or email
-  address, without their explicit permission
-* Other conduct which could reasonably be considered inappropriate in a
-  professional setting
-
-## Enforcement Responsibilities
-
-Community leaders are responsible for clarifying and enforcing our standards of
-acceptable behavior and will take appropriate and fair corrective action in
-response to any behavior that they deem inappropriate, threatening, offensive,
-or harmful.
-
-Community leaders have the right and responsibility to remove, edit, or reject
-comments, commits, code, wiki edits, issues, and other contributions that are
-not aligned to this Code of Conduct, and will communicate reasons for moderation
-decisions when appropriate.
-
-## Scope
-
-This Code of Conduct applies within all community spaces, and also applies when
-an individual is officially representing the community in public spaces.
-Examples of representing our community include using an official e-mail address,
-posting via an official social media account, or acting as an appointed
-representative at an online or offline event.
-
-## Enforcement
-
-Instances of abusive, harassing, or otherwise unacceptable behavior may be
-reported to the community leaders responsible for enforcement at
-ken.hibino7@gmail.com.
-All complaints will be reviewed and investigated promptly and fairly.
-
-All community leaders are obligated to respect the privacy and security of the
-reporter of any incident.
-
-## Enforcement Guidelines
-
-Community leaders will follow these Community Impact Guidelines in determining
-the consequences for any action they deem in violation of this Code of Conduct:
-
-### 1. Correction
-
-**Community Impact**: Use of inappropriate language or other behavior deemed
-unprofessional or unwelcome in the community.
-
-**Consequence**: A private, written warning from community leaders, providing
-clarity around the nature of the violation and an explanation of why the
-behavior was inappropriate. A public apology may be requested.
-
-### 2. Warning
-
-**Community Impact**: A violation through a single incident or series
-of actions.
-
-**Consequence**: A warning with consequences for continued behavior. No
-interaction with the people involved, including unsolicited interaction with
-those enforcing the Code of Conduct, for a specified period of time. This
-includes avoiding interactions in community spaces as well as external channels
-like social media. Violating these terms may lead to a temporary or
-permanent ban.
-
-### 3. Temporary Ban
-
-**Community Impact**: A serious violation of community standards, including
-sustained inappropriate behavior.
-
-**Consequence**: A temporary ban from any sort of interaction or public
-communication with the community for a specified period of time. No public or
-private interaction with the people involved, including unsolicited interaction
-with those enforcing the Code of Conduct, is allowed during this period.
-Violating these terms may lead to a permanent ban.
-
-### 4. Permanent Ban
-
-**Community Impact**: Demonstrating a pattern of violation of community
-standards, including sustained inappropriate behavior,  harassment of an
-individual, or aggression toward or disparagement of classes of individuals.
-
-**Consequence**: A permanent ban from any sort of public interaction within
-the community.
-
-## Attribution
-
-This Code of Conduct is adapted from the [Contributor Covenant][homepage],
-version 2.0, available at
-https://www.contributor-covenant.org/version/2/0/code_of_conduct.html.
-
-Community Impact Guidelines were inspired by [Mozilla's code of conduct
-enforcement ladder](https://github.com/mozilla/diversity).
-
-[homepage]: https://www.contributor-covenant.org
-
-For answers to common questions about this code of conduct, see the FAQ at
-https://www.contributor-covenant.org/faq. Translations are available at
-https://www.contributor-covenant.org/translations.

CONTRIBUTING.md

@@ -45,7 +45,6 @@ Thank you! We'll try to respond as quickly as possible.
 6. Create a new pull request
 
 Please try to keep your pull request focused in scope and avoid including unrelated commits.
-Please run tests against redis cluster locally with `--redis_cluster` flag to ensure that code works for Redis cluster. TODO: Run tests using Redis cluster on CI.
 
 After you have submitted your pull request, we'll try to get back to you as soon as possible. We may suggest some changes or improvements.
 

Makefile

@@ -1,7 +0,0 @@
-ROOT_DIR:=$(shell dirname $(realpath $(firstword $(MAKEFILE_LIST))))
-
-proto: internal/proto/asynq.proto
-	protoc -I=$(ROOT_DIR)/internal/proto \
-				 --go_out=$(ROOT_DIR)/internal/proto \
-				 --go_opt=module=github.com/hibiken/asynq/internal/proto \
-				 $(ROOT_DIR)/internal/proto/asynq.proto

README.md

@@ -1,114 +1,87 @@
-<img src="https://user-images.githubusercontent.com/11155743/114697792-ffbfa580-9d26-11eb-8e5b-33bef69476dc.png" alt="Asynq logo" width="360px" />
+# Asynq
 
-# Simple, reliable & efficient distributed task queue in Go
+[![Build Status](https://travis-ci.com/hibiken/asynq.svg?token=paqzfpSkF4p23s5Ux39b&branch=master)](https://travis-ci.com/hibiken/asynq)
-
-[![GoDoc](https://godoc.org/github.com/hibiken/asynq?status.svg)](https://godoc.org/github.com/hibiken/asynq)
-[![Go Report Card](https://goreportcard.com/badge/github.com/hibiken/asynq)](https://goreportcard.com/report/github.com/hibiken/asynq)
-![Build Status](https://github.com/hibiken/asynq/workflows/build/badge.svg)
 [![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)](https://opensource.org/licenses/MIT)
+[![Go Report Card](https://goreportcard.com/badge/github.com/hibiken/asynq)](https://goreportcard.com/report/github.com/hibiken/asynq)
+[![GoDoc](https://godoc.org/github.com/hibiken/asynq?status.svg)](https://godoc.org/github.com/hibiken/asynq)
 [![Gitter chat](https://badges.gitter.im/go-asynq/gitter.svg)](https://gitter.im/go-asynq/community)
+[![codecov](https://codecov.io/gh/hibiken/asynq/branch/master/graph/badge.svg)](https://codecov.io/gh/hibiken/asynq)
 
-Asynq is a Go library for queueing tasks and processing them asynchronously with workers. It's backed by [Redis](https://redis.io/) and is designed to be scalable yet easy to get started.
+## Overview
+
+Asynq is a Go library for queueing tasks and processing them in the background with workers. It is backed by Redis and it is designed to have a low barrier to entry. It should be integrated in your web stack easily.
 
 Highlevel overview of how Asynq works:
 
-- Client puts tasks on a queue
+- Client puts task on a queue
-- Server pulls tasks off queues and starts a worker goroutine for each task
+- Server pulls task off queues and starts a worker goroutine for each task
 - Tasks are processed concurrently by multiple workers
 
-Task queues are used as a mechanism to distribute work across multiple machines. A system can consist of multiple worker servers and brokers, giving way to high availability and horizontal scaling.
+Task queues are used as a mechanism to distribute work across multiple machines.  
+A system can consist of multiple worker servers and brokers, giving way to high availability and horizontal scaling.
 
-**Example use case**
+![Task Queue Diagram](/docs/assets/overview.png)
 
-![Task Queue Diagram](https://user-images.githubusercontent.com/11155743/116358505-656f5f80-a806-11eb-9c16-94e49dab0f99.jpg)
+## Stability and Compatibility
+
+**Important Note**: Current major version is zero (v0.x.x) to accomodate rapid development and fast iteration while getting early feedback from users (Feedback on APIs are appreciated!). The public API could change without a major version update before v1.0.0 release.
+
+**Status**: The library is currently undergoing heavy development with frequent, breaking API changes.
 
 ## Features
 
 - Guaranteed [at least one execution](https://www.cloudcomputingpatterns.org/at_least_once_delivery/) of a task
 - Scheduling of tasks
+- Durability since tasks are written to Redis
 - [Retries](https://github.com/hibiken/asynq/wiki/Task-Retry) of failed tasks
-- Automatic recovery of tasks in the event of a worker crash
+- [Weighted priority queues](https://github.com/hibiken/asynq/wiki/Priority-Queues#weighted-priority-queues)
-- [Weighted priority queues](https://github.com/hibiken/asynq/wiki/Queue-Priority#weighted-priority)
+- [Strict priority queues](https://github.com/hibiken/asynq/wiki/Priority-Queues#strict-priority-queues)
-- [Strict priority queues](https://github.com/hibiken/asynq/wiki/Queue-Priority#strict-priority)
 - Low latency to add a task since writes are fast in Redis
 - De-duplication of tasks using [unique option](https://github.com/hibiken/asynq/wiki/Unique-Tasks)
 - Allow [timeout and deadline per task](https://github.com/hibiken/asynq/wiki/Task-Timeout-and-Cancelation)
 - [Flexible handler interface with support for middlewares](https://github.com/hibiken/asynq/wiki/Handler-Deep-Dive)
 - [Ability to pause queue](/tools/asynq/README.md#pause) to stop processing tasks from the queue
-- [Periodic Tasks](https://github.com/hibiken/asynq/wiki/Periodic-Tasks)
+- [Support Redis Sentinels](https://github.com/hibiken/asynq/wiki/Automatic-Failover) for HA
-- [Support Redis Cluster](https://github.com/hibiken/asynq/wiki/Redis-Cluster) for automatic sharding and high availability
-- [Support Redis Sentinels](https://github.com/hibiken/asynq/wiki/Automatic-Failover) for high availability
-- Integration with [Prometheus](https://prometheus.io/) to collect and visualize queue metrics
-- [Web UI](#web-ui) to inspect and remote-control queues and tasks
 - [CLI](#command-line-tool) to inspect and remote-control queues and tasks
 
-## Stability and Compatibility
-
-**Status**: The library is currently undergoing **heavy development** with frequent, breaking API changes.
-
-> ☝️ **Important Note**: Current major version is zero (`v0.x.x`) to accomodate rapid development and fast iteration while getting early feedback from users (_feedback on APIs are appreciated!_). The public API could change without a major version update before `v1.0.0` release.
-
 ## Quickstart
 
-Make sure you have Go installed ([download](https://golang.org/dl/)). Version `1.14` or higher is required.
+First, make sure you are running a Redis server locally.
-
-Initialize your project by creating a folder and then running `go mod init github.com/your/repo` ([learn more](https://blog.golang.org/using-go-modules)) inside the folder. Then install Asynq library with the [`go get`](https://golang.org/cmd/go/#hdr-Add_dependencies_to_current_module_and_install_them) command:
 
 ```sh
-go get -u github.com/hibiken/asynq
+$ redis-server
 ```
 
-Make sure you're running a Redis server locally or from a [Docker](https://hub.docker.com/_/redis) container. Version `4.0` or higher is required.
-
 Next, write a package that encapsulates task creation and task handling.
 
 ```go
 package tasks
 
 import (
-    "context"
-    "encoding/json"
     "fmt"
-    "log"
+
-    "time"
     "github.com/hibiken/asynq"
 )
 
 // A list of task types.
 const (
-    TypeEmailDelivery   = "email:deliver"
+    EmailDelivery   = "email:deliver"
-    TypeImageResize     = "image:resize"
+    ImageProcessing = "image:process"
 )
 
-type EmailDeliveryPayload struct {
-    UserID     int
-    TemplateID string
-}
-
-type ImageResizePayload struct {
-    SourceURL string
-}
-
 //----------------------------------------------
 // Write a function NewXXXTask to create a task.
 // A task consists of a type and a payload.
 //----------------------------------------------
 
-func NewEmailDeliveryTask(userID int, tmplID string) (*asynq.Task, error) {
+func NewEmailDeliveryTask(userID int, tmplID string) *asynq.Task {
-    payload, err := json.Marshal(EmailDeliveryPayload{UserID: userID, TemplateID: tmplID})
+    payload := map[string]interface{}{"user_id": userID, "template_id": tmplID}
-    if err != nil {
+    return asynq.NewTask(EmailDelivery, payload)
-        return nil, err
-    }
-    return asynq.NewTask(TypeEmailDelivery, payload), nil
 }
 
-func NewImageResizeTask(src string) (*asynq.Task, error) {
+func NewImageProcessingTask(src, dst string) *asynq.Task {
-    payload, err := json.Marshal(ImageResizePayload{SourceURL: src})
+    payload := map[string]interface{}{"src": src, "dst": dst}
-    if err != nil {
+    return asynq.NewTask(ImageProcessing, payload)
-        return nil, err
-    }
-    // task options can be passed to NewTask, which can be overridden at enqueue time.
-    return asynq.NewTask(TypeImageResize, payload, asynq.MaxRetry(5), asynq.Timeout(20 * time.Minute)), nil
 }
 
 //---------------------------------------------------------------
@@ -120,42 +93,51 @@ func NewImageResizeTask(src string) (*asynq.Task, error) {
 //---------------------------------------------------------------
 
 func HandleEmailDeliveryTask(ctx context.Context, t *asynq.Task) error {
-    var p EmailDeliveryPayload
+    userID, err := t.Payload.GetInt("user_id")
-    if err := json.Unmarshal(t.Payload(), &p); err != nil {
+    if err != nil {
-        return fmt.Errorf("json.Unmarshal failed: %v: %w", err, asynq.SkipRetry)
+        return err
     }
-    log.Printf("Sending Email to User: user_id=%d, template_id=%s", p.UserID, p.TemplateID)
+    tmplID, err := t.Payload.GetString("template_id")
-    // Email delivery code ...
+    if err != nil {
+        return err
+    }
+    fmt.Printf("Send Email to User: user_id = %d, template_id = %s\n", userID, tmplID)
+    // Email delivery logic ...
     return nil
 }
 
 // ImageProcessor implements asynq.Handler interface.
-type ImageProcessor struct {
+type ImageProcesser struct {
     // ... fields for struct
 }
 
-func (processor *ImageProcessor) ProcessTask(ctx context.Context, t *asynq.Task) error {
+func (p *ImageProcessor) ProcessTask(ctx context.Context, t *asynq.Task) error {
-    var p ImageResizePayload
+    src, err := t.Payload.GetString("src")
-    if err := json.Unmarshal(t.Payload(), &p); err != nil {
+    if err != nil {
-        return fmt.Errorf("json.Unmarshal failed: %v: %w", err, asynq.SkipRetry)
+        return err
     }
-    log.Printf("Resizing image: src=%s", p.SourceURL)
+    dst, err := t.Payload.GetString("dst")
-    // Image resizing code ...
+    if err != nil {
+        return err
+    }
+    fmt.Printf("Process image: src = %s, dst = %s\n", src, dst)
+    // Image processing logic ...
     return nil
 }
 
 func NewImageProcessor() *ImageProcessor {
-	return &ImageProcessor{}
+    // ... return an instance
 }
 ```
 
-In your application code, import the above package and use [`Client`](https://pkg.go.dev/github.com/hibiken/asynq?tab=doc#Client) to put tasks on queues.
+In your web application code, import the above package and use [`Client`](https://pkg.go.dev/github.com/hibiken/asynq?tab=doc#Client) to put tasks on the queue.  
+A task will be processed asynchronously by a background worker as soon as the task gets enqueued.  
+Scheduled tasks will be stored in Redis and will be enqueued at the specified time.
 
 ```go
 package main
 
 import (
-    "log"
     "time"
 
     "github.com/hibiken/asynq"
@@ -165,57 +147,68 @@ import (
 const redisAddr = "127.0.0.1:6379"
 
 func main() {
-    client := asynq.NewClient(asynq.RedisClientOpt{Addr: redisAddr})
+    r := asynq.RedisClientOpt{Addr: redisAddr}
-    defer client.Close()
+    c := asynq.NewClient(r)
+    defer c.Close()
 
     // ------------------------------------------------------
     // Example 1: Enqueue task to be processed immediately.
     //            Use (*Client).Enqueue method.
     // ------------------------------------------------------
 
-    task, err := tasks.NewEmailDeliveryTask(42, "some:template:id")
+    t := tasks.NewEmailDeliveryTask(42, "some:template:id")
+    res, err := c.Enqueue(t)
     if err != nil {
-        log.Fatalf("could not create task: %v", err)
+        log.Fatal("could not enqueue task: %v", err)
     }
-    info, err := client.Enqueue(task)
+    fmt.Printf("Enqueued Result: %+v\n", res)
-    if err != nil {
-        log.Fatalf("could not enqueue task: %v", err)
-    }
-    log.Printf("enqueued task: id=%s queue=%s", info.ID, info.Queue)
 
 
     // ------------------------------------------------------------
     // Example 2: Schedule task to be processed in the future.
-    //            Use ProcessIn or ProcessAt option.
+    //            Use (*Client).EnqueueIn or (*Client).EnqueueAt.
     // ------------------------------------------------------------
 
-    info, err = client.Enqueue(task, asynq.ProcessIn(24*time.Hour))
+    t = tasks.NewEmailDeliveryTask(42, "other:template:id")
+    res, err = c.EnqueueIn(24*time.Hour, t)
     if err != nil {
-        log.Fatalf("could not schedule task: %v", err)
+        log.Fatal("could not schedule task: %v", err)
     }
-    log.Printf("enqueued task: id=%s queue=%s", info.ID, info.Queue)
+    fmt.Printf("Enqueued Result: %+v\n", res)
 
 
     // ----------------------------------------------------------------------------
-    // Example 3: Set other options to tune task processing behavior.
+    // Example 3: Set options to tune task processing behavior.
     //            Options include MaxRetry, Queue, Timeout, Deadline, Unique etc.
     // ----------------------------------------------------------------------------
 
-    task, err = tasks.NewImageResizeTask("https://example.com/myassets/image.jpg")
+    c.SetDefaultOptions(tasks.ImageProcessing, asynq.MaxRetry(10), asynq.Timeout(time.Minute))
+
+    t = tasks.NewImageProcessingTask("some/blobstore/url", "other/blobstore/url")
+    res, err = c.Enqueue(t)
     if err != nil {
-        log.Fatalf("could not create task: %v", err)
+        log.Fatal("could not enqueue task: %v", err)
     }
-    info, err = client.Enqueue(task, asynq.MaxRetry(10), asynq.Timeout(3 * time.Minute))
+    fmt.Printf("Enqueued Result: %+v\n", res)
+
+    // ---------------------------------------------------------------------------
+    // Example 4: Pass options to tune task processing behavior at enqueue time.
+    //            Options passed at enqueue time override default ones, if any.
+    // ---------------------------------------------------------------------------
+
+    t = tasks.NewImageProcessingTask("some/blobstore/url", "other/blobstore/url")
+    res, err = c.Enqueue(t, asynq.Queue("critical"), asynq.Timeout(30*time.Second))
     if err != nil {
-        log.Fatalf("could not enqueue task: %v", err)
+        log.Fatal("could not enqueue task: %v", err)
     }
-    log.Printf("enqueued task: id=%s queue=%s", info.ID, info.Queue)
+    fmt.Printf("Enqueued Result: %+v\n", res)
 }
 ```
 
-Next, start a worker server to process these tasks in the background. To start the background workers, use [`Server`](https://pkg.go.dev/github.com/hibiken/asynq?tab=doc#Server) and provide your [`Handler`](https://pkg.go.dev/github.com/hibiken/asynq?tab=doc#Handler) to process the tasks.
+Next, create a worker server to process these tasks in the background.  
+To start the background workers, use [`Server`](https://pkg.go.dev/github.com/hibiken/asynq?tab=doc#Server) and provide your [`Handler`](https://pkg.go.dev/github.com/hibiken/asynq?tab=doc#Handler) to process the tasks.
 
-You can optionally use [`ServeMux`](https://pkg.go.dev/github.com/hibiken/asynq?tab=doc#ServeMux) to create a handler, just as you would with [`net/http`](https://golang.org/pkg/net/http/) Handler.
+You can optionally use [`ServeMux`](https://pkg.go.dev/github.com/hibiken/asynq?tab=doc#ServeMux) to create a handler, just as you would with [`"net/http"`](https://golang.org/pkg/net/http/) Handler.
 
 ```go
 package main
@@ -230,9 +223,9 @@ import (
 const redisAddr = "127.0.0.1:6379"
 
 func main() {
-    srv := asynq.NewServer(
+    r := asynq.RedisClientOpt{Addr: redisAddr}
-        asynq.RedisClientOpt{Addr: redisAddr},
+
-        asynq.Config{
+    srv := asynq.NewServer(r, asynq.Config{
         // Specify how many concurrent workers to use
         Concurrency: 10,
         // Optionally specify multiple queues with different priority.
@@ -242,13 +235,12 @@ func main() {
             "low":      1,
         },
         // See the godoc for other configuration options
-        },
+    })
-    )
 
     // mux maps a type to a handler
     mux := asynq.NewServeMux()
-    mux.HandleFunc(tasks.TypeEmailDelivery, tasks.HandleEmailDeliveryTask)
+    mux.HandleFunc(tasks.EmailDelivery, tasks.HandleEmailDeliveryTask)
-    mux.Handle(tasks.TypeImageResize, tasks.NewImageProcessor())
+    mux.Handle(tasks.ImageProcessing, tasks.NewImageProcessor())
     // ...register other handlers...
 
     if err := srv.Run(mux); err != nil {
@@ -257,55 +249,52 @@ func main() {
 }
 ```
 
-For a more detailed walk-through of the library, see our [Getting Started](https://github.com/hibiken/asynq/wiki/Getting-Started) guide.
+For a more detailed walk-through of the library, see our [Getting Started Guide](https://github.com/hibiken/asynq/wiki/Getting-Started).
 
-To learn more about `asynq` features and APIs, see the package [godoc](https://godoc.org/github.com/hibiken/asynq).
+To Learn more about `asynq` features and APIs, see our [Wiki](https://github.com/hibiken/asynq/wiki) and [godoc](https://godoc.org/github.com/hibiken/asynq).
-
-## Web UI
-
-[Asynqmon](https://github.com/hibiken/asynqmon) is a web based tool for monitoring and administrating Asynq queues and tasks.
-
-Here's a few screenshots of the Web UI:
-
-**Queues view**
-
-![Web UI Queues View](https://user-images.githubusercontent.com/11155743/114697016-07327f00-9d26-11eb-808c-0ac841dc888e.png)
-
-**Tasks view**
-
-![Web UI TasksView](https://user-images.githubusercontent.com/11155743/114697070-1f0a0300-9d26-11eb-855c-d3ec263865b7.png)
-
-**Metrics view**
-<img width="1532" alt="Screen Shot 2021-12-19 at 4 37 19 PM" src="https://user-images.githubusercontent.com/10953044/146777420-cae6c476-bac6-469c-acce-b2f6584e8707.png">
-
-**Settings and adaptive dark mode**
-
-![Web UI Settings and adaptive dark mode](https://user-images.githubusercontent.com/11155743/114697149-3517c380-9d26-11eb-9f7a-ae2dd00aad5b.png)
-
-For details on how to use the tool, refer to the tool's [README](https://github.com/hibiken/asynqmon#readme).
 
 ## Command Line Tool
 
 Asynq ships with a command line tool to inspect the state of queues and tasks.
 
+Here's an example of running the `stats` command.
+
+![Gif](/docs/assets/demo.gif)
+
+For details on how to use the tool, refer to the tool's [README](/tools/asynq/README.md).
+
+## Installation
+
+To install `asynq` library, run the following command:
+
+```sh
+go get -u github.com/hibiken/asynq
+```
+
 To install the CLI tool, run the following command:
 
 ```sh
 go get -u github.com/hibiken/asynq/tools/asynq
 ```
 
-Here's an example of running the `asynq stats` command:
+## Requirements
 
-![Gif](/docs/assets/demo.gif)
+| Dependency                 | Version |
-
+| -------------------------- | ------- |
-For details on how to use the tool, refer to the tool's [README](/tools/asynq/README.md).
+| [Redis](https://redis.io/) | v2.8+   |
+| [Go](https://golang.org/)  | v1.13+  |
 
 ## Contributing
 
-We are open to, and grateful for, any contributions (GitHub issues/PRs, feedback on [Gitter channel](https://gitter.im/go-asynq/community), etc) made by the community.
+We are open to, and grateful for, any contributions (Github issues/pull-requests, feedback on Gitter channel, etc) made by the community.
-
 Please see the [Contribution Guide](/CONTRIBUTING.md) before contributing.
 
+## Acknowledgements
+
+- [Sidekiq](https://github.com/mperham/sidekiq) : Many of the design ideas are taken from sidekiq and its Web UI
+- [RQ](https://github.com/rq/rq) : Client APIs are inspired by rq library.
+- [Cobra](https://github.com/spf13/cobra) : Asynq CLI is built with cobra
+
 ## License
 
-Copyright (c) 2019-present [Ken Hibino](https://github.com/hibiken) and [Contributors](https://github.com/hibiken/asynq/graphs/contributors). `Asynq` is free and open-source software licensed under the [MIT License](https://github.com/hibiken/asynq/blob/master/LICENSE). Official logo was created by [Vic Shóstak](https://github.com/koddr) and distributed under [Creative Commons](https://creativecommons.org/publicdomain/zero/1.0/) license (CC0 1.0 Universal).
+Asynq is released under the MIT license. See [LICENSE](https://github.com/hibiken/asynq/blob/master/LICENSE).

asynq.go

@@ -5,213 +5,40 @@
 package asynq
 
 import (
-	"context"
 	"crypto/tls"
 	"fmt"
 	"net/url"
 	"strconv"
 	"strings"
-	"time"
 
-	"github.com/go-redis/redis/v8"
+	"github.com/go-redis/redis/v7"
-	"github.com/hibiken/asynq/internal/base"
 )
 
 // Task represents a unit of work to be performed.
 type Task struct {
-	// typename indicates the type of task to be performed.
+	// Type indicates the type of task to be performed.
-	typename string
-
-	// payload holds data needed to perform the task.
-	payload []byte
-
-	// opts holds options for the task.
-	opts []Option
-
-	// w is the ResultWriter for the task.
-	w *ResultWriter
-}
-
-func (t *Task) Type() string    { return t.typename }
-func (t *Task) Payload() []byte { return t.payload }
-
-// ResultWriter returns a pointer to the ResultWriter associated with the task.
-//
-// Nil pointer is returned if called on a newly created task (i.e. task created by calling NewTask).
-// Only the tasks passed to Handler.ProcessTask have a valid ResultWriter pointer.
-func (t *Task) ResultWriter() *ResultWriter { return t.w }
-
-// NewTask returns a new Task given a type name and payload data.
-// Options can be passed to configure task processing behavior.
-func NewTask(typename string, payload []byte, opts ...Option) *Task {
-	return &Task{
-		typename: typename,
-		payload:  payload,
-		opts:     opts,
-	}
-}
-
-// newTask creates a task with the given typename, payload and ResultWriter.
-func newTask(typename string, payload []byte, w *ResultWriter) *Task {
-	return &Task{
-		typename: typename,
-		payload:  payload,
-		w:        w,
-	}
-}
-
-// A TaskInfo describes a task and its metadata.
-type TaskInfo struct {
-	// ID is the identifier of the task.
-	ID string
-
-	// Queue is the name of the queue in which the task belongs.
-	Queue string
-
-	// Type is the type name of the task.
 	Type string
 
-	// Payload is the payload data of the task.
+	// Payload holds data needed to perform the task.
-	Payload []byte
+	Payload Payload
-
-	// State indicates the task state.
-	State TaskState
-
-	// MaxRetry is the maximum number of times the task can be retried.
-	MaxRetry int
-
-	// Retried is the number of times the task has retried so far.
-	Retried int
-
-	// LastErr is the error message from the last failure.
-	LastErr string
-
-	// LastFailedAt is the time time of the last failure if any.
-	// If the task has no failures, LastFailedAt is zero time (i.e. time.Time{}).
-	LastFailedAt time.Time
-
-	// Timeout is the duration the task can be processed by Handler before being retried,
-	// zero if not specified
-	Timeout time.Duration
-
-	// Deadline is the deadline for the task, zero value if not specified.
-	Deadline time.Time
-
-	// NextProcessAt is the time the task is scheduled to be processed,
-	// zero if not applicable.
-	NextProcessAt time.Time
-
-	// Retention is duration of the retention period after the task is successfully processed.
-	Retention time.Duration
-
-	// CompletedAt is the time when the task is processed successfully.
-	// Zero value (i.e. time.Time{}) indicates no value.
-	CompletedAt time.Time
-
-	// Result holds the result data associated with the task.
-	// Use ResultWriter to write result data from the Handler.
-	Result []byte
 }
 
-// If t is non-zero, returns time converted from t as unix time in seconds.
+// NewTask returns a new Task given a type name and payload data.
-// If t is zero, returns zero value of time.Time.
+//
-func fromUnixTimeOrZero(t int64) time.Time {
+// The payload values must be serializable.
-	if t == 0 {
+func NewTask(typename string, payload map[string]interface{}) *Task {
-		return time.Time{}
+	return &Task{
+		Type:    typename,
+		Payload: Payload{payload},
 	}
-	return time.Unix(t, 0)
-}
-
-func newTaskInfo(msg *base.TaskMessage, state base.TaskState, nextProcessAt time.Time, result []byte) *TaskInfo {
-	info := TaskInfo{
-		ID:            msg.ID,
-		Queue:         msg.Queue,
-		Type:          msg.Type,
-		Payload:       msg.Payload, // Do we need to make a copy?
-		MaxRetry:      msg.Retry,
-		Retried:       msg.Retried,
-		LastErr:       msg.ErrorMsg,
-		Timeout:       time.Duration(msg.Timeout) * time.Second,
-		Deadline:      fromUnixTimeOrZero(msg.Deadline),
-		Retention:     time.Duration(msg.Retention) * time.Second,
-		NextProcessAt: nextProcessAt,
-		LastFailedAt:  fromUnixTimeOrZero(msg.LastFailedAt),
-		CompletedAt:   fromUnixTimeOrZero(msg.CompletedAt),
-		Result:        result,
-	}
-
-	switch state {
-	case base.TaskStateActive:
-		info.State = TaskStateActive
-	case base.TaskStatePending:
-		info.State = TaskStatePending
-	case base.TaskStateScheduled:
-		info.State = TaskStateScheduled
-	case base.TaskStateRetry:
-		info.State = TaskStateRetry
-	case base.TaskStateArchived:
-		info.State = TaskStateArchived
-	case base.TaskStateCompleted:
-		info.State = TaskStateCompleted
-	default:
-		panic(fmt.Sprintf("internal error: unknown state: %d", state))
-	}
-	return &info
-}
-
-// TaskState denotes the state of a task.
-type TaskState int
-
-const (
-	// Indicates that the task is currently being processed by Handler.
-	TaskStateActive TaskState = iota + 1
-
-	// Indicates that the task is ready to be processed by Handler.
-	TaskStatePending
-
-	// Indicates that the task is scheduled to be processed some time in the future.
-	TaskStateScheduled
-
-	// Indicates that the task has previously failed and scheduled to be processed some time in the future.
-	TaskStateRetry
-
-	// Indicates that the task is archived and stored for inspection purposes.
-	TaskStateArchived
-
-	// Indicates that the task is processed successfully and retained until the retention TTL expires.
-	TaskStateCompleted
-)
-
-func (s TaskState) String() string {
-	switch s {
-	case TaskStateActive:
-		return "active"
-	case TaskStatePending:
-		return "pending"
-	case TaskStateScheduled:
-		return "scheduled"
-	case TaskStateRetry:
-		return "retry"
-	case TaskStateArchived:
-		return "archived"
-	case TaskStateCompleted:
-		return "completed"
-	}
-	panic("asynq: unknown task state")
 }
 
 // RedisConnOpt is a discriminated union of types that represent Redis connection configuration option.
 //
 // RedisConnOpt represents a sum of following types:
 //
-//   - RedisClientOpt
+// RedisClientOpt | *RedisClientOpt | RedisFailoverClientOpt | *RedisFailoverClientOpt
-//   - RedisFailoverClientOpt
+type RedisConnOpt interface{}
-//   - RedisClusterClientOpt
-type RedisConnOpt interface {
-	// MakeRedisClient returns a new redis client instance.
-	// Return value is intentionally opaque to hide the implementation detail of redis client.
-	MakeRedisClient() interface{}
-}
 
 // RedisClientOpt is used to create a redis client that connects
 // to a redis server directly.
@@ -223,38 +50,13 @@ type RedisClientOpt struct {
 	// Redis server address in "host:port" format.
 	Addr string
 
-	// Username to authenticate the current connection when Redis ACLs are used.
+	// Redis server password.
-	// See: https://redis.io/commands/auth.
-	Username string
-
-	// Password to authenticate the current connection.
-	// See: https://redis.io/commands/auth.
 	Password string
 
 	// Redis DB to select after connecting to a server.
 	// See: https://redis.io/commands/select.
 	DB int
 
-	// Dial timeout for establishing new connections.
-	// Default is 5 seconds.
-	DialTimeout time.Duration
-
-	// Timeout for socket reads.
-	// If timeout is reached, read commands will fail with a timeout error
-	// instead of blocking.
-	//
-	// Use value -1 for no timeout and 0 for default.
-	// Default is 3 seconds.
-	ReadTimeout time.Duration
-
-	// Timeout for socket writes.
-	// If timeout is reached, write commands will fail with a timeout error
-	// instead of blocking.
-	//
-	// Use value -1 for no timeout and 0 for default.
-	// Default is ReadTimout.
-	WriteTimeout time.Duration
-
 	// Maximum number of socket connections.
 	// Default is 10 connections per every CPU as reported by runtime.NumCPU.
 	PoolSize int
@@ -264,21 +66,6 @@ type RedisClientOpt struct {
 	TLSConfig *tls.Config
 }
 
-func (opt RedisClientOpt) MakeRedisClient() interface{} {
-	return redis.NewClient(&redis.Options{
-		Network:      opt.Network,
-		Addr:         opt.Addr,
-		Username:     opt.Username,
-		Password:     opt.Password,
-		DB:           opt.DB,
-		DialTimeout:  opt.DialTimeout,
-		ReadTimeout:  opt.ReadTimeout,
-		WriteTimeout: opt.WriteTimeout,
-		PoolSize:     opt.PoolSize,
-		TLSConfig:    opt.TLSConfig,
-	})
-}
-
 // RedisFailoverClientOpt is used to creates a redis client that talks
 // to redis sentinels for service discovery and has an automatic failover
 // capability.
@@ -294,38 +81,13 @@ type RedisFailoverClientOpt struct {
 	// Redis sentinel password.
 	SentinelPassword string
 
-	// Username to authenticate the current connection when Redis ACLs are used.
+	// Redis server password.
-	// See: https://redis.io/commands/auth.
-	Username string
-
-	// Password to authenticate the current connection.
-	// See: https://redis.io/commands/auth.
 	Password string
 
 	// Redis DB to select after connecting to a server.
 	// See: https://redis.io/commands/select.
 	DB int
 
-	// Dial timeout for establishing new connections.
-	// Default is 5 seconds.
-	DialTimeout time.Duration
-
-	// Timeout for socket reads.
-	// If timeout is reached, read commands will fail with a timeout error
-	// instead of blocking.
-	//
-	// Use value -1 for no timeout and 0 for default.
-	// Default is 3 seconds.
-	ReadTimeout time.Duration
-
-	// Timeout for socket writes.
-	// If timeout is reached, write commands will fail with a timeout error
-	// instead of blocking.
-	//
-	// Use value -1 for no timeout and 0 for default.
-	// Default is ReadTimeout
-	WriteTimeout time.Duration
-
 	// Maximum number of socket connections.
 	// Default is 10 connections per every CPU as reported by runtime.NumCPU.
 	PoolSize int
@@ -335,79 +97,6 @@ type RedisFailoverClientOpt struct {
 	TLSConfig *tls.Config
 }
 
-func (opt RedisFailoverClientOpt) MakeRedisClient() interface{} {
-	return redis.NewFailoverClient(&redis.FailoverOptions{
-		MasterName:       opt.MasterName,
-		SentinelAddrs:    opt.SentinelAddrs,
-		SentinelPassword: opt.SentinelPassword,
-		Username:         opt.Username,
-		Password:         opt.Password,
-		DB:               opt.DB,
-		DialTimeout:      opt.DialTimeout,
-		ReadTimeout:      opt.ReadTimeout,
-		WriteTimeout:     opt.WriteTimeout,
-		PoolSize:         opt.PoolSize,
-		TLSConfig:        opt.TLSConfig,
-	})
-}
-
-// RedisClusterClientOpt is used to creates a redis client that connects to
-// redis cluster.
-type RedisClusterClientOpt struct {
-	// A seed list of host:port addresses of cluster nodes.
-	Addrs []string
-
-	// The maximum number of retries before giving up.
-	// Command is retried on network errors and MOVED/ASK redirects.
-	// Default is 8 retries.
-	MaxRedirects int
-
-	// Username to authenticate the current connection when Redis ACLs are used.
-	// See: https://redis.io/commands/auth.
-	Username string
-
-	// Password to authenticate the current connection.
-	// See: https://redis.io/commands/auth.
-	Password string
-
-	// Dial timeout for establishing new connections.
-	// Default is 5 seconds.
-	DialTimeout time.Duration
-
-	// Timeout for socket reads.
-	// If timeout is reached, read commands will fail with a timeout error
-	// instead of blocking.
-	//
-	// Use value -1 for no timeout and 0 for default.
-	// Default is 3 seconds.
-	ReadTimeout time.Duration
-
-	// Timeout for socket writes.
-	// If timeout is reached, write commands will fail with a timeout error
-	// instead of blocking.
-	//
-	// Use value -1 for no timeout and 0 for default.
-	// Default is ReadTimeout.
-	WriteTimeout time.Duration
-
-	// TLS Config used to connect to a server.
-	// TLS will be negotiated only if this field is set.
-	TLSConfig *tls.Config
-}
-
-func (opt RedisClusterClientOpt) MakeRedisClient() interface{} {
-	return redis.NewClusterClient(&redis.ClusterOptions{
-		Addrs:        opt.Addrs,
-		MaxRedirects: opt.MaxRedirects,
-		Username:     opt.Username,
-		Password:     opt.Password,
-		DialTimeout:  opt.DialTimeout,
-		ReadTimeout:  opt.ReadTimeout,
-		WriteTimeout: opt.WriteTimeout,
-		TLSConfig:    opt.TLSConfig,
-	})
-}
-
 // ParseRedisURI parses redis uri string and returns RedisConnOpt if uri is valid.
 // It returns a non-nil error if uri cannot be parsed.
 //
@@ -481,26 +170,50 @@ func parseRedisSentinelURI(u *url.URL) (RedisConnOpt, error) {
 	return RedisFailoverClientOpt{MasterName: master, SentinelAddrs: addrs, Password: password}, nil
 }
 
-// ResultWriter is a client interface to write result data for a task.
+// createRedisClient returns a redis client given a redis connection configuration.
-// It writes the data to the redis instance the server is connected to.
+//
-type ResultWriter struct {
+// Passing an unexpected type as a RedisConnOpt argument will cause panic.
-	id     string // task ID this writer is responsible for
+func createRedisClient(r RedisConnOpt) *redis.Client {
-	qname  string // queue name the task belongs to
+	switch r := r.(type) {
-	broker base.Broker
+	case *RedisClientOpt:
-	ctx    context.Context // context associated with the task
+		return redis.NewClient(&redis.Options{
-}
+			Network:   r.Network,
-
+			Addr:      r.Addr,
-// Write writes the given data as a result of the task the ResultWriter is associated with.
+			Password:  r.Password,
-func (w *ResultWriter) Write(data []byte) (n int, err error) {
+			DB:        r.DB,
-	select {
+			PoolSize:  r.PoolSize,
-	case <-w.ctx.Done():
+			TLSConfig: r.TLSConfig,
-		return 0, fmt.Errorf("failed to result task result: %v", w.ctx.Err())
+		})
+	case RedisClientOpt:
+		return redis.NewClient(&redis.Options{
+			Network:   r.Network,
+			Addr:      r.Addr,
+			Password:  r.Password,
+			DB:        r.DB,
+			PoolSize:  r.PoolSize,
+			TLSConfig: r.TLSConfig,
+		})
+	case *RedisFailoverClientOpt:
+		return redis.NewFailoverClient(&redis.FailoverOptions{
+			MasterName:       r.MasterName,
+			SentinelAddrs:    r.SentinelAddrs,
+			SentinelPassword: r.SentinelPassword,
+			Password:         r.Password,
+			DB:               r.DB,
+			PoolSize:         r.PoolSize,
+			TLSConfig:        r.TLSConfig,
+		})
+	case RedisFailoverClientOpt:
+		return redis.NewFailoverClient(&redis.FailoverOptions{
+			MasterName:       r.MasterName,
+			SentinelAddrs:    r.SentinelAddrs,
+			SentinelPassword: r.SentinelPassword,
+			Password:         r.Password,
+			DB:               r.DB,
+			PoolSize:         r.PoolSize,
+			TLSConfig:        r.TLSConfig,
+		})
 	default:
+		panic(fmt.Sprintf("asynq: unexpected type %T for RedisConnOpt", r))
 	}
-	return w.broker.WriteResult(w.qname, w.id, data)
-}
-
-// TaskID returns the ID of the task the ResultWriter is associated with.
-func (w *ResultWriter) TaskID() string {
-	return w.id
 }

asynq_test.go

@@ -7,10 +7,9 @@ package asynq
 import (
 	"flag"
 	"sort"
-	"strings"
 	"testing"
 
-	"github.com/go-redis/redis/v8"
+	"github.com/go-redis/redis/v7"
 	"github.com/google/go-cmp/cmp"
 	h "github.com/hibiken/asynq/internal/asynqtest"
 	"github.com/hibiken/asynq/internal/log"
@@ -25,9 +24,6 @@ var (
 	redisAddr string
 	redisDB   int
 
-	useRedisCluster   bool
-	redisClusterAddrs string // comma-separated list of host:port
-
 	testLogLevel = FatalLevel
 )
 
@@ -36,56 +32,27 @@ var testLogger *log.Logger
 func init() {
 	flag.StringVar(&redisAddr, "redis_addr", "localhost:6379", "redis address to use in testing")
 	flag.IntVar(&redisDB, "redis_db", 14, "redis db number to use in testing")
-	flag.BoolVar(&useRedisCluster, "redis_cluster", false, "use redis cluster as a broker in testing")
-	flag.StringVar(&redisClusterAddrs, "redis_cluster_addrs", "localhost:7000,localhost:7001,localhost:7002", "comma separated list of redis server addresses")
 	flag.Var(&testLogLevel, "loglevel", "log level to use in testing")
 
 	testLogger = log.NewLogger(nil)
 	testLogger.SetLevel(toInternalLogLevel(testLogLevel))
 }
 
-func setup(tb testing.TB) (r redis.UniversalClient) {
+func setup(tb testing.TB) *redis.Client {
 	tb.Helper()
-	if useRedisCluster {
+	r := redis.NewClient(&redis.Options{
-		addrs := strings.Split(redisClusterAddrs, ",")
-		if len(addrs) == 0 {
-			tb.Fatal("No redis cluster addresses provided. Please set addresses using --redis_cluster_addrs flag.")
-		}
-		r = redis.NewClusterClient(&redis.ClusterOptions{
-			Addrs: addrs,
-		})
-	} else {
-		r = redis.NewClient(&redis.Options{
 		Addr: redisAddr,
 		DB:   redisDB,
 	})
-	}
 	// Start each test with a clean slate.
 	h.FlushDB(tb, r)
 	return r
 }
 
-func getRedisConnOpt(tb testing.TB) RedisConnOpt {
-	tb.Helper()
-	if useRedisCluster {
-		addrs := strings.Split(redisClusterAddrs, ",")
-		if len(addrs) == 0 {
-			tb.Fatal("No redis cluster addresses provided. Please set addresses using --redis_cluster_addrs flag.")
-		}
-		return RedisClusterClientOpt{
-			Addrs: addrs,
-		}
-	}
-	return RedisClientOpt{
-		Addr: redisAddr,
-		DB:   redisDB,
-	}
-}
-
 var sortTaskOpt = cmp.Transformer("SortMsg", func(in []*Task) []*Task {
 	out := append([]*Task(nil), in...) // Copy input to avoid mutating it
 	sort.Slice(out, func(i, j int) bool {
-		return out[i].Type() < out[j].Type()
+		return out[i].Type < out[j].Type
 	})
 	return out
 })

benchmark_test.go

@@ -6,31 +6,22 @@ package asynq
 
 import (
 	"context"
-	"encoding/json"
 	"fmt"
 	"sync"
 	"testing"
 	"time"
-
-	h "github.com/hibiken/asynq/internal/asynqtest"
 )
 
-// Creates a new task of type "task<n>" with payload {"data": n}.
-func makeTask(n int) *Task {
-	b, err := json.Marshal(map[string]int{"data": n})
-	if err != nil {
-		panic(err)
-	}
-	return NewTask(fmt.Sprintf("task%d", n), b)
-}
-
 // Simple E2E Benchmark testing with no scheduled tasks and retries.
 func BenchmarkEndToEndSimple(b *testing.B) {
 	const count = 100000
 	for n := 0; n < b.N; n++ {
 		b.StopTimer() // begin setup
 		setup(b)
-		redis := getRedisConnOpt(b)
+		redis := &RedisClientOpt{
+			Addr: redisAddr,
+			DB:   redisDB,
+		}
 		client := NewClient(redis)
 		srv := NewServer(redis, Config{
 			Concurrency: 10,
@@ -41,11 +32,11 @@ func BenchmarkEndToEndSimple(b *testing.B) {
 		})
 		// Create a bunch of tasks
 		for i := 0; i < count; i++ {
-			if _, err := client.Enqueue(makeTask(i)); err != nil {
+			t := NewTask(fmt.Sprintf("task%d", i), map[string]interface{}{"data": i})
+			if _, err := client.Enqueue(t); err != nil {
 				b.Fatalf("could not enqueue a task: %v", err)
 			}
 		}
-		client.Close()
 
 		var wg sync.WaitGroup
 		wg.Add(count)
@@ -70,7 +61,10 @@ func BenchmarkEndToEnd(b *testing.B) {
 	for n := 0; n < b.N; n++ {
 		b.StopTimer() // begin setup
 		setup(b)
-		redis := getRedisConnOpt(b)
+		redis := &RedisClientOpt{
+			Addr: redisAddr,
+			DB:   redisDB,
+		}
 		client := NewClient(redis)
 		srv := NewServer(redis, Config{
 			Concurrency: 10,
@@ -81,32 +75,28 @@ func BenchmarkEndToEnd(b *testing.B) {
 		})
 		// Create a bunch of tasks
 		for i := 0; i < count; i++ {
-			if _, err := client.Enqueue(makeTask(i)); err != nil {
+			t := NewTask(fmt.Sprintf("task%d", i), map[string]interface{}{"data": i})
+			if _, err := client.Enqueue(t); err != nil {
 				b.Fatalf("could not enqueue a task: %v", err)
 			}
 		}
 		for i := 0; i < count; i++ {
-			if _, err := client.Enqueue(makeTask(i), ProcessIn(1*time.Second)); err != nil {
+			t := NewTask(fmt.Sprintf("scheduled%d", i), map[string]interface{}{"data": i})
+			if _, err := client.EnqueueAt(time.Now().Add(time.Second), t); err != nil {
 				b.Fatalf("could not enqueue a task: %v", err)
 			}
 		}
-		client.Close()
 
 		var wg sync.WaitGroup
 		wg.Add(count * 2)
 		handler := func(ctx context.Context, t *Task) error {
-			var p map[string]int
+			n, err := t.Payload.GetInt("data")
-			if err := json.Unmarshal(t.Payload(), &p); err != nil {
+			if err != nil {
 				b.Logf("internal error: %v", err)
 			}
-			n, ok := p["data"]
-			if !ok {
-				n = 1
-				b.Logf("internal error: could not get data from payload")
-			}
 			retried, ok := GetRetryCount(ctx)
 			if !ok {
-				b.Logf("internal error: could not get retry count from context")
+				b.Logf("internal error: %v", err)
 			}
 			// Fail 1% of tasks for the first attempt.
 			if retried == 0 && n%100 == 0 {
@@ -137,7 +127,10 @@ func BenchmarkEndToEndMultipleQueues(b *testing.B) {
 	for n := 0; n < b.N; n++ {
 		b.StopTimer() // begin setup
 		setup(b)
-		redis := getRedisConnOpt(b)
+		redis := &RedisClientOpt{
+			Addr: redisAddr,
+			DB:   redisDB,
+		}
 		client := NewClient(redis)
 		srv := NewServer(redis, Config{
 			Concurrency: 10,
@@ -150,21 +143,23 @@ func BenchmarkEndToEndMultipleQueues(b *testing.B) {
 		})
 		// Create a bunch of tasks
 		for i := 0; i < highCount; i++ {
-			if _, err := client.Enqueue(makeTask(i), Queue("high")); err != nil {
+			t := NewTask(fmt.Sprintf("task%d", i), map[string]interface{}{"data": i})
+			if _, err := client.Enqueue(t, Queue("high")); err != nil {
 				b.Fatalf("could not enqueue a task: %v", err)
 			}
 		}
 		for i := 0; i < defaultCount; i++ {
-			if _, err := client.Enqueue(makeTask(i)); err != nil {
+			t := NewTask(fmt.Sprintf("task%d", i), map[string]interface{}{"data": i})
+			if _, err := client.Enqueue(t); err != nil {
 				b.Fatalf("could not enqueue a task: %v", err)
 			}
 		}
 		for i := 0; i < lowCount; i++ {
-			if _, err := client.Enqueue(makeTask(i), Queue("low")); err != nil {
+			t := NewTask(fmt.Sprintf("task%d", i), map[string]interface{}{"data": i})
+			if _, err := client.Enqueue(t, Queue("low")); err != nil {
 				b.Fatalf("could not enqueue a task: %v", err)
 			}
 		}
-		client.Close()
 
 		var wg sync.WaitGroup
 		wg.Add(highCount + defaultCount + lowCount)
@@ -190,7 +185,10 @@ func BenchmarkClientWhileServerRunning(b *testing.B) {
 	for n := 0; n < b.N; n++ {
 		b.StopTimer() // begin setup
 		setup(b)
-		redis := getRedisConnOpt(b)
+		redis := &RedisClientOpt{
+			Addr: redisAddr,
+			DB:   redisDB,
+		}
 		client := NewClient(redis)
 		srv := NewServer(redis, Config{
 			Concurrency: 10,
@@ -201,13 +199,15 @@ func BenchmarkClientWhileServerRunning(b *testing.B) {
 		})
 		// Enqueue 10,000 tasks.
 		for i := 0; i < count; i++ {
-			if _, err := client.Enqueue(makeTask(i)); err != nil {
+			t := NewTask(fmt.Sprintf("task%d", i), map[string]interface{}{"data": i})
+			if _, err := client.Enqueue(t); err != nil {
 				b.Fatalf("could not enqueue a task: %v", err)
 			}
 		}
 		// Schedule 10,000 tasks.
 		for i := 0; i < count; i++ {
-			if _, err := client.Enqueue(makeTask(i), ProcessIn(1*time.Second)); err != nil {
+			t := NewTask(fmt.Sprintf("scheduled%d", i), map[string]interface{}{"data": i})
+			if _, err := client.EnqueueAt(time.Now().Add(time.Second), t); err != nil {
 				b.Fatalf("could not enqueue a task: %v", err)
 			}
 		}
@@ -222,7 +222,7 @@ func BenchmarkClientWhileServerRunning(b *testing.B) {
 		b.Log("Starting enqueueing")
 		enqueued := 0
 		for enqueued < 100000 {
-			t := NewTask(fmt.Sprintf("enqueued%d", enqueued), h.JSON(map[string]interface{}{"data": enqueued}))
+			t := NewTask(fmt.Sprintf("enqueued%d", enqueued), map[string]interface{}{"data": enqueued})
 			if _, err := client.Enqueue(t); err != nil {
 				b.Logf("could not enqueue task %d: %v", enqueued, err)
 				continue
@@ -233,7 +233,6 @@ func BenchmarkClientWhileServerRunning(b *testing.B) {
 
 		b.StopTimer() // begin teardown
 		srv.Stop()
-		client.Close()
 		b.StartTimer() // end teardown
 	}
 }

client.go

@@ -5,15 +5,15 @@
 package asynq
 
 import (
-	"context"
+	"errors"
 	"fmt"
+	"sort"
 	"strings"
+	"sync"
 	"time"
 
-	"github.com/go-redis/redis/v8"
 	"github.com/google/uuid"
 	"github.com/hibiken/asynq/internal/base"
-	"github.com/hibiken/asynq/internal/errors"
 	"github.com/hibiken/asynq/internal/rdb"
 )
 
@@ -24,55 +24,30 @@ import (
 //
 // Clients are safe for concurrent use by multiple goroutines.
 type Client struct {
+	mu   sync.Mutex
+	opts map[string][]Option
 	rdb  *rdb.RDB
 }
 
-// NewClient returns a new Client instance given a redis connection option.
+// NewClient and returns a new Client given a redis connection option.
 func NewClient(r RedisConnOpt) *Client {
-	c, ok := r.MakeRedisClient().(redis.UniversalClient)
+	rdb := rdb.NewRDB(createRedisClient(r))
-	if !ok {
+	return &Client{
-		panic(fmt.Sprintf("asynq: unsupported RedisConnOpt type %T", r))
+		opts: make(map[string][]Option),
+		rdb:  rdb,
 	}
-	return &Client{rdb: rdb.NewRDB(c)}
 }
 
-type OptionType int
-
-const (
-	MaxRetryOpt OptionType = iota
-	QueueOpt
-	TimeoutOpt
-	DeadlineOpt
-	UniqueOpt
-	ProcessAtOpt
-	ProcessInOpt
-	TaskIDOpt
-	RetentionOpt
-)
-
 // Option specifies the task processing behavior.
-type Option interface {
+type Option interface{}
-	// String returns a string representation of the option.
-	String() string
-
-	// Type describes the type of the option.
-	Type() OptionType
-
-	// Value returns a value used to create this option.
-	Value() interface{}
-}
 
 // Internal option representations.
 type (
 	retryOption    int
 	queueOption    string
-	taskIDOption    string
 	timeoutOption  time.Duration
 	deadlineOption time.Time
 	uniqueOption   time.Duration
-	processAtOption time.Time
-	processInOption time.Duration
-	retentionOption time.Duration
 )
 
 // MaxRetry returns an option to specify the max number of times
@@ -86,28 +61,13 @@ func MaxRetry(n int) Option {
 	return retryOption(n)
 }
 
-func (n retryOption) String() string     { return fmt.Sprintf("MaxRetry(%d)", int(n)) }
-func (n retryOption) Type() OptionType   { return MaxRetryOpt }
-func (n retryOption) Value() interface{} { return int(n) }
-
 // Queue returns an option to specify the queue to enqueue the task into.
-func Queue(qname string) Option {
+//
-	return queueOption(qname)
+// Queue name is case-insensitive and the lowercased version is used.
+func Queue(name string) Option {
+	return queueOption(strings.ToLower(name))
 }
 
-func (qname queueOption) String() string     { return fmt.Sprintf("Queue(%q)", string(qname)) }
-func (qname queueOption) Type() OptionType   { return QueueOpt }
-func (qname queueOption) Value() interface{} { return string(qname) }
-
-// TaskID returns an option to specify the task ID.
-func TaskID(id string) Option {
-	return taskIDOption(id)
-}
-
-func (id taskIDOption) String() string     { return fmt.Sprintf("TaskID(%q)", string(id)) }
-func (id taskIDOption) Type() OptionType   { return TaskIDOpt }
-func (id taskIDOption) Value() interface{} { return string(id) }
-
 // Timeout returns an option to specify how long a task may run.
 // If the timeout elapses before the Handler returns, then the task
 // will be retried.
@@ -120,10 +80,6 @@ func Timeout(d time.Duration) Option {
 	return timeoutOption(d)
 }
 
-func (d timeoutOption) String() string     { return fmt.Sprintf("Timeout(%v)", time.Duration(d)) }
-func (d timeoutOption) Type() OptionType   { return TimeoutOpt }
-func (d timeoutOption) Value() interface{} { return time.Duration(d) }
-
 // Deadline returns an option to specify the deadline for the given task.
 // If it reaches the deadline before the Handler returns, then the task
 // will be retried.
@@ -134,17 +90,10 @@ func Deadline(t time.Time) Option {
 	return deadlineOption(t)
 }
 
-func (t deadlineOption) String() string {
-	return fmt.Sprintf("Deadline(%v)", time.Time(t).Format(time.UnixDate))
-}
-func (t deadlineOption) Type() OptionType   { return DeadlineOpt }
-func (t deadlineOption) Value() interface{} { return time.Time(t) }
-
 // Unique returns an option to enqueue a task only if the given task is unique.
 // Task enqueued with this option is guaranteed to be unique within the given ttl.
 // Once the task gets processed successfully or once the TTL has expired, another task with the same uniqueness may be enqueued.
 // ErrDuplicateTask error is returned when enqueueing a duplicate task.
-// TTL duration must be greater than or equal to 1 second.
 //
 // Uniqueness of a task is based on the following properties:
 //     - Task Type
@@ -154,124 +103,76 @@ func Unique(ttl time.Duration) Option {
 	return uniqueOption(ttl)
 }
 
-func (ttl uniqueOption) String() string     { return fmt.Sprintf("Unique(%v)", time.Duration(ttl)) }
-func (ttl uniqueOption) Type() OptionType   { return UniqueOpt }
-func (ttl uniqueOption) Value() interface{} { return time.Duration(ttl) }
-
-// ProcessAt returns an option to specify when to process the given task.
-//
-// If there's a conflicting ProcessIn option, the last option passed to Enqueue overrides the others.
-func ProcessAt(t time.Time) Option {
-	return processAtOption(t)
-}
-
-func (t processAtOption) String() string {
-	return fmt.Sprintf("ProcessAt(%v)", time.Time(t).Format(time.UnixDate))
-}
-func (t processAtOption) Type() OptionType   { return ProcessAtOpt }
-func (t processAtOption) Value() interface{} { return time.Time(t) }
-
-// ProcessIn returns an option to specify when to process the given task relative to the current time.
-//
-// If there's a conflicting ProcessAt option, the last option passed to Enqueue overrides the others.
-func ProcessIn(d time.Duration) Option {
-	return processInOption(d)
-}
-
-func (d processInOption) String() string     { return fmt.Sprintf("ProcessIn(%v)", time.Duration(d)) }
-func (d processInOption) Type() OptionType   { return ProcessInOpt }
-func (d processInOption) Value() interface{} { return time.Duration(d) }
-
-// Retention returns an option to specify the duration of retention period for the task.
-// If this option is provided, the task will be stored as a completed task after successful processing.
-// A completed task will be deleted after the specified duration elapses.
-func Retention(d time.Duration) Option {
-	return retentionOption(d)
-}
-
-func (ttl retentionOption) String() string     { return fmt.Sprintf("Retention(%v)", time.Duration(ttl)) }
-func (ttl retentionOption) Type() OptionType   { return RetentionOpt }
-func (ttl retentionOption) Value() interface{} { return time.Duration(ttl) }
-
 // ErrDuplicateTask indicates that the given task could not be enqueued since it's a duplicate of another task.
 //
 // ErrDuplicateTask error only applies to tasks enqueued with a Unique option.
 var ErrDuplicateTask = errors.New("task already exists")
 
-// ErrTaskIDConflict indicates that the given task could not be enqueued since its task ID already exists.
-//
-// ErrTaskIDConflict error only applies to tasks enqueued with a TaskID option.
-var ErrTaskIDConflict = errors.New("task ID conflicts with another task")
-
 type option struct {
 	retry     int
 	queue     string
-	taskID    string
 	timeout   time.Duration
 	deadline  time.Time
 	uniqueTTL time.Duration
-	processAt time.Time
-	retention time.Duration
 }
 
-// composeOptions merges user provided options into the default options
+func composeOptions(opts ...Option) option {
-// and returns the composed option.
-// It also validates the user provided options and returns an error if any of
-// the user provided options fail the validations.
-func composeOptions(opts ...Option) (option, error) {
 	res := option{
 		retry:    defaultMaxRetry,
 		queue:    base.DefaultQueueName,
-		taskID:    uuid.NewString(),
 		timeout:  0, // do not set to deafultTimeout here
 		deadline: time.Time{},
-		processAt: time.Now(),
 	}
 	for _, opt := range opts {
 		switch opt := opt.(type) {
 		case retryOption:
 			res.retry = int(opt)
 		case queueOption:
-			qname := string(opt)
+			res.queue = string(opt)
-			if err := base.ValidateQueueName(qname); err != nil {
-				return option{}, err
-			}
-			res.queue = qname
-		case taskIDOption:
-			id := string(opt)
-			if err := validateTaskID(id); err != nil {
-				return option{}, err
-			}
-			res.taskID = id
 		case timeoutOption:
 			res.timeout = time.Duration(opt)
 		case deadlineOption:
 			res.deadline = time.Time(opt)
 		case uniqueOption:
-			ttl := time.Duration(opt)
+			res.uniqueTTL = time.Duration(opt)
-			if ttl < 1*time.Second {
-				return option{}, errors.New("Unique TTL cannot be less than 1s")
-			}
-			res.uniqueTTL = ttl
-		case processAtOption:
-			res.processAt = time.Time(opt)
-		case processInOption:
-			res.processAt = time.Now().Add(time.Duration(opt))
-		case retentionOption:
-			res.retention = time.Duration(opt)
 		default:
 			// ignore unexpected option
 		}
 	}
-	return res, nil
+	return res
 }
 
-// validates user provided task ID string.
+// uniqueKey computes the redis key used for the given task.
-func validateTaskID(id string) error {
+// It returns an empty string if ttl is zero.
-	if strings.TrimSpace(id) == "" {
+func uniqueKey(t *Task, ttl time.Duration, qname string) string {
-		return errors.New("task ID cannot be empty")
+	if ttl == 0 {
+		return ""
 	}
-	return nil
+	return fmt.Sprintf("%s:%s:%s", t.Type, serializePayload(t.Payload.data), qname)
+}
+
+func serializePayload(payload map[string]interface{}) string {
+	if payload == nil {
+		return "nil"
+	}
+	type entry struct {
+		k string
+		v interface{}
+	}
+	var es []entry
+	for k, v := range payload {
+		es = append(es, entry{k, v})
+	}
+	// sort entries by key
+	sort.Slice(es, func(i, j int) bool { return es[i].k < es[j].k })
+	var b strings.Builder
+	for _, e := range es {
+		if b.Len() > 0 {
+			b.WriteString(",")
+		}
+		b.WriteString(fmt.Sprintf("%s=%v", e.k, e.v))
+	}
+	return b.String()
 }
 
 const (
@@ -288,49 +189,91 @@ var (
 	noDeadline time.Time     = time.Unix(0, 0)
 )
 
-// Close closes the connection with redis.
+// SetDefaultOptions sets options to be used for a given task type.
+// The argument opts specifies the behavior of task processing.
+// If there are conflicting Option values the last one overrides others.
+//
+// Default options can be overridden by options passed at enqueue time.
+func (c *Client) SetDefaultOptions(taskType string, opts ...Option) {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	c.opts[taskType] = opts
+}
+
+// A Result holds enqueued task's metadata.
+type Result struct {
+	// ID is a unique identifier for the task.
+	ID string
+
+	// Retry is the maximum number of retry for the task.
+	Retry int
+
+	// Queue is a name of the queue the task is enqueued to.
+	Queue string
+
+	// Timeout is the timeout value for the task.
+	// Counting for timeout starts when a worker starts processing the task.
+	// If task processing doesn't complete within the timeout, the task will be retried.
+	// The value zero means no timeout.
+	//
+	// If deadline is set, min(now+timeout, deadline) is used, where the now is the time when
+	// a worker starts processing the task.
+	Timeout time.Duration
+
+	// Deadline is the deadline value for the task.
+	// If task processing doesn't complete before the deadline, the task will be retried.
+	// The value time.Unix(0, 0) means no deadline.
+	//
+	// If timeout is set, min(now+timeout, deadline) is used, where the now is the time when
+	// a worker starts processing the task.
+	Deadline time.Time
+}
+
+// EnqueueAt schedules task to be enqueued at the specified time.
+//
+// EnqueueAt returns nil if the task is scheduled successfully, otherwise returns a non-nil error.
+//
+// The argument opts specifies the behavior of task processing.
+// If there are conflicting Option values the last one overrides others.
+// By deafult, max retry is set to 25 and timeout is set to 30 minutes.
+func (c *Client) EnqueueAt(t time.Time, task *Task, opts ...Option) (*Result, error) {
+	return c.enqueueAt(t, task, opts...)
+}
+
+// Enqueue enqueues task to be processed immediately.
+//
+// Enqueue returns nil if the task is enqueued successfully, otherwise returns a non-nil error.
+//
+// The argument opts specifies the behavior of task processing.
+// If there are conflicting Option values the last one overrides others.
+// By deafult, max retry is set to 25 and timeout is set to 30 minutes.
+func (c *Client) Enqueue(task *Task, opts ...Option) (*Result, error) {
+	return c.enqueueAt(time.Now(), task, opts...)
+}
+
+// EnqueueIn schedules task to be enqueued after the specified delay.
+//
+// EnqueueIn returns nil if the task is scheduled successfully, otherwise returns a non-nil error.
+//
+// The argument opts specifies the behavior of task processing.
+// If there are conflicting Option values the last one overrides others.
+// By deafult, max retry is set to 25 and timeout is set to 30 minutes.
+func (c *Client) EnqueueIn(d time.Duration, task *Task, opts ...Option) (*Result, error) {
+	return c.enqueueAt(time.Now().Add(d), task, opts...)
+}
+
+// Close closes the connection with redis server.
 func (c *Client) Close() error {
 	return c.rdb.Close()
 }
 
-// Enqueue enqueues the given task to a queue.
+func (c *Client) enqueueAt(t time.Time, task *Task, opts ...Option) (*Result, error) {
-//
+	c.mu.Lock()
-// Enqueue returns TaskInfo and nil error if the task is enqueued successfully, otherwise returns a non-nil error.
+	defer c.mu.Unlock()
-//
+	if defaults, ok := c.opts[task.Type]; ok {
-// The argument opts specifies the behavior of task processing.
+		opts = append(defaults, opts...)
-// If there are conflicting Option values the last one overrides others.
-// Any options provided to NewTask can be overridden by options passed to Enqueue.
-// By deafult, max retry is set to 25 and timeout is set to 30 minutes.
-//
-// If no ProcessAt or ProcessIn options are provided, the task will be pending immediately.
-//
-// Enqueue uses context.Background internally; to specify the context, use EnqueueContext.
-func (c *Client) Enqueue(task *Task, opts ...Option) (*TaskInfo, error) {
-	return c.EnqueueContext(context.Background(), task, opts...)
-}
-
-// EnqueueContext enqueues the given task to a queue.
-//
-// EnqueueContext returns TaskInfo and nil error if the task is enqueued successfully, otherwise returns a non-nil error.
-//
-// The argument opts specifies the behavior of task processing.
-// If there are conflicting Option values the last one overrides others.
-// Any options provided to NewTask can be overridden by options passed to Enqueue.
-// By deafult, max retry is set to 25 and timeout is set to 30 minutes.
-//
-// If no ProcessAt or ProcessIn options are provided, the task will be pending immediately.
-//
-// The first argument context applies to the enqueue operation. To specify task timeout and deadline, use Timeout and Deadline option instead.
-func (c *Client) EnqueueContext(ctx context.Context, task *Task, opts ...Option) (*TaskInfo, error) {
-	if strings.TrimSpace(task.Type()) == "" {
-		return nil, fmt.Errorf("task typename cannot be empty")
-	}
-	// merge task options with the options provided at enqueue time.
-	opts = append(task.opts, opts...)
-	opt, err := composeOptions(opts...)
-	if err != nil {
-		return nil, err
 	}
+	opt := composeOptions(opts...)
 	deadline := noDeadline
 	if !opt.deadline.IsZero() {
 		deadline = opt.deadline
@@ -343,53 +286,49 @@ func (c *Client) EnqueueContext(ctx context.Context, task *Task, opts ...Option)
 		// If neither deadline nor timeout are set, use default timeout.
 		timeout = defaultTimeout
 	}
-	var uniqueKey string
-	if opt.uniqueTTL > 0 {
-		uniqueKey = base.UniqueKey(opt.queue, task.Type(), task.Payload())
-	}
 	msg := &base.TaskMessage{
-		ID:        opt.taskID,
+		ID:        uuid.New(),
-		Type:      task.Type(),
+		Type:      task.Type,
-		Payload:   task.Payload(),
+		Payload:   task.Payload.data,
 		Queue:     opt.queue,
 		Retry:     opt.retry,
 		Deadline:  deadline.Unix(),
 		Timeout:   int64(timeout.Seconds()),
-		UniqueKey: uniqueKey,
+		UniqueKey: uniqueKey(task, opt.uniqueTTL, opt.queue),
-		Retention: int64(opt.retention.Seconds()),
 	}
+	var err error
 	now := time.Now()
-	var state base.TaskState
+	if t.Before(now) || t.Equal(now) {
-	if opt.processAt.Before(now) || opt.processAt.Equal(now) {
+		err = c.enqueue(msg, opt.uniqueTTL)
-		opt.processAt = now
-		err = c.enqueue(ctx, msg, opt.uniqueTTL)
-		state = base.TaskStatePending
 	} else {
-		err = c.schedule(ctx, msg, opt.processAt, opt.uniqueTTL)
+		err = c.schedule(msg, t, opt.uniqueTTL)
-		state = base.TaskStateScheduled
 	}
 	switch {
-	case errors.Is(err, errors.ErrDuplicateTask):
+	case err == rdb.ErrDuplicateTask:
 		return nil, fmt.Errorf("%w", ErrDuplicateTask)
-	case errors.Is(err, errors.ErrTaskIdConflict):
-		return nil, fmt.Errorf("%w", ErrTaskIDConflict)
 	case err != nil:
 		return nil, err
 	}
-	return newTaskInfo(msg, state, opt.processAt, nil), nil
+	return &Result{
+		ID:       msg.ID.String(),
+		Queue:    msg.Queue,
+		Retry:    msg.Retry,
+		Timeout:  timeout,
+		Deadline: deadline,
+	}, nil
 }
 
-func (c *Client) enqueue(ctx context.Context, msg *base.TaskMessage, uniqueTTL time.Duration) error {
+func (c *Client) enqueue(msg *base.TaskMessage, uniqueTTL time.Duration) error {
 	if uniqueTTL > 0 {
-		return c.rdb.EnqueueUnique(ctx, msg, uniqueTTL)
+		return c.rdb.EnqueueUnique(msg, uniqueTTL)
 	}
-	return c.rdb.Enqueue(ctx, msg)
+	return c.rdb.Enqueue(msg)
 }
 
-func (c *Client) schedule(ctx context.Context, msg *base.TaskMessage, t time.Time, uniqueTTL time.Duration) error {
+func (c *Client) schedule(msg *base.TaskMessage, t time.Time, uniqueTTL time.Duration) error {
 	if uniqueTTL > 0 {
 		ttl := t.Add(uniqueTTL).Sub(time.Now())
-		return c.rdb.ScheduleUnique(ctx, msg, t, ttl)
+		return c.rdb.ScheduleUnique(msg, t, ttl)
 	}
-	return c.rdb.Schedule(ctx, msg, t)
+	return c.rdb.Schedule(msg, t)
 }

context.go

@@ -6,16 +6,47 @@ package asynq
 
 import (
 	"context"
+	"time"
 
-	asynqcontext "github.com/hibiken/asynq/internal/context"
+	"github.com/hibiken/asynq/internal/base"
 )
 
+// A taskMetadata holds task scoped data to put in context.
+type taskMetadata struct {
+	id         string
+	maxRetry   int
+	retryCount int
+}
+
+// ctxKey type is unexported to prevent collisions with context keys defined in
+// other packages.
+type ctxKey int
+
+// metadataCtxKey is the context key for the task metadata.
+// Its value of zero is arbitrary.
+const metadataCtxKey ctxKey = 0
+
+// createContext returns a context and cancel function for a given task message.
+func createContext(msg *base.TaskMessage, deadline time.Time) (context.Context, context.CancelFunc) {
+	metadata := taskMetadata{
+		id:         msg.ID.String(),
+		maxRetry:   msg.Retry,
+		retryCount: msg.Retried,
+	}
+	ctx := context.WithValue(context.Background(), metadataCtxKey, metadata)
+	return context.WithDeadline(ctx, deadline)
+}
+
 // GetTaskID extracts a task ID from a context, if any.
 //
 // ID of a task is guaranteed to be unique.
 // ID of a task doesn't change if the task is being retried.
 func GetTaskID(ctx context.Context) (id string, ok bool) {
-	return asynqcontext.GetTaskID(ctx)
+	metadata, ok := ctx.Value(metadataCtxKey).(taskMetadata)
+	if !ok {
+		return "", false
+	}
+	return metadata.id, true
 }
 
 // GetRetryCount extracts retry count from a context, if any.
@@ -23,7 +54,11 @@ func GetTaskID(ctx context.Context) (id string, ok bool) {
 // Return value n indicates the number of times associated task has been
 // retried so far.
 func GetRetryCount(ctx context.Context) (n int, ok bool) {
-	return asynqcontext.GetRetryCount(ctx)
+	metadata, ok := ctx.Value(metadataCtxKey).(taskMetadata)
+	if !ok {
+		return 0, false
+	}
+	return metadata.retryCount, true
 }
 
 // GetMaxRetry extracts maximum retry from a context, if any.
@@ -31,12 +66,9 @@ func GetRetryCount(ctx context.Context) (n int, ok bool) {
 // Return value n indicates the maximum number of times the assoicated task
 // can be retried if ProcessTask returns a non-nil error.
 func GetMaxRetry(ctx context.Context) (n int, ok bool) {
-	return asynqcontext.GetMaxRetry(ctx)
+	metadata, ok := ctx.Value(metadataCtxKey).(taskMetadata)
+	if !ok {
+		return 0, false
 	}
-
+	return metadata.maxRetry, true
-// GetQueueName extracts queue name from a context, if any.
-//
-// Return value qname indicates which queue the task was pulled from.
-func GetQueueName(ctx context.Context) (qname string, ok bool) {
-	return asynqcontext.GetQueueName(ctx)
 }

context_test.go

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a MIT license
 // that can be found in the LICENSE file.
 
-package context
+package asynq
 
 import (
 	"context"
@@ -24,11 +24,12 @@ func TestCreateContextWithFutureDeadline(t *testing.T) {
 	for _, tc := range tests {
 		msg := &base.TaskMessage{
 			Type:    "something",
-			ID:      uuid.NewString(),
+			ID:      uuid.New(),
 			Payload: nil,
 		}
 
-		ctx, cancel := New(msg, tc.deadline)
+		ctx, cancel := createContext(msg, tc.deadline)
+
 		select {
 		case x := <-ctx.Done():
 			t.Errorf("<-ctx.Done() == %v, want nothing (it should block)", x)
@@ -63,11 +64,11 @@ func TestCreateContextWithPastDeadline(t *testing.T) {
 	for _, tc := range tests {
 		msg := &base.TaskMessage{
 			Type:    "something",
-			ID:      uuid.NewString(),
+			ID:      uuid.New(),
 			Payload: nil,
 		}
 
-		ctx, cancel := New(msg, tc.deadline)
+		ctx, cancel := createContext(msg, tc.deadline)
 		defer cancel()
 
 		select {
@@ -91,21 +92,20 @@ func TestGetTaskMetadataFromContext(t *testing.T) {
 		desc string
 		msg  *base.TaskMessage
 	}{
-		{"with zero retried message", &base.TaskMessage{Type: "something", ID: uuid.NewString(), Retry: 25, Retried: 0, Timeout: 1800, Queue: "default"}},
+		{"with zero retried message", &base.TaskMessage{Type: "something", ID: uuid.New(), Retry: 25, Retried: 0, Timeout: 1800}},
-		{"with non-zero retried message", &base.TaskMessage{Type: "something", ID: uuid.NewString(), Retry: 10, Retried: 5, Timeout: 1800, Queue: "default"}},
+		{"with non-zero retried message", &base.TaskMessage{Type: "something", ID: uuid.New(), Retry: 10, Retried: 5, Timeout: 1800}},
-		{"with custom queue name", &base.TaskMessage{Type: "something", ID: uuid.NewString(), Retry: 25, Retried: 0, Timeout: 1800, Queue: "custom"}},
 	}
 
 	for _, tc := range tests {
-		ctx, cancel := New(tc.msg, time.Now().Add(30*time.Minute))
+		ctx, cancel := createContext(tc.msg, time.Now().Add(30*time.Minute))
 		defer cancel()
 
 		id, ok := GetTaskID(ctx)
 		if !ok {
 			t.Errorf("%s: GetTaskID(ctx) returned ok == false", tc.desc)
 		}
-		if ok && id != tc.msg.ID {
+		if ok && id != tc.msg.ID.String() {
-			t.Errorf("%s: GetTaskID(ctx) returned id == %q, want %q", tc.desc, id, tc.msg.ID)
+			t.Errorf("%s: GetTaskID(ctx) returned id == %q, want %q", tc.desc, id, tc.msg.ID.String())
 		}
 
 		retried, ok := GetRetryCount(ctx)
@@ -123,14 +123,6 @@ func TestGetTaskMetadataFromContext(t *testing.T) {
 		if ok && maxRetry != tc.msg.Retry {
 			t.Errorf("%s: GetMaxRetry(ctx) returned n == %d want %d", tc.desc, maxRetry, tc.msg.Retry)
 		}
-
-		qname, ok := GetQueueName(ctx)
-		if !ok {
-			t.Errorf("%s: GetQueueName(ctx) returned ok == false", tc.desc)
-		}
-		if ok && qname != tc.msg.Queue {
-			t.Errorf("%s: GetQueueName(ctx) returned qname == %q, want %q", tc.desc, qname, tc.msg.Queue)
-		}
 	}
 }
 
@@ -152,8 +144,5 @@ func TestGetTaskMetadataFromContextError(t *testing.T) {
 		if _, ok := GetMaxRetry(tc.ctx); ok {
 			t.Errorf("%s: GetMaxRetry(ctx) returned ok == true", tc.desc)
 		}
-		if _, ok := GetQueueName(tc.ctx); ok {
-			t.Errorf("%s: GetQueueName(ctx) returned ok == true", tc.desc)
-		}
 	}
 }

doc.go

@@ -3,46 +3,40 @@
 // that can be found in the LICENSE file.
 
 /*
-Package asynq provides a framework for Redis based distrubted task queue.
+Package asynq provides a framework for asynchronous task processing.
 
-Asynq uses Redis as a message broker. To connect to redis,
+Asynq uses Redis as a message broker. To connect to redis server,
-specify the connection using one of RedisConnOpt types.
+specify the options using one of RedisConnOpt types.
 
-    redisConnOpt = asynq.RedisClientOpt{
+    redis = &asynq.RedisClientOpt{
         Addr:     "127.0.0.1:6379",
         Password: "xxxxx",
-        DB:       2,
+        DB:       3,
     }
 
-The Client is used to enqueue a task.
+The Client is used to enqueue a task to be processed at the specified time.
 
+Task is created with two parameters: its type and payload.
 
-    client := asynq.NewClient(redisConnOpt)
+    client := asynq.NewClient(redis)
 
-    // Task is created with two parameters: its type and payload.
+    t := asynq.NewTask(
-    // Payload data is simply an array of bytes. It can be encoded in JSON, Protocol Buffer, Gob, etc.
+        "send_email",
-    b, err := json.Marshal(ExamplePayload{UserID: 42})
+        map[string]interface{}{"user_id": 42})
-    if err != nil {
-        log.Fatal(err)
-    }
-
-    task := asynq.NewTask("example", b)
 
     // Enqueue the task to be processed immediately.
-    info, err := client.Enqueue(task)
+    res, err := client.Enqueue(t)
 
     // Schedule the task to be processed after one minute.
-    info, err = client.Enqueue(t, asynq.ProcessIn(1*time.Minute))
+    res, err = client.EnqueueIn(time.Minute, t)
 
-The Server is used to run the task processing workers with a given
+The Server is used to run the background task processing with a given
 handler.
-    srv := asynq.NewServer(redisConnOpt, asynq.Config{
+    srv := asynq.NewServer(redis, asynq.Config{
         Concurrency: 10,
     })
 
-    if err := srv.Run(handler); err != nil {
+    srv.Run(handler)
-        log.Fatal(err)
-    }
 
 Handler is an interface type with a method which
 takes a task and returns an error. Handler should return nil if
@@ -56,13 +50,10 @@ Example of a type that implements the Handler interface.
 
     func (h *TaskHandler) ProcessTask(ctx context.Context, task *asynq.Task) error {
         switch task.Type {
-        case "example":
+        case "send_email":
-            var data ExamplePayload
+            id, err := task.Payload.GetInt("user_id")
-            if err := json.Unmarshal(task.Payload(), &data); err != nil {
+            // send email
-                return err
+        //...
-            }
-            // perform task with the data
-
         default:
             return fmt.Errorf("unexpected task type %q", task.Type)
         }

example_test.go

@@ -9,7 +9,6 @@ import (
 	"log"
 	"os"
 	"os/signal"
-	"time"
 
 	"github.com/hibiken/asynq"
 	"golang.org/x/sys/unix"
@@ -30,7 +29,7 @@ func ExampleServer_Run() {
 	}
 }
 
-func ExampleServer_Shutdown() {
+func ExampleServer_Stop() {
 	srv := asynq.NewServer(
 		asynq.RedisClientOpt{Addr: ":6379"},
 		asynq.Config{Concurrency: 20},
@@ -47,10 +46,10 @@ func ExampleServer_Shutdown() {
 	signal.Notify(sigs, unix.SIGTERM, unix.SIGINT)
 	<-sigs // wait for termination signal
 
-	srv.Shutdown()
+	srv.Stop()
 }
 
-func ExampleServer_Stop() {
+func ExampleServer_Quiet() {
 	srv := asynq.NewServer(
 		asynq.RedisClientOpt{Addr: ":6379"},
 		asynq.Config{Concurrency: 20},
@@ -70,32 +69,13 @@ func ExampleServer_Stop() {
 	for {
 		s := <-sigs
 		if s == unix.SIGTSTP {
-			srv.Stop() // stop processing new tasks
+			srv.Quiet() // stop processing new tasks
 			continue
 		}
-		break // received SIGTERM or SIGINT signal
+		break
 	}
 
-	srv.Shutdown()
+	srv.Stop()
-}
-
-func ExampleScheduler() {
-	scheduler := asynq.NewScheduler(
-		asynq.RedisClientOpt{Addr: ":6379"},
-		&asynq.SchedulerOpts{Location: time.Local},
-	)
-
-	if _, err := scheduler.Register("* * * * *", asynq.NewTask("task1", nil)); err != nil {
-		log.Fatal(err)
-	}
-	if _, err := scheduler.Register("@every 30s", asynq.NewTask("task2", nil)); err != nil {
-		log.Fatal(err)
-	}
-
-	// Run blocks and waits for os signal to terminate the program.
-	if err := scheduler.Run(); err != nil {
-		log.Fatal(err)
-	}
 }
 
 func ExampleParseRedisURI() {

forwarder.go

@@ -1,75 +0,0 @@
-// Copyright 2020 Kentaro Hibino. All rights reserved.
-// Use of this source code is governed by a MIT license
-// that can be found in the LICENSE file.
-
-package asynq
-
-import (
-	"sync"
-	"time"
-
-	"github.com/hibiken/asynq/internal/base"
-	"github.com/hibiken/asynq/internal/log"
-)
-
-// A forwarder is responsible for moving scheduled and retry tasks to pending state
-// so that the tasks get processed by the workers.
-type forwarder struct {
-	logger *log.Logger
-	broker base.Broker
-
-	// channel to communicate back to the long running "forwarder" goroutine.
-	done chan struct{}
-
-	// list of queue names to check and enqueue.
-	queues []string
-
-	// poll interval on average
-	avgInterval time.Duration
-}
-
-type forwarderParams struct {
-	logger   *log.Logger
-	broker   base.Broker
-	queues   []string
-	interval time.Duration
-}
-
-func newForwarder(params forwarderParams) *forwarder {
-	return &forwarder{
-		logger:      params.logger,
-		broker:      params.broker,
-		done:        make(chan struct{}),
-		queues:      params.queues,
-		avgInterval: params.interval,
-	}
-}
-
-func (f *forwarder) shutdown() {
-	f.logger.Debug("Forwarder shutting down...")
-	// Signal the forwarder goroutine to stop polling.
-	f.done <- struct{}{}
-}
-
-// start starts the "forwarder" goroutine.
-func (f *forwarder) start(wg *sync.WaitGroup) {
-	wg.Add(1)
-	go func() {
-		defer wg.Done()
-		for {
-			select {
-			case <-f.done:
-				f.logger.Debug("Forwarder done")
-				return
-			case <-time.After(f.avgInterval):
-				f.exec()
-			}
-		}
-	}()
-}
-
-func (f *forwarder) exec() {
-	if err := f.broker.ForwardIfReady(f.queues...); err != nil {
-		f.logger.Errorf("Could not enqueue scheduled tasks: %v", err)
-	}
-}

forwarder_test.go

@@ -1,137 +0,0 @@
-// Copyright 2020 Kentaro Hibino. All rights reserved.
-// Use of this source code is governed by a MIT license
-// that can be found in the LICENSE file.
-
-package asynq
-
-import (
-	"sync"
-	"testing"
-	"time"
-
-	"github.com/google/go-cmp/cmp"
-	h "github.com/hibiken/asynq/internal/asynqtest"
-	"github.com/hibiken/asynq/internal/base"
-	"github.com/hibiken/asynq/internal/rdb"
-)
-
-func TestForwarder(t *testing.T) {
-	r := setup(t)
-	defer r.Close()
-	rdbClient := rdb.NewRDB(r)
-	const pollInterval = time.Second
-	s := newForwarder(forwarderParams{
-		logger:   testLogger,
-		broker:   rdbClient,
-		queues:   []string{"default", "critical"},
-		interval: pollInterval,
-	})
-	t1 := h.NewTaskMessageWithQueue("gen_thumbnail", nil, "default")
-	t2 := h.NewTaskMessageWithQueue("send_email", nil, "critical")
-	t3 := h.NewTaskMessageWithQueue("reindex", nil, "default")
-	t4 := h.NewTaskMessageWithQueue("sync", nil, "critical")
-	now := time.Now()
-
-	tests := []struct {
-		initScheduled map[string][]base.Z            // scheduled queue initial state
-		initRetry     map[string][]base.Z            // retry queue initial state
-		initPending   map[string][]*base.TaskMessage // default queue initial state
-		wait          time.Duration                  // wait duration before checking for final state
-		wantScheduled map[string][]*base.TaskMessage // schedule queue final state
-		wantRetry     map[string][]*base.TaskMessage // retry queue final state
-		wantPending   map[string][]*base.TaskMessage // default queue final state
-	}{
-		{
-			initScheduled: map[string][]base.Z{
-				"default":  {{Message: t1, Score: now.Add(time.Hour).Unix()}},
-				"critical": {{Message: t2, Score: now.Add(-2 * time.Second).Unix()}},
-			},
-			initRetry: map[string][]base.Z{
-				"default":  {{Message: t3, Score: time.Now().Add(-500 * time.Millisecond).Unix()}},
-				"critical": {},
-			},
-			initPending: map[string][]*base.TaskMessage{
-				"default":  {},
-				"critical": {t4},
-			},
-			wait: pollInterval * 2,
-			wantScheduled: map[string][]*base.TaskMessage{
-				"default":  {t1},
-				"critical": {},
-			},
-			wantRetry: map[string][]*base.TaskMessage{
-				"default":  {},
-				"critical": {},
-			},
-			wantPending: map[string][]*base.TaskMessage{
-				"default":  {t3},
-				"critical": {t2, t4},
-			},
-		},
-		{
-			initScheduled: map[string][]base.Z{
-				"default": {
-					{Message: t1, Score: now.Unix()},
-					{Message: t3, Score: now.Add(-500 * time.Millisecond).Unix()},
-				},
-				"critical": {
-					{Message: t2, Score: now.Add(-2 * time.Second).Unix()},
-				},
-			},
-			initRetry: map[string][]base.Z{
-				"default":  {},
-				"critical": {},
-			},
-			initPending: map[string][]*base.TaskMessage{
-				"default":  {},
-				"critical": {t4},
-			},
-			wait: pollInterval * 2,
-			wantScheduled: map[string][]*base.TaskMessage{
-				"default":  {},
-				"critical": {},
-			},
-			wantRetry: map[string][]*base.TaskMessage{
-				"default":  {},
-				"critical": {},
-			},
-			wantPending: map[string][]*base.TaskMessage{
-				"default":  {t1, t3},
-				"critical": {t2, t4},
-			},
-		},
-	}
-
-	for _, tc := range tests {
-		h.FlushDB(t, r)                                  // clean up db before each test case.
-		h.SeedAllScheduledQueues(t, r, tc.initScheduled) // initialize scheduled queue
-		h.SeedAllRetryQueues(t, r, tc.initRetry)         // initialize retry queue
-		h.SeedAllPendingQueues(t, r, tc.initPending)     // initialize default queue
-
-		var wg sync.WaitGroup
-		s.start(&wg)
-		time.Sleep(tc.wait)
-		s.shutdown()
-
-		for qname, want := range tc.wantScheduled {
-			gotScheduled := h.GetScheduledMessages(t, r, qname)
-			if diff := cmp.Diff(want, gotScheduled, h.SortMsgOpt); diff != "" {
-				t.Errorf("mismatch found in %q after running forwarder: (-want, +got)\n%s", base.ScheduledKey(qname), diff)
-			}
-		}
-
-		for qname, want := range tc.wantRetry {
-			gotRetry := h.GetRetryMessages(t, r, qname)
-			if diff := cmp.Diff(want, gotRetry, h.SortMsgOpt); diff != "" {
-				t.Errorf("mismatch found in %q after running forwarder: (-want, +got)\n%s", base.RetryKey(qname), diff)
-			}
-		}
-
-		for qname, want := range tc.wantPending {
-			gotPending := h.GetPendingMessages(t, r, qname)
-			if diff := cmp.Diff(want, gotPending, h.SortMsgOpt); diff != "" {
-				t.Errorf("mismatch found in %q after running forwarder: (-want, +got)\n%s", base.PendingKey(qname), diff)
-			}
-		}
-	}
-}

go.mod

@@ -3,17 +3,12 @@ module github.com/hibiken/asynq
 go 1.13
 
 require (
-	github.com/go-redis/redis/v8 v8.11.2
+	github.com/go-redis/redis/v7 v7.2.0
-	github.com/golang/protobuf v1.4.2
+	github.com/google/go-cmp v0.4.0
-	github.com/google/go-cmp v0.5.6
+	github.com/google/uuid v1.1.1
-	github.com/google/uuid v1.2.0
-	github.com/kr/pretty v0.1.0 // indirect
-	github.com/robfig/cron/v3 v3.0.1
 	github.com/spf13/cast v1.3.1
-	github.com/stretchr/testify v1.6.1 // indirect
 	go.uber.org/goleak v0.10.0
-	golang.org/x/sys v0.0.0-20210112080510-489259a85091
+	golang.org/x/sys v0.0.0-20191204072324-ce4227a45e2e
 	golang.org/x/time v0.0.0-20190308202827-9d24e82272b4
-	google.golang.org/protobuf v1.25.0
+	gopkg.in/yaml.v2 v2.2.7 // indirect
-	gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15 // indirect
 )

go.sum

@@ -1,165 +1,57 @@
-cloud.google.com/go v0.26.0 h1:e0WKqKTd5BnrG8aKH3J3h+QvEIQtSUcf2n5UZ5ZgLtQ=
-cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
-github.com/BurntSushi/toml v0.3.1 h1:WXkYYl6Yr3qBf1K79EBnL4mak0OimBfB0XUf9Vl28OQ=
-github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
-github.com/census-instrumentation/opencensus-proto v0.2.1 h1:glEXhBS5PSLLv4IXzLA5yPRVX4bilULVyxxbrfOtDAk=
-github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU=
-github.com/cespare/xxhash/v2 v2.1.1 h1:6MnRN8NT7+YBpUIWxHtefFZOKTAPgGjpQSxqLNn0+qY=
-github.com/cespare/xxhash/v2 v2.1.1/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
-github.com/client9/misspell v0.3.4 h1:ta993UF76GwbvJcIo3Y68y/M3WxlpEHPWIGDkJYwzJI=
-github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw=
-github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f h1:lO4WD4F/rVNCu3HqELle0jiPLLBs70cWOduZpkS1E78=
+github.com/fsnotify/fsnotify v1.4.7 h1:IXs+QLmnXW2CcXuY+8Mzv/fWEsPGWxqefPtCP5CnV9I=
-github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f/go.mod h1:cuUVRXasLTGF7a8hSLbxyZXjz+1KgoB3wDUb6vlszIc=
-github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473 h1:4cmBvAEBNJaGARUEs3/suWRyfyBfhf7I60WBZq+bv2w=
-github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
-github.com/envoyproxy/protoc-gen-validate v0.1.0 h1:EQciDnbrYxy13PgWoY8AqoxGiPrpgBZ1R8UNe3ddc+A=
-github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c=
 github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
-github.com/fsnotify/fsnotify v1.4.9 h1:hsms1Qyu0jgnwNXIxa+/V/PDsU6CfLf6CNO8H7IWoS4=
+github.com/go-redis/redis/v7 v7.2.0 h1:CrCexy/jYWZjW0AyVoHlcJUeZN19VWlbepTh1Vq6dJs=
-github.com/fsnotify/fsnotify v1.4.9/go.mod h1:znqG4EE+3YCdAaPaxE2ZRY/06pZUdp0tY4IgpuI1SZQ=
+github.com/go-redis/redis/v7 v7.2.0/go.mod h1:JDNMw23GTyLNC4GZu9njt15ctBQVn7xjRfnwdHj/Dcg=
-github.com/go-redis/redis/v8 v8.11.2 h1:WqlSpAwz8mxDSMCvbyz1Mkiqe0LE5OY4j3lgkvu1Ts0=
-github.com/go-redis/redis/v8 v8.11.2/go.mod h1:DLomh7y2e3ggQXQLd1YgmvIfecPJoFl7WU5SOQ/r06M=
-github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b h1:VKtxabqXZkF25pY9ekfRL6a582T4P37/31XEstQ5p58=
-github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q=
-github.com/golang/mock v1.1.1 h1:G5FRp8JnTd7RQH5kemVNlMeyXQAztQ3mOWV95KxsXH8=
-github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
 github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/golang/protobuf v1.3.2 h1:6nsPYzhq5kReh6QImI3k5qWzO4PEbvbIW2cwSfR/6xs=
 github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
-github.com/golang/protobuf v1.4.0-rc.1/go.mod h1:ceaxUfeHdC40wWswd/P6IGgMaK3YpKi5j83Wpe3EHw8=
+github.com/google/go-cmp v0.4.0 h1:xsAVV57WRhGj6kEIi8ReJzQlHHqcBYCElAvkovg3B/4=
-github.com/golang/protobuf v1.4.0-rc.1.0.20200221234624-67d41d38c208/go.mod h1:xKAWHe0F5eneWXFV3EuXVDTCmh+JuBKY0li0aMyXATA=
-github.com/golang/protobuf v1.4.0-rc.2/go.mod h1:LlEzMj4AhA7rCAGe4KMBDvJI+AwstrUpVNzEA03Pprs=
-github.com/golang/protobuf v1.4.0-rc.4.0.20200313231945-b860323f09d0/go.mod h1:WU3c8KckQ9AFe+yFwt9sWVRKCVIyN9cPHBJSNnbL67w=
-github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvqG2KuDX0=
-github.com/golang/protobuf v1.4.1/go.mod h1:U8fpvMrcmy5pZrNK1lt4xCsGvpyWQ/VVv6QDs8UjoX8=
-github.com/golang/protobuf v1.4.2 h1:+Z5KGCizgyZCbGh1KZqA0fcLLkwbsjIzS4aV2v7wJX0=
-github.com/golang/protobuf v1.4.2/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
-github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M=
-github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
-github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
 github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/google/go-cmp v0.5.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/uuid v1.1.1 h1:Gkbcsh/GbpXz7lPftLA3P6TYMwjCLYm83jiFQZF/3gY=
-github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ=
+github.com/google/uuid v1.1.1/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
-github.com/google/go-cmp v0.5.6/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/google/uuid v1.2.0 h1:qJYtXnJRWmpe7m/3XlyhrsLrEURqHRM2kxzoxXqyUDs=
-github.com/google/uuid v1.2.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/hpcloud/tail v1.0.0 h1:nfCOvKYfkgYP8hkirhJocXT2+zOD8yUNjXaWfTlyFKI=
 github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU=
 github.com/kr/pretty v0.1.0 h1:L/CwN0zerZDmRFUapSPitk6f+Q3+0za1rQkzVuMiMFI=
 github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
-github.com/kr/pty v1.1.1 h1:VkoXIwSboBpnk99O/KFauAEILuNHv5DVFKZMBN/gUgw=
 github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
 github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE=
 github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
-github.com/nxadm/tail v1.4.4 h1:DQuhQpB1tVlglWS2hLQ5OV6B5r8aGxSrPc5Qo6uTN78=
-github.com/nxadm/tail v1.4.4/go.mod h1:kenIhsEOeOJmVchQTgglprH7qJGnHDVpk1VPCcaMI8A=
 github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
-github.com/onsi/ginkgo v1.12.1/go.mod h1:zj2OWP4+oCPe1qIXoGWkgMRwljMUYCdkwsT2108oapk=
+github.com/onsi/ginkgo v1.10.1 h1:q/mM8GF/n0shIN8SaAZ0V+jnLPzen6WIVZdiwrRlMlo=
-github.com/onsi/ginkgo v1.15.0 h1:1V1NfVQR87RtWAgp1lv9JZJ5Jap+XFGKPi00andXGi4=
+github.com/onsi/ginkgo v1.10.1/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
-github.com/onsi/ginkgo v1.15.0/go.mod h1:hF8qUzuuC8DJGygJH3726JnCZX4MYbRB8yFfISqnKUg=
+github.com/onsi/gomega v1.7.0 h1:XPnZz8VVBHjVsy1vzJmRwIcSwiUO+JFfrv/xGiigmME=
-github.com/onsi/gomega v1.7.1/go.mod h1:XdKZgCCFLUoM/7CFJVPcG8C1xQ1AJ0vpAezJrB7JYyY=
+github.com/onsi/gomega v1.7.0/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY=
-github.com/onsi/gomega v1.10.1/go.mod h1:iN09h71vgCQne3DLsj+A5owkum+a2tYe+TOCB1ybHNo=
-github.com/onsi/gomega v1.10.5 h1:7n6FEkpFmfCoo2t+YYqXH0evK+a9ICQz0xcAy9dYcaQ=
-github.com/onsi/gomega v1.10.5/go.mod h1:gza4q3jKQJijlu05nKWRCW/GavJumGt8aNRxWg7mt48=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4 h1:gQz4mCbXsO+nc9n1hCxHcGA3Zx3Eo+UHZoInFGUIXNM=
-github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
-github.com/robfig/cron/v3 v3.0.1 h1:WdRxkvbJztn8LMz/QEvLN5sBU+xKpSqwwUO1Pjr4qDs=
-github.com/robfig/cron/v3 v3.0.1/go.mod h1:eQICP3HwyT7UooqI/z+Ov+PtYAWygg1TEWWzGIFLtro=
 github.com/spf13/cast v1.3.1 h1:nFm6S0SMdyzrzcmThSipiEubIDy8WEXKNZ0UOgiRpng=
 github.com/spf13/cast v1.3.1/go.mod h1:Qx5cxh0v+4UWYiBimWS+eyWzqEqokIECu5etghLkUJE=
-github.com/stretchr/objx v0.1.0 h1:4G4v2dO3VZwixGIRoQ5Lfboy6nUhCyYzaqnIAPPhYs4=
+github.com/stretchr/testify v1.2.2 h1:bSDNvY7ZPG5RlJ8otE/7V6gMiyenm9RtJ7IUVIAoJ1w=
-github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
-github.com/stretchr/testify v1.6.1 h1:hDPOHmpOpP40lSULcqw7IrRb/u7w6RpDC9399XyoNd0=
-github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-github.com/yuin/goldmark v1.2.1 h1:ruQGxdhGHe7FWOJPT0mKs5+pD2Xs1Bm/kdGlHO04FmM=
-github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
 go.uber.org/goleak v0.10.0 h1:G3eWbSNIskeRqtsN/1uI5B+eP73y3JUuBsv9AZjehb4=
 go.uber.org/goleak v0.10.0/go.mod h1:VCZuO8V8mFPlL0F5J5GK1rtHV3DrFcQ1R8ryq7FK0aI=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
-golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
+golang.org/x/net v0.0.0-20180906233101-161cd47e91fd h1:nTDtHvHSdCn1m6ITfMRqtOd/9+7a3s8RBNOZ3eYZzJA=
-golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9 h1:psW17arqaxU48Z5kZ0CQnkZWQJsqcURM6tKiBApRjXI=
-golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
-golang.org/x/exp v0.0.0-20190121172915-509febef88a4 h1:c2HOrn5iMezYjSlGPncknSEr/8x5LELb/ilJbXi9DEA=
-golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
-golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
-golang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvxsM5YxQ5yQlVC4a0KAMCusXpPoU=
-golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3 h1:XQyxROzUlZH+WIQwySDgnISgOivlhjIEwaQaJEJrrN0=
-golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
-golang.org/x/mod v0.3.0 h1:RM4zey1++hCTbCVQfnWeKs9/IEsaBLA8vTkd0WVtmH4=
-golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
-golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20190923162816-aa69164e4478 h1:l5EDrHhldLYb3ZRHDUhXF7Om7MvYXnkV9/iQNo1lX6g=
-golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190923162816-aa69164e4478/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
-golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20200520004742-59133d7f0dd7/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
-golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
-golang.org/x/net v0.0.0-20201202161906-c7110b5ffcbb h1:eBmm0M9fYhWpKZLjQUUKka/LtIxf46G4fxeEz5KJr9U=
-golang.org/x/net v0.0.0-20201202161906-c7110b5ffcbb/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
-golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be h1:vEDujvNQGv4jgYKudGeI/+DAX4Jffq6hpD55MmoEvKs=
-golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
 golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e h1:o3PsSEY8E4eXWkXrIP9YJALUkVZqzHJT5DOasTyn8Vs=
-golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9 h1:SQFwaSi55rU7vdNs9Yr0Z324VNlrF+0wMqRXT4St8ck=
-golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191010194322-b09406accb47/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190904154756-749cb33beabd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191204072324-ce4227a45e2e h1:9vRrk9YW2BTzLP0VCB9ZDjU4cPqkg+IDWL7XgxA1yxQ=
-golang.org/x/sys v0.0.0-20191005200804-aed5e4c7ecf9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191204072324-ce4227a45e2e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20191120155948-bd437916bb0e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/text v0.3.0 h1:g61tztE5qeGQ89tm6NTjjM9VPIm088od1l6aSorWRWg=
-golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210112080510-489259a85091 h1:DMyOG0U+gKfu8JZzg2UQe9MeaC1X+xQWlAKcRnjxjCw=
-golang.org/x/sys v0.0.0-20210112080510-489259a85091/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
-golang.org/x/text v0.3.3 h1:cokOdA+Jmi5PJGXLlLllQSgYigAEfHXJAERHVMaCc2k=
+golang.org/x/text v0.3.2 h1:tW2bmiBqwgJj/UpqtC8EpXEZVYOwU0yG4iWbprSVAcs=
-golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
 golang.org/x/time v0.0.0-20190308202827-9d24e82272b4 h1:SvFZT6jyqRaOeXpc5h/JSfZenJ2O330aBsf7JfSUXmQ=
 golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
-golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4=
-golang.org/x/tools v0.0.0-20190226205152-f727befe758c/go.mod h1:9Yl7xja0Znq3iFh3HoIrodX9oNMXvdceNzlUR8zjMvY=
-golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
-golang.org/x/tools v0.0.0-20190524140312-2c0ae7006135/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
-golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.0.0-20201224043029-2b0845dc783e h1:4nW4NLDYnU28ojHaHO8OVxFHk/aQ33U01a9cjED+pzE=
-golang.org/x/tools v0.0.0-20201224043029-2b0845dc783e/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
-golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 h1:go1bK/D/BFZV2I8cIQd1NKEZ+0owSTG1fDTci4IqFcE=
-golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM=
-google.golang.org/appengine v1.4.0 h1:/wp5JvzpHIxhs/dumFmF7BXTf3Z+dd4uXta4kVyO508=
-google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
-google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc=
-google.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc=
-google.golang.org/genproto v0.0.0-20200526211855-cb27e3aa2013 h1:+kGHl1aib/qcwaRi1CbqBZ1rk19r85MNUf8HaBghugY=
-google.golang.org/genproto v0.0.0-20200526211855-cb27e3aa2013/go.mod h1:NbSheEEYHJ7i3ixzK3sjbqSGDJWnxyFXZblF3eUsNvo=
-google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c=
-google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg=
-google.golang.org/grpc v1.27.0 h1:rRYRFMVgRv6E0D70Skyfsr28tDXIuuPZyWGMPdMcnXg=
-google.golang.org/grpc v1.27.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk=
-google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8=
-google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0=
-google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM=
-google.golang.org/protobuf v1.20.1-0.20200309200217-e05f789c0967/go.mod h1:A+miEFZTKqfCUM6K7xSMQL9OKL/b6hQv+e19PK+JZNE=
-google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo=
-google.golang.org/protobuf v1.22.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
-google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
-google.golang.org/protobuf v1.23.1-0.20200526195155-81db48ad09cc/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
-google.golang.org/protobuf v1.25.0 h1:Ejskq+SyPohKW+1uil0JJMtmHCgJPJ/qWTxr8qp+R4c=
-google.golang.org/protobuf v1.25.0/go.mod h1:9JNX74DMeImyA3h4bdi1ymwjUzf21/xIlbajtzgsN7c=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15 h1:YR8cESwS4TdDjEe65xsg0ogRM/Nc3DYOhEAlW+xobZo=
 gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
@@ -167,11 +59,8 @@ gopkg.in/fsnotify.v1 v1.4.7 h1:xOHLXZwVvI9hhs+cLKq5+I5onOuwQLhQwiu63xxlHs4=
 gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys=
 gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 h1:uRGJdciOHaEIrze2W8Q3AKkepLTh2hOroT7a+7czfdQ=
 gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw=
+gopkg.in/yaml.v2 v2.2.1 h1:mUhvW9EsL+naU5Q3cakzfE91YhliOondGd6ZrsDBHQE=
+gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v2 v2.3.0 h1:clyUAQHOM3G0M3f5vQj7LuJrETvjVot3Z5el9nffUtU=
+gopkg.in/yaml.v2 v2.2.7 h1:VUgggvou5XRW9mHwD/yXxIYSMtY0zoKQf/v226p2nyo=
-gopkg.in/yaml.v2 v2.3.0/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.2.7/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c h1:dUUwHk2QECo/6vqA44rthZ8ie2QXMNeKRTHCNY2nXvo=
-gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
-honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
-honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc h1:/hemPrYIhOhy8zYrNj+069zDB68us2sMGsfkFJO0iZs=
-honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=

healthcheck.go

@@ -1,80 +0,0 @@
-// Copyright 2020 Kentaro Hibino. All rights reserved.
-// Use of this source code is governed by a MIT license
-// that can be found in the LICENSE file.
-
-package asynq
-
-import (
-	"sync"
-	"time"
-
-	"github.com/hibiken/asynq/internal/base"
-	"github.com/hibiken/asynq/internal/log"
-)
-
-// healthchecker is responsible for pinging broker periodically
-// and call user provided HeathCheckFunc with the ping result.
-type healthchecker struct {
-	logger *log.Logger
-	broker base.Broker
-
-	// channel to communicate back to the long running "healthchecker" goroutine.
-	done chan struct{}
-
-	// interval between healthchecks.
-	interval time.Duration
-
-	// function to call periodically.
-	healthcheckFunc func(error)
-}
-
-type healthcheckerParams struct {
-	logger          *log.Logger
-	broker          base.Broker
-	interval        time.Duration
-	healthcheckFunc func(error)
-}
-
-func newHealthChecker(params healthcheckerParams) *healthchecker {
-	return &healthchecker{
-		logger:          params.logger,
-		broker:          params.broker,
-		done:            make(chan struct{}),
-		interval:        params.interval,
-		healthcheckFunc: params.healthcheckFunc,
-	}
-}
-
-func (hc *healthchecker) shutdown() {
-	if hc.healthcheckFunc == nil {
-		return
-	}
-
-	hc.logger.Debug("Healthchecker shutting down...")
-	// Signal the healthchecker goroutine to stop.
-	hc.done <- struct{}{}
-}
-
-func (hc *healthchecker) start(wg *sync.WaitGroup) {
-	if hc.healthcheckFunc == nil {
-		return
-	}
-
-	wg.Add(1)
-	go func() {
-		defer wg.Done()
-		timer := time.NewTimer(hc.interval)
-		for {
-			select {
-			case <-hc.done:
-				hc.logger.Debug("Healthchecker done")
-				timer.Stop()
-				return
-			case <-timer.C:
-				err := hc.broker.Ping()
-				hc.healthcheckFunc(err)
-				timer.Reset(hc.interval)
-			}
-		}
-	}()
-}

healthcheck_test.go

@@ -1,103 +0,0 @@
-// Copyright 2020 Kentaro Hibino. All rights reserved.
-// Use of this source code is governed by a MIT license
-// that can be found in the LICENSE file.
-
-package asynq
-
-import (
-	"sync"
-	"testing"
-	"time"
-
-	"github.com/hibiken/asynq/internal/rdb"
-	"github.com/hibiken/asynq/internal/testbroker"
-)
-
-func TestHealthChecker(t *testing.T) {
-	r := setup(t)
-	defer r.Close()
-	rdbClient := rdb.NewRDB(r)
-
-	var (
-		// mu guards called and e variables.
-		mu     sync.Mutex
-		called int
-		e      error
-	)
-	checkFn := func(err error) {
-		mu.Lock()
-		defer mu.Unlock()
-		called++
-		e = err
-	}
-
-	hc := newHealthChecker(healthcheckerParams{
-		logger:          testLogger,
-		broker:          rdbClient,
-		interval:        1 * time.Second,
-		healthcheckFunc: checkFn,
-	})
-
-	hc.start(&sync.WaitGroup{})
-
-	time.Sleep(2 * time.Second)
-
-	mu.Lock()
-	if called == 0 {
-		t.Errorf("Healthchecker did not call the provided HealthCheckFunc")
-	}
-	if e != nil {
-		t.Errorf("HealthCheckFunc was called with non-nil error: %v", e)
-	}
-	mu.Unlock()
-
-	hc.shutdown()
-}
-
-func TestHealthCheckerWhenRedisDown(t *testing.T) {
-	// Make sure that healthchecker goroutine doesn't panic
-	// if it cannot connect to redis.
-	defer func() {
-		if r := recover(); r != nil {
-			t.Errorf("panic occurred: %v", r)
-		}
-	}()
-	r := rdb.NewRDB(setup(t))
-	defer r.Close()
-	testBroker := testbroker.NewTestBroker(r)
-	var (
-		// mu guards called and e variables.
-		mu     sync.Mutex
-		called int
-		e      error
-	)
-	checkFn := func(err error) {
-		mu.Lock()
-		defer mu.Unlock()
-		called++
-		e = err
-	}
-
-	hc := newHealthChecker(healthcheckerParams{
-		logger:          testLogger,
-		broker:          testBroker,
-		interval:        1 * time.Second,
-		healthcheckFunc: checkFn,
-	})
-
-	testBroker.Sleep()
-	hc.start(&sync.WaitGroup{})
-
-	time.Sleep(2 * time.Second)
-
-	mu.Lock()
-	if called == 0 {
-		t.Errorf("Healthchecker did not call the provided HealthCheckFunc")
-	}
-	if e == nil {
-		t.Errorf("HealthCheckFunc was called with nil; want non-nil error")
-	}
-	mu.Unlock()
-
-	hc.shutdown()
-}

heartbeat.go

@@ -38,13 +38,13 @@ type heartbeater struct {
 	// heartbeater goroutine. In other words, confine these variables
 	// to this goroutine only.
 	started time.Time
-	workers map[string]*workerInfo
+	workers map[string]workerStat
 
-	// state is shared with other goroutine but is concurrency safe.
+	// status is shared with other goroutine but is concurrency safe.
-	state *serverState
+	status *base.ServerStatus
 
 	// channels to receive updates on active workers.
-	starting <-chan *workerInfo
+	starting <-chan *base.TaskMessage
 	finished <-chan *base.TaskMessage
 }
 
@@ -55,8 +55,8 @@ type heartbeaterParams struct {
 	concurrency    int
 	queues         map[string]int
 	strictPriority bool
-	state          *serverState
+	status         *base.ServerStatus
-	starting       <-chan *workerInfo
+	starting       <-chan *base.TaskMessage
 	finished       <-chan *base.TaskMessage
 }
 
@@ -79,27 +79,24 @@ func newHeartbeater(params heartbeaterParams) *heartbeater {
 		queues:         params.queues,
 		strictPriority: params.strictPriority,
 
-		state:    params.state,
+		status:   params.status,
-		workers:  make(map[string]*workerInfo),
+		workers:  make(map[string]workerStat),
 		starting: params.starting,
 		finished: params.finished,
 	}
 }
 
-func (h *heartbeater) shutdown() {
+func (h *heartbeater) terminate() {
 	h.logger.Debug("Heartbeater shutting down...")
 	// Signal the heartbeater goroutine to stop.
 	h.done <- struct{}{}
 }
 
-// A workerInfo holds an active worker information.
+// A workerStat records the message a worker is working on
-type workerInfo struct {
+// and the time the worker has started processing the message.
-	// the task message the worker is processing.
+type workerStat struct {
-	msg *base.TaskMessage
-	// the time the worker has started processing the message.
 	started time.Time
-	// deadline the worker has to finish processing the task by.
+	msg     *base.TaskMessage
-	deadline time.Time
 }
 
 func (h *heartbeater) start(wg *sync.WaitGroup) {
@@ -124,21 +121,17 @@ func (h *heartbeater) start(wg *sync.WaitGroup) {
 				h.beat()
 				timer.Reset(h.interval)
 
-			case w := <-h.starting:
+			case msg := <-h.starting:
-				h.workers[w.msg.ID] = w
+				h.workers[msg.ID.String()] = workerStat{time.Now(), msg}
 
 			case msg := <-h.finished:
-				delete(h.workers, msg.ID)
+				delete(h.workers, msg.ID.String())
 			}
 		}
 	}()
 }
 
 func (h *heartbeater) beat() {
-	h.state.mu.Lock()
-	srvStatus := h.state.value.String()
-	h.state.mu.Unlock()
-
 	info := base.ServerInfo{
 		Host:              h.host,
 		PID:               h.pid,
@@ -146,23 +139,21 @@ func (h *heartbeater) beat() {
 		Concurrency:       h.concurrency,
 		Queues:            h.queues,
 		StrictPriority:    h.strictPriority,
-		Status:            srvStatus,
+		Status:            h.status.String(),
 		Started:           h.started,
 		ActiveWorkerCount: len(h.workers),
 	}
 
 	var ws []*base.WorkerInfo
-	for id, w := range h.workers {
+	for id, stat := range h.workers {
 		ws = append(ws, &base.WorkerInfo{
 			Host:    h.host,
 			PID:     h.pid,
-			ServerID: h.serverID,
 			ID:      id,
-			Type:     w.msg.Type,
+			Type:    stat.msg.Type,
-			Queue:    w.msg.Queue,
+			Queue:   stat.msg.Queue,
-			Payload:  w.msg.Payload,
+			Payload: stat.msg.Payload,
-			Started:  w.started,
+			Started: stat.started,
-			Deadline: w.deadline,
 		})
 	}
 

heartbeat_test.go

@@ -19,7 +19,6 @@ import (
 
 func TestHeartbeater(t *testing.T) {
 	r := setup(t)
-	defer r.Close()
 	rdbClient := rdb.NewRDB(r)
 
 	tests := []struct {
@@ -29,7 +28,7 @@ func TestHeartbeater(t *testing.T) {
 		queues      map[string]int
 		concurrency int
 	}{
-		{2 * time.Second, "localhost", 45678, map[string]int{"default": 1}, 10},
+		{time.Second, "localhost", 45678, map[string]int{"default": 1}, 10},
 	}
 
 	timeCmpOpt := cmpopts.EquateApproxTime(10 * time.Millisecond)
@@ -38,7 +37,7 @@ func TestHeartbeater(t *testing.T) {
 	for _, tc := range tests {
 		h.FlushDB(t, r)
 
-		srvState := &serverState{}
+		status := base.NewServerStatus(base.StatusIdle)
 		hb := newHeartbeater(heartbeaterParams{
 			logger:         testLogger,
 			broker:         rdbClient,
@@ -46,8 +45,8 @@ func TestHeartbeater(t *testing.T) {
 			concurrency:    tc.concurrency,
 			queues:         tc.queues,
 			strictPriority: false,
-			state:          srvState,
+			status:         status,
-			starting:       make(chan *workerInfo),
+			starting:       make(chan *base.TaskMessage),
 			finished:       make(chan *base.TaskMessage),
 		})
 
@@ -55,10 +54,7 @@ func TestHeartbeater(t *testing.T) {
 		hb.host = tc.host
 		hb.pid = tc.pid
 
-		srvState.mu.Lock()
+		status.Set(base.StatusRunning)
-		srvState.value = srvStateActive // simulating Server.Start
-		srvState.mu.Unlock()
-
 		var wg sync.WaitGroup
 		hb.start(&wg)
 
@@ -68,60 +64,58 @@ func TestHeartbeater(t *testing.T) {
 			Queues:      tc.queues,
 			Concurrency: tc.concurrency,
 			Started:     time.Now(),
-			Status:      "active",
+			Status:      "running",
 		}
 
 		// allow for heartbeater to write to redis
-		time.Sleep(tc.interval)
+		time.Sleep(tc.interval * 2)
 
 		ss, err := rdbClient.ListServers()
 		if err != nil {
 			t.Errorf("could not read server info from redis: %v", err)
-			hb.shutdown()
+			hb.terminate()
 			continue
 		}
 
 		if len(ss) != 1 {
 			t.Errorf("(*RDB).ListServers returned %d process info, want 1", len(ss))
-			hb.shutdown()
+			hb.terminate()
 			continue
 		}
 
 		if diff := cmp.Diff(want, ss[0], timeCmpOpt, ignoreOpt, ignoreFieldOpt); diff != "" {
 			t.Errorf("redis stored process status %+v, want %+v; (-want, +got)\n%s", ss[0], want, diff)
-			hb.shutdown()
+			hb.terminate()
 			continue
 		}
 
-		// server state change; simulating Server.Shutdown
+		// status change
-		srvState.mu.Lock()
+		status.Set(base.StatusStopped)
-		srvState.value = srvStateClosed
-		srvState.mu.Unlock()
 
 		// allow for heartbeater to write to redis
 		time.Sleep(tc.interval * 2)
 
-		want.Status = "closed"
+		want.Status = "stopped"
 		ss, err = rdbClient.ListServers()
 		if err != nil {
 			t.Errorf("could not read process status from redis: %v", err)
-			hb.shutdown()
+			hb.terminate()
 			continue
 		}
 
 		if len(ss) != 1 {
 			t.Errorf("(*RDB).ListProcesses returned %d process info, want 1", len(ss))
-			hb.shutdown()
+			hb.terminate()
 			continue
 		}
 
 		if diff := cmp.Diff(want, ss[0], timeCmpOpt, ignoreOpt, ignoreFieldOpt); diff != "" {
 			t.Errorf("redis stored process status %+v, want %+v; (-want, +got)\n%s", ss[0], want, diff)
-			hb.shutdown()
+			hb.terminate()
 			continue
 		}
 
-		hb.shutdown()
+		hb.terminate()
 	}
 }
 
@@ -134,9 +128,7 @@ func TestHeartbeaterWithRedisDown(t *testing.T) {
 		}
 	}()
 	r := rdb.NewRDB(setup(t))
-	defer r.Close()
 	testBroker := testbroker.NewTestBroker(r)
-	state := &serverState{value: srvStateActive}
 	hb := newHeartbeater(heartbeaterParams{
 		logger:         testLogger,
 		broker:         testBroker,
@@ -144,8 +136,8 @@ func TestHeartbeaterWithRedisDown(t *testing.T) {
 		concurrency:    10,
 		queues:         map[string]int{"default": 1},
 		strictPriority: false,
-		state:          state,
+		status:         base.NewServerStatus(base.StatusRunning),
-		starting:       make(chan *workerInfo),
+		starting:       make(chan *base.TaskMessage),
 		finished:       make(chan *base.TaskMessage),
 	})
 
@@ -156,5 +148,5 @@ func TestHeartbeaterWithRedisDown(t *testing.T) {
 	// wait for heartbeater to try writing data to redis
 	time.Sleep(2 * time.Second)
 
-	hb.shutdown()
+	hb.terminate()
 }

inspector.go

@@ -1,909 +0,0 @@
-// Copyright 2020 Kentaro Hibino. All rights reserved.
-// Use of this source code is governed by a MIT license
-// that can be found in the LICENSE file.
-
-package asynq
-
-import (
-	"fmt"
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/go-redis/redis/v8"
-	"github.com/hibiken/asynq/internal/base"
-	"github.com/hibiken/asynq/internal/errors"
-	"github.com/hibiken/asynq/internal/rdb"
-)
-
-// Inspector is a client interface to inspect and mutate the state of
-// queues and tasks.
-type Inspector struct {
-	rdb *rdb.RDB
-}
-
-// New returns a new instance of Inspector.
-func NewInspector(r RedisConnOpt) *Inspector {
-	c, ok := r.MakeRedisClient().(redis.UniversalClient)
-	if !ok {
-		panic(fmt.Sprintf("inspeq: unsupported RedisConnOpt type %T", r))
-	}
-	return &Inspector{
-		rdb: rdb.NewRDB(c),
-	}
-}
-
-// Close closes the connection with redis.
-func (i *Inspector) Close() error {
-	return i.rdb.Close()
-}
-
-// Queues returns a list of all queue names.
-func (i *Inspector) Queues() ([]string, error) {
-	return i.rdb.AllQueues()
-}
-
-// QueueInfo represents a state of queues at a certain time.
-type QueueInfo struct {
-	// Name of the queue.
-	Queue string
-
-	// Total number of bytes that the queue and its tasks require to be stored in redis.
-	// It is an approximate memory usage value in bytes since the value is computed by sampling.
-	MemoryUsage int64
-
-	// Latency of the queue, measured by the oldest pending task in the queue.
-	Latency time.Duration
-
-	// Size is the total number of tasks in the queue.
-	// The value is the sum of Pending, Active, Scheduled, Retry, and Archived.
-	Size int
-
-	// Number of pending tasks.
-	Pending int
-	// Number of active tasks.
-	Active int
-	// Number of scheduled tasks.
-	Scheduled int
-	// Number of retry tasks.
-	Retry int
-	// Number of archived tasks.
-	Archived int
-	// Number of stored completed tasks.
-	Completed int
-
-	// Total number of tasks being processed within the given date (counter resets daily).
-	// The number includes both succeeded and failed tasks.
-	Processed int
-	// Total number of tasks failed to be processed within the given date (counter resets daily).
-	Failed int
-
-	// Total number of tasks processed (cumulative).
-	ProcessedTotal int
-	// Total number of tasks failed (cumulative).
-	FailedTotal int
-
-	// Paused indicates whether the queue is paused.
-	// If true, tasks in the queue will not be processed.
-	Paused bool
-
-	// Time when this queue info snapshot was taken.
-	Timestamp time.Time
-}
-
-// GetQueueInfo returns current information of the given queue.
-func (i *Inspector) GetQueueInfo(qname string) (*QueueInfo, error) {
-	if err := base.ValidateQueueName(qname); err != nil {
-		return nil, err
-	}
-	stats, err := i.rdb.CurrentStats(qname)
-	if err != nil {
-		return nil, err
-	}
-	return &QueueInfo{
-		Queue:          stats.Queue,
-		MemoryUsage:    stats.MemoryUsage,
-		Latency:        stats.Latency,
-		Size:           stats.Size,
-		Pending:        stats.Pending,
-		Active:         stats.Active,
-		Scheduled:      stats.Scheduled,
-		Retry:          stats.Retry,
-		Archived:       stats.Archived,
-		Completed:      stats.Completed,
-		Processed:      stats.Processed,
-		Failed:         stats.Failed,
-		ProcessedTotal: stats.ProcessedTotal,
-		FailedTotal:    stats.FailedTotal,
-		Paused:         stats.Paused,
-		Timestamp:      stats.Timestamp,
-	}, nil
-}
-
-// DailyStats holds aggregate data for a given day for a given queue.
-type DailyStats struct {
-	// Name of the queue.
-	Queue string
-	// Total number of tasks being processed during the given date.
-	// The number includes both succeeded and failed tasks.
-	Processed int
-	// Total number of tasks failed to be processed during the given date.
-	Failed int
-	// Date this stats was taken.
-	Date time.Time
-}
-
-// History returns a list of stats from the last n days.
-func (i *Inspector) History(qname string, n int) ([]*DailyStats, error) {
-	if err := base.ValidateQueueName(qname); err != nil {
-		return nil, err
-	}
-	stats, err := i.rdb.HistoricalStats(qname, n)
-	if err != nil {
-		return nil, err
-	}
-	var res []*DailyStats
-	for _, s := range stats {
-		res = append(res, &DailyStats{
-			Queue:     s.Queue,
-			Processed: s.Processed,
-			Failed:    s.Failed,
-			Date:      s.Time,
-		})
-	}
-	return res, nil
-}
-
-var (
-	// ErrQueueNotFound indicates that the specified queue does not exist.
-	ErrQueueNotFound = errors.New("queue not found")
-
-	// ErrQueueNotEmpty indicates that the specified queue is not empty.
-	ErrQueueNotEmpty = errors.New("queue is not empty")
-
-	// ErrTaskNotFound indicates that the specified task cannot be found in the queue.
-	ErrTaskNotFound = errors.New("task not found")
-)
-
-// DeleteQueue removes the specified queue.
-//
-// If force is set to true, DeleteQueue will remove the queue regardless of
-// the queue size as long as no tasks are active in the queue.
-// If force is set to false, DeleteQueue will remove the queue only if
-// the queue is empty.
-//
-// If the specified queue does not exist, DeleteQueue returns ErrQueueNotFound.
-// If force is set to false and the specified queue is not empty, DeleteQueue
-// returns ErrQueueNotEmpty.
-func (i *Inspector) DeleteQueue(qname string, force bool) error {
-	err := i.rdb.RemoveQueue(qname, force)
-	if errors.IsQueueNotFound(err) {
-		return fmt.Errorf("%w: queue=%q", ErrQueueNotFound, qname)
-	}
-	if errors.IsQueueNotEmpty(err) {
-		return fmt.Errorf("%w: queue=%q", ErrQueueNotEmpty, qname)
-	}
-	return err
-}
-
-// GetTaskInfo retrieves task information given a task id and queue name.
-//
-// Returns an error wrapping ErrQueueNotFound if a queue with the given name doesn't exist.
-// Returns an error wrapping ErrTaskNotFound if a task with the given id doesn't exist in the queue.
-func (i *Inspector) GetTaskInfo(qname, id string) (*TaskInfo, error) {
-	info, err := i.rdb.GetTaskInfo(qname, id)
-	switch {
-	case errors.IsQueueNotFound(err):
-		return nil, fmt.Errorf("asynq: %w", ErrQueueNotFound)
-	case errors.IsTaskNotFound(err):
-		return nil, fmt.Errorf("asynq: %w", ErrTaskNotFound)
-	case err != nil:
-		return nil, fmt.Errorf("asynq: %v", err)
-	}
-	return newTaskInfo(info.Message, info.State, info.NextProcessAt, info.Result), nil
-}
-
-// ListOption specifies behavior of list operation.
-type ListOption interface{}
-
-// Internal list option representations.
-type (
-	pageSizeOpt int
-	pageNumOpt  int
-)
-
-type listOption struct {
-	pageSize int
-	pageNum  int
-}
-
-const (
-	// Page size used by default in list operation.
-	defaultPageSize = 30
-
-	// Page number used by default in list operation.
-	defaultPageNum = 1
-)
-
-func composeListOptions(opts ...ListOption) listOption {
-	res := listOption{
-		pageSize: defaultPageSize,
-		pageNum:  defaultPageNum,
-	}
-	for _, opt := range opts {
-		switch opt := opt.(type) {
-		case pageSizeOpt:
-			res.pageSize = int(opt)
-		case pageNumOpt:
-			res.pageNum = int(opt)
-		default:
-			// ignore unexpected option
-		}
-	}
-	return res
-}
-
-// PageSize returns an option to specify the page size for list operation.
-//
-// Negative page size is treated as zero.
-func PageSize(n int) ListOption {
-	if n < 0 {
-		n = 0
-	}
-	return pageSizeOpt(n)
-}
-
-// Page returns an option to specify the page number for list operation.
-// The value 1 fetches the first page.
-//
-// Negative page number is treated as one.
-func Page(n int) ListOption {
-	if n < 0 {
-		n = 1
-	}
-	return pageNumOpt(n)
-}
-
-// ListPendingTasks retrieves pending tasks from the specified queue.
-//
-// By default, it retrieves the first 30 tasks.
-func (i *Inspector) ListPendingTasks(qname string, opts ...ListOption) ([]*TaskInfo, error) {
-	if err := base.ValidateQueueName(qname); err != nil {
-		return nil, fmt.Errorf("asynq: %v", err)
-	}
-	opt := composeListOptions(opts...)
-	pgn := rdb.Pagination{Size: opt.pageSize, Page: opt.pageNum - 1}
-	infos, err := i.rdb.ListPending(qname, pgn)
-	switch {
-	case errors.IsQueueNotFound(err):
-		return nil, fmt.Errorf("asynq: %w", ErrQueueNotFound)
-	case err != nil:
-		return nil, fmt.Errorf("asynq: %v", err)
-	}
-	var tasks []*TaskInfo
-	for _, i := range infos {
-		tasks = append(tasks, newTaskInfo(
-			i.Message,
-			i.State,
-			i.NextProcessAt,
-			i.Result,
-		))
-	}
-	return tasks, err
-}
-
-// ListActiveTasks retrieves active tasks from the specified queue.
-//
-// By default, it retrieves the first 30 tasks.
-func (i *Inspector) ListActiveTasks(qname string, opts ...ListOption) ([]*TaskInfo, error) {
-	if err := base.ValidateQueueName(qname); err != nil {
-		return nil, fmt.Errorf("asynq: %v", err)
-	}
-	opt := composeListOptions(opts...)
-	pgn := rdb.Pagination{Size: opt.pageSize, Page: opt.pageNum - 1}
-	infos, err := i.rdb.ListActive(qname, pgn)
-	switch {
-	case errors.IsQueueNotFound(err):
-		return nil, fmt.Errorf("asynq: %w", ErrQueueNotFound)
-	case err != nil:
-		return nil, fmt.Errorf("asynq: %v", err)
-	}
-	var tasks []*TaskInfo
-	for _, i := range infos {
-		tasks = append(tasks, newTaskInfo(
-			i.Message,
-			i.State,
-			i.NextProcessAt,
-			i.Result,
-		))
-	}
-	return tasks, err
-}
-
-// ListScheduledTasks retrieves scheduled tasks from the specified queue.
-// Tasks are sorted by NextProcessAt in ascending order.
-//
-// By default, it retrieves the first 30 tasks.
-func (i *Inspector) ListScheduledTasks(qname string, opts ...ListOption) ([]*TaskInfo, error) {
-	if err := base.ValidateQueueName(qname); err != nil {
-		return nil, fmt.Errorf("asynq: %v", err)
-	}
-	opt := composeListOptions(opts...)
-	pgn := rdb.Pagination{Size: opt.pageSize, Page: opt.pageNum - 1}
-	infos, err := i.rdb.ListScheduled(qname, pgn)
-	switch {
-	case errors.IsQueueNotFound(err):
-		return nil, fmt.Errorf("asynq: %w", ErrQueueNotFound)
-	case err != nil:
-		return nil, fmt.Errorf("asynq: %v", err)
-	}
-	var tasks []*TaskInfo
-	for _, i := range infos {
-		tasks = append(tasks, newTaskInfo(
-			i.Message,
-			i.State,
-			i.NextProcessAt,
-			i.Result,
-		))
-	}
-	return tasks, nil
-}
-
-// ListRetryTasks retrieves retry tasks from the specified queue.
-// Tasks are sorted by NextProcessAt in ascending order.
-//
-// By default, it retrieves the first 30 tasks.
-func (i *Inspector) ListRetryTasks(qname string, opts ...ListOption) ([]*TaskInfo, error) {
-	if err := base.ValidateQueueName(qname); err != nil {
-		return nil, fmt.Errorf("asynq: %v", err)
-	}
-	opt := composeListOptions(opts...)
-	pgn := rdb.Pagination{Size: opt.pageSize, Page: opt.pageNum - 1}
-	infos, err := i.rdb.ListRetry(qname, pgn)
-	switch {
-	case errors.IsQueueNotFound(err):
-		return nil, fmt.Errorf("asynq: %w", ErrQueueNotFound)
-	case err != nil:
-		return nil, fmt.Errorf("asynq: %v", err)
-	}
-	var tasks []*TaskInfo
-	for _, i := range infos {
-		tasks = append(tasks, newTaskInfo(
-			i.Message,
-			i.State,
-			i.NextProcessAt,
-			i.Result,
-		))
-	}
-	return tasks, nil
-}
-
-// ListArchivedTasks retrieves archived tasks from the specified queue.
-// Tasks are sorted by LastFailedAt in descending order.
-//
-// By default, it retrieves the first 30 tasks.
-func (i *Inspector) ListArchivedTasks(qname string, opts ...ListOption) ([]*TaskInfo, error) {
-	if err := base.ValidateQueueName(qname); err != nil {
-		return nil, fmt.Errorf("asynq: %v", err)
-	}
-	opt := composeListOptions(opts...)
-	pgn := rdb.Pagination{Size: opt.pageSize, Page: opt.pageNum - 1}
-	infos, err := i.rdb.ListArchived(qname, pgn)
-	switch {
-	case errors.IsQueueNotFound(err):
-		return nil, fmt.Errorf("asynq: %w", ErrQueueNotFound)
-	case err != nil:
-		return nil, fmt.Errorf("asynq: %v", err)
-	}
-	var tasks []*TaskInfo
-	for _, i := range infos {
-		tasks = append(tasks, newTaskInfo(
-			i.Message,
-			i.State,
-			i.NextProcessAt,
-			i.Result,
-		))
-	}
-	return tasks, nil
-}
-
-// ListCompletedTasks retrieves completed tasks from the specified queue.
-// Tasks are sorted by expiration time (i.e. CompletedAt + Retention) in descending order.
-//
-// By default, it retrieves the first 30 tasks.
-func (i *Inspector) ListCompletedTasks(qname string, opts ...ListOption) ([]*TaskInfo, error) {
-	if err := base.ValidateQueueName(qname); err != nil {
-		return nil, fmt.Errorf("asynq: %v", err)
-	}
-	opt := composeListOptions(opts...)
-	pgn := rdb.Pagination{Size: opt.pageSize, Page: opt.pageNum - 1}
-	infos, err := i.rdb.ListCompleted(qname, pgn)
-	switch {
-	case errors.IsQueueNotFound(err):
-		return nil, fmt.Errorf("asynq: %w", ErrQueueNotFound)
-	case err != nil:
-		return nil, fmt.Errorf("asynq: %v", err)
-	}
-	var tasks []*TaskInfo
-	for _, i := range infos {
-		tasks = append(tasks, newTaskInfo(
-			i.Message,
-			i.State,
-			i.NextProcessAt,
-			i.Result,
-		))
-	}
-	return tasks, nil
-}
-
-// DeleteAllPendingTasks deletes all pending tasks from the specified queue,
-// and reports the number tasks deleted.
-func (i *Inspector) DeleteAllPendingTasks(qname string) (int, error) {
-	if err := base.ValidateQueueName(qname); err != nil {
-		return 0, err
-	}
-	n, err := i.rdb.DeleteAllPendingTasks(qname)
-	return int(n), err
-}
-
-// DeleteAllScheduledTasks deletes all scheduled tasks from the specified queue,
-// and reports the number tasks deleted.
-func (i *Inspector) DeleteAllScheduledTasks(qname string) (int, error) {
-	if err := base.ValidateQueueName(qname); err != nil {
-		return 0, err
-	}
-	n, err := i.rdb.DeleteAllScheduledTasks(qname)
-	return int(n), err
-}
-
-// DeleteAllRetryTasks deletes all retry tasks from the specified queue,
-// and reports the number tasks deleted.
-func (i *Inspector) DeleteAllRetryTasks(qname string) (int, error) {
-	if err := base.ValidateQueueName(qname); err != nil {
-		return 0, err
-	}
-	n, err := i.rdb.DeleteAllRetryTasks(qname)
-	return int(n), err
-}
-
-// DeleteAllArchivedTasks deletes all archived tasks from the specified queue,
-// and reports the number tasks deleted.
-func (i *Inspector) DeleteAllArchivedTasks(qname string) (int, error) {
-	if err := base.ValidateQueueName(qname); err != nil {
-		return 0, err
-	}
-	n, err := i.rdb.DeleteAllArchivedTasks(qname)
-	return int(n), err
-}
-
-// DeleteAllCompletedTasks deletes all completed tasks from the specified queue,
-// and reports the number tasks deleted.
-func (i *Inspector) DeleteAllCompletedTasks(qname string) (int, error) {
-	if err := base.ValidateQueueName(qname); err != nil {
-		return 0, err
-	}
-	n, err := i.rdb.DeleteAllCompletedTasks(qname)
-	return int(n), err
-}
-
-// DeleteTask deletes a task with the given id from the given queue.
-// The task needs to be in pending, scheduled, retry, or archived state,
-// otherwise DeleteTask will return an error.
-//
-// If a queue with the given name doesn't exist, it returns an error wrapping ErrQueueNotFound.
-// If a task with the given id doesn't exist in the queue, it returns an error wrapping ErrTaskNotFound.
-// If the task is in active state, it returns a non-nil error.
-func (i *Inspector) DeleteTask(qname, id string) error {
-	if err := base.ValidateQueueName(qname); err != nil {
-		return fmt.Errorf("asynq: %v", err)
-	}
-	err := i.rdb.DeleteTask(qname, id)
-	switch {
-	case errors.IsQueueNotFound(err):
-		return fmt.Errorf("asynq: %w", ErrQueueNotFound)
-	case errors.IsTaskNotFound(err):
-		return fmt.Errorf("asynq: %w", ErrTaskNotFound)
-	case err != nil:
-		return fmt.Errorf("asynq: %v", err)
-	}
-	return nil
-
-}
-
-// RunAllScheduledTasks transition all scheduled tasks to pending state from the given queue,
-// and reports the number of tasks transitioned.
-func (i *Inspector) RunAllScheduledTasks(qname string) (int, error) {
-	if err := base.ValidateQueueName(qname); err != nil {
-		return 0, err
-	}
-	n, err := i.rdb.RunAllScheduledTasks(qname)
-	return int(n), err
-}
-
-// RunAllRetryTasks transition all retry tasks to pending state from the given queue,
-// and reports the number of tasks transitioned.
-func (i *Inspector) RunAllRetryTasks(qname string) (int, error) {
-	if err := base.ValidateQueueName(qname); err != nil {
-		return 0, err
-	}
-	n, err := i.rdb.RunAllRetryTasks(qname)
-	return int(n), err
-}
-
-// RunAllArchivedTasks transition all archived tasks to pending state from the given queue,
-// and reports the number of tasks transitioned.
-func (i *Inspector) RunAllArchivedTasks(qname string) (int, error) {
-	if err := base.ValidateQueueName(qname); err != nil {
-		return 0, err
-	}
-	n, err := i.rdb.RunAllArchivedTasks(qname)
-	return int(n), err
-}
-
-// RunTask updates the task to pending state given a queue name and task id.
-// The task needs to be in scheduled, retry, or archived state, otherwise RunTask
-// will return an error.
-//
-// If a queue with the given name doesn't exist, it returns an error wrapping ErrQueueNotFound.
-// If a task with the given id doesn't exist in the queue, it returns an error wrapping ErrTaskNotFound.
-// If the task is in pending or active state, it returns a non-nil error.
-func (i *Inspector) RunTask(qname, id string) error {
-	if err := base.ValidateQueueName(qname); err != nil {
-		return fmt.Errorf("asynq: %v", err)
-	}
-	err := i.rdb.RunTask(qname, id)
-	switch {
-	case errors.IsQueueNotFound(err):
-		return fmt.Errorf("asynq: %w", ErrQueueNotFound)
-	case errors.IsTaskNotFound(err):
-		return fmt.Errorf("asynq: %w", ErrTaskNotFound)
-	case err != nil:
-		return fmt.Errorf("asynq: %v", err)
-	}
-	return nil
-}
-
-// ArchiveAllPendingTasks archives all pending tasks from the given queue,
-// and reports the number of tasks archived.
-func (i *Inspector) ArchiveAllPendingTasks(qname string) (int, error) {
-	if err := base.ValidateQueueName(qname); err != nil {
-		return 0, err
-	}
-	n, err := i.rdb.ArchiveAllPendingTasks(qname)
-	return int(n), err
-}
-
-// ArchiveAllScheduledTasks archives all scheduled tasks from the given queue,
-// and reports the number of tasks archiveed.
-func (i *Inspector) ArchiveAllScheduledTasks(qname string) (int, error) {
-	if err := base.ValidateQueueName(qname); err != nil {
-		return 0, err
-	}
-	n, err := i.rdb.ArchiveAllScheduledTasks(qname)
-	return int(n), err
-}
-
-// ArchiveAllRetryTasks archives all retry tasks from the given queue,
-// and reports the number of tasks archiveed.
-func (i *Inspector) ArchiveAllRetryTasks(qname string) (int, error) {
-	if err := base.ValidateQueueName(qname); err != nil {
-		return 0, err
-	}
-	n, err := i.rdb.ArchiveAllRetryTasks(qname)
-	return int(n), err
-}
-
-// ArchiveTask archives a task with the given id in the given queue.
-// The task needs to be in pending, scheduled, or retry state, otherwise ArchiveTask
-// will return an error.
-//
-// If a queue with the given name doesn't exist, it returns an error wrapping ErrQueueNotFound.
-// If a task with the given id doesn't exist in the queue, it returns an error wrapping ErrTaskNotFound.
-// If the task is in already archived, it returns a non-nil error.
-func (i *Inspector) ArchiveTask(qname, id string) error {
-	if err := base.ValidateQueueName(qname); err != nil {
-		return fmt.Errorf("asynq: err")
-	}
-	err := i.rdb.ArchiveTask(qname, id)
-	switch {
-	case errors.IsQueueNotFound(err):
-		return fmt.Errorf("asynq: %w", ErrQueueNotFound)
-	case errors.IsTaskNotFound(err):
-		return fmt.Errorf("asynq: %w", ErrTaskNotFound)
-	case err != nil:
-		return fmt.Errorf("asynq: %v", err)
-	}
-	return nil
-}
-
-// CancelProcessing sends a signal to cancel processing of the task
-// given a task id. CancelProcessing is best-effort, which means that it does not
-// guarantee that the task with the given id will be canceled. The return
-// value only indicates whether the cancelation signal has been sent.
-func (i *Inspector) CancelProcessing(id string) error {
-	return i.rdb.PublishCancelation(id)
-}
-
-// PauseQueue pauses task processing on the specified queue.
-// If the queue is already paused, it will return a non-nil error.
-func (i *Inspector) PauseQueue(qname string) error {
-	if err := base.ValidateQueueName(qname); err != nil {
-		return err
-	}
-	return i.rdb.Pause(qname)
-}
-
-// UnpauseQueue resumes task processing on the specified queue.
-// If the queue is not paused, it will return a non-nil error.
-func (i *Inspector) UnpauseQueue(qname string) error {
-	if err := base.ValidateQueueName(qname); err != nil {
-		return err
-	}
-	return i.rdb.Unpause(qname)
-}
-
-// Servers return a list of running servers' information.
-func (i *Inspector) Servers() ([]*ServerInfo, error) {
-	servers, err := i.rdb.ListServers()
-	if err != nil {
-		return nil, err
-	}
-	workers, err := i.rdb.ListWorkers()
-	if err != nil {
-		return nil, err
-	}
-	m := make(map[string]*ServerInfo) // ServerInfo keyed by serverID
-	for _, s := range servers {
-		m[s.ServerID] = &ServerInfo{
-			ID:             s.ServerID,
-			Host:           s.Host,
-			PID:            s.PID,
-			Concurrency:    s.Concurrency,
-			Queues:         s.Queues,
-			StrictPriority: s.StrictPriority,
-			Started:        s.Started,
-			Status:         s.Status,
-			ActiveWorkers:  make([]*WorkerInfo, 0),
-		}
-	}
-	for _, w := range workers {
-		srvInfo, ok := m[w.ServerID]
-		if !ok {
-			continue
-		}
-		wrkInfo := &WorkerInfo{
-			TaskID:      w.ID,
-			TaskType:    w.Type,
-			TaskPayload: w.Payload,
-			Queue:       w.Queue,
-			Started:     w.Started,
-			Deadline:    w.Deadline,
-		}
-		srvInfo.ActiveWorkers = append(srvInfo.ActiveWorkers, wrkInfo)
-	}
-	var out []*ServerInfo
-	for _, srvInfo := range m {
-		out = append(out, srvInfo)
-	}
-	return out, nil
-}
-
-// ServerInfo describes a running Server instance.
-type ServerInfo struct {
-	// Unique Identifier for the server.
-	ID string
-	// Host machine on which the server is running.
-	Host string
-	// PID of the process in which the server is running.
-	PID int
-
-	// Server configuration details.
-	// See Config doc for field descriptions.
-	Concurrency    int
-	Queues         map[string]int
-	StrictPriority bool
-
-	// Time the server started.
-	Started time.Time
-	// Status indicates the status of the server.
-	// TODO: Update comment with more details.
-	Status string
-	// A List of active workers currently processing tasks.
-	ActiveWorkers []*WorkerInfo
-}
-
-// WorkerInfo describes a running worker processing a task.
-type WorkerInfo struct {
-	// ID of the task the worker is processing.
-	TaskID string
-	// Type of the task the worker is processing.
-	TaskType string
-	// Payload of the task the worker is processing.
-	TaskPayload []byte
-	// Queue from which the worker got its task.
-	Queue string
-	// Time the worker started processing the task.
-	Started time.Time
-	// Time the worker needs to finish processing the task by.
-	Deadline time.Time
-}
-
-// ClusterKeySlot returns an integer identifying the hash slot the given queue hashes to.
-func (i *Inspector) ClusterKeySlot(qname string) (int64, error) {
-	return i.rdb.ClusterKeySlot(qname)
-}
-
-// ClusterNode describes a node in redis cluster.
-type ClusterNode struct {
-	// Node ID in the cluster.
-	ID string
-
-	// Address of the node.
-	Addr string
-}
-
-// ClusterNodes returns a list of nodes the given queue belongs to.
-//
-// Only relevant if task queues are stored in redis cluster.
-func (i *Inspector) ClusterNodes(qname string) ([]*ClusterNode, error) {
-	nodes, err := i.rdb.ClusterNodes(qname)
-	if err != nil {
-		return nil, err
-	}
-	var res []*ClusterNode
-	for _, node := range nodes {
-		res = append(res, &ClusterNode{ID: node.ID, Addr: node.Addr})
-	}
-	return res, nil
-}
-
-// SchedulerEntry holds information about a periodic task registered with a scheduler.
-type SchedulerEntry struct {
-	// Identifier of this entry.
-	ID string
-
-	// Spec describes the schedule of this entry.
-	Spec string
-
-	// Periodic Task registered for this entry.
-	Task *Task
-
-	// Opts is the options for the periodic task.
-	Opts []Option
-
-	// Next shows the next time the task will be enqueued.
-	Next time.Time
-
-	// Prev shows the last time the task was enqueued.
-	// Zero time if task was never enqueued.
-	Prev time.Time
-}
-
-// SchedulerEntries returns a list of all entries registered with
-// currently running schedulers.
-func (i *Inspector) SchedulerEntries() ([]*SchedulerEntry, error) {
-	var entries []*SchedulerEntry
-	res, err := i.rdb.ListSchedulerEntries()
-	if err != nil {
-		return nil, err
-	}
-	for _, e := range res {
-		task := NewTask(e.Type, e.Payload)
-		var opts []Option
-		for _, s := range e.Opts {
-			if o, err := parseOption(s); err == nil {
-				// ignore bad data
-				opts = append(opts, o)
-			}
-		}
-		entries = append(entries, &SchedulerEntry{
-			ID:   e.ID,
-			Spec: e.Spec,
-			Task: task,
-			Opts: opts,
-			Next: e.Next,
-			Prev: e.Prev,
-		})
-	}
-	return entries, nil
-}
-
-// parseOption interprets a string s as an Option and returns the Option if parsing is successful,
-// otherwise returns non-nil error.
-func parseOption(s string) (Option, error) {
-	fn, arg := parseOptionFunc(s), parseOptionArg(s)
-	switch fn {
-	case "Queue":
-		qname, err := strconv.Unquote(arg)
-		if err != nil {
-			return nil, err
-		}
-		return Queue(qname), nil
-	case "MaxRetry":
-		n, err := strconv.Atoi(arg)
-		if err != nil {
-			return nil, err
-		}
-		return MaxRetry(n), nil
-	case "Timeout":
-		d, err := time.ParseDuration(arg)
-		if err != nil {
-			return nil, err
-		}
-		return Timeout(d), nil
-	case "Deadline":
-		t, err := time.Parse(time.UnixDate, arg)
-		if err != nil {
-			return nil, err
-		}
-		return Deadline(t), nil
-	case "Unique":
-		d, err := time.ParseDuration(arg)
-		if err != nil {
-			return nil, err
-		}
-		return Unique(d), nil
-	case "ProcessAt":
-		t, err := time.Parse(time.UnixDate, arg)
-		if err != nil {
-			return nil, err
-		}
-		return ProcessAt(t), nil
-	case "ProcessIn":
-		d, err := time.ParseDuration(arg)
-		if err != nil {
-			return nil, err
-		}
-		return ProcessIn(d), nil
-	case "Retention":
-		d, err := time.ParseDuration(arg)
-		if err != nil {
-			return nil, err
-		}
-		return Retention(d), nil
-	default:
-		return nil, fmt.Errorf("cannot not parse option string %q", s)
-	}
-}
-
-func parseOptionFunc(s string) string {
-	i := strings.Index(s, "(")
-	return s[:i]
-}
-
-func parseOptionArg(s string) string {
-	i := strings.Index(s, "(")
-	if i >= 0 {
-		j := strings.Index(s, ")")
-		if j > i {
-			return s[i+1 : j]
-		}
-	}
-	return ""
-}
-
-// SchedulerEnqueueEvent holds information about an enqueue event by a scheduler.
-type SchedulerEnqueueEvent struct {
-	// ID of the task that was enqueued.
-	TaskID string
-
-	// Time the task was enqueued.
-	EnqueuedAt time.Time
-}
-
-// ListSchedulerEnqueueEvents retrieves a list of enqueue events from the specified scheduler entry.
-//
-// By default, it retrieves the first 30 tasks.
-func (i *Inspector) ListSchedulerEnqueueEvents(entryID string, opts ...ListOption) ([]*SchedulerEnqueueEvent, error) {
-	opt := composeListOptions(opts...)
-	pgn := rdb.Pagination{Size: opt.pageSize, Page: opt.pageNum - 1}
-	data, err := i.rdb.ListSchedulerEnqueueEvents(entryID, pgn)
-	if err != nil {
-		return nil, err
-	}
-	var events []*SchedulerEnqueueEvent
-	for _, e := range data {
-		events = append(events, &SchedulerEnqueueEvent{TaskID: e.TaskID, EnqueuedAt: e.EnqueuedAt})
-	}
-	return events, nil
-}

internal/asynqtest/asynqtest.go

@@ -6,42 +6,37 @@
 package asynqtest
 
 import (
-	"context"
 	"encoding/json"
-	"math"
 	"sort"
 	"testing"
-	"time"
 
-	"github.com/go-redis/redis/v8"
+	"github.com/go-redis/redis/v7"
 	"github.com/google/go-cmp/cmp"
 	"github.com/google/go-cmp/cmp/cmpopts"
 	"github.com/google/uuid"
 	"github.com/hibiken/asynq/internal/base"
 )
 
-// EquateInt64Approx returns a Comparer option that treats int64 values
+// ZSetEntry is an entry in redis sorted set.
-// to be equal if they are within the given margin.
+type ZSetEntry struct {
-func EquateInt64Approx(margin int64) cmp.Option {
+	Msg   *base.TaskMessage
-	return cmp.Comparer(func(a, b int64) bool {
+	Score float64
-		return math.Abs(float64(a-b)) <= float64(margin)
-	})
 }
 
 // SortMsgOpt is a cmp.Option to sort base.TaskMessage for comparing slice of task messages.
 var SortMsgOpt = cmp.Transformer("SortTaskMessages", func(in []*base.TaskMessage) []*base.TaskMessage {
 	out := append([]*base.TaskMessage(nil), in...) // Copy input to avoid mutating it
 	sort.Slice(out, func(i, j int) bool {
-		return out[i].ID < out[j].ID
+		return out[i].ID.String() < out[j].ID.String()
 	})
 	return out
 })
 
 // SortZSetEntryOpt is an cmp.Option to sort ZSetEntry for comparing slice of zset entries.
-var SortZSetEntryOpt = cmp.Transformer("SortZSetEntries", func(in []base.Z) []base.Z {
+var SortZSetEntryOpt = cmp.Transformer("SortZSetEntries", func(in []ZSetEntry) []ZSetEntry {
-	out := append([]base.Z(nil), in...) // Copy input to avoid mutating it
+	out := append([]ZSetEntry(nil), in...) // Copy input to avoid mutating it
 	sort.Slice(out, func(i, j int) bool {
-		return out[i].Message.ID < out[j].Message.ID
+		return out[i].Msg.ID.String() < out[j].Msg.ID.String()
 	})
 	return out
 })
@@ -67,24 +62,6 @@ var SortWorkerInfoOpt = cmp.Transformer("SortWorkerInfo", func(in []*base.Worker
 	return out
 })
 
-// SortSchedulerEntryOpt is a cmp.Option to sort base.SchedulerEntry for comparing slice of entries.
-var SortSchedulerEntryOpt = cmp.Transformer("SortSchedulerEntry", func(in []*base.SchedulerEntry) []*base.SchedulerEntry {
-	out := append([]*base.SchedulerEntry(nil), in...) // Copy input to avoid mutating it
-	sort.Slice(out, func(i, j int) bool {
-		return out[i].Spec < out[j].Spec
-	})
-	return out
-})
-
-// SortSchedulerEnqueueEventOpt is a cmp.Option to sort base.SchedulerEnqueueEvent for comparing slice of events.
-var SortSchedulerEnqueueEventOpt = cmp.Transformer("SortSchedulerEnqueueEvent", func(in []*base.SchedulerEnqueueEvent) []*base.SchedulerEnqueueEvent {
-	out := append([]*base.SchedulerEnqueueEvent(nil), in...)
-	sort.Slice(out, func(i, j int) bool {
-		return out[i].EnqueuedAt.Unix() < out[j].EnqueuedAt.Unix()
-	})
-	return out
-})
-
 // SortStringSliceOpt is a cmp.Option to sort string slice.
 var SortStringSliceOpt = cmp.Transformer("SortStringSlice", func(in []string) []string {
 	out := append([]string(nil), in...)
@@ -96,17 +73,11 @@ var SortStringSliceOpt = cmp.Transformer("SortStringSlice", func(in []string) []
 var IgnoreIDOpt = cmpopts.IgnoreFields(base.TaskMessage{}, "ID")
 
 // NewTaskMessage returns a new instance of TaskMessage given a task type and payload.
-func NewTaskMessage(taskType string, payload []byte) *base.TaskMessage {
+func NewTaskMessage(taskType string, payload map[string]interface{}) *base.TaskMessage {
-	return NewTaskMessageWithQueue(taskType, payload, base.DefaultQueueName)
-}
-
-// NewTaskMessageWithQueue returns a new instance of TaskMessage given a
-// task type, payload and queue name.
-func NewTaskMessageWithQueue(taskType string, payload []byte, qname string) *base.TaskMessage {
 	return &base.TaskMessage{
-		ID:       uuid.NewString(),
+		ID:       uuid.New(),
 		Type:     taskType,
-		Queue:    qname,
+		Queue:    base.DefaultQueueName,
 		Retry:    25,
 		Payload:  payload,
 		Timeout:  1800, // default timeout of 30 mins
@@ -114,34 +85,29 @@ func NewTaskMessageWithQueue(taskType string, payload []byte, qname string) *bas
 	}
 }
 
-// JSON serializes the given key-value pairs into stream of bytes in JSON.
+// NewTaskMessageWithQueue returns a new instance of TaskMessage given a
-func JSON(kv map[string]interface{}) []byte {
+// task type, payload and queue name.
-	b, err := json.Marshal(kv)
+func NewTaskMessageWithQueue(taskType string, payload map[string]interface{}, qname string) *base.TaskMessage {
-	if err != nil {
+	return &base.TaskMessage{
-		panic(err)
+		ID:      uuid.New(),
+		Type:    taskType,
+		Queue:   qname,
+		Retry:   25,
+		Payload: payload,
 	}
-	return b
 }
 
 // TaskMessageAfterRetry returns an updated copy of t after retry.
-// It increments retry count and sets the error message and last_failed_at time.
+// It increments retry count and sets the error message.
-func TaskMessageAfterRetry(t base.TaskMessage, errMsg string, failedAt time.Time) *base.TaskMessage {
+func TaskMessageAfterRetry(t base.TaskMessage, errMsg string) *base.TaskMessage {
 	t.Retried = t.Retried + 1
 	t.ErrorMsg = errMsg
-	t.LastFailedAt = failedAt.Unix()
 	return &t
 }
 
 // TaskMessageWithError returns an updated copy of t with the given error message.
-func TaskMessageWithError(t base.TaskMessage, errMsg string, failedAt time.Time) *base.TaskMessage {
+func TaskMessageWithError(t base.TaskMessage, errMsg string) *base.TaskMessage {
 	t.ErrorMsg = errMsg
-	t.LastFailedAt = failedAt.Unix()
-	return &t
-}
-
-// TaskMessageWithCompletedAt returns an updated copy of t after completion.
-func TaskMessageWithCompletedAt(t base.TaskMessage, completedAt time.Time) *base.TaskMessage {
-	t.CompletedAt = completedAt.Unix()
 	return &t
 }
 
@@ -149,7 +115,7 @@ func TaskMessageWithCompletedAt(t base.TaskMessage, completedAt time.Time) *base
 // Calling test will fail if marshaling errors out.
 func MustMarshal(tb testing.TB, msg *base.TaskMessage) string {
 	tb.Helper()
-	data, err := base.EncodeMessage(msg)
+	data, err := json.Marshal(msg)
 	if err != nil {
 		tb.Fatal(err)
 	}
@@ -160,324 +126,183 @@ func MustMarshal(tb testing.TB, msg *base.TaskMessage) string {
 // Calling test will fail if unmarshaling errors out.
 func MustUnmarshal(tb testing.TB, data string) *base.TaskMessage {
 	tb.Helper()
-	msg, err := base.DecodeMessage([]byte(data))
+	var msg base.TaskMessage
+	err := json.Unmarshal([]byte(data), &msg)
 	if err != nil {
 		tb.Fatal(err)
 	}
-	return msg
+	return &msg
+}
+
+// MustMarshalSlice marshals a slice of task messages and return a slice of
+// json strings. Calling test will fail if marshaling errors out.
+func MustMarshalSlice(tb testing.TB, msgs []*base.TaskMessage) []string {
+	tb.Helper()
+	var data []string
+	for _, m := range msgs {
+		data = append(data, MustMarshal(tb, m))
+	}
+	return data
+}
+
+// MustUnmarshalSlice unmarshals a slice of strings into a slice of task message structs.
+// Calling test will fail if marshaling errors out.
+func MustUnmarshalSlice(tb testing.TB, data []string) []*base.TaskMessage {
+	tb.Helper()
+	var msgs []*base.TaskMessage
+	for _, s := range data {
+		msgs = append(msgs, MustUnmarshal(tb, s))
+	}
+	return msgs
 }
 
 // FlushDB deletes all the keys of the currently selected DB.
-func FlushDB(tb testing.TB, r redis.UniversalClient) {
+func FlushDB(tb testing.TB, r *redis.Client) {
 	tb.Helper()
-	switch r := r.(type) {
+	if err := r.FlushDB().Err(); err != nil {
-	case *redis.Client:
-		if err := r.FlushDB(context.Background()).Err(); err != nil {
-			tb.Fatal(err)
-		}
-	case *redis.ClusterClient:
-		err := r.ForEachMaster(context.Background(), func(ctx context.Context, c *redis.Client) error {
-			if err := c.FlushAll(ctx).Err(); err != nil {
-				return err
-			}
-			return nil
-		})
-		if err != nil {
 		tb.Fatal(err)
 	}
 }
+
+// SeedEnqueuedQueue initializes the specified queue with the given messages.
+//
+// If queue name option is not passed, it defaults to the default queue.
+func SeedEnqueuedQueue(tb testing.TB, r *redis.Client, msgs []*base.TaskMessage, queueOpt ...string) {
+	tb.Helper()
+	queue := base.DefaultQueue
+	if len(queueOpt) > 0 {
+		queue = base.QueueKey(queueOpt[0])
+	}
+	r.SAdd(base.AllQueues, queue)
+	seedRedisList(tb, r, queue, msgs)
 }
 
-// SeedPendingQueue initializes the specified queue with the given messages.
+// SeedInProgressQueue initializes the in-progress queue with the given messages.
-func SeedPendingQueue(tb testing.TB, r redis.UniversalClient, msgs []*base.TaskMessage, qname string) {
+func SeedInProgressQueue(tb testing.TB, r *redis.Client, msgs []*base.TaskMessage) {
 	tb.Helper()
-	r.SAdd(context.Background(), base.AllQueues, qname)
+	seedRedisList(tb, r, base.InProgressQueue, msgs)
-	seedRedisList(tb, r, base.PendingKey(qname), msgs, base.TaskStatePending)
-}
-
-// SeedActiveQueue initializes the active queue with the given messages.
-func SeedActiveQueue(tb testing.TB, r redis.UniversalClient, msgs []*base.TaskMessage, qname string) {
-	tb.Helper()
-	r.SAdd(context.Background(), base.AllQueues, qname)
-	seedRedisList(tb, r, base.ActiveKey(qname), msgs, base.TaskStateActive)
 }
 
 // SeedScheduledQueue initializes the scheduled queue with the given messages.
-func SeedScheduledQueue(tb testing.TB, r redis.UniversalClient, entries []base.Z, qname string) {
+func SeedScheduledQueue(tb testing.TB, r *redis.Client, entries []ZSetEntry) {
 	tb.Helper()
-	r.SAdd(context.Background(), base.AllQueues, qname)
+	seedRedisZSet(tb, r, base.ScheduledQueue, entries)
-	seedRedisZSet(tb, r, base.ScheduledKey(qname), entries, base.TaskStateScheduled)
 }
 
 // SeedRetryQueue initializes the retry queue with the given messages.
-func SeedRetryQueue(tb testing.TB, r redis.UniversalClient, entries []base.Z, qname string) {
+func SeedRetryQueue(tb testing.TB, r *redis.Client, entries []ZSetEntry) {
 	tb.Helper()
-	r.SAdd(context.Background(), base.AllQueues, qname)
+	seedRedisZSet(tb, r, base.RetryQueue, entries)
-	seedRedisZSet(tb, r, base.RetryKey(qname), entries, base.TaskStateRetry)
 }
 
-// SeedArchivedQueue initializes the archived queue with the given messages.
+// SeedDeadQueue initializes the dead queue with the given messages.
-func SeedArchivedQueue(tb testing.TB, r redis.UniversalClient, entries []base.Z, qname string) {
+func SeedDeadQueue(tb testing.TB, r *redis.Client, entries []ZSetEntry) {
 	tb.Helper()
-	r.SAdd(context.Background(), base.AllQueues, qname)
+	seedRedisZSet(tb, r, base.DeadQueue, entries)
-	seedRedisZSet(tb, r, base.ArchivedKey(qname), entries, base.TaskStateArchived)
 }
 
 // SeedDeadlines initializes the deadlines set with the given entries.
-func SeedDeadlines(tb testing.TB, r redis.UniversalClient, entries []base.Z, qname string) {
+func SeedDeadlines(tb testing.TB, r *redis.Client, entries []ZSetEntry) {
 	tb.Helper()
-	r.SAdd(context.Background(), base.AllQueues, qname)
+	seedRedisZSet(tb, r, base.KeyDeadlines, entries)
-	seedRedisZSet(tb, r, base.DeadlinesKey(qname), entries, base.TaskStateActive)
 }
 
-// SeedCompletedQueue initializes the completed set witht the given entries.
+func seedRedisList(tb testing.TB, c *redis.Client, key string, msgs []*base.TaskMessage) {
-func SeedCompletedQueue(tb testing.TB, r redis.UniversalClient, entries []base.Z, qname string) {
+	data := MustMarshalSlice(tb, msgs)
-	tb.Helper()
+	for _, s := range data {
-	r.SAdd(context.Background(), base.AllQueues, qname)
+		if err := c.LPush(key, s).Err(); err != nil {
-	seedRedisZSet(tb, r, base.CompletedKey(qname), entries, base.TaskStateCompleted)
-}
-
-// SeedAllPendingQueues initializes all of the specified queues with the given messages.
-//
-// pending maps a queue name to a list of messages.
-func SeedAllPendingQueues(tb testing.TB, r redis.UniversalClient, pending map[string][]*base.TaskMessage) {
-	tb.Helper()
-	for q, msgs := range pending {
-		SeedPendingQueue(tb, r, msgs, q)
-	}
-}
-
-// SeedAllActiveQueues initializes all of the specified active queues with the given messages.
-func SeedAllActiveQueues(tb testing.TB, r redis.UniversalClient, active map[string][]*base.TaskMessage) {
-	tb.Helper()
-	for q, msgs := range active {
-		SeedActiveQueue(tb, r, msgs, q)
-	}
-}
-
-// SeedAllScheduledQueues initializes all of the specified scheduled queues with the given entries.
-func SeedAllScheduledQueues(tb testing.TB, r redis.UniversalClient, scheduled map[string][]base.Z) {
-	tb.Helper()
-	for q, entries := range scheduled {
-		SeedScheduledQueue(tb, r, entries, q)
-	}
-}
-
-// SeedAllRetryQueues initializes all of the specified retry queues with the given entries.
-func SeedAllRetryQueues(tb testing.TB, r redis.UniversalClient, retry map[string][]base.Z) {
-	tb.Helper()
-	for q, entries := range retry {
-		SeedRetryQueue(tb, r, entries, q)
-	}
-}
-
-// SeedAllArchivedQueues initializes all of the specified archived queues with the given entries.
-func SeedAllArchivedQueues(tb testing.TB, r redis.UniversalClient, archived map[string][]base.Z) {
-	tb.Helper()
-	for q, entries := range archived {
-		SeedArchivedQueue(tb, r, entries, q)
-	}
-}
-
-// SeedAllDeadlines initializes all of the deadlines with the given entries.
-func SeedAllDeadlines(tb testing.TB, r redis.UniversalClient, deadlines map[string][]base.Z) {
-	tb.Helper()
-	for q, entries := range deadlines {
-		SeedDeadlines(tb, r, entries, q)
-	}
-}
-
-// SeedAllCompletedQueues initializes all of the completed queues with the given entries.
-func SeedAllCompletedQueues(tb testing.TB, r redis.UniversalClient, completed map[string][]base.Z) {
-	tb.Helper()
-	for q, entries := range completed {
-		SeedCompletedQueue(tb, r, entries, q)
-	}
-}
-
-func seedRedisList(tb testing.TB, c redis.UniversalClient, key string,
-	msgs []*base.TaskMessage, state base.TaskState) {
-	tb.Helper()
-	for _, msg := range msgs {
-		encoded := MustMarshal(tb, msg)
-		if err := c.LPush(context.Background(), key, msg.ID).Err(); err != nil {
 			tb.Fatal(err)
 		}
-		key := base.TaskKey(msg.Queue, msg.ID)
-		data := map[string]interface{}{
-			"msg":        encoded,
-			"state":      state.String(),
-			"timeout":    msg.Timeout,
-			"deadline":   msg.Deadline,
-			"unique_key": msg.UniqueKey,
-		}
-		if err := c.HSet(context.Background(), key, data).Err(); err != nil {
-			tb.Fatal(err)
-		}
-		if len(msg.UniqueKey) > 0 {
-			err := c.SetNX(context.Background(), msg.UniqueKey, msg.ID, 1*time.Minute).Err()
-			if err != nil {
-				tb.Fatalf("Failed to set unique lock in redis: %v", err)
-			}
-		}
 	}
 }
 
-func seedRedisZSet(tb testing.TB, c redis.UniversalClient, key string,
+func seedRedisZSet(tb testing.TB, c *redis.Client, key string, items []ZSetEntry) {
-	items []base.Z, state base.TaskState) {
-	tb.Helper()
 	for _, item := range items {
-		msg := item.Message
+		z := &redis.Z{Member: MustMarshal(tb, item.Msg), Score: float64(item.Score)}
-		encoded := MustMarshal(tb, msg)
+		if err := c.ZAdd(key, z).Err(); err != nil {
-		z := &redis.Z{Member: msg.ID, Score: float64(item.Score)}
-		if err := c.ZAdd(context.Background(), key, z).Err(); err != nil {
 			tb.Fatal(err)
 		}
-		key := base.TaskKey(msg.Queue, msg.ID)
-		data := map[string]interface{}{
-			"msg":        encoded,
-			"state":      state.String(),
-			"timeout":    msg.Timeout,
-			"deadline":   msg.Deadline,
-			"unique_key": msg.UniqueKey,
-		}
-		if err := c.HSet(context.Background(), key, data).Err(); err != nil {
-			tb.Fatal(err)
-		}
-		if len(msg.UniqueKey) > 0 {
-			err := c.SetNX(context.Background(), msg.UniqueKey, msg.ID, 1*time.Minute).Err()
-			if err != nil {
-				tb.Fatalf("Failed to set unique lock in redis: %v", err)
-			}
-		}
 	}
 }
 
-// GetPendingMessages returns all pending messages in the given queue.
+// GetEnqueuedMessages returns all task messages in the specified queue.
-// It also asserts the state field of the task.
+//
-func GetPendingMessages(tb testing.TB, r redis.UniversalClient, qname string) []*base.TaskMessage {
+// If queue name option is not passed, it defaults to the default queue.
+func GetEnqueuedMessages(tb testing.TB, r *redis.Client, queueOpt ...string) []*base.TaskMessage {
 	tb.Helper()
-	return getMessagesFromList(tb, r, qname, base.PendingKey, base.TaskStatePending)
+	queue := base.DefaultQueue
+	if len(queueOpt) > 0 {
+		queue = base.QueueKey(queueOpt[0])
+	}
+	return getListMessages(tb, r, queue)
 }
 
-// GetActiveMessages returns all active messages in the given queue.
+// GetInProgressMessages returns all task messages in the in-progress queue.
-// It also asserts the state field of the task.
+func GetInProgressMessages(tb testing.TB, r *redis.Client) []*base.TaskMessage {
-func GetActiveMessages(tb testing.TB, r redis.UniversalClient, qname string) []*base.TaskMessage {
 	tb.Helper()
-	return getMessagesFromList(tb, r, qname, base.ActiveKey, base.TaskStateActive)
+	return getListMessages(tb, r, base.InProgressQueue)
 }
 
-// GetScheduledMessages returns all scheduled task messages in the given queue.
+// GetScheduledMessages returns all task messages in the scheduled queue.
-// It also asserts the state field of the task.
+func GetScheduledMessages(tb testing.TB, r *redis.Client) []*base.TaskMessage {
-func GetScheduledMessages(tb testing.TB, r redis.UniversalClient, qname string) []*base.TaskMessage {
 	tb.Helper()
-	return getMessagesFromZSet(tb, r, qname, base.ScheduledKey, base.TaskStateScheduled)
+	return getZSetMessages(tb, r, base.ScheduledQueue)
 }
 
-// GetRetryMessages returns all retry messages in the given queue.
+// GetRetryMessages returns all task messages in the retry queue.
-// It also asserts the state field of the task.
+func GetRetryMessages(tb testing.TB, r *redis.Client) []*base.TaskMessage {
-func GetRetryMessages(tb testing.TB, r redis.UniversalClient, qname string) []*base.TaskMessage {
 	tb.Helper()
-	return getMessagesFromZSet(tb, r, qname, base.RetryKey, base.TaskStateRetry)
+	return getZSetMessages(tb, r, base.RetryQueue)
 }
 
-// GetArchivedMessages returns all archived messages in the given queue.
+// GetDeadMessages returns all task messages in the dead queue.
-// It also asserts the state field of the task.
+func GetDeadMessages(tb testing.TB, r *redis.Client) []*base.TaskMessage {
-func GetArchivedMessages(tb testing.TB, r redis.UniversalClient, qname string) []*base.TaskMessage {
 	tb.Helper()
-	return getMessagesFromZSet(tb, r, qname, base.ArchivedKey, base.TaskStateArchived)
+	return getZSetMessages(tb, r, base.DeadQueue)
 }
 
-// GetCompletedMessages returns all completed task messages in the given queue.
+// GetScheduledEntries returns all task messages and its score in the scheduled queue.
-// It also asserts the state field of the task.
+func GetScheduledEntries(tb testing.TB, r *redis.Client) []ZSetEntry {
-func GetCompletedMessages(tb testing.TB, r redis.UniversalClient, qname string) []*base.TaskMessage {
 	tb.Helper()
-	return getMessagesFromZSet(tb, r, qname, base.CompletedKey, base.TaskStateCompleted)
+	return getZSetEntries(tb, r, base.ScheduledQueue)
 }
 
-// GetScheduledEntries returns all scheduled messages and its score in the given queue.
+// GetRetryEntries returns all task messages and its score in the retry queue.
-// It also asserts the state field of the task.
+func GetRetryEntries(tb testing.TB, r *redis.Client) []ZSetEntry {
-func GetScheduledEntries(tb testing.TB, r redis.UniversalClient, qname string) []base.Z {
 	tb.Helper()
-	return getMessagesFromZSetWithScores(tb, r, qname, base.ScheduledKey, base.TaskStateScheduled)
+	return getZSetEntries(tb, r, base.RetryQueue)
 }
 
-// GetRetryEntries returns all retry messages and its score in the given queue.
+// GetDeadEntries returns all task messages and its score in the dead queue.
-// It also asserts the state field of the task.
+func GetDeadEntries(tb testing.TB, r *redis.Client) []ZSetEntry {
-func GetRetryEntries(tb testing.TB, r redis.UniversalClient, qname string) []base.Z {
 	tb.Helper()
-	return getMessagesFromZSetWithScores(tb, r, qname, base.RetryKey, base.TaskStateRetry)
+	return getZSetEntries(tb, r, base.DeadQueue)
 }
 
-// GetArchivedEntries returns all archived messages and its score in the given queue.
+// GetDeadlinesEntries returns all task messages and its score in the deadlines set.
-// It also asserts the state field of the task.
+func GetDeadlinesEntries(tb testing.TB, r *redis.Client) []ZSetEntry {
-func GetArchivedEntries(tb testing.TB, r redis.UniversalClient, qname string) []base.Z {
 	tb.Helper()
-	return getMessagesFromZSetWithScores(tb, r, qname, base.ArchivedKey, base.TaskStateArchived)
+	return getZSetEntries(tb, r, base.KeyDeadlines)
 }
 
-// GetDeadlinesEntries returns all task messages and its score in the deadlines set for the given queue.
+func getListMessages(tb testing.TB, r *redis.Client, list string) []*base.TaskMessage {
-// It also asserts the state field of the task.
+	data := r.LRange(list, 0, -1).Val()
-func GetDeadlinesEntries(tb testing.TB, r redis.UniversalClient, qname string) []base.Z {
+	return MustUnmarshalSlice(tb, data)
-	tb.Helper()
-	return getMessagesFromZSetWithScores(tb, r, qname, base.DeadlinesKey, base.TaskStateActive)
 }
 
-// GetCompletedEntries returns all completed messages and its score in the given queue.
+func getZSetMessages(tb testing.TB, r *redis.Client, zset string) []*base.TaskMessage {
-// It also asserts the state field of the task.
+	data := r.ZRange(zset, 0, -1).Val()
-func GetCompletedEntries(tb testing.TB, r redis.UniversalClient, qname string) []base.Z {
+	return MustUnmarshalSlice(tb, data)
-	tb.Helper()
-	return getMessagesFromZSetWithScores(tb, r, qname, base.CompletedKey, base.TaskStateCompleted)
 }
 
-// Retrieves all messages stored under `keyFn(qname)` key in redis list.
+func getZSetEntries(tb testing.TB, r *redis.Client, zset string) []ZSetEntry {
-func getMessagesFromList(tb testing.TB, r redis.UniversalClient, qname string,
+	data := r.ZRangeWithScores(zset, 0, -1).Val()
-	keyFn func(qname string) string, state base.TaskState) []*base.TaskMessage {
+	var entries []ZSetEntry
-	tb.Helper()
+	for _, z := range data {
-	ids := r.LRange(context.Background(), keyFn(qname), 0, -1).Val()
+		entries = append(entries, ZSetEntry{
-	var msgs []*base.TaskMessage
+			Msg:   MustUnmarshal(tb, z.Member.(string)),
-	for _, id := range ids {
+			Score: z.Score,
-		taskKey := base.TaskKey(qname, id)
+		})
-		data := r.HGet(context.Background(), taskKey, "msg").Val()
-		msgs = append(msgs, MustUnmarshal(tb, data))
-		if gotState := r.HGet(context.Background(), taskKey, "state").Val(); gotState != state.String() {
-			tb.Errorf("task (id=%q) is in %q state, want %v", id, gotState, state)
 	}
-	}
+	return entries
-	return msgs
-}
-
-// Retrieves all messages stored under `keyFn(qname)` key in redis zset (sorted-set).
-func getMessagesFromZSet(tb testing.TB, r redis.UniversalClient, qname string,
-	keyFn func(qname string) string, state base.TaskState) []*base.TaskMessage {
-	tb.Helper()
-	ids := r.ZRange(context.Background(), keyFn(qname), 0, -1).Val()
-	var msgs []*base.TaskMessage
-	for _, id := range ids {
-		taskKey := base.TaskKey(qname, id)
-		msg := r.HGet(context.Background(), taskKey, "msg").Val()
-		msgs = append(msgs, MustUnmarshal(tb, msg))
-		if gotState := r.HGet(context.Background(), taskKey, "state").Val(); gotState != state.String() {
-			tb.Errorf("task (id=%q) is in %q state, want %v", id, gotState, state)
-		}
-	}
-	return msgs
-}
-
-// Retrieves all messages along with their scores stored under `keyFn(qname)` key in redis zset (sorted-set).
-func getMessagesFromZSetWithScores(tb testing.TB, r redis.UniversalClient,
-	qname string, keyFn func(qname string) string, state base.TaskState) []base.Z {
-	tb.Helper()
-	zs := r.ZRangeWithScores(context.Background(), keyFn(qname), 0, -1).Val()
-	var res []base.Z
-	for _, z := range zs {
-		taskID := z.Member.(string)
-		taskKey := base.TaskKey(qname, taskID)
-		msg := r.HGet(context.Background(), taskKey, "msg").Val()
-		res = append(res, base.Z{Message: MustUnmarshal(tb, msg), Score: int64(z.Score)})
-		if gotState := r.HGet(context.Background(), taskKey, "state").Val(); gotState != state.String() {
-			tb.Errorf("task (id=%q) is in %q state, want %v", taskID, gotState, state)
-		}
-	}
-	return res
 }

internal/base/base.go

@@ -7,196 +7,65 @@ package base
 
 import (
 	"context"
-	"crypto/md5"
+	"encoding/json"
-	"encoding/hex"
 	"fmt"
 	"strings"
 	"sync"
 	"time"
 
-	"github.com/go-redis/redis/v8"
+	"github.com/go-redis/redis/v7"
-	"github.com/golang/protobuf/ptypes"
+	"github.com/google/uuid"
-	"github.com/hibiken/asynq/internal/errors"
-	pb "github.com/hibiken/asynq/internal/proto"
-	"google.golang.org/protobuf/proto"
 )
 
 // Version of asynq library and CLI.
-const Version = "0.21.0"
+const Version = "0.10.0"
 
 // DefaultQueueName is the queue name used if none are specified by user.
 const DefaultQueueName = "default"
 
-// DefaultQueue is the redis key for the default queue.
+// Redis keys
-var DefaultQueue = PendingKey(DefaultQueueName)
-
-// Global Redis keys.
 const (
 	AllServers      = "asynq:servers"                // ZSET
+	serversPrefix   = "asynq:servers:"               // STRING - asynq:ps:<host>:<pid>:<serverid>
 	AllWorkers      = "asynq:workers"                // ZSET
-	AllSchedulers = "asynq:schedulers" // ZSET
+	workersPrefix   = "asynq:workers:"               // HASH   - asynq:workers:<host:<pid>:<serverid>
+	processedPrefix = "asynq:processed:"             // STRING - asynq:processed:<yyyy-mm-dd>
+	failurePrefix   = "asynq:failure:"               // STRING - asynq:failure:<yyyy-mm-dd>
+	QueuePrefix     = "asynq:queues:"                // LIST   - asynq:queues:<qname>
 	AllQueues       = "asynq:queues"                 // SET
+	DefaultQueue    = QueuePrefix + DefaultQueueName // LIST
+	ScheduledQueue  = "asynq:scheduled"              // ZSET
+	RetryQueue      = "asynq:retry"                  // ZSET
+	DeadQueue       = "asynq:dead"                   // ZSET
+	InProgressQueue = "asynq:in_progress"            // LIST
+	KeyDeadlines    = "asynq:deadlines"              // ZSET
+	PausedQueues    = "asynq:paused"                 // SET
 	CancelChannel   = "asynq:cancel"                 // PubSub channel
 )
 
-// TaskState denotes the state of a task.
+// QueueKey returns a redis key for the given queue name.
-type TaskState int
+func QueueKey(qname string) string {
-
+	return QueuePrefix + strings.ToLower(qname)
-const (
-	TaskStateActive TaskState = iota + 1
-	TaskStatePending
-	TaskStateScheduled
-	TaskStateRetry
-	TaskStateArchived
-	TaskStateCompleted
-)
-
-func (s TaskState) String() string {
-	switch s {
-	case TaskStateActive:
-		return "active"
-	case TaskStatePending:
-		return "pending"
-	case TaskStateScheduled:
-		return "scheduled"
-	case TaskStateRetry:
-		return "retry"
-	case TaskStateArchived:
-		return "archived"
-	case TaskStateCompleted:
-		return "completed"
-	}
-	panic(fmt.Sprintf("internal error: unknown task state %d", s))
 }
 
-func TaskStateFromString(s string) (TaskState, error) {
+// ProcessedKey returns a redis key for processed count for the given day.
-	switch s {
+func ProcessedKey(t time.Time) string {
-	case "active":
+	return processedPrefix + t.UTC().Format("2006-01-02")
-		return TaskStateActive, nil
-	case "pending":
-		return TaskStatePending, nil
-	case "scheduled":
-		return TaskStateScheduled, nil
-	case "retry":
-		return TaskStateRetry, nil
-	case "archived":
-		return TaskStateArchived, nil
-	case "completed":
-		return TaskStateCompleted, nil
-	}
-	return 0, errors.E(errors.FailedPrecondition, fmt.Sprintf("%q is not supported task state", s))
 }
 
-// ValidateQueueName validates a given qname to be used as a queue name.
+// FailureKey returns a redis key for failure count for the given day.
-// Returns nil if valid, otherwise returns non-nil error.
+func FailureKey(t time.Time) string {
-func ValidateQueueName(qname string) error {
+	return failurePrefix + t.UTC().Format("2006-01-02")
-	if len(strings.TrimSpace(qname)) == 0 {
-		return fmt.Errorf("queue name must contain one or more characters")
-	}
-	return nil
-}
-
-// QueueKeyPrefix returns a prefix for all keys in the given queue.
-func QueueKeyPrefix(qname string) string {
-	return fmt.Sprintf("asynq:{%s}:", qname)
-}
-
-// TaskKeyPrefix returns a prefix for task key.
-func TaskKeyPrefix(qname string) string {
-	return fmt.Sprintf("%st:", QueueKeyPrefix(qname))
-}
-
-// TaskKey returns a redis key for the given task message.
-func TaskKey(qname, id string) string {
-	return fmt.Sprintf("%s%s", TaskKeyPrefix(qname), id)
-}
-
-// PendingKey returns a redis key for the given queue name.
-func PendingKey(qname string) string {
-	return fmt.Sprintf("%spending", QueueKeyPrefix(qname))
-}
-
-// ActiveKey returns a redis key for the active tasks.
-func ActiveKey(qname string) string {
-	return fmt.Sprintf("%sactive", QueueKeyPrefix(qname))
-}
-
-// ScheduledKey returns a redis key for the scheduled tasks.
-func ScheduledKey(qname string) string {
-	return fmt.Sprintf("%sscheduled", QueueKeyPrefix(qname))
-}
-
-// RetryKey returns a redis key for the retry tasks.
-func RetryKey(qname string) string {
-	return fmt.Sprintf("%sretry", QueueKeyPrefix(qname))
-}
-
-// ArchivedKey returns a redis key for the archived tasks.
-func ArchivedKey(qname string) string {
-	return fmt.Sprintf("%sarchived", QueueKeyPrefix(qname))
-}
-
-// DeadlinesKey returns a redis key for the deadlines.
-func DeadlinesKey(qname string) string {
-	return fmt.Sprintf("%sdeadlines", QueueKeyPrefix(qname))
-}
-
-func CompletedKey(qname string) string {
-	return fmt.Sprintf("%scompleted", QueueKeyPrefix(qname))
-}
-
-// PausedKey returns a redis key to indicate that the given queue is paused.
-func PausedKey(qname string) string {
-	return fmt.Sprintf("%spaused", QueueKeyPrefix(qname))
-}
-
-// ProcessedTotalKey returns a redis key for total processed count for the given queue.
-func ProcessedTotalKey(qname string) string {
-	return fmt.Sprintf("%sprocessed", QueueKeyPrefix(qname))
-}
-
-// FailedTotalKey returns a redis key for total failure count for the given queue.
-func FailedTotalKey(qname string) string {
-	return fmt.Sprintf("%sfailed", QueueKeyPrefix(qname))
-}
-
-// ProcessedKey returns a redis key for processed count for the given day for the queue.
-func ProcessedKey(qname string, t time.Time) string {
-	return fmt.Sprintf("%sprocessed:%s", QueueKeyPrefix(qname), t.UTC().Format("2006-01-02"))
-}
-
-// FailedKey returns a redis key for failure count for the given day for the queue.
-func FailedKey(qname string, t time.Time) string {
-	return fmt.Sprintf("%sfailed:%s", QueueKeyPrefix(qname), t.UTC().Format("2006-01-02"))
 }
 
 // ServerInfoKey returns a redis key for process info.
-func ServerInfoKey(hostname string, pid int, serverID string) string {
+func ServerInfoKey(hostname string, pid int, sid string) string {
-	return fmt.Sprintf("asynq:servers:{%s:%d:%s}", hostname, pid, serverID)
+	return fmt.Sprintf("%s%s:%d:%s", serversPrefix, hostname, pid, sid)
 }
 
 // WorkersKey returns a redis key for the workers given hostname, pid, and server ID.
-func WorkersKey(hostname string, pid int, serverID string) string {
+func WorkersKey(hostname string, pid int, sid string) string {
-	return fmt.Sprintf("asynq:workers:{%s:%d:%s}", hostname, pid, serverID)
+	return fmt.Sprintf("%s%s:%d:%s", workersPrefix, hostname, pid, sid)
-}
-
-// SchedulerEntriesKey returns a redis key for the scheduler entries given scheduler ID.
-func SchedulerEntriesKey(schedulerID string) string {
-	return fmt.Sprintf("asynq:schedulers:{%s}", schedulerID)
-}
-
-// SchedulerHistoryKey returns a redis key for the scheduler's history for the given entry.
-func SchedulerHistoryKey(entryID string) string {
-	return fmt.Sprintf("asynq:scheduler_history:%s", entryID)
-}
-
-// UniqueKey returns a redis key with the given type, payload, and queue name.
-func UniqueKey(qname, tasktype string, payload []byte) string {
-	if payload == nil {
-		return fmt.Sprintf("%sunique:%s:", QueueKeyPrefix(qname), tasktype)
-	}
-	checksum := md5.Sum(payload)
-	return fmt.Sprintf("%sunique:%s:%s", QueueKeyPrefix(qname), tasktype, hex.EncodeToString(checksum[:]))
 }
 
 // TaskMessage is the internal representation of a task with additional metadata fields.
@@ -206,10 +75,10 @@ type TaskMessage struct {
 	Type string
 
 	// Payload holds data needed to process the task.
-	Payload []byte
+	Payload map[string]interface{}
 
 	// ID is a unique identifier for each task.
-	ID string
+	ID uuid.UUID
 
 	// Queue is a name this message should be enqueued to.
 	Queue string
@@ -223,15 +92,9 @@ type TaskMessage struct {
 	// ErrorMsg holds the error message from the last failure.
 	ErrorMsg string
 
-	// Time of last failure in Unix time,
-	// the number of seconds elapsed since January 1, 1970 UTC.
-	//
-	// Use zero to indicate no last failure
-	LastFailedAt int64
-
 	// Timeout specifies timeout in seconds.
 	// If task processing doesn't complete within the timeout, the task will be retried
-	// if retry count is remaining. Otherwise it will be moved to the archive.
+	// if retry count is remaining. Otherwise it will be moved to the dead queue.
 	//
 	// Use zero to indicate no timeout.
 	Timeout int64
@@ -239,7 +102,7 @@ type TaskMessage struct {
 	// Deadline specifies the deadline for the task in Unix time,
 	// the number of seconds elapsed since January 1, 1970 UTC.
 	// If task processing doesn't complete before the deadline, the task will be retried
-	// if retry count is remaining. Otherwise it will be moved to the archive.
+	// if retry count is remaining. Otherwise it will be moved to the dead queue.
 	//
 	// Use zero to indicate no deadline.
 	Deadline int64
@@ -248,74 +111,85 @@ type TaskMessage struct {
 	//
 	// Empty string indicates that no uniqueness lock was used.
 	UniqueKey string
-
-	// Retention specifies the number of seconds the task should be retained after completion.
-	Retention int64
-
-	// CompletedAt is the time the task was processed successfully in Unix time,
-	// the number of seconds elapsed since January 1, 1970 UTC.
-	//
-	// Use zero to indicate no value.
-	CompletedAt int64
 }
 
-// EncodeMessage marshals the given task message and returns an encoded bytes.
+// EncodeMessage marshals the given task message in JSON and returns an encoded string.
-func EncodeMessage(msg *TaskMessage) ([]byte, error) {
+func EncodeMessage(msg *TaskMessage) (string, error) {
-	if msg == nil {
+	b, err := json.Marshal(msg)
-		return nil, fmt.Errorf("cannot encode nil message")
+	if err != nil {
+		return "", err
 	}
-	return proto.Marshal(&pb.TaskMessage{
+	return string(b), nil
-		Type:         msg.Type,
-		Payload:      msg.Payload,
-		Id:           msg.ID,
-		Queue:        msg.Queue,
-		Retry:        int32(msg.Retry),
-		Retried:      int32(msg.Retried),
-		ErrorMsg:     msg.ErrorMsg,
-		LastFailedAt: msg.LastFailedAt,
-		Timeout:      msg.Timeout,
-		Deadline:     msg.Deadline,
-		UniqueKey:    msg.UniqueKey,
-		Retention:    msg.Retention,
-		CompletedAt:  msg.CompletedAt,
-	})
 }
 
-// DecodeMessage unmarshals the given bytes and returns a decoded task message.
+// DecodeMessage unmarshals the given encoded string and returns a decoded task message.
-func DecodeMessage(data []byte) (*TaskMessage, error) {
+func DecodeMessage(s string) (*TaskMessage, error) {
-	var pbmsg pb.TaskMessage
+	d := json.NewDecoder(strings.NewReader(s))
-	if err := proto.Unmarshal(data, &pbmsg); err != nil {
+	d.UseNumber()
+	var msg TaskMessage
+	if err := d.Decode(&msg); err != nil {
 		return nil, err
 	}
-	return &TaskMessage{
+	return &msg, nil
-		Type:         pbmsg.GetType(),
-		Payload:      pbmsg.GetPayload(),
-		ID:           pbmsg.GetId(),
-		Queue:        pbmsg.GetQueue(),
-		Retry:        int(pbmsg.GetRetry()),
-		Retried:      int(pbmsg.GetRetried()),
-		ErrorMsg:     pbmsg.GetErrorMsg(),
-		LastFailedAt: pbmsg.GetLastFailedAt(),
-		Timeout:      pbmsg.GetTimeout(),
-		Deadline:     pbmsg.GetDeadline(),
-		UniqueKey:    pbmsg.GetUniqueKey(),
-		Retention:    pbmsg.GetRetention(),
-		CompletedAt:  pbmsg.GetCompletedAt(),
-	}, nil
 }
 
-// TaskInfo describes a task message and its metadata.
+// ServerStatus represents status of a server.
-type TaskInfo struct {
+// ServerStatus methods are concurrency safe.
-	Message       *TaskMessage
+type ServerStatus struct {
-	State         TaskState
+	mu  sync.Mutex
-	NextProcessAt time.Time
+	val ServerStatusValue
-	Result        []byte
 }
 
-// Z represents sorted set member.
+// NewServerStatus returns a new status instance given an initial value.
-type Z struct {
+func NewServerStatus(v ServerStatusValue) *ServerStatus {
-	Message *TaskMessage
+	return &ServerStatus{val: v}
-	Score   int64
+}
+
+type ServerStatusValue int
+
+const (
+	// StatusIdle indicates the server is in idle state.
+	StatusIdle ServerStatusValue = iota
+
+	// StatusRunning indicates the servier is up and processing tasks.
+	StatusRunning
+
+	// StatusQuiet indicates the server is up but not processing new tasks.
+	StatusQuiet
+
+	// StatusStopped indicates the server server has been stopped.
+	StatusStopped
+)
+
+var statuses = []string{
+	"idle",
+	"running",
+	"quiet",
+	"stopped",
+}
+
+func (s *ServerStatus) String() string {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	if StatusIdle <= s.val && s.val <= StatusStopped {
+		return statuses[s.val]
+	}
+	return "unknown status"
+}
+
+// Get returns the status value.
+func (s *ServerStatus) Get() ServerStatusValue {
+	s.mu.Lock()
+	v := s.val
+	s.mu.Unlock()
+	return v
+}
+
+// Set sets the status value.
+func (s *ServerStatus) Set(v ServerStatusValue) {
+	s.mu.Lock()
+	s.val = v
+	s.mu.Unlock()
 }
 
 // ServerInfo holds information about a running server.
@@ -331,242 +205,18 @@ type ServerInfo struct {
 	ActiveWorkerCount int
 }
 
-// EncodeServerInfo marshals the given ServerInfo and returns the encoded bytes.
-func EncodeServerInfo(info *ServerInfo) ([]byte, error) {
-	if info == nil {
-		return nil, fmt.Errorf("cannot encode nil server info")
-	}
-	queues := make(map[string]int32)
-	for q, p := range info.Queues {
-		queues[q] = int32(p)
-	}
-	started, err := ptypes.TimestampProto(info.Started)
-	if err != nil {
-		return nil, err
-	}
-	return proto.Marshal(&pb.ServerInfo{
-		Host:              info.Host,
-		Pid:               int32(info.PID),
-		ServerId:          info.ServerID,
-		Concurrency:       int32(info.Concurrency),
-		Queues:            queues,
-		StrictPriority:    info.StrictPriority,
-		Status:            info.Status,
-		StartTime:         started,
-		ActiveWorkerCount: int32(info.ActiveWorkerCount),
-	})
-}
-
-// DecodeServerInfo decodes the given bytes into ServerInfo.
-func DecodeServerInfo(b []byte) (*ServerInfo, error) {
-	var pbmsg pb.ServerInfo
-	if err := proto.Unmarshal(b, &pbmsg); err != nil {
-		return nil, err
-	}
-	queues := make(map[string]int)
-	for q, p := range pbmsg.GetQueues() {
-		queues[q] = int(p)
-	}
-	startTime, err := ptypes.Timestamp(pbmsg.GetStartTime())
-	if err != nil {
-		return nil, err
-	}
-	return &ServerInfo{
-		Host:              pbmsg.GetHost(),
-		PID:               int(pbmsg.GetPid()),
-		ServerID:          pbmsg.GetServerId(),
-		Concurrency:       int(pbmsg.GetConcurrency()),
-		Queues:            queues,
-		StrictPriority:    pbmsg.GetStrictPriority(),
-		Status:            pbmsg.GetStatus(),
-		Started:           startTime,
-		ActiveWorkerCount: int(pbmsg.GetActiveWorkerCount()),
-	}, nil
-}
-
 // WorkerInfo holds information about a running worker.
 type WorkerInfo struct {
 	Host    string
 	PID     int
-	ServerID string
 	ID      string
 	Type    string
-	Payload  []byte
 	Queue   string
+	Payload map[string]interface{}
 	Started time.Time
-	Deadline time.Time
 }
 
-// EncodeWorkerInfo marshals the given WorkerInfo and returns the encoded bytes.
+// Cancelations is a collection that holds cancel functions for all in-progress tasks.
-func EncodeWorkerInfo(info *WorkerInfo) ([]byte, error) {
-	if info == nil {
-		return nil, fmt.Errorf("cannot encode nil worker info")
-	}
-	startTime, err := ptypes.TimestampProto(info.Started)
-	if err != nil {
-		return nil, err
-	}
-	deadline, err := ptypes.TimestampProto(info.Deadline)
-	if err != nil {
-		return nil, err
-	}
-	return proto.Marshal(&pb.WorkerInfo{
-		Host:        info.Host,
-		Pid:         int32(info.PID),
-		ServerId:    info.ServerID,
-		TaskId:      info.ID,
-		TaskType:    info.Type,
-		TaskPayload: info.Payload,
-		Queue:       info.Queue,
-		StartTime:   startTime,
-		Deadline:    deadline,
-	})
-}
-
-// DecodeWorkerInfo decodes the given bytes into WorkerInfo.
-func DecodeWorkerInfo(b []byte) (*WorkerInfo, error) {
-	var pbmsg pb.WorkerInfo
-	if err := proto.Unmarshal(b, &pbmsg); err != nil {
-		return nil, err
-	}
-	startTime, err := ptypes.Timestamp(pbmsg.GetStartTime())
-	if err != nil {
-		return nil, err
-	}
-	deadline, err := ptypes.Timestamp(pbmsg.GetDeadline())
-	if err != nil {
-		return nil, err
-	}
-	return &WorkerInfo{
-		Host:     pbmsg.GetHost(),
-		PID:      int(pbmsg.GetPid()),
-		ServerID: pbmsg.GetServerId(),
-		ID:       pbmsg.GetTaskId(),
-		Type:     pbmsg.GetTaskType(),
-		Payload:  pbmsg.GetTaskPayload(),
-		Queue:    pbmsg.GetQueue(),
-		Started:  startTime,
-		Deadline: deadline,
-	}, nil
-}
-
-// SchedulerEntry holds information about a periodic task registered with a scheduler.
-type SchedulerEntry struct {
-	// Identifier of this entry.
-	ID string
-
-	// Spec describes the schedule of this entry.
-	Spec string
-
-	// Type is the task type of the periodic task.
-	Type string
-
-	// Payload is the payload of the periodic task.
-	Payload []byte
-
-	// Opts is the options for the periodic task.
-	Opts []string
-
-	// Next shows the next time the task will be enqueued.
-	Next time.Time
-
-	// Prev shows the last time the task was enqueued.
-	// Zero time if task was never enqueued.
-	Prev time.Time
-}
-
-// EncodeSchedulerEntry marshals the given entry and returns an encoded bytes.
-func EncodeSchedulerEntry(entry *SchedulerEntry) ([]byte, error) {
-	if entry == nil {
-		return nil, fmt.Errorf("cannot encode nil scheduler entry")
-	}
-	next, err := ptypes.TimestampProto(entry.Next)
-	if err != nil {
-		return nil, err
-	}
-	prev, err := ptypes.TimestampProto(entry.Prev)
-	if err != nil {
-		return nil, err
-	}
-	return proto.Marshal(&pb.SchedulerEntry{
-		Id:              entry.ID,
-		Spec:            entry.Spec,
-		TaskType:        entry.Type,
-		TaskPayload:     entry.Payload,
-		EnqueueOptions:  entry.Opts,
-		NextEnqueueTime: next,
-		PrevEnqueueTime: prev,
-	})
-}
-
-// DecodeSchedulerEntry unmarshals the given bytes and returns a decoded SchedulerEntry.
-func DecodeSchedulerEntry(b []byte) (*SchedulerEntry, error) {
-	var pbmsg pb.SchedulerEntry
-	if err := proto.Unmarshal(b, &pbmsg); err != nil {
-		return nil, err
-	}
-	next, err := ptypes.Timestamp(pbmsg.GetNextEnqueueTime())
-	if err != nil {
-		return nil, err
-	}
-	prev, err := ptypes.Timestamp(pbmsg.GetPrevEnqueueTime())
-	if err != nil {
-		return nil, err
-	}
-	return &SchedulerEntry{
-		ID:      pbmsg.GetId(),
-		Spec:    pbmsg.GetSpec(),
-		Type:    pbmsg.GetTaskType(),
-		Payload: pbmsg.GetTaskPayload(),
-		Opts:    pbmsg.GetEnqueueOptions(),
-		Next:    next,
-		Prev:    prev,
-	}, nil
-}
-
-// SchedulerEnqueueEvent holds information about an enqueue event by a scheduler.
-type SchedulerEnqueueEvent struct {
-	// ID of the task that was enqueued.
-	TaskID string
-
-	// Time the task was enqueued.
-	EnqueuedAt time.Time
-}
-
-// EncodeSchedulerEnqueueEvent marshals the given event
-// and returns an encoded bytes.
-func EncodeSchedulerEnqueueEvent(event *SchedulerEnqueueEvent) ([]byte, error) {
-	if event == nil {
-		return nil, fmt.Errorf("cannot encode nil enqueue event")
-	}
-	enqueuedAt, err := ptypes.TimestampProto(event.EnqueuedAt)
-	if err != nil {
-		return nil, err
-	}
-	return proto.Marshal(&pb.SchedulerEnqueueEvent{
-		TaskId:      event.TaskID,
-		EnqueueTime: enqueuedAt,
-	})
-}
-
-// DecodeSchedulerEnqueueEvent unmarshals the given bytes
-// and returns a decoded SchedulerEnqueueEvent.
-func DecodeSchedulerEnqueueEvent(b []byte) (*SchedulerEnqueueEvent, error) {
-	var pbmsg pb.SchedulerEnqueueEvent
-	if err := proto.Unmarshal(b, &pbmsg); err != nil {
-		return nil, err
-	}
-	enqueuedAt, err := ptypes.Timestamp(pbmsg.GetEnqueueTime())
-	if err != nil {
-		return nil, err
-	}
-	return &SchedulerEnqueueEvent{
-		TaskID:     pbmsg.GetTaskId(),
-		EnqueuedAt: enqueuedAt,
-	}, nil
-}
-
-// Cancelations is a collection that holds cancel functions for all active tasks.
 //
 // Cancelations are safe for concurrent use by multipel goroutines.
 type Cancelations struct {
@@ -607,24 +257,20 @@ func (c *Cancelations) Get(id string) (fn context.CancelFunc, ok bool) {
 //
 // See rdb.RDB as a reference implementation.
 type Broker interface {
-	Ping() error
+	Enqueue(msg *TaskMessage) error
-	Enqueue(ctx context.Context, msg *TaskMessage) error
+	EnqueueUnique(msg *TaskMessage, ttl time.Duration) error
-	EnqueueUnique(ctx context.Context, msg *TaskMessage, ttl time.Duration) error
 	Dequeue(qnames ...string) (*TaskMessage, time.Time, error)
 	Done(msg *TaskMessage) error
-	MarkAsComplete(msg *TaskMessage) error
 	Requeue(msg *TaskMessage) error
-	Schedule(ctx context.Context, msg *TaskMessage, processAt time.Time) error
+	Schedule(msg *TaskMessage, processAt time.Time) error
-	ScheduleUnique(ctx context.Context, msg *TaskMessage, processAt time.Time, ttl time.Duration) error
+	ScheduleUnique(msg *TaskMessage, processAt time.Time, ttl time.Duration) error
-	Retry(msg *TaskMessage, processAt time.Time, errMsg string, isFailure bool) error
+	Retry(msg *TaskMessage, processAt time.Time, errMsg string) error
-	Archive(msg *TaskMessage, errMsg string) error
+	Kill(msg *TaskMessage, errMsg string) error
-	ForwardIfReady(qnames ...string) error
+	CheckAndEnqueue() error
-	DeleteExpiredCompletedTasks(qname string) error
+	ListDeadlineExceeded(deadline time.Time) ([]*TaskMessage, error)
-	ListDeadlineExceeded(deadline time.Time, qnames ...string) ([]*TaskMessage, error)
 	WriteServerState(info *ServerInfo, workers []*WorkerInfo, ttl time.Duration) error
 	ClearServerState(host string, pid int, serverID string) error
 	CancelationPubSub() (*redis.PubSub, error) // TODO: Need to decouple from redis to support other brokers
 	PublishCancelation(id string) error
-	WriteResult(qname, id string, data []byte) (n int, err error)
 	Close() error
 }

internal/base/base_test.go

@@ -6,10 +6,7 @@ package base
 
 import (
 	"context"
-	"crypto/md5"
-	"encoding/hex"
 	"encoding/json"
-	"fmt"
 	"sync"
 	"testing"
 	"time"
@@ -18,227 +15,52 @@ import (
 	"github.com/google/uuid"
 )
 
-func TestTaskKey(t *testing.T) {
-	id := uuid.NewString()
-
-	tests := []struct {
-		qname string
-		id    string
-		want  string
-	}{
-		{"default", id, fmt.Sprintf("asynq:{default}:t:%s", id)},
-	}
-
-	for _, tc := range tests {
-		got := TaskKey(tc.qname, tc.id)
-		if got != tc.want {
-			t.Errorf("TaskKey(%q, %s) = %q, want %q", tc.qname, tc.id, got, tc.want)
-		}
-	}
-}
-
 func TestQueueKey(t *testing.T) {
 	tests := []struct {
 		qname string
 		want  string
 	}{
-		{"default", "asynq:{default}:pending"},
+		{"custom", "asynq:queues:custom"},
-		{"custom", "asynq:{custom}:pending"},
 	}
 
 	for _, tc := range tests {
-		got := PendingKey(tc.qname)
+		got := QueueKey(tc.qname)
 		if got != tc.want {
 			t.Errorf("QueueKey(%q) = %q, want %q", tc.qname, got, tc.want)
 		}
 	}
 }
 
-func TestActiveKey(t *testing.T) {
-	tests := []struct {
-		qname string
-		want  string
-	}{
-		{"default", "asynq:{default}:active"},
-		{"custom", "asynq:{custom}:active"},
-	}
-
-	for _, tc := range tests {
-		got := ActiveKey(tc.qname)
-		if got != tc.want {
-			t.Errorf("ActiveKey(%q) = %q, want %q", tc.qname, got, tc.want)
-		}
-	}
-}
-
-func TestDeadlinesKey(t *testing.T) {
-	tests := []struct {
-		qname string
-		want  string
-	}{
-		{"default", "asynq:{default}:deadlines"},
-		{"custom", "asynq:{custom}:deadlines"},
-	}
-
-	for _, tc := range tests {
-		got := DeadlinesKey(tc.qname)
-		if got != tc.want {
-			t.Errorf("DeadlinesKey(%q) = %q, want %q", tc.qname, got, tc.want)
-		}
-	}
-}
-
-func TestScheduledKey(t *testing.T) {
-	tests := []struct {
-		qname string
-		want  string
-	}{
-		{"default", "asynq:{default}:scheduled"},
-		{"custom", "asynq:{custom}:scheduled"},
-	}
-
-	for _, tc := range tests {
-		got := ScheduledKey(tc.qname)
-		if got != tc.want {
-			t.Errorf("ScheduledKey(%q) = %q, want %q", tc.qname, got, tc.want)
-		}
-	}
-}
-
-func TestRetryKey(t *testing.T) {
-	tests := []struct {
-		qname string
-		want  string
-	}{
-		{"default", "asynq:{default}:retry"},
-		{"custom", "asynq:{custom}:retry"},
-	}
-
-	for _, tc := range tests {
-		got := RetryKey(tc.qname)
-		if got != tc.want {
-			t.Errorf("RetryKey(%q) = %q, want %q", tc.qname, got, tc.want)
-		}
-	}
-}
-
-func TestArchivedKey(t *testing.T) {
-	tests := []struct {
-		qname string
-		want  string
-	}{
-		{"default", "asynq:{default}:archived"},
-		{"custom", "asynq:{custom}:archived"},
-	}
-
-	for _, tc := range tests {
-		got := ArchivedKey(tc.qname)
-		if got != tc.want {
-			t.Errorf("ArchivedKey(%q) = %q, want %q", tc.qname, got, tc.want)
-		}
-	}
-}
-
-func TestCompletedKey(t *testing.T) {
-	tests := []struct {
-		qname string
-		want  string
-	}{
-		{"default", "asynq:{default}:completed"},
-		{"custom", "asynq:{custom}:completed"},
-	}
-
-	for _, tc := range tests {
-		got := CompletedKey(tc.qname)
-		if got != tc.want {
-			t.Errorf("CompletedKey(%q) = %q, want %q", tc.qname, got, tc.want)
-		}
-	}
-}
-
-func TestPausedKey(t *testing.T) {
-	tests := []struct {
-		qname string
-		want  string
-	}{
-		{"default", "asynq:{default}:paused"},
-		{"custom", "asynq:{custom}:paused"},
-	}
-
-	for _, tc := range tests {
-		got := PausedKey(tc.qname)
-		if got != tc.want {
-			t.Errorf("PausedKey(%q) = %q, want %q", tc.qname, got, tc.want)
-		}
-	}
-}
-
-func TestProcessedTotalKey(t *testing.T) {
-	tests := []struct {
-		qname string
-		want  string
-	}{
-		{"default", "asynq:{default}:processed"},
-		{"custom", "asynq:{custom}:processed"},
-	}
-
-	for _, tc := range tests {
-		got := ProcessedTotalKey(tc.qname)
-		if got != tc.want {
-			t.Errorf("ProcessedTotalKey(%q) = %q, want %q", tc.qname, got, tc.want)
-		}
-	}
-}
-
-func TestFailedTotalKey(t *testing.T) {
-	tests := []struct {
-		qname string
-		want  string
-	}{
-		{"default", "asynq:{default}:failed"},
-		{"custom", "asynq:{custom}:failed"},
-	}
-
-	for _, tc := range tests {
-		got := FailedTotalKey(tc.qname)
-		if got != tc.want {
-			t.Errorf("FailedTotalKey(%q) = %q, want %q", tc.qname, got, tc.want)
-		}
-	}
-}
-
 func TestProcessedKey(t *testing.T) {
 	tests := []struct {
-		qname string
 		input time.Time
 		want  string
 	}{
-		{"default", time.Date(2019, 11, 14, 10, 30, 1, 1, time.UTC), "asynq:{default}:processed:2019-11-14"},
+		{time.Date(2019, 11, 14, 10, 30, 1, 1, time.UTC), "asynq:processed:2019-11-14"},
-		{"critical", time.Date(2020, 12, 1, 1, 0, 1, 1, time.UTC), "asynq:{critical}:processed:2020-12-01"},
+		{time.Date(2020, 12, 1, 1, 0, 1, 1, time.UTC), "asynq:processed:2020-12-01"},
-		{"default", time.Date(2020, 1, 6, 15, 02, 1, 1, time.UTC), "asynq:{default}:processed:2020-01-06"},
+		{time.Date(2020, 1, 6, 15, 02, 1, 1, time.UTC), "asynq:processed:2020-01-06"},
 	}
 
 	for _, tc := range tests {
-		got := ProcessedKey(tc.qname, tc.input)
+		got := ProcessedKey(tc.input)
 		if got != tc.want {
 			t.Errorf("ProcessedKey(%v) = %q, want %q", tc.input, got, tc.want)
 		}
 	}
 }
 
-func TestFailedKey(t *testing.T) {
+func TestFailureKey(t *testing.T) {
 	tests := []struct {
-		qname string
 		input time.Time
 		want  string
 	}{
-		{"default", time.Date(2019, 11, 14, 10, 30, 1, 1, time.UTC), "asynq:{default}:failed:2019-11-14"},
+		{time.Date(2019, 11, 14, 10, 30, 1, 1, time.UTC), "asynq:failure:2019-11-14"},
-		{"custom", time.Date(2020, 12, 1, 1, 0, 1, 1, time.UTC), "asynq:{custom}:failed:2020-12-01"},
+		{time.Date(2020, 12, 1, 1, 0, 1, 1, time.UTC), "asynq:failure:2020-12-01"},
-		{"low", time.Date(2020, 1, 6, 15, 02, 1, 1, time.UTC), "asynq:{low}:failed:2020-01-06"},
+		{time.Date(2020, 1, 6, 15, 02, 1, 1, time.UTC), "asynq:failure:2020-01-06"},
 	}
 
 	for _, tc := range tests {
-		got := FailedKey(tc.qname, tc.input)
+		got := FailureKey(tc.input)
 		if got != tc.want {
 			t.Errorf("FailureKey(%v) = %q, want %q", tc.input, got, tc.want)
 		}
@@ -252,8 +74,8 @@ func TestServerInfoKey(t *testing.T) {
 		sid      string
 		want     string
 	}{
-		{"localhost", 9876, "server123", "asynq:servers:{localhost:9876:server123}"},
+		{"localhost", 9876, "server123", "asynq:servers:localhost:9876:server123"},
-		{"127.0.0.1", 1234, "server987", "asynq:servers:{127.0.0.1:1234:server987}"},
+		{"127.0.0.1", 1234, "server987", "asynq:servers:127.0.0.1:1234:server987"},
 	}
 
 	for _, tc := range tests {
@@ -272,8 +94,8 @@ func TestWorkersKey(t *testing.T) {
 		sid      string
 		want     string
 	}{
-		{"localhost", 9876, "server1", "asynq:workers:{localhost:9876:server1}"},
+		{"localhost", 9876, "server1", "asynq:workers:localhost:9876:server1"},
-		{"127.0.0.1", 1234, "server2", "asynq:workers:{127.0.0.1:1234:server2}"},
+		{"127.0.0.1", 1234, "server2", "asynq:workers:127.0.0.1:1234:server2"},
 	}
 
 	for _, tc := range tests {
@@ -285,117 +107,8 @@ func TestWorkersKey(t *testing.T) {
 	}
 }
 
-func TestSchedulerEntriesKey(t *testing.T) {
-	tests := []struct {
-		schedulerID string
-		want        string
-	}{
-		{"localhost:9876:scheduler123", "asynq:schedulers:{localhost:9876:scheduler123}"},
-		{"127.0.0.1:1234:scheduler987", "asynq:schedulers:{127.0.0.1:1234:scheduler987}"},
-	}
-
-	for _, tc := range tests {
-		got := SchedulerEntriesKey(tc.schedulerID)
-		if got != tc.want {
-			t.Errorf("SchedulerEntriesKey(%q) = %q, want %q", tc.schedulerID, got, tc.want)
-		}
-	}
-}
-
-func TestSchedulerHistoryKey(t *testing.T) {
-	tests := []struct {
-		entryID string
-		want    string
-	}{
-		{"entry876", "asynq:scheduler_history:entry876"},
-		{"entry345", "asynq:scheduler_history:entry345"},
-	}
-
-	for _, tc := range tests {
-		got := SchedulerHistoryKey(tc.entryID)
-		if got != tc.want {
-			t.Errorf("SchedulerHistoryKey(%q) = %q, want %q",
-				tc.entryID, got, tc.want)
-		}
-	}
-}
-
-func toBytes(m map[string]interface{}) []byte {
-	b, err := json.Marshal(m)
-	if err != nil {
-		panic(err)
-	}
-	return b
-}
-
-func TestUniqueKey(t *testing.T) {
-	payload1 := toBytes(map[string]interface{}{"a": 123, "b": "hello", "c": true})
-	payload2 := toBytes(map[string]interface{}{"b": "hello", "c": true, "a": 123})
-	payload3 := toBytes(map[string]interface{}{
-		"address": map[string]string{"line": "123 Main St", "city": "Boston", "state": "MA"},
-		"names":   []string{"bob", "mike", "rob"}})
-	payload4 := toBytes(map[string]interface{}{
-		"time":     time.Date(2020, time.July, 28, 0, 0, 0, 0, time.UTC),
-		"duration": time.Hour})
-
-	checksum := func(data []byte) string {
-		sum := md5.Sum(data)
-		return hex.EncodeToString(sum[:])
-	}
-	tests := []struct {
-		desc     string
-		qname    string
-		tasktype string
-		payload  []byte
-		want     string
-	}{
-		{
-			"with primitive types",
-			"default",
-			"email:send",
-			payload1,
-			fmt.Sprintf("asynq:{default}:unique:email:send:%s", checksum(payload1)),
-		},
-		{
-			"with unsorted keys",
-			"default",
-			"email:send",
-			payload2,
-			fmt.Sprintf("asynq:{default}:unique:email:send:%s", checksum(payload2)),
-		},
-		{
-			"with composite types",
-			"default",
-			"email:send",
-			payload3,
-			fmt.Sprintf("asynq:{default}:unique:email:send:%s", checksum(payload3)),
-		},
-		{
-			"with complex types",
-			"default",
-			"email:send",
-			payload4,
-			fmt.Sprintf("asynq:{default}:unique:email:send:%s", checksum(payload4)),
-		},
-		{
-			"with nil payload",
-			"default",
-			"reindex",
-			nil,
-			"asynq:{default}:unique:reindex:",
-		},
-	}
-
-	for _, tc := range tests {
-		got := UniqueKey(tc.qname, tc.tasktype, tc.payload)
-		if got != tc.want {
-			t.Errorf("%s: UniqueKey(%q, %q, %v) = %q, want %q", tc.desc, tc.qname, tc.tasktype, tc.payload, got, tc.want)
-		}
-	}
-}
-
 func TestMessageEncoding(t *testing.T) {
-	id := uuid.NewString()
+	id := uuid.New()
 	tests := []struct {
 		in  *TaskMessage
 		out *TaskMessage
@@ -403,25 +116,23 @@ func TestMessageEncoding(t *testing.T) {
 		{
 			in: &TaskMessage{
 				Type:     "task1",
-				Payload:   toBytes(map[string]interface{}{"a": 1, "b": "hello!", "c": true}),
+				Payload:  map[string]interface{}{"a": 1, "b": "hello!", "c": true},
 				ID:       id,
 				Queue:    "default",
 				Retry:    10,
 				Retried:  0,
 				Timeout:  1800,
 				Deadline: 1692311100,
-				Retention: 3600,
 			},
 			out: &TaskMessage{
 				Type:     "task1",
-				Payload:   toBytes(map[string]interface{}{"a": json.Number("1"), "b": "hello!", "c": true}),
+				Payload:  map[string]interface{}{"a": json.Number("1"), "b": "hello!", "c": true},
 				ID:       id,
 				Queue:    "default",
 				Retry:    10,
 				Retried:  0,
 				Timeout:  1800,
 				Deadline: 1692311100,
-				Retention: 3600,
 			},
 		},
 	}
@@ -444,143 +155,28 @@ func TestMessageEncoding(t *testing.T) {
 	}
 }
 
-func TestServerInfoEncoding(t *testing.T) {
+// Test for status being accessed by multiple goroutines.
-	tests := []struct {
+// Run with -race flag to check for data race.
-		info ServerInfo
+func TestStatusConcurrentAccess(t *testing.T) {
-	}{
+	status := NewServerStatus(StatusIdle)
-		{
-			info: ServerInfo{
-				Host:              "127.0.0.1",
-				PID:               9876,
-				ServerID:          "abc123",
-				Concurrency:       10,
-				Queues:            map[string]int{"default": 1, "critical": 2},
-				StrictPriority:    false,
-				Status:            "active",
-				Started:           time.Now().Add(-3 * time.Hour),
-				ActiveWorkerCount: 8,
-			},
-		},
-	}
 
-	for _, tc := range tests {
+	var wg sync.WaitGroup
-		encoded, err := EncodeServerInfo(&tc.info)
-		if err != nil {
-			t.Errorf("EncodeServerInfo(info) returned error: %v", err)
-			continue
-		}
-		decoded, err := DecodeServerInfo(encoded)
-		if err != nil {
-			t.Errorf("DecodeServerInfo(encoded) returned error: %v", err)
-			continue
-		}
-		if diff := cmp.Diff(&tc.info, decoded); diff != "" {
-			t.Errorf("Decoded ServerInfo == %+v, want %+v;(-want,+got)\n%s",
-				decoded, tc.info, diff)
-		}
-	}
-}
 
-func TestWorkerInfoEncoding(t *testing.T) {
+	wg.Add(1)
-	tests := []struct {
+	go func() {
-		info WorkerInfo
+		defer wg.Done()
-	}{
+		status.Get()
-		{
+		status.String()
-			info: WorkerInfo{
+	}()
-				Host:     "127.0.0.1",
-				PID:      9876,
-				ServerID: "abc123",
-				ID:       uuid.NewString(),
-				Type:     "taskA",
-				Payload:  toBytes(map[string]interface{}{"foo": "bar"}),
-				Queue:    "default",
-				Started:  time.Now().Add(-3 * time.Hour),
-				Deadline: time.Now().Add(30 * time.Second),
-			},
-		},
-	}
 
-	for _, tc := range tests {
+	wg.Add(1)
-		encoded, err := EncodeWorkerInfo(&tc.info)
+	go func() {
-		if err != nil {
+		defer wg.Done()
-			t.Errorf("EncodeWorkerInfo(info) returned error: %v", err)
+		status.Set(StatusStopped)
-			continue
+		status.String()
-		}
+	}()
-		decoded, err := DecodeWorkerInfo(encoded)
-		if err != nil {
-			t.Errorf("DecodeWorkerInfo(encoded) returned error: %v", err)
-			continue
-		}
-		if diff := cmp.Diff(&tc.info, decoded); diff != "" {
-			t.Errorf("Decoded WorkerInfo == %+v, want %+v;(-want,+got)\n%s",
-				decoded, tc.info, diff)
-		}
-	}
-}
 
-func TestSchedulerEntryEncoding(t *testing.T) {
+	wg.Wait()
-	tests := []struct {
-		entry SchedulerEntry
-	}{
-		{
-			entry: SchedulerEntry{
-				ID:      uuid.NewString(),
-				Spec:    "* * * * *",
-				Type:    "task_A",
-				Payload: toBytes(map[string]interface{}{"foo": "bar"}),
-				Opts:    []string{"Queue('email')"},
-				Next:    time.Now().Add(30 * time.Second).UTC(),
-				Prev:    time.Now().Add(-2 * time.Minute).UTC(),
-			},
-		},
-	}
-
-	for _, tc := range tests {
-		encoded, err := EncodeSchedulerEntry(&tc.entry)
-		if err != nil {
-			t.Errorf("EncodeSchedulerEntry(entry) returned error: %v", err)
-			continue
-		}
-		decoded, err := DecodeSchedulerEntry(encoded)
-		if err != nil {
-			t.Errorf("DecodeSchedulerEntry(encoded) returned error: %v", err)
-			continue
-		}
-		if diff := cmp.Diff(&tc.entry, decoded); diff != "" {
-			t.Errorf("Decoded SchedulerEntry == %+v, want %+v;(-want,+got)\n%s",
-				decoded, tc.entry, diff)
-		}
-	}
-}
-
-func TestSchedulerEnqueueEventEncoding(t *testing.T) {
-	tests := []struct {
-		event SchedulerEnqueueEvent
-	}{
-		{
-			event: SchedulerEnqueueEvent{
-				TaskID:     uuid.NewString(),
-				EnqueuedAt: time.Now().Add(-30 * time.Second).UTC(),
-			},
-		},
-	}
-
-	for _, tc := range tests {
-		encoded, err := EncodeSchedulerEnqueueEvent(&tc.event)
-		if err != nil {
-			t.Errorf("EncodeSchedulerEnqueueEvent(event) returned error: %v", err)
-			continue
-		}
-		decoded, err := DecodeSchedulerEnqueueEvent(encoded)
-		if err != nil {
-			t.Errorf("DecodeSchedulerEnqueueEvent(encoded) returned error: %v", err)
-			continue
-		}
-		if diff := cmp.Diff(&tc.event, decoded); diff != "" {
-			t.Errorf("Decoded SchedulerEnqueueEvent == %+v, want %+v;(-want,+got)\n%s",
-				decoded, tc.event, diff)
-		}
-	}
 }
 
 // Test for cancelations being accessed by multiple goroutines.

internal/context/context.go

@@ -1,87 +0,0 @@
-// Copyright 2020 Kentaro Hibino. All rights reserved.
-// Use of this source code is governed by a MIT license
-// that can be found in the LICENSE file.
-
-package context
-
-import (
-	"context"
-	"time"
-
-	"github.com/hibiken/asynq/internal/base"
-)
-
-// A taskMetadata holds task scoped data to put in context.
-type taskMetadata struct {
-	id         string
-	maxRetry   int
-	retryCount int
-	qname      string
-}
-
-// ctxKey type is unexported to prevent collisions with context keys defined in
-// other packages.
-type ctxKey int
-
-// metadataCtxKey is the context key for the task metadata.
-// Its value of zero is arbitrary.
-const metadataCtxKey ctxKey = 0
-
-// New returns a context and cancel function for a given task message.
-func New(msg *base.TaskMessage, deadline time.Time) (context.Context, context.CancelFunc) {
-	metadata := taskMetadata{
-		id:         msg.ID,
-		maxRetry:   msg.Retry,
-		retryCount: msg.Retried,
-		qname:      msg.Queue,
-	}
-	ctx := context.WithValue(context.Background(), metadataCtxKey, metadata)
-	return context.WithDeadline(ctx, deadline)
-}
-
-// GetTaskID extracts a task ID from a context, if any.
-//
-// ID of a task is guaranteed to be unique.
-// ID of a task doesn't change if the task is being retried.
-func GetTaskID(ctx context.Context) (id string, ok bool) {
-	metadata, ok := ctx.Value(metadataCtxKey).(taskMetadata)
-	if !ok {
-		return "", false
-	}
-	return metadata.id, true
-}
-
-// GetRetryCount extracts retry count from a context, if any.
-//
-// Return value n indicates the number of times associated task has been
-// retried so far.
-func GetRetryCount(ctx context.Context) (n int, ok bool) {
-	metadata, ok := ctx.Value(metadataCtxKey).(taskMetadata)
-	if !ok {
-		return 0, false
-	}
-	return metadata.retryCount, true
-}
-
-// GetMaxRetry extracts maximum retry from a context, if any.
-//
-// Return value n indicates the maximum number of times the assoicated task
-// can be retried if ProcessTask returns a non-nil error.
-func GetMaxRetry(ctx context.Context) (n int, ok bool) {
-	metadata, ok := ctx.Value(metadataCtxKey).(taskMetadata)
-	if !ok {
-		return 0, false
-	}
-	return metadata.maxRetry, true
-}
-
-// GetQueueName extracts queue name from a context, if any.
-//
-// Return value qname indicates which queue the task was pulled from.
-func GetQueueName(ctx context.Context) (qname string, ok bool) {
-	metadata, ok := ctx.Value(metadataCtxKey).(taskMetadata)
-	if !ok {
-		return "", false
-	}
-	return metadata.qname, true
-}

internal/errors/errors.go

@@ -1,288 +0,0 @@
-// Copyright 2020 Kentaro Hibino. All rights reserved.
-// Use of this source code is governed by a MIT license
-// that can be found in the LICENSE file.
-
-// Package errors defines the error type and functions used by
-// asynq and its internal packages.
-package errors
-
-// Note: This package is inspired by a blog post about error handling in project Upspin
-// https://commandcenter.blogspot.com/2017/12/error-handling-in-upspin.html.
-
-import (
-	"errors"
-	"fmt"
-	"log"
-	"runtime"
-	"strings"
-)
-
-// Error is the type that implements the error interface.
-// It contains a number of fields, each of different type.
-// An Error value may leave some values unset.
-type Error struct {
-	Code Code
-	Op   Op
-	Err  error
-}
-
-func (e *Error) DebugString() string {
-	var b strings.Builder
-	if e.Op != "" {
-		b.WriteString(string(e.Op))
-	}
-	if e.Code != Unspecified {
-		if b.Len() > 0 {
-			b.WriteString(": ")
-		}
-		b.WriteString(e.Code.String())
-	}
-	if e.Err != nil {
-		if b.Len() > 0 {
-			b.WriteString(": ")
-		}
-		b.WriteString(e.Err.Error())
-	}
-	return b.String()
-}
-
-func (e *Error) Error() string {
-	var b strings.Builder
-	if e.Code != Unspecified {
-		b.WriteString(e.Code.String())
-	}
-	if e.Err != nil {
-		if b.Len() > 0 {
-			b.WriteString(": ")
-		}
-		b.WriteString(e.Err.Error())
-	}
-	return b.String()
-}
-
-func (e *Error) Unwrap() error {
-	return e.Err
-}
-
-// Code defines the canonical error code.
-type Code uint8
-
-// List of canonical error codes.
-const (
-	Unspecified Code = iota
-	NotFound
-	FailedPrecondition
-	Internal
-	AlreadyExists
-	Unknown
-	// Note: If you add a new value here, make sure to update String method.
-)
-
-func (c Code) String() string {
-	switch c {
-	case Unspecified:
-		return "ERROR_CODE_UNSPECIFIED"
-	case NotFound:
-		return "NOT_FOUND"
-	case FailedPrecondition:
-		return "FAILED_PRECONDITION"
-	case Internal:
-		return "INTERNAL_ERROR"
-	case AlreadyExists:
-		return "ALREADY_EXISTS"
-	case Unknown:
-		return "UNKNOWN"
-	}
-	panic(fmt.Sprintf("unknown error code %d", c))
-}
-
-// Op describes an operation, usually as the package and method,
-// such as "rdb.Enqueue".
-type Op string
-
-// E builds an error value from its arguments.
-// There must be at least one argument or E panics.
-// The type of each argument determines its meaning.
-// If more than one argument of a given type is presented,
-// only the last one is recorded.
-//
-// The types are:
-//	errors.Op
-//		The operation being performed, usually the method
-//		being invoked (Get, Put, etc.).
-//	errors.Code
-//		The canonical error code, such as NOT_FOUND.
-//	string
-//		Treated as an error message and assigned to the
-//		Err field after a call to errors.New.
-//	error
-//		The underlying error that triggered this one.
-//
-// If the error is printed, only those items that have been
-// set to non-zero values will appear in the result.
-func E(args ...interface{}) error {
-	if len(args) == 0 {
-		panic("call to errors.E with no arguments")
-	}
-	e := &Error{}
-	for _, arg := range args {
-		switch arg := arg.(type) {
-		case Op:
-			e.Op = arg
-		case Code:
-			e.Code = arg
-		case error:
-			e.Err = arg
-		case string:
-			e.Err = errors.New(arg)
-		default:
-			_, file, line, _ := runtime.Caller(1)
-			log.Printf("errors.E: bad call from %s:%d: %v", file, line, args)
-			return fmt.Errorf("unknown type %T, value %v in error call", arg, arg)
-		}
-	}
-	return e
-}
-
-// CanonicalCode returns the canonical code of the given error if one is present.
-// Otherwise it returns Unspecified.
-func CanonicalCode(err error) Code {
-	if err == nil {
-		return Unspecified
-	}
-	e, ok := err.(*Error)
-	if !ok {
-		return Unspecified
-	}
-	if e.Code == Unspecified {
-		return CanonicalCode(e.Err)
-	}
-	return e.Code
-}
-
-/******************************************
-    Domin Specific Error Types & Values
-*******************************************/
-
-var (
-	// ErrNoProcessableTask indicates that there are no tasks ready to be processed.
-	ErrNoProcessableTask = errors.New("no tasks are ready for processing")
-
-	// ErrDuplicateTask indicates that another task with the same unique key holds the uniqueness lock.
-	ErrDuplicateTask = errors.New("task already exists")
-
-	// ErrTaskIdConflict indicates that another task with the same task ID already exist
-	ErrTaskIdConflict = errors.New("task id conflicts with another task")
-)
-
-// TaskNotFoundError indicates that a task with the given ID does not exist
-// in the given queue.
-type TaskNotFoundError struct {
-	Queue string // queue name
-	ID    string // task id
-}
-
-func (e *TaskNotFoundError) Error() string {
-	return fmt.Sprintf("cannot find task with id=%s in queue %q", e.ID, e.Queue)
-}
-
-// IsTaskNotFound reports whether any error in err's chain is of type TaskNotFoundError.
-func IsTaskNotFound(err error) bool {
-	var target *TaskNotFoundError
-	return As(err, &target)
-}
-
-// QueueNotFoundError indicates that a queue with the given name does not exist.
-type QueueNotFoundError struct {
-	Queue string // queue name
-}
-
-func (e *QueueNotFoundError) Error() string {
-	return fmt.Sprintf("queue %q does not exist", e.Queue)
-}
-
-// IsQueueNotFound reports whether any error in err's chain is of type QueueNotFoundError.
-func IsQueueNotFound(err error) bool {
-	var target *QueueNotFoundError
-	return As(err, &target)
-}
-
-// QueueNotEmptyError indicates that the given queue is not empty.
-type QueueNotEmptyError struct {
-	Queue string // queue name
-}
-
-func (e *QueueNotEmptyError) Error() string {
-	return fmt.Sprintf("queue %q is not empty", e.Queue)
-}
-
-// IsQueueNotEmpty reports whether any error in err's chain is of type QueueNotEmptyError.
-func IsQueueNotEmpty(err error) bool {
-	var target *QueueNotEmptyError
-	return As(err, &target)
-}
-
-// TaskAlreadyArchivedError indicates that the task in question is already archived.
-type TaskAlreadyArchivedError struct {
-	Queue string // queue name
-	ID    string // task id
-}
-
-func (e *TaskAlreadyArchivedError) Error() string {
-	return fmt.Sprintf("task is already archived: id=%s, queue=%s", e.ID, e.Queue)
-}
-
-// IsTaskAlreadyArchived reports whether any error in err's chain is of type TaskAlreadyArchivedError.
-func IsTaskAlreadyArchived(err error) bool {
-	var target *TaskAlreadyArchivedError
-	return As(err, &target)
-}
-
-// RedisCommandError indicates that the given redis command returned error.
-type RedisCommandError struct {
-	Command string // redis command (e.g. LRANGE, ZADD, etc)
-	Err     error  // underlying error
-}
-
-func (e *RedisCommandError) Error() string {
-	return fmt.Sprintf("redis command error: %s failed: %v", strings.ToUpper(e.Command), e.Err)
-}
-
-func (e *RedisCommandError) Unwrap() error { return e.Err }
-
-// IsRedisCommandError reports whether any error in err's chain is of type RedisCommandError.
-func IsRedisCommandError(err error) bool {
-	var target *RedisCommandError
-	return As(err, &target)
-}
-
-/*************************************************
-    Standard Library errors package functions
-*************************************************/
-
-// New returns an error that formats as the given text.
-// Each call to New returns a distinct error value even if the text is identical.
-//
-// This function is the errors.New function from the standard libarary (https://golang.org/pkg/errors/#New).
-// It is exported from this package for import convinience.
-func New(text string) error { return errors.New(text) }
-
-// Is reports whether any error in err's chain matches target.
-//
-// This function is the errors.Is function from the standard libarary (https://golang.org/pkg/errors/#Is).
-// It is exported from this package for import convinience.
-func Is(err, target error) bool { return errors.Is(err, target) }
-
-// As finds the first error in err's chain that matches target, and if so, sets target to that error value and returns true.
-// Otherwise, it returns false.
-//
-// This function is the errors.As function from the standard libarary (https://golang.org/pkg/errors/#As).
-// It is exported from this package for import convinience.
-func As(err error, target interface{}) bool { return errors.As(err, target) }
-
-// Unwrap returns the result of calling the Unwrap method on err, if err's type contains an Unwrap method returning error.
-// Otherwise, Unwrap returns nil.
-//
-// This function is the errors.Unwrap function from the standard libarary (https://golang.org/pkg/errors/#Unwrap).
-// It is exported from this package for import convinience.
-func Unwrap(err error) error { return errors.Unwrap(err) }

internal/errors/errors_test.go

@@ -1,176 +0,0 @@
-// Copyright 2020 Kentaro Hibino. All rights reserved.
-// Use of this source code is governed by a MIT license
-// that can be found in the LICENSE file.
-
-package errors
-
-import "testing"
-
-func TestErrorDebugString(t *testing.T) {
-	// DebugString should include Op since its meant to be used by
-	// maintainers/contributors of the asynq package.
-	tests := []struct {
-		desc string
-		err  error
-		want string
-	}{
-		{
-			desc: "With Op, Code, and string",
-			err:  E(Op("rdb.DeleteTask"), NotFound, "cannot find task with id=123"),
-			want: "rdb.DeleteTask: NOT_FOUND: cannot find task with id=123",
-		},
-		{
-			desc: "With Op, Code and error",
-			err:  E(Op("rdb.DeleteTask"), NotFound, &TaskNotFoundError{Queue: "default", ID: "123"}),
-			want: `rdb.DeleteTask: NOT_FOUND: cannot find task with id=123 in queue "default"`,
-		},
-	}
-
-	for _, tc := range tests {
-		if got := tc.err.(*Error).DebugString(); got != tc.want {
-			t.Errorf("%s: got=%q, want=%q", tc.desc, got, tc.want)
-		}
-	}
-}
-
-func TestErrorString(t *testing.T) {
-	// String method should omit Op since op is an internal detail
-	// and we don't want to provide it to users of the package.
-	tests := []struct {
-		desc string
-		err  error
-		want string
-	}{
-		{
-			desc: "With Op, Code, and string",
-			err:  E(Op("rdb.DeleteTask"), NotFound, "cannot find task with id=123"),
-			want: "NOT_FOUND: cannot find task with id=123",
-		},
-		{
-			desc: "With Op, Code and error",
-			err:  E(Op("rdb.DeleteTask"), NotFound, &TaskNotFoundError{Queue: "default", ID: "123"}),
-			want: `NOT_FOUND: cannot find task with id=123 in queue "default"`,
-		},
-	}
-
-	for _, tc := range tests {
-		if got := tc.err.Error(); got != tc.want {
-			t.Errorf("%s: got=%q, want=%q", tc.desc, got, tc.want)
-		}
-	}
-}
-
-func TestErrorIs(t *testing.T) {
-	var ErrCustom = New("custom sentinel error")
-
-	tests := []struct {
-		desc   string
-		err    error
-		target error
-		want   bool
-	}{
-		{
-			desc:   "should unwrap one level",
-			err:    E(Op("rdb.DeleteTask"), ErrCustom),
-			target: ErrCustom,
-			want:   true,
-		},
-	}
-
-	for _, tc := range tests {
-		if got := Is(tc.err, tc.target); got != tc.want {
-			t.Errorf("%s: got=%t, want=%t", tc.desc, got, tc.want)
-		}
-	}
-}
-
-func TestErrorAs(t *testing.T) {
-	tests := []struct {
-		desc   string
-		err    error
-		target interface{}
-		want   bool
-	}{
-		{
-			desc:   "should unwrap one level",
-			err:    E(Op("rdb.DeleteTask"), NotFound, &QueueNotFoundError{Queue: "email"}),
-			target: &QueueNotFoundError{},
-			want:   true,
-		},
-	}
-
-	for _, tc := range tests {
-		if got := As(tc.err, &tc.target); got != tc.want {
-			t.Errorf("%s: got=%t, want=%t", tc.desc, got, tc.want)
-		}
-	}
-}
-
-func TestErrorPredicates(t *testing.T) {
-	tests := []struct {
-		desc string
-		fn   func(err error) bool
-		err  error
-		want bool
-	}{
-		{
-			desc: "IsTaskNotFound should detect presence of TaskNotFoundError in err's chain",
-			fn:   IsTaskNotFound,
-			err:  E(Op("rdb.ArchiveTask"), NotFound, &TaskNotFoundError{Queue: "default", ID: "9876"}),
-			want: true,
-		},
-		{
-			desc: "IsTaskNotFound should detect absence of TaskNotFoundError in err's chain",
-			fn:   IsTaskNotFound,
-			err:  E(Op("rdb.ArchiveTask"), NotFound, &QueueNotFoundError{Queue: "default"}),
-			want: false,
-		},
-		{
-			desc: "IsQueueNotFound should detect presence of QueueNotFoundError in err's chain",
-			fn:   IsQueueNotFound,
-			err:  E(Op("rdb.ArchiveTask"), NotFound, &QueueNotFoundError{Queue: "default"}),
-			want: true,
-		},
-	}
-
-	for _, tc := range tests {
-		if got := tc.fn(tc.err); got != tc.want {
-			t.Errorf("%s: got=%t, want=%t", tc.desc, got, tc.want)
-		}
-	}
-}
-
-func TestCanonicalCode(t *testing.T) {
-	tests := []struct {
-		desc string
-		err  error
-		want Code
-	}{
-		{
-			desc: "without nesting",
-			err:  E(Op("rdb.DeleteTask"), NotFound, &TaskNotFoundError{Queue: "default", ID: "123"}),
-			want: NotFound,
-		},
-		{
-			desc: "with nesting",
-			err:  E(FailedPrecondition, E(NotFound)),
-			want: FailedPrecondition,
-		},
-		{
-			desc: "returns Unspecified if err is not *Error",
-			err:  New("some other error"),
-			want: Unspecified,
-		},
-		{
-			desc: "returns Unspecified if err is nil",
-			err:  nil,
-			want: Unspecified,
-		},
-	}
-
-	for _, tc := range tests {
-		if got := CanonicalCode(tc.err); got != tc.want {
-			t.Errorf("%s: got=%s, want=%s", tc.desc, got, tc.want)
-		}
-	}
-}

internal/proto/asynq.pb.go

@@ -1,838 +0,0 @@
-// Copyright 2020 Kentaro Hibino. All rights reserved.
-// Use of this source code is governed by a MIT license
-// that can be found in the LICENSE file.
-
-// Code generated by protoc-gen-go. DO NOT EDIT.
-// versions:
-// 	protoc-gen-go v1.25.0
-// 	protoc        v3.17.3
-// source: asynq.proto
-
-package proto
-
-import (
-	proto "github.com/golang/protobuf/proto"
-	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
-	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
-	timestamppb "google.golang.org/protobuf/types/known/timestamppb"
-	reflect "reflect"
-	sync "sync"
-)
-
-const (
-	// Verify that this generated code is sufficiently up-to-date.
-	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
-	// Verify that runtime/protoimpl is sufficiently up-to-date.
-	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
-)
-
-// This is a compile-time assertion that a sufficiently up-to-date version
-// of the legacy proto package is being used.
-const _ = proto.ProtoPackageIsVersion4
-
-// TaskMessage is the internal representation of a task with additional
-// metadata fields.
-type TaskMessage struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	// Type indicates the kind of the task to be performed.
-	Type string `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"`
-	// Payload holds data needed to process the task.
-	Payload []byte `protobuf:"bytes,2,opt,name=payload,proto3" json:"payload,omitempty"`
-	// Unique identifier for the task.
-	Id string `protobuf:"bytes,3,opt,name=id,proto3" json:"id,omitempty"`
-	// Name of the queue to which this task belongs.
-	Queue string `protobuf:"bytes,4,opt,name=queue,proto3" json:"queue,omitempty"`
-	// Max number of retries for this task.
-	Retry int32 `protobuf:"varint,5,opt,name=retry,proto3" json:"retry,omitempty"`
-	// Number of times this task has been retried so far.
-	Retried int32 `protobuf:"varint,6,opt,name=retried,proto3" json:"retried,omitempty"`
-	// Error message from the last failure.
-	ErrorMsg string `protobuf:"bytes,7,opt,name=error_msg,json=errorMsg,proto3" json:"error_msg,omitempty"`
-	// Time of last failure in Unix time,
-	// the number of seconds elapsed since January 1, 1970 UTC.
-	// Use zero to indicate no last failure.
-	LastFailedAt int64 `protobuf:"varint,11,opt,name=last_failed_at,json=lastFailedAt,proto3" json:"last_failed_at,omitempty"`
-	// Timeout specifies timeout in seconds.
-	// Use zero to indicate no timeout.
-	Timeout int64 `protobuf:"varint,8,opt,name=timeout,proto3" json:"timeout,omitempty"`
-	// Deadline specifies the deadline for the task in Unix time,
-	// the number of seconds elapsed since January 1, 1970 UTC.
-	// Use zero to indicate no deadline.
-	Deadline int64 `protobuf:"varint,9,opt,name=deadline,proto3" json:"deadline,omitempty"`
-	// UniqueKey holds the redis key used for uniqueness lock for this task.
-	// Empty string indicates that no uniqueness lock was used.
-	UniqueKey string `protobuf:"bytes,10,opt,name=unique_key,json=uniqueKey,proto3" json:"unique_key,omitempty"`
-	// Retention period specified in a number of seconds.
-	// The task will be stored in redis as a completed task until the TTL
-	// expires.
-	Retention int64 `protobuf:"varint,12,opt,name=retention,proto3" json:"retention,omitempty"`
-	// Time when the task completed in success in Unix time,
-	// the number of seconds elapsed since January 1, 1970 UTC.
-	// This field is populated if result_ttl > 0 upon completion.
-	CompletedAt int64 `protobuf:"varint,13,opt,name=completed_at,json=completedAt,proto3" json:"completed_at,omitempty"`
-}
-
-func (x *TaskMessage) Reset() {
-	*x = TaskMessage{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_asynq_proto_msgTypes[0]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *TaskMessage) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*TaskMessage) ProtoMessage() {}
-
-func (x *TaskMessage) ProtoReflect() protoreflect.Message {
-	mi := &file_asynq_proto_msgTypes[0]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use TaskMessage.ProtoReflect.Descriptor instead.
-func (*TaskMessage) Descriptor() ([]byte, []int) {
-	return file_asynq_proto_rawDescGZIP(), []int{0}
-}
-
-func (x *TaskMessage) GetType() string {
-	if x != nil {
-		return x.Type
-	}
-	return ""
-}
-
-func (x *TaskMessage) GetPayload() []byte {
-	if x != nil {
-		return x.Payload
-	}
-	return nil
-}
-
-func (x *TaskMessage) GetId() string {
-	if x != nil {
-		return x.Id
-	}
-	return ""
-}
-
-func (x *TaskMessage) GetQueue() string {
-	if x != nil {
-		return x.Queue
-	}
-	return ""
-}
-
-func (x *TaskMessage) GetRetry() int32 {
-	if x != nil {
-		return x.Retry
-	}
-	return 0
-}
-
-func (x *TaskMessage) GetRetried() int32 {
-	if x != nil {
-		return x.Retried
-	}
-	return 0
-}
-
-func (x *TaskMessage) GetErrorMsg() string {
-	if x != nil {
-		return x.ErrorMsg
-	}
-	return ""
-}
-
-func (x *TaskMessage) GetLastFailedAt() int64 {
-	if x != nil {
-		return x.LastFailedAt
-	}
-	return 0
-}
-
-func (x *TaskMessage) GetTimeout() int64 {
-	if x != nil {
-		return x.Timeout
-	}
-	return 0
-}
-
-func (x *TaskMessage) GetDeadline() int64 {
-	if x != nil {
-		return x.Deadline
-	}
-	return 0
-}
-
-func (x *TaskMessage) GetUniqueKey() string {
-	if x != nil {
-		return x.UniqueKey
-	}
-	return ""
-}
-
-func (x *TaskMessage) GetRetention() int64 {
-	if x != nil {
-		return x.Retention
-	}
-	return 0
-}
-
-func (x *TaskMessage) GetCompletedAt() int64 {
-	if x != nil {
-		return x.CompletedAt
-	}
-	return 0
-}
-
-// ServerInfo holds information about a running server.
-type ServerInfo struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	// Host machine the server is running on.
-	Host string `protobuf:"bytes,1,opt,name=host,proto3" json:"host,omitempty"`
-	// PID of the server process.
-	Pid int32 `protobuf:"varint,2,opt,name=pid,proto3" json:"pid,omitempty"`
-	// Unique identifier for this server.
-	ServerId string `protobuf:"bytes,3,opt,name=server_id,json=serverId,proto3" json:"server_id,omitempty"`
-	// Maximum number of concurrency this server will use.
-	Concurrency int32 `protobuf:"varint,4,opt,name=concurrency,proto3" json:"concurrency,omitempty"`
-	// List of queue names with their priorities.
-	// The server will consume tasks from the queues and prioritize
-	// queues with higher priority numbers.
-	Queues map[string]int32 `protobuf:"bytes,5,rep,name=queues,proto3" json:"queues,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
-	// If set, the server will always consume tasks from a queue with higher
-	// priority.
-	StrictPriority bool `protobuf:"varint,6,opt,name=strict_priority,json=strictPriority,proto3" json:"strict_priority,omitempty"`
-	// Status indicates the status of the server.
-	Status string `protobuf:"bytes,7,opt,name=status,proto3" json:"status,omitempty"`
-	// Time this server was started.
-	StartTime *timestamppb.Timestamp `protobuf:"bytes,8,opt,name=start_time,json=startTime,proto3" json:"start_time,omitempty"`
-	// Number of workers currently processing tasks.
-	ActiveWorkerCount int32 `protobuf:"varint,9,opt,name=active_worker_count,json=activeWorkerCount,proto3" json:"active_worker_count,omitempty"`
-}
-
-func (x *ServerInfo) Reset() {
-	*x = ServerInfo{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_asynq_proto_msgTypes[1]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *ServerInfo) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*ServerInfo) ProtoMessage() {}
-
-func (x *ServerInfo) ProtoReflect() protoreflect.Message {
-	mi := &file_asynq_proto_msgTypes[1]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use ServerInfo.ProtoReflect.Descriptor instead.
-func (*ServerInfo) Descriptor() ([]byte, []int) {
-	return file_asynq_proto_rawDescGZIP(), []int{1}
-}
-
-func (x *ServerInfo) GetHost() string {
-	if x != nil {
-		return x.Host
-	}
-	return ""
-}
-
-func (x *ServerInfo) GetPid() int32 {
-	if x != nil {
-		return x.Pid
-	}
-	return 0
-}
-
-func (x *ServerInfo) GetServerId() string {
-	if x != nil {
-		return x.ServerId
-	}
-	return ""
-}
-
-func (x *ServerInfo) GetConcurrency() int32 {
-	if x != nil {
-		return x.Concurrency
-	}
-	return 0
-}
-
-func (x *ServerInfo) GetQueues() map[string]int32 {
-	if x != nil {
-		return x.Queues
-	}
-	return nil
-}
-
-func (x *ServerInfo) GetStrictPriority() bool {
-	if x != nil {
-		return x.StrictPriority
-	}
-	return false
-}
-
-func (x *ServerInfo) GetStatus() string {
-	if x != nil {
-		return x.Status
-	}
-	return ""
-}
-
-func (x *ServerInfo) GetStartTime() *timestamppb.Timestamp {
-	if x != nil {
-		return x.StartTime
-	}
-	return nil
-}
-
-func (x *ServerInfo) GetActiveWorkerCount() int32 {
-	if x != nil {
-		return x.ActiveWorkerCount
-	}
-	return 0
-}
-
-// WorkerInfo holds information about a running worker.
-type WorkerInfo struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	// Host matchine this worker is running on.
-	Host string `protobuf:"bytes,1,opt,name=host,proto3" json:"host,omitempty"`
-	// PID of the process in which this worker is running.
-	Pid int32 `protobuf:"varint,2,opt,name=pid,proto3" json:"pid,omitempty"`
-	// ID of the server in which this worker is running.
-	ServerId string `protobuf:"bytes,3,opt,name=server_id,json=serverId,proto3" json:"server_id,omitempty"`
-	// ID of the task this worker is processing.
-	TaskId string `protobuf:"bytes,4,opt,name=task_id,json=taskId,proto3" json:"task_id,omitempty"`
-	// Type of the task this worker is processing.
-	TaskType string `protobuf:"bytes,5,opt,name=task_type,json=taskType,proto3" json:"task_type,omitempty"`
-	// Payload of the task this worker is processing.
-	TaskPayload []byte `protobuf:"bytes,6,opt,name=task_payload,json=taskPayload,proto3" json:"task_payload,omitempty"`
-	// Name of the queue the task the worker is processing belongs.
-	Queue string `protobuf:"bytes,7,opt,name=queue,proto3" json:"queue,omitempty"`
-	// Time this worker started processing the task.
-	StartTime *timestamppb.Timestamp `protobuf:"bytes,8,opt,name=start_time,json=startTime,proto3" json:"start_time,omitempty"`
-	// Deadline by which the worker needs to complete processing
-	// the task. If worker exceeds the deadline, the task will fail.
-	Deadline *timestamppb.Timestamp `protobuf:"bytes,9,opt,name=deadline,proto3" json:"deadline,omitempty"`
-}
-
-func (x *WorkerInfo) Reset() {
-	*x = WorkerInfo{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_asynq_proto_msgTypes[2]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *WorkerInfo) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*WorkerInfo) ProtoMessage() {}
-
-func (x *WorkerInfo) ProtoReflect() protoreflect.Message {
-	mi := &file_asynq_proto_msgTypes[2]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use WorkerInfo.ProtoReflect.Descriptor instead.
-func (*WorkerInfo) Descriptor() ([]byte, []int) {
-	return file_asynq_proto_rawDescGZIP(), []int{2}
-}
-
-func (x *WorkerInfo) GetHost() string {
-	if x != nil {
-		return x.Host
-	}
-	return ""
-}
-
-func (x *WorkerInfo) GetPid() int32 {
-	if x != nil {
-		return x.Pid
-	}
-	return 0
-}
-
-func (x *WorkerInfo) GetServerId() string {
-	if x != nil {
-		return x.ServerId
-	}
-	return ""
-}
-
-func (x *WorkerInfo) GetTaskId() string {
-	if x != nil {
-		return x.TaskId
-	}
-	return ""
-}
-
-func (x *WorkerInfo) GetTaskType() string {
-	if x != nil {
-		return x.TaskType
-	}
-	return ""
-}
-
-func (x *WorkerInfo) GetTaskPayload() []byte {
-	if x != nil {
-		return x.TaskPayload
-	}
-	return nil
-}
-
-func (x *WorkerInfo) GetQueue() string {
-	if x != nil {
-		return x.Queue
-	}
-	return ""
-}
-
-func (x *WorkerInfo) GetStartTime() *timestamppb.Timestamp {
-	if x != nil {
-		return x.StartTime
-	}
-	return nil
-}
-
-func (x *WorkerInfo) GetDeadline() *timestamppb.Timestamp {
-	if x != nil {
-		return x.Deadline
-	}
-	return nil
-}
-
-// SchedulerEntry holds information about a periodic task registered
-// with a scheduler.
-type SchedulerEntry struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	// Identifier of the scheduler entry.
-	Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
-	// Periodic schedule spec of the entry.
-	Spec string `protobuf:"bytes,2,opt,name=spec,proto3" json:"spec,omitempty"`
-	// Task type of the periodic task.
-	TaskType string `protobuf:"bytes,3,opt,name=task_type,json=taskType,proto3" json:"task_type,omitempty"`
-	// Task payload of the periodic task.
-	TaskPayload []byte `protobuf:"bytes,4,opt,name=task_payload,json=taskPayload,proto3" json:"task_payload,omitempty"`
-	// Options used to enqueue the periodic task.
-	EnqueueOptions []string `protobuf:"bytes,5,rep,name=enqueue_options,json=enqueueOptions,proto3" json:"enqueue_options,omitempty"`
-	// Next time the task will be enqueued.
-	NextEnqueueTime *timestamppb.Timestamp `protobuf:"bytes,6,opt,name=next_enqueue_time,json=nextEnqueueTime,proto3" json:"next_enqueue_time,omitempty"`
-	// Last time the task was enqueued.
-	// Zero time if task was never enqueued.
-	PrevEnqueueTime *timestamppb.Timestamp `protobuf:"bytes,7,opt,name=prev_enqueue_time,json=prevEnqueueTime,proto3" json:"prev_enqueue_time,omitempty"`
-}
-
-func (x *SchedulerEntry) Reset() {
-	*x = SchedulerEntry{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_asynq_proto_msgTypes[3]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *SchedulerEntry) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*SchedulerEntry) ProtoMessage() {}
-
-func (x *SchedulerEntry) ProtoReflect() protoreflect.Message {
-	mi := &file_asynq_proto_msgTypes[3]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use SchedulerEntry.ProtoReflect.Descriptor instead.
-func (*SchedulerEntry) Descriptor() ([]byte, []int) {
-	return file_asynq_proto_rawDescGZIP(), []int{3}
-}
-
-func (x *SchedulerEntry) GetId() string {
-	if x != nil {
-		return x.Id
-	}
-	return ""
-}
-
-func (x *SchedulerEntry) GetSpec() string {
-	if x != nil {
-		return x.Spec
-	}
-	return ""
-}
-
-func (x *SchedulerEntry) GetTaskType() string {
-	if x != nil {
-		return x.TaskType
-	}
-	return ""
-}
-
-func (x *SchedulerEntry) GetTaskPayload() []byte {
-	if x != nil {
-		return x.TaskPayload
-	}
-	return nil
-}
-
-func (x *SchedulerEntry) GetEnqueueOptions() []string {
-	if x != nil {
-		return x.EnqueueOptions
-	}
-	return nil
-}
-
-func (x *SchedulerEntry) GetNextEnqueueTime() *timestamppb.Timestamp {
-	if x != nil {
-		return x.NextEnqueueTime
-	}
-	return nil
-}
-
-func (x *SchedulerEntry) GetPrevEnqueueTime() *timestamppb.Timestamp {
-	if x != nil {
-		return x.PrevEnqueueTime
-	}
-	return nil
-}
-
-// SchedulerEnqueueEvent holds information about an enqueue event
-// by a scheduler.
-type SchedulerEnqueueEvent struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	// ID of the task that was enqueued.
-	TaskId string `protobuf:"bytes,1,opt,name=task_id,json=taskId,proto3" json:"task_id,omitempty"`
-	// Time the task was enqueued.
-	EnqueueTime *timestamppb.Timestamp `protobuf:"bytes,2,opt,name=enqueue_time,json=enqueueTime,proto3" json:"enqueue_time,omitempty"`
-}
-
-func (x *SchedulerEnqueueEvent) Reset() {
-	*x = SchedulerEnqueueEvent{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_asynq_proto_msgTypes[4]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *SchedulerEnqueueEvent) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*SchedulerEnqueueEvent) ProtoMessage() {}
-
-func (x *SchedulerEnqueueEvent) ProtoReflect() protoreflect.Message {
-	mi := &file_asynq_proto_msgTypes[4]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use SchedulerEnqueueEvent.ProtoReflect.Descriptor instead.
-func (*SchedulerEnqueueEvent) Descriptor() ([]byte, []int) {
-	return file_asynq_proto_rawDescGZIP(), []int{4}
-}
-
-func (x *SchedulerEnqueueEvent) GetTaskId() string {
-	if x != nil {
-		return x.TaskId
-	}
-	return ""
-}
-
-func (x *SchedulerEnqueueEvent) GetEnqueueTime() *timestamppb.Timestamp {
-	if x != nil {
-		return x.EnqueueTime
-	}
-	return nil
-}
-
-var File_asynq_proto protoreflect.FileDescriptor
-
-var file_asynq_proto_rawDesc = []byte{
-	0x0a, 0x0b, 0x61, 0x73, 0x79, 0x6e, 0x71, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x05, 0x61,
-	0x73, 0x79, 0x6e, 0x71, 0x1a, 0x1f, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f,
-	0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x2e,
-	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xea, 0x02, 0x0a, 0x0b, 0x54, 0x61, 0x73, 0x6b, 0x4d, 0x65,
-	0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x01, 0x20,
-	0x01, 0x28, 0x09, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x70, 0x61, 0x79,
-	0x6c, 0x6f, 0x61, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x07, 0x70, 0x61, 0x79, 0x6c,
-	0x6f, 0x61, 0x64, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52,
-	0x02, 0x69, 0x64, 0x12, 0x14, 0x0a, 0x05, 0x71, 0x75, 0x65, 0x75, 0x65, 0x18, 0x04, 0x20, 0x01,
-	0x28, 0x09, 0x52, 0x05, 0x71, 0x75, 0x65, 0x75, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x72, 0x65, 0x74,
-	0x72, 0x79, 0x18, 0x05, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x72, 0x65, 0x74, 0x72, 0x79, 0x12,
-	0x18, 0x0a, 0x07, 0x72, 0x65, 0x74, 0x72, 0x69, 0x65, 0x64, 0x18, 0x06, 0x20, 0x01, 0x28, 0x05,
-	0x52, 0x07, 0x72, 0x65, 0x74, 0x72, 0x69, 0x65, 0x64, 0x12, 0x1b, 0x0a, 0x09, 0x65, 0x72, 0x72,
-	0x6f, 0x72, 0x5f, 0x6d, 0x73, 0x67, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x72,
-	0x72, 0x6f, 0x72, 0x4d, 0x73, 0x67, 0x12, 0x24, 0x0a, 0x0e, 0x6c, 0x61, 0x73, 0x74, 0x5f, 0x66,
-	0x61, 0x69, 0x6c, 0x65, 0x64, 0x5f, 0x61, 0x74, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0c,
-	0x6c, 0x61, 0x73, 0x74, 0x46, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x41, 0x74, 0x12, 0x18, 0x0a, 0x07,
-	0x74, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x18, 0x08, 0x20, 0x01, 0x28, 0x03, 0x52, 0x07, 0x74,
-	0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x64, 0x65, 0x61, 0x64, 0x6c, 0x69,
-	0x6e, 0x65, 0x18, 0x09, 0x20, 0x01, 0x28, 0x03, 0x52, 0x08, 0x64, 0x65, 0x61, 0x64, 0x6c, 0x69,
-	0x6e, 0x65, 0x12, 0x1d, 0x0a, 0x0a, 0x75, 0x6e, 0x69, 0x71, 0x75, 0x65, 0x5f, 0x6b, 0x65, 0x79,
-	0x18, 0x0a, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x75, 0x6e, 0x69, 0x71, 0x75, 0x65, 0x4b, 0x65,
-	0x79, 0x12, 0x1c, 0x0a, 0x09, 0x72, 0x65, 0x74, 0x65, 0x6e, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x0c,
-	0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x72, 0x65, 0x74, 0x65, 0x6e, 0x74, 0x69, 0x6f, 0x6e, 0x12,
-	0x21, 0x0a, 0x0c, 0x63, 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x65, 0x64, 0x5f, 0x61, 0x74, 0x18,
-	0x0d, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0b, 0x63, 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x65, 0x64,
-	0x41, 0x74, 0x22, 0x8f, 0x03, 0x0a, 0x0a, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x49, 0x6e, 0x66,
-	0x6f, 0x12, 0x12, 0x0a, 0x04, 0x68, 0x6f, 0x73, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52,
-	0x04, 0x68, 0x6f, 0x73, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x70, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01,
-	0x28, 0x05, 0x52, 0x03, 0x70, 0x69, 0x64, 0x12, 0x1b, 0x0a, 0x09, 0x73, 0x65, 0x72, 0x76, 0x65,
-	0x72, 0x5f, 0x69, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x73, 0x65, 0x72, 0x76,
-	0x65, 0x72, 0x49, 0x64, 0x12, 0x20, 0x0a, 0x0b, 0x63, 0x6f, 0x6e, 0x63, 0x75, 0x72, 0x72, 0x65,
-	0x6e, 0x63, 0x79, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0b, 0x63, 0x6f, 0x6e, 0x63, 0x75,
-	0x72, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x12, 0x35, 0x0a, 0x06, 0x71, 0x75, 0x65, 0x75, 0x65, 0x73,
-	0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x61, 0x73, 0x79, 0x6e, 0x71, 0x2e, 0x53,
-	0x65, 0x72, 0x76, 0x65, 0x72, 0x49, 0x6e, 0x66, 0x6f, 0x2e, 0x51, 0x75, 0x65, 0x75, 0x65, 0x73,
-	0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x06, 0x71, 0x75, 0x65, 0x75, 0x65, 0x73, 0x12, 0x27, 0x0a,
-	0x0f, 0x73, 0x74, 0x72, 0x69, 0x63, 0x74, 0x5f, 0x70, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79,
-	0x18, 0x06, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0e, 0x73, 0x74, 0x72, 0x69, 0x63, 0x74, 0x50, 0x72,
-	0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73,
-	0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x39,
-	0x0a, 0x0a, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x08, 0x20, 0x01,
-	0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74,
-	0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x09,
-	0x73, 0x74, 0x61, 0x72, 0x74, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x2e, 0x0a, 0x13, 0x61, 0x63, 0x74,
-	0x69, 0x76, 0x65, 0x5f, 0x77, 0x6f, 0x72, 0x6b, 0x65, 0x72, 0x5f, 0x63, 0x6f, 0x75, 0x6e, 0x74,
-	0x18, 0x09, 0x20, 0x01, 0x28, 0x05, 0x52, 0x11, 0x61, 0x63, 0x74, 0x69, 0x76, 0x65, 0x57, 0x6f,
-	0x72, 0x6b, 0x65, 0x72, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x1a, 0x39, 0x0a, 0x0b, 0x51, 0x75, 0x65,
-	0x75, 0x65, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18,
-	0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61,
-	0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65,
-	0x3a, 0x02, 0x38, 0x01, 0x22, 0xb1, 0x02, 0x0a, 0x0a, 0x57, 0x6f, 0x72, 0x6b, 0x65, 0x72, 0x49,
-	0x6e, 0x66, 0x6f, 0x12, 0x12, 0x0a, 0x04, 0x68, 0x6f, 0x73, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28,
-	0x09, 0x52, 0x04, 0x68, 0x6f, 0x73, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x70, 0x69, 0x64, 0x18, 0x02,
-	0x20, 0x01, 0x28, 0x05, 0x52, 0x03, 0x70, 0x69, 0x64, 0x12, 0x1b, 0x0a, 0x09, 0x73, 0x65, 0x72,
-	0x76, 0x65, 0x72, 0x5f, 0x69, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x73, 0x65,
-	0x72, 0x76, 0x65, 0x72, 0x49, 0x64, 0x12, 0x17, 0x0a, 0x07, 0x74, 0x61, 0x73, 0x6b, 0x5f, 0x69,
-	0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x74, 0x61, 0x73, 0x6b, 0x49, 0x64, 0x12,
-	0x1b, 0x0a, 0x09, 0x74, 0x61, 0x73, 0x6b, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x05, 0x20, 0x01,
-	0x28, 0x09, 0x52, 0x08, 0x74, 0x61, 0x73, 0x6b, 0x54, 0x79, 0x70, 0x65, 0x12, 0x21, 0x0a, 0x0c,
-	0x74, 0x61, 0x73, 0x6b, 0x5f, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x18, 0x06, 0x20, 0x01,
-	0x28, 0x0c, 0x52, 0x0b, 0x74, 0x61, 0x73, 0x6b, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x12,
-	0x14, 0x0a, 0x05, 0x71, 0x75, 0x65, 0x75, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05,
-	0x71, 0x75, 0x65, 0x75, 0x65, 0x12, 0x39, 0x0a, 0x0a, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x74,
-	0x69, 0x6d, 0x65, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
-	0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65,
-	0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x09, 0x73, 0x74, 0x61, 0x72, 0x74, 0x54, 0x69, 0x6d, 0x65,
-	0x12, 0x36, 0x0a, 0x08, 0x64, 0x65, 0x61, 0x64, 0x6c, 0x69, 0x6e, 0x65, 0x18, 0x09, 0x20, 0x01,
-	0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74,
-	0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x08,
-	0x64, 0x65, 0x61, 0x64, 0x6c, 0x69, 0x6e, 0x65, 0x22, 0xad, 0x02, 0x0a, 0x0e, 0x53, 0x63, 0x68,
-	0x65, 0x64, 0x75, 0x6c, 0x65, 0x72, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x0e, 0x0a, 0x02, 0x69,
-	0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x73,
-	0x70, 0x65, 0x63, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x73, 0x70, 0x65, 0x63, 0x12,
-	0x1b, 0x0a, 0x09, 0x74, 0x61, 0x73, 0x6b, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x03, 0x20, 0x01,
-	0x28, 0x09, 0x52, 0x08, 0x74, 0x61, 0x73, 0x6b, 0x54, 0x79, 0x70, 0x65, 0x12, 0x21, 0x0a, 0x0c,
-	0x74, 0x61, 0x73, 0x6b, 0x5f, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x18, 0x04, 0x20, 0x01,
-	0x28, 0x0c, 0x52, 0x0b, 0x74, 0x61, 0x73, 0x6b, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x12,
-	0x27, 0x0a, 0x0f, 0x65, 0x6e, 0x71, 0x75, 0x65, 0x75, 0x65, 0x5f, 0x6f, 0x70, 0x74, 0x69, 0x6f,
-	0x6e, 0x73, 0x18, 0x05, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0e, 0x65, 0x6e, 0x71, 0x75, 0x65, 0x75,
-	0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x46, 0x0a, 0x11, 0x6e, 0x65, 0x78, 0x74,
-	0x5f, 0x65, 0x6e, 0x71, 0x75, 0x65, 0x75, 0x65, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x06, 0x20,
-	0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f,
-	0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52,
-	0x0f, 0x6e, 0x65, 0x78, 0x74, 0x45, 0x6e, 0x71, 0x75, 0x65, 0x75, 0x65, 0x54, 0x69, 0x6d, 0x65,
-	0x12, 0x46, 0x0a, 0x11, 0x70, 0x72, 0x65, 0x76, 0x5f, 0x65, 0x6e, 0x71, 0x75, 0x65, 0x75, 0x65,
-	0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f,
-	0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69,
-	0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x0f, 0x70, 0x72, 0x65, 0x76, 0x45, 0x6e, 0x71,
-	0x75, 0x65, 0x75, 0x65, 0x54, 0x69, 0x6d, 0x65, 0x22, 0x6f, 0x0a, 0x15, 0x53, 0x63, 0x68, 0x65,
-	0x64, 0x75, 0x6c, 0x65, 0x72, 0x45, 0x6e, 0x71, 0x75, 0x65, 0x75, 0x65, 0x45, 0x76, 0x65, 0x6e,
-	0x74, 0x12, 0x17, 0x0a, 0x07, 0x74, 0x61, 0x73, 0x6b, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01,
-	0x28, 0x09, 0x52, 0x06, 0x74, 0x61, 0x73, 0x6b, 0x49, 0x64, 0x12, 0x3d, 0x0a, 0x0c, 0x65, 0x6e,
-	0x71, 0x75, 0x65, 0x75, 0x65, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b,
-	0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62,
-	0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x0b, 0x65, 0x6e,
-	0x71, 0x75, 0x65, 0x75, 0x65, 0x54, 0x69, 0x6d, 0x65, 0x42, 0x29, 0x5a, 0x27, 0x67, 0x69, 0x74,
-	0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x68, 0x69, 0x62, 0x69, 0x6b, 0x65, 0x6e, 0x2f,
-	0x61, 0x73, 0x79, 0x6e, 0x71, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x70,
-	0x72, 0x6f, 0x74, 0x6f, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
-}
-
-var (
-	file_asynq_proto_rawDescOnce sync.Once
-	file_asynq_proto_rawDescData = file_asynq_proto_rawDesc
-)
-
-func file_asynq_proto_rawDescGZIP() []byte {
-	file_asynq_proto_rawDescOnce.Do(func() {
-		file_asynq_proto_rawDescData = protoimpl.X.CompressGZIP(file_asynq_proto_rawDescData)
-	})
-	return file_asynq_proto_rawDescData
-}
-
-var file_asynq_proto_msgTypes = make([]protoimpl.MessageInfo, 6)
-var file_asynq_proto_goTypes = []interface{}{
-	(*TaskMessage)(nil),           // 0: asynq.TaskMessage
-	(*ServerInfo)(nil),            // 1: asynq.ServerInfo
-	(*WorkerInfo)(nil),            // 2: asynq.WorkerInfo
-	(*SchedulerEntry)(nil),        // 3: asynq.SchedulerEntry
-	(*SchedulerEnqueueEvent)(nil), // 4: asynq.SchedulerEnqueueEvent
-	nil,                           // 5: asynq.ServerInfo.QueuesEntry
-	(*timestamppb.Timestamp)(nil), // 6: google.protobuf.Timestamp
-}
-var file_asynq_proto_depIdxs = []int32{
-	5, // 0: asynq.ServerInfo.queues:type_name -> asynq.ServerInfo.QueuesEntry
-	6, // 1: asynq.ServerInfo.start_time:type_name -> google.protobuf.Timestamp
-	6, // 2: asynq.WorkerInfo.start_time:type_name -> google.protobuf.Timestamp
-	6, // 3: asynq.WorkerInfo.deadline:type_name -> google.protobuf.Timestamp
-	6, // 4: asynq.SchedulerEntry.next_enqueue_time:type_name -> google.protobuf.Timestamp
-	6, // 5: asynq.SchedulerEntry.prev_enqueue_time:type_name -> google.protobuf.Timestamp
-	6, // 6: asynq.SchedulerEnqueueEvent.enqueue_time:type_name -> google.protobuf.Timestamp
-	7, // [7:7] is the sub-list for method output_type
-	7, // [7:7] is the sub-list for method input_type
-	7, // [7:7] is the sub-list for extension type_name
-	7, // [7:7] is the sub-list for extension extendee
-	0, // [0:7] is the sub-list for field type_name
-}
-
-func init() { file_asynq_proto_init() }
-func file_asynq_proto_init() {
-	if File_asynq_proto != nil {
-		return
-	}
-	if !protoimpl.UnsafeEnabled {
-		file_asynq_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*TaskMessage); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-		file_asynq_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*ServerInfo); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-		file_asynq_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*WorkerInfo); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-		file_asynq_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*SchedulerEntry); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-		file_asynq_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*SchedulerEnqueueEvent); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-	}
-	type x struct{}
-	out := protoimpl.TypeBuilder{
-		File: protoimpl.DescBuilder{
-			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
-			RawDescriptor: file_asynq_proto_rawDesc,
-			NumEnums:      0,
-			NumMessages:   6,
-			NumExtensions: 0,
-			NumServices:   0,
-		},
-		GoTypes:           file_asynq_proto_goTypes,
-		DependencyIndexes: file_asynq_proto_depIdxs,
-		MessageInfos:      file_asynq_proto_msgTypes,
-	}.Build()
-	File_asynq_proto = out.File
-	file_asynq_proto_rawDesc = nil
-	file_asynq_proto_goTypes = nil
-	file_asynq_proto_depIdxs = nil
-}

internal/proto/asynq.proto

@@ -1,163 +0,0 @@
-// Copyright 2020 Kentaro Hibino. All rights reserved.
-// Use of this source code is governed by a MIT license
-// that can be found in the LICENSE file.
-
-syntax = "proto3";
-package asynq;
-
-import "google/protobuf/timestamp.proto";
-
-option go_package = "github.com/hibiken/asynq/internal/proto";
-
-// TaskMessage is the internal representation of a task with additional
-// metadata fields.
-message TaskMessage {
-	// Type indicates the kind of the task to be performed.
-  string type = 1;
-
-	// Payload holds data needed to process the task.
-  bytes payload = 2;
-
-	// Unique identifier for the task.
-  string id = 3;
-
-	// Name of the queue to which this task belongs.
-  string queue = 4;
-
-	// Max number of retries for this task.
-  int32 retry = 5;
-
-	// Number of times this task has been retried so far.
-  int32 retried = 6;
-
-	// Error message from the last failure.
-  string error_msg = 7;
-
-  // Time of last failure in Unix time,
-  // the number of seconds elapsed since January 1, 1970 UTC.
-  // Use zero to indicate no last failure.
-  int64 last_failed_at = 11;
-
-	// Timeout specifies timeout in seconds.
-	// Use zero to indicate no timeout.
-  int64 timeout = 8;
-
-	// Deadline specifies the deadline for the task in Unix time,
-	// the number of seconds elapsed since January 1, 1970 UTC.
-	// Use zero to indicate no deadline.
-  int64 deadline = 9;
-
-	// UniqueKey holds the redis key used for uniqueness lock for this task.
-	// Empty string indicates that no uniqueness lock was used.
-  string unique_key = 10;
-
-  // Retention period specified in a number of seconds.
-  // The task will be stored in redis as a completed task until the TTL
-  // expires.
-  int64 retention = 12;
-
-  // Time when the task completed in success in Unix time,
-  // the number of seconds elapsed since January 1, 1970 UTC.
-  // This field is populated if result_ttl > 0 upon completion.
-  int64 completed_at = 13;
-};
-
-// ServerInfo holds information about a running server.
-message ServerInfo {
-  // Host machine the server is running on.
-  string host = 1;
-
-  // PID of the server process.
-  int32 pid = 2;
-
-  // Unique identifier for this server.
-  string server_id = 3;
-
-  // Maximum number of concurrency this server will use.
-  int32 concurrency = 4;
-
-  // List of queue names with their priorities.
-  // The server will consume tasks from the queues and prioritize
-  // queues with higher priority numbers.
-  map<string, int32> queues = 5;
-
-  // If set, the server will always consume tasks from a queue with higher
-  // priority.
-  bool strict_priority = 6;
-
-  // Status indicates the status of the server.
-  string status = 7;
-
-  // Time this server was started.
-  google.protobuf.Timestamp start_time = 8;
-
-  // Number of workers currently processing tasks.
-  int32 active_worker_count = 9;
-};
-
-// WorkerInfo holds information about a running worker.
-message WorkerInfo {
-  // Host matchine this worker is running on.
-  string host = 1;
-
-  // PID of the process in which this worker is running.
-  int32 pid = 2;
-
-  // ID of the server in which this worker is running.
-  string server_id = 3;
-
-  // ID of the task this worker is processing.
-  string task_id = 4;
-
-  // Type of the task this worker is processing.
-  string task_type = 5;
-
-  // Payload of the task this worker is processing.
-  bytes task_payload = 6;
-
-  // Name of the queue the task the worker is processing belongs.
-  string queue = 7;
-
-  // Time this worker started processing the task.
-  google.protobuf.Timestamp start_time = 8;
-
-  // Deadline by which the worker needs to complete processing 
-  // the task. If worker exceeds the deadline, the task will fail.
-  google.protobuf.Timestamp deadline = 9;
-};
-
-// SchedulerEntry holds information about a periodic task registered 
-// with a scheduler.
-message SchedulerEntry {
-	// Identifier of the scheduler entry.
-	string id = 1;
-
-	// Periodic schedule spec of the entry.
-	string spec = 2;
-
-	// Task type of the periodic task.
-	string task_type = 3;
-
-	// Task payload of the periodic task.
-	bytes task_payload = 4;
-
-	// Options used to enqueue the periodic task.
-	repeated string enqueue_options = 5;
-
-	// Next time the task will be enqueued.
-  google.protobuf.Timestamp next_enqueue_time = 6;
-
-	// Last time the task was enqueued.
-	// Zero time if task was never enqueued.
-  google.protobuf.Timestamp prev_enqueue_time = 7;
-};
-
-// SchedulerEnqueueEvent holds information about an enqueue event
-// by a scheduler.
-message SchedulerEnqueueEvent {
-	// ID of the task that was enqueued.
-  string task_id = 1;
-
-	// Time the task was enqueued.
-  google.protobuf.Timestamp enqueue_time = 2;
-};

internal/rdb/benchmark_test.go

@@ -5,269 +5,37 @@
 package rdb
 
 import (
-	"context"
-	"fmt"
 	"testing"
-	"time"
 
-	"github.com/hibiken/asynq/internal/asynqtest"
+	"github.com/go-redis/redis/v7"
+	h "github.com/hibiken/asynq/internal/asynqtest"
 	"github.com/hibiken/asynq/internal/base"
 )
 
-func BenchmarkEnqueue(b *testing.B) {
-	r := setup(b)
-	ctx := context.Background()
-	msg := asynqtest.NewTaskMessage("task1", nil)
-	b.ResetTimer()
-
-	for i := 0; i < b.N; i++ {
-		b.StopTimer()
-		asynqtest.FlushDB(b, r.client)
-		b.StartTimer()
-
-		if err := r.Enqueue(ctx, msg); err != nil {
-			b.Fatalf("Enqueue failed: %v", err)
-		}
-	}
-}
-
-func BenchmarkEnqueueUnique(b *testing.B) {
-	r := setup(b)
-	ctx := context.Background()
-	msg := &base.TaskMessage{
-		Type:      "task1",
-		Payload:   nil,
-		Queue:     base.DefaultQueueName,
-		UniqueKey: base.UniqueKey("default", "task1", nil),
-	}
-	uniqueTTL := 5 * time.Minute
-	b.ResetTimer()
-
-	for i := 0; i < b.N; i++ {
-		b.StopTimer()
-		asynqtest.FlushDB(b, r.client)
-		b.StartTimer()
-
-		if err := r.EnqueueUnique(ctx, msg, uniqueTTL); err != nil {
-			b.Fatalf("EnqueueUnique failed: %v", err)
-		}
-	}
-}
-
-func BenchmarkSchedule(b *testing.B) {
-	r := setup(b)
-	ctx := context.Background()
-	msg := asynqtest.NewTaskMessage("task1", nil)
-	processAt := time.Now().Add(3 * time.Minute)
-	b.ResetTimer()
-
-	for i := 0; i < b.N; i++ {
-		b.StopTimer()
-		asynqtest.FlushDB(b, r.client)
-		b.StartTimer()
-
-		if err := r.Schedule(ctx, msg, processAt); err != nil {
-			b.Fatalf("Schedule failed: %v", err)
-		}
-	}
-}
-
-func BenchmarkScheduleUnique(b *testing.B) {
-	r := setup(b)
-	ctx := context.Background()
-	msg := &base.TaskMessage{
-		Type:      "task1",
-		Payload:   nil,
-		Queue:     base.DefaultQueueName,
-		UniqueKey: base.UniqueKey("default", "task1", nil),
-	}
-	processAt := time.Now().Add(3 * time.Minute)
-	uniqueTTL := 5 * time.Minute
-	b.ResetTimer()
-
-	for i := 0; i < b.N; i++ {
-		b.StopTimer()
-		asynqtest.FlushDB(b, r.client)
-		b.StartTimer()
-
-		if err := r.ScheduleUnique(ctx, msg, processAt, uniqueTTL); err != nil {
-			b.Fatalf("EnqueueUnique failed: %v", err)
-		}
-	}
-}
-
-func BenchmarkDequeueSingleQueue(b *testing.B) {
-	r := setup(b)
-	ctx := context.Background()
-	b.ResetTimer()
-
-	for i := 0; i < b.N; i++ {
-		b.StopTimer()
-		asynqtest.FlushDB(b, r.client)
-		for i := 0; i < 10; i++ {
-			m := asynqtest.NewTaskMessageWithQueue(
-				fmt.Sprintf("task%d", i), nil, base.DefaultQueueName)
-			if err := r.Enqueue(ctx, m); err != nil {
-				b.Fatalf("Enqueue failed: %v", err)
-			}
-		}
-		b.StartTimer()
-
-		if _, _, err := r.Dequeue(base.DefaultQueueName); err != nil {
-			b.Fatalf("Dequeue failed: %v", err)
-		}
-	}
-}
-
-func BenchmarkDequeueMultipleQueues(b *testing.B) {
-	qnames := []string{"critical", "default", "low"}
-	r := setup(b)
-	ctx := context.Background()
-	b.ResetTimer()
-
-	for i := 0; i < b.N; i++ {
-		b.StopTimer()
-		asynqtest.FlushDB(b, r.client)
-		for i := 0; i < 10; i++ {
-			for _, qname := range qnames {
-				m := asynqtest.NewTaskMessageWithQueue(
-					fmt.Sprintf("%s_task%d", qname, i), nil, qname)
-				if err := r.Enqueue(ctx, m); err != nil {
-					b.Fatalf("Enqueue failed: %v", err)
-				}
-			}
-		}
-		b.StartTimer()
-
-		if _, _, err := r.Dequeue(qnames...); err != nil {
-			b.Fatalf("Dequeue failed: %v", err)
-		}
-	}
-}
-
 func BenchmarkDone(b *testing.B) {
-	r := setup(b)
+	r := redis.NewClient(&redis.Options{
-	m1 := asynqtest.NewTaskMessage("task1", nil)
+		Addr: "localhost:6379",
-	m2 := asynqtest.NewTaskMessage("task2", nil)
+		DB:   8,
-	m3 := asynqtest.NewTaskMessage("task3", nil)
+	})
-	msgs := []*base.TaskMessage{m1, m2, m3}
+	h.FlushDB(b, r)
-	zs := []base.Z{
-		{Message: m1, Score: time.Now().Add(10 * time.Second).Unix()},
-		{Message: m2, Score: time.Now().Add(20 * time.Second).Unix()},
-		{Message: m3, Score: time.Now().Add(30 * time.Second).Unix()},
-	}
-	b.ResetTimer()
 
-	for i := 0; i < b.N; i++ {
+	// populate in-progress queue with messages
+	var inProgress []*base.TaskMessage
+	for i := 0; i < 40; i++ {
+		inProgress = append(inProgress,
+			h.NewTaskMessage("send_email", map[string]interface{}{"subject": "hello", "recipient_id": 123}))
+	}
+	h.SeedInProgressQueue(b, r, inProgress)
+
+	rdb := NewRDB(r)
+
+	b.ResetTimer()
+	for n := 0; n < b.N; n++ {
 		b.StopTimer()
-		asynqtest.FlushDB(b, r.client)
+		msg := h.NewTaskMessage("reindex", map[string]interface{}{"config": "path/to/config/file"})
-		asynqtest.SeedActiveQueue(b, r.client, msgs, base.DefaultQueueName)
+		r.LPush(base.InProgressQueue, h.MustMarshal(b, msg))
-		asynqtest.SeedDeadlines(b, r.client, zs, base.DefaultQueueName)
 		b.StartTimer()
 
-		if err := r.Done(msgs[0]); err != nil {
+		rdb.Done(msg)
-			b.Fatalf("Done failed: %v", err)
-		}
-	}
-}
-
-func BenchmarkRetry(b *testing.B) {
-	r := setup(b)
-	m1 := asynqtest.NewTaskMessage("task1", nil)
-	m2 := asynqtest.NewTaskMessage("task2", nil)
-	m3 := asynqtest.NewTaskMessage("task3", nil)
-	msgs := []*base.TaskMessage{m1, m2, m3}
-	zs := []base.Z{
-		{Message: m1, Score: time.Now().Add(10 * time.Second).Unix()},
-		{Message: m2, Score: time.Now().Add(20 * time.Second).Unix()},
-		{Message: m3, Score: time.Now().Add(30 * time.Second).Unix()},
-	}
-	b.ResetTimer()
-
-	for i := 0; i < b.N; i++ {
-		b.StopTimer()
-		asynqtest.FlushDB(b, r.client)
-		asynqtest.SeedActiveQueue(b, r.client, msgs, base.DefaultQueueName)
-		asynqtest.SeedDeadlines(b, r.client, zs, base.DefaultQueueName)
-		b.StartTimer()
-
-		if err := r.Retry(msgs[0], time.Now().Add(1*time.Minute), "error", true /*isFailure*/); err != nil {
-			b.Fatalf("Retry failed: %v", err)
-		}
-	}
-}
-
-func BenchmarkArchive(b *testing.B) {
-	r := setup(b)
-	m1 := asynqtest.NewTaskMessage("task1", nil)
-	m2 := asynqtest.NewTaskMessage("task2", nil)
-	m3 := asynqtest.NewTaskMessage("task3", nil)
-	msgs := []*base.TaskMessage{m1, m2, m3}
-	zs := []base.Z{
-		{Message: m1, Score: time.Now().Add(10 * time.Second).Unix()},
-		{Message: m2, Score: time.Now().Add(20 * time.Second).Unix()},
-		{Message: m3, Score: time.Now().Add(30 * time.Second).Unix()},
-	}
-	b.ResetTimer()
-
-	for i := 0; i < b.N; i++ {
-		b.StopTimer()
-		asynqtest.FlushDB(b, r.client)
-		asynqtest.SeedActiveQueue(b, r.client, msgs, base.DefaultQueueName)
-		asynqtest.SeedDeadlines(b, r.client, zs, base.DefaultQueueName)
-		b.StartTimer()
-
-		if err := r.Archive(msgs[0], "error"); err != nil {
-			b.Fatalf("Archive failed: %v", err)
-		}
-	}
-}
-
-func BenchmarkRequeue(b *testing.B) {
-	r := setup(b)
-	m1 := asynqtest.NewTaskMessage("task1", nil)
-	m2 := asynqtest.NewTaskMessage("task2", nil)
-	m3 := asynqtest.NewTaskMessage("task3", nil)
-	msgs := []*base.TaskMessage{m1, m2, m3}
-	zs := []base.Z{
-		{Message: m1, Score: time.Now().Add(10 * time.Second).Unix()},
-		{Message: m2, Score: time.Now().Add(20 * time.Second).Unix()},
-		{Message: m3, Score: time.Now().Add(30 * time.Second).Unix()},
-	}
-	b.ResetTimer()
-
-	for i := 0; i < b.N; i++ {
-		b.StopTimer()
-		asynqtest.FlushDB(b, r.client)
-		asynqtest.SeedActiveQueue(b, r.client, msgs, base.DefaultQueueName)
-		asynqtest.SeedDeadlines(b, r.client, zs, base.DefaultQueueName)
-		b.StartTimer()
-
-		if err := r.Requeue(msgs[0]); err != nil {
-			b.Fatalf("Requeue failed: %v", err)
-		}
-	}
-}
-
-func BenchmarkCheckAndEnqueue(b *testing.B) {
-	r := setup(b)
-	now := time.Now()
-	var zs []base.Z
-	for i := -100; i < 100; i++ {
-		msg := asynqtest.NewTaskMessage(fmt.Sprintf("task%d", i), nil)
-		score := now.Add(time.Duration(i) * time.Second).Unix()
-		zs = append(zs, base.Z{Message: msg, Score: score})
-	}
-	b.ResetTimer()
-
-	for i := 0; i < b.N; i++ {
-		b.StopTimer()
-		asynqtest.FlushDB(b, r.client)
-		asynqtest.SeedScheduledQueue(b, r.client, zs, base.DefaultQueueName)
-		b.StartTimer()
-
-		if err := r.ForwardIfReady(base.DefaultQueueName); err != nil {
-			b.Fatalf("ForwardIfReady failed: %v", err)
-		}
 	}
 }

internal/testbroker/testbroker.go

@@ -6,12 +6,11 @@
 package testbroker
 
 import (
-	"context"
 	"errors"
 	"sync"
 	"time"
 
-	"github.com/go-redis/redis/v8"
+	"github.com/go-redis/redis/v7"
 	"github.com/hibiken/asynq/internal/base"
 )
 
@@ -46,22 +45,22 @@ func (tb *TestBroker) Wakeup() {
 	tb.sleeping = false
 }
 
-func (tb *TestBroker) Enqueue(ctx context.Context, msg *base.TaskMessage) error {
+func (tb *TestBroker) Enqueue(msg *base.TaskMessage) error {
 	tb.mu.Lock()
 	defer tb.mu.Unlock()
 	if tb.sleeping {
 		return errRedisDown
 	}
-	return tb.real.Enqueue(ctx, msg)
+	return tb.real.Enqueue(msg)
 }
 
-func (tb *TestBroker) EnqueueUnique(ctx context.Context, msg *base.TaskMessage, ttl time.Duration) error {
+func (tb *TestBroker) EnqueueUnique(msg *base.TaskMessage, ttl time.Duration) error {
 	tb.mu.Lock()
 	defer tb.mu.Unlock()
 	if tb.sleeping {
 		return errRedisDown
 	}
-	return tb.real.EnqueueUnique(ctx, msg, ttl)
+	return tb.real.EnqueueUnique(msg, ttl)
 }
 
 func (tb *TestBroker) Dequeue(qnames ...string) (*base.TaskMessage, time.Time, error) {
@@ -82,15 +81,6 @@ func (tb *TestBroker) Done(msg *base.TaskMessage) error {
 	return tb.real.Done(msg)
 }
 
-func (tb *TestBroker) MarkAsComplete(msg *base.TaskMessage) error {
-	tb.mu.Lock()
-	defer tb.mu.Unlock()
-	if tb.sleeping {
-		return errRedisDown
-	}
-	return tb.real.MarkAsComplete(msg)
-}
-
 func (tb *TestBroker) Requeue(msg *base.TaskMessage) error {
 	tb.mu.Lock()
 	defer tb.mu.Unlock()
@@ -100,67 +90,58 @@ func (tb *TestBroker) Requeue(msg *base.TaskMessage) error {
 	return tb.real.Requeue(msg)
 }
 
-func (tb *TestBroker) Schedule(ctx context.Context, msg *base.TaskMessage, processAt time.Time) error {
+func (tb *TestBroker) Schedule(msg *base.TaskMessage, processAt time.Time) error {
 	tb.mu.Lock()
 	defer tb.mu.Unlock()
 	if tb.sleeping {
 		return errRedisDown
 	}
-	return tb.real.Schedule(ctx, msg, processAt)
+	return tb.real.Schedule(msg, processAt)
 }
 
-func (tb *TestBroker) ScheduleUnique(ctx context.Context, msg *base.TaskMessage, processAt time.Time, ttl time.Duration) error {
+func (tb *TestBroker) ScheduleUnique(msg *base.TaskMessage, processAt time.Time, ttl time.Duration) error {
 	tb.mu.Lock()
 	defer tb.mu.Unlock()
 	if tb.sleeping {
 		return errRedisDown
 	}
-	return tb.real.ScheduleUnique(ctx, msg, processAt, ttl)
+	return tb.real.ScheduleUnique(msg, processAt, ttl)
 }
 
-func (tb *TestBroker) Retry(msg *base.TaskMessage, processAt time.Time, errMsg string, isFailure bool) error {
+func (tb *TestBroker) Retry(msg *base.TaskMessage, processAt time.Time, errMsg string) error {
 	tb.mu.Lock()
 	defer tb.mu.Unlock()
 	if tb.sleeping {
 		return errRedisDown
 	}
-	return tb.real.Retry(msg, processAt, errMsg, isFailure)
+	return tb.real.Retry(msg, processAt, errMsg)
 }
 
-func (tb *TestBroker) Archive(msg *base.TaskMessage, errMsg string) error {
+func (tb *TestBroker) Kill(msg *base.TaskMessage, errMsg string) error {
 	tb.mu.Lock()
 	defer tb.mu.Unlock()
 	if tb.sleeping {
 		return errRedisDown
 	}
-	return tb.real.Archive(msg, errMsg)
+	return tb.real.Kill(msg, errMsg)
 }
 
-func (tb *TestBroker) ForwardIfReady(qnames ...string) error {
+func (tb *TestBroker) CheckAndEnqueue() error {
 	tb.mu.Lock()
 	defer tb.mu.Unlock()
 	if tb.sleeping {
 		return errRedisDown
 	}
-	return tb.real.ForwardIfReady(qnames...)
+	return tb.real.CheckAndEnqueue()
 }
 
-func (tb *TestBroker) DeleteExpiredCompletedTasks(qname string) error {
+func (tb *TestBroker) ListDeadlineExceeded(deadline time.Time) ([]*base.TaskMessage, error) {
-	tb.mu.Lock()
-	defer tb.mu.Unlock()
-	if tb.sleeping {
-		return errRedisDown
-	}
-	return tb.real.DeleteExpiredCompletedTasks(qname)
-}
-
-func (tb *TestBroker) ListDeadlineExceeded(deadline time.Time, qnames ...string) ([]*base.TaskMessage, error) {
 	tb.mu.Lock()
 	defer tb.mu.Unlock()
 	if tb.sleeping {
 		return nil, errRedisDown
 	}
-	return tb.real.ListDeadlineExceeded(deadline, qnames...)
+	return tb.real.ListDeadlineExceeded(deadline)
 }
 
 func (tb *TestBroker) WriteServerState(info *base.ServerInfo, workers []*base.WorkerInfo, ttl time.Duration) error {
@@ -199,24 +180,6 @@ func (tb *TestBroker) PublishCancelation(id string) error {
 	return tb.real.PublishCancelation(id)
 }
 
-func (tb *TestBroker) WriteResult(qname, id string, data []byte) (int, error) {
-	tb.mu.Lock()
-	defer tb.mu.Unlock()
-	if tb.sleeping {
-		return 0, errRedisDown
-	}
-	return tb.real.WriteResult(qname, id, data)
-}
-
-func (tb *TestBroker) Ping() error {
-	tb.mu.Lock()
-	defer tb.mu.Unlock()
-	if tb.sleeping {
-		return errRedisDown
-	}
-	return tb.real.Ping()
-}
-
 func (tb *TestBroker) Close() error {
 	tb.mu.Lock()
 	defer tb.mu.Unlock()

internal/timeutil/timeutil.go

@@ -1,38 +0,0 @@
-// Package timeutil exports functions and types related to time and date.
-package timeutil
-
-import "time"
-
-// A Clock is an object that can tell you the current time.
-//
-// This interface allows decoupling code that uses time from the code that creates
-// a point in time. You can use this to your advantage by injecting Clocks into interfaces
-// rather than having implementations call time.Now() directly.
-//
-// Use RealClock() in production.
-// Use SimulatedClock() in test.
-type Clock interface {
-	Now() time.Time
-}
-
-func NewRealClock() Clock { return &realTimeClock{} }
-
-type realTimeClock struct{}
-
-func (_ *realTimeClock) Now() time.Time { return time.Now() }
-
-// A SimulatedClock is a concrete Clock implementation that doesn't "tick" on its own.
-// Time is advanced by explicit call to the AdvanceTime() or SetTime() functions.
-type SimulatedClock struct {
-	t time.Time
-}
-
-func NewSimulatedClock(t time.Time) *SimulatedClock {
-	return &SimulatedClock{t}
-}
-
-func (c *SimulatedClock) Now() time.Time { return c.t }
-
-func (c *SimulatedClock) SetTime(t time.Time) { c.t = t }
-
-func (c *SimulatedClock) AdvanceTime(d time.Duration) { c.t.Add(d) }

janitor.go

@@ -1,81 +0,0 @@
-// Copyright 2021 Kentaro Hibino. All rights reserved.
-// Use of this source code is governed by a MIT license
-// that can be found in the LICENSE file.
-
-package asynq
-
-import (
-	"sync"
-	"time"
-
-	"github.com/hibiken/asynq/internal/base"
-	"github.com/hibiken/asynq/internal/log"
-)
-
-// A janitor is responsible for deleting expired completed tasks from the specified
-// queues. It periodically checks for any expired tasks in the completed set, and
-// deletes them.
-type janitor struct {
-	logger *log.Logger
-	broker base.Broker
-
-	// channel to communicate back to the long running "janitor" goroutine.
-	done chan struct{}
-
-	// list of queue names to check.
-	queues []string
-
-	// average interval between checks.
-	avgInterval time.Duration
-}
-
-type janitorParams struct {
-	logger   *log.Logger
-	broker   base.Broker
-	queues   []string
-	interval time.Duration
-}
-
-func newJanitor(params janitorParams) *janitor {
-	return &janitor{
-		logger:      params.logger,
-		broker:      params.broker,
-		done:        make(chan struct{}),
-		queues:      params.queues,
-		avgInterval: params.interval,
-	}
-}
-
-func (j *janitor) shutdown() {
-	j.logger.Debug("Janitor shutting down...")
-	// Signal the janitor goroutine to stop.
-	j.done <- struct{}{}
-}
-
-// start starts the "janitor" goroutine.
-func (j *janitor) start(wg *sync.WaitGroup) {
-	wg.Add(1)
-	timer := time.NewTimer(j.avgInterval) // randomize this interval with margin of 1s
-	go func() {
-		defer wg.Done()
-		for {
-			select {
-			case <-j.done:
-				j.logger.Debug("Janitor done")
-				return
-			case <-timer.C:
-				j.exec()
-				timer.Reset(j.avgInterval)
-			}
-		}
-	}()
-}
-
-func (j *janitor) exec() {
-	for _, qname := range j.queues {
-		if err := j.broker.DeleteExpiredCompletedTasks(qname); err != nil {
-			j.logger.Errorf("Could not delete expired completed tasks from queue %q: %v",
-				qname, err)
-		}
-	}
-}

janitor_test.go

@@ -1,89 +0,0 @@
-// Copyright 2021 Kentaro Hibino. All rights reserved.
-// Use of this source code is governed by a MIT license
-// that can be found in the LICENSE file.
-
-package asynq
-
-import (
-	"sync"
-	"testing"
-	"time"
-
-	"github.com/google/go-cmp/cmp"
-	h "github.com/hibiken/asynq/internal/asynqtest"
-	"github.com/hibiken/asynq/internal/base"
-	"github.com/hibiken/asynq/internal/rdb"
-)
-
-func newCompletedTask(qname, tasktype string, payload []byte, completedAt time.Time) *base.TaskMessage {
-	msg := h.NewTaskMessageWithQueue(tasktype, payload, qname)
-	msg.CompletedAt = completedAt.Unix()
-	return msg
-}
-
-func TestJanitor(t *testing.T) {
-	r := setup(t)
-	defer r.Close()
-	rdbClient := rdb.NewRDB(r)
-	const interval = 1 * time.Second
-	janitor := newJanitor(janitorParams{
-		logger:   testLogger,
-		broker:   rdbClient,
-		queues:   []string{"default", "custom"},
-		interval: interval,
-	})
-
-	now := time.Now()
-	hourAgo := now.Add(-1 * time.Hour)
-	minuteAgo := now.Add(-1 * time.Minute)
-	halfHourAgo := now.Add(-30 * time.Minute)
-	halfHourFromNow := now.Add(30 * time.Minute)
-	fiveMinFromNow := now.Add(5 * time.Minute)
-	msg1 := newCompletedTask("default", "task1", nil, hourAgo)
-	msg2 := newCompletedTask("default", "task2", nil, minuteAgo)
-	msg3 := newCompletedTask("custom", "task3", nil, hourAgo)
-	msg4 := newCompletedTask("custom", "task4", nil, minuteAgo)
-
-	tests := []struct {
-		completed     map[string][]base.Z // initial completed sets
-		wantCompleted map[string][]base.Z // expected completed sets after janitor runs
-	}{
-		{
-			completed: map[string][]base.Z{
-				"default": {
-					{Message: msg1, Score: halfHourAgo.Unix()},
-					{Message: msg2, Score: fiveMinFromNow.Unix()},
-				},
-				"custom": {
-					{Message: msg3, Score: halfHourFromNow.Unix()},
-					{Message: msg4, Score: minuteAgo.Unix()},
-				},
-			},
-			wantCompleted: map[string][]base.Z{
-				"default": {
-					{Message: msg2, Score: fiveMinFromNow.Unix()},
-				},
-				"custom": {
-					{Message: msg3, Score: halfHourFromNow.Unix()},
-				},
-			},
-		},
-	}
-
-	for _, tc := range tests {
-		h.FlushDB(t, r)
-		h.SeedAllCompletedQueues(t, r, tc.completed)
-
-		var wg sync.WaitGroup
-		janitor.start(&wg)
-		time.Sleep(2 * interval) // make sure to let janitor run at least one time
-		janitor.shutdown()
-
-		for qname, want := range tc.wantCompleted {
-			got := h.GetCompletedEntries(t, r, qname)
-			if diff := cmp.Diff(want, got, h.SortZSetEntryOpt); diff != "" {
-				t.Errorf("diff found in %q after running janitor: (-want, +got)\n%s", base.CompletedKey(qname), diff)
-			}
-		}
-	}
-}

payload.go

@@ -0,0 +1,220 @@
+// Copyright 2020 Kentaro Hibino. All rights reserved.
+// Use of this source code is governed by a MIT license
+// that can be found in the LICENSE file.
+
+package asynq
+
+import (
+	"encoding/json"
+	"fmt"
+	"time"
+
+	"github.com/spf13/cast"
+)
+
+// Payload holds arbitrary data needed for task execution.
+type Payload struct {
+	data map[string]interface{}
+}
+
+type errKeyNotFound struct {
+	key string
+}
+
+func (e *errKeyNotFound) Error() string {
+	return fmt.Sprintf("key %q does not exist", e.key)
+}
+
+// Has reports whether key exists.
+func (p Payload) Has(key string) bool {
+	_, ok := p.data[key]
+	return ok
+}
+
+func toInt(v interface{}) (int, error) {
+	switch v := v.(type) {
+	case json.Number:
+		val, err := v.Int64()
+		if err != nil {
+			return 0, err
+		}
+		return int(val), nil
+	default:
+		return cast.ToIntE(v)
+	}
+}
+
+// GetString returns a string value if a string type is associated with
+// the key, otherwise reports an error.
+func (p Payload) GetString(key string) (string, error) {
+	v, ok := p.data[key]
+	if !ok {
+		return "", &errKeyNotFound{key}
+	}
+	return cast.ToStringE(v)
+}
+
+// GetInt returns an int value if a numeric type is associated with
+// the key, otherwise reports an error.
+func (p Payload) GetInt(key string) (int, error) {
+	v, ok := p.data[key]
+	if !ok {
+		return 0, &errKeyNotFound{key}
+	}
+	return toInt(v)
+}
+
+// GetFloat64 returns a float64 value if a numeric type is associated with
+// the key, otherwise reports an error.
+func (p Payload) GetFloat64(key string) (float64, error) {
+	v, ok := p.data[key]
+	if !ok {
+		return 0, &errKeyNotFound{key}
+	}
+	switch v := v.(type) {
+	case json.Number:
+		return v.Float64()
+	default:
+		return cast.ToFloat64E(v)
+	}
+}
+
+// GetBool returns a boolean value if a boolean type is associated with
+// the key, otherwise reports an error.
+func (p Payload) GetBool(key string) (bool, error) {
+	v, ok := p.data[key]
+	if !ok {
+		return false, &errKeyNotFound{key}
+	}
+	return cast.ToBoolE(v)
+}
+
+// GetStringSlice returns a slice of strings if a string slice type is associated with
+// the key, otherwise reports an error.
+func (p Payload) GetStringSlice(key string) ([]string, error) {
+	v, ok := p.data[key]
+	if !ok {
+		return nil, &errKeyNotFound{key}
+	}
+	return cast.ToStringSliceE(v)
+}
+
+// GetIntSlice returns a slice of ints if a int slice type is associated with
+// the key, otherwise reports an error.
+func (p Payload) GetIntSlice(key string) ([]int, error) {
+	v, ok := p.data[key]
+	if !ok {
+		return nil, &errKeyNotFound{key}
+	}
+	switch v := v.(type) {
+	case []interface{}:
+		var res []int
+		for _, elem := range v {
+			val, err := toInt(elem)
+			if err != nil {
+				return nil, err
+			}
+			res = append(res, int(val))
+		}
+		return res, nil
+	default:
+		return cast.ToIntSliceE(v)
+	}
+}
+
+// GetStringMap returns a map of string to empty interface
+// if a correct map type is associated with the key,
+// otherwise reports an error.
+func (p Payload) GetStringMap(key string) (map[string]interface{}, error) {
+	v, ok := p.data[key]
+	if !ok {
+		return nil, &errKeyNotFound{key}
+	}
+	return cast.ToStringMapE(v)
+}
+
+// GetStringMapString returns a map of string to string
+// if a correct map type is associated with the key,
+// otherwise reports an error.
+func (p Payload) GetStringMapString(key string) (map[string]string, error) {
+	v, ok := p.data[key]
+	if !ok {
+		return nil, &errKeyNotFound{key}
+	}
+	return cast.ToStringMapStringE(v)
+}
+
+// GetStringMapStringSlice returns a map of string to string slice
+// if a correct map type is associated with the key,
+// otherwise reports an error.
+func (p Payload) GetStringMapStringSlice(key string) (map[string][]string, error) {
+	v, ok := p.data[key]
+	if !ok {
+		return nil, &errKeyNotFound{key}
+	}
+	return cast.ToStringMapStringSliceE(v)
+}
+
+// GetStringMapInt returns a map of string to int
+// if a correct map type is associated with the key,
+// otherwise reports an error.
+func (p Payload) GetStringMapInt(key string) (map[string]int, error) {
+	v, ok := p.data[key]
+	if !ok {
+		return nil, &errKeyNotFound{key}
+	}
+	switch v := v.(type) {
+	case map[string]interface{}:
+		res := make(map[string]int)
+		for key, val := range v {
+			ival, err := toInt(val)
+			if err != nil {
+				return nil, err
+			}
+			res[key] = ival
+		}
+		return res, nil
+	default:
+		return cast.ToStringMapIntE(v)
+	}
+}
+
+// GetStringMapBool returns a map of string to boolean
+// if a correct map type is associated with the key,
+// otherwise reports an error.
+func (p Payload) GetStringMapBool(key string) (map[string]bool, error) {
+	v, ok := p.data[key]
+	if !ok {
+		return nil, &errKeyNotFound{key}
+	}
+	return cast.ToStringMapBoolE(v)
+}
+
+// GetTime returns a time value if a correct map type is associated with the key,
+// otherwise reports an error.
+func (p Payload) GetTime(key string) (time.Time, error) {
+	v, ok := p.data[key]
+	if !ok {
+		return time.Time{}, &errKeyNotFound{key}
+	}
+	return cast.ToTimeE(v)
+}
+
+// GetDuration returns a duration value if a correct map type is associated with the key,
+// otherwise reports an error.
+func (p Payload) GetDuration(key string) (time.Duration, error) {
+	v, ok := p.data[key]
+	if !ok {
+		return 0, &errKeyNotFound{key}
+	}
+	switch v := v.(type) {
+	case json.Number:
+		val, err := v.Int64()
+		if err != nil {
+			return 0, err
+		}
+		return time.Duration(val), nil
+	default:
+		return cast.ToDurationE(v)
+	}
+}

payload_test.go

@@ -0,0 +1,647 @@
+// Copyright 2020 Kentaro Hibino. All rights reserved.
+// Use of this source code is governed by a MIT license
+// that can be found in the LICENSE file.
+
+package asynq
+
+import (
+	"encoding/json"
+	"testing"
+	"time"
+
+	"github.com/google/go-cmp/cmp"
+	"github.com/google/go-cmp/cmp/cmpopts"
+	h "github.com/hibiken/asynq/internal/asynqtest"
+	"github.com/hibiken/asynq/internal/base"
+)
+
+type payloadTest struct {
+	data   map[string]interface{}
+	key    string
+	nonkey string
+}
+
+func TestPayloadString(t *testing.T) {
+	tests := []payloadTest{
+		{
+			data:   map[string]interface{}{"name": "gopher"},
+			key:    "name",
+			nonkey: "unknown",
+		},
+	}
+
+	for _, tc := range tests {
+		payload := Payload{tc.data}
+
+		got, err := payload.GetString(tc.key)
+		if err != nil || got != tc.data[tc.key] {
+			t.Errorf("Payload.GetString(%q) = %v, %v, want %v, nil",
+				tc.key, got, err, tc.data[tc.key])
+		}
+
+		// encode and then decode task messsage.
+		in := h.NewTaskMessage("testing", tc.data)
+		encoded, err := base.EncodeMessage(in)
+		if err != nil {
+			t.Fatal(err)
+		}
+		out, err := base.DecodeMessage(encoded)
+		if err != nil {
+			t.Fatal(err)
+		}
+		payload = Payload{out.Payload}
+		got, err = payload.GetString(tc.key)
+		if err != nil || got != tc.data[tc.key] {
+			t.Errorf("With Marshaling: Payload.GetString(%q) = %v, %v, want %v, nil",
+				tc.key, got, err, tc.data[tc.key])
+		}
+
+		// access non-existent key.
+		got, err = payload.GetString(tc.nonkey)
+		if err == nil || got != "" {
+			t.Errorf("Payload.GetString(%q) = %v, %v; want '', error",
+				tc.key, got, err)
+		}
+	}
+}
+
+func TestPayloadInt(t *testing.T) {
+	tests := []payloadTest{
+		{
+			data:   map[string]interface{}{"user_id": 42},
+			key:    "user_id",
+			nonkey: "unknown",
+		},
+	}
+
+	for _, tc := range tests {
+		payload := Payload{tc.data}
+
+		got, err := payload.GetInt(tc.key)
+		if err != nil || got != tc.data[tc.key] {
+			t.Errorf("Payload.GetInt(%q) = %v, %v, want %v, nil",
+				tc.key, got, err, tc.data[tc.key])
+		}
+
+		// encode and then decode task messsage.
+		in := h.NewTaskMessage("testing", tc.data)
+		encoded, err := base.EncodeMessage(in)
+		if err != nil {
+			t.Fatal(err)
+		}
+		out, err := base.DecodeMessage(encoded)
+		if err != nil {
+			t.Fatal(err)
+		}
+		payload = Payload{out.Payload}
+		got, err = payload.GetInt(tc.key)
+		if err != nil || got != tc.data[tc.key] {
+			t.Errorf("With Marshaling: Payload.GetInt(%q) = %v, %v, want %v, nil",
+				tc.key, got, err, tc.data[tc.key])
+		}
+
+		// access non-existent key.
+		got, err = payload.GetInt(tc.nonkey)
+		if err == nil || got != 0 {
+			t.Errorf("Payload.GetInt(%q) = %v, %v; want 0, error",
+				tc.key, got, err)
+		}
+	}
+}
+
+func TestPayloadFloat64(t *testing.T) {
+	tests := []payloadTest{
+		{
+			data:   map[string]interface{}{"pi": 3.14},
+			key:    "pi",
+			nonkey: "unknown",
+		},
+	}
+
+	for _, tc := range tests {
+		payload := Payload{tc.data}
+
+		got, err := payload.GetFloat64(tc.key)
+		if err != nil || got != tc.data[tc.key] {
+			t.Errorf("Payload.GetFloat64(%q) = %v, %v, want %v, nil",
+				tc.key, got, err, tc.data[tc.key])
+		}
+
+		// encode and then decode task messsage.
+		in := h.NewTaskMessage("testing", tc.data)
+		encoded, err := base.EncodeMessage(in)
+		if err != nil {
+			t.Fatal(err)
+		}
+		out, err := base.DecodeMessage(encoded)
+		if err != nil {
+			t.Fatal(err)
+		}
+		payload = Payload{out.Payload}
+		got, err = payload.GetFloat64(tc.key)
+		if err != nil || got != tc.data[tc.key] {
+			t.Errorf("With Marshaling: Payload.GetFloat64(%q) = %v, %v, want %v, nil",
+				tc.key, got, err, tc.data[tc.key])
+		}
+
+		// access non-existent key.
+		got, err = payload.GetFloat64(tc.nonkey)
+		if err == nil || got != 0 {
+			t.Errorf("Payload.GetFloat64(%q) = %v, %v; want 0, error",
+				tc.key, got, err)
+		}
+	}
+}
+
+func TestPayloadBool(t *testing.T) {
+	tests := []payloadTest{
+		{
+			data:   map[string]interface{}{"enabled": true},
+			key:    "enabled",
+			nonkey: "unknown",
+		},
+	}
+
+	for _, tc := range tests {
+		payload := Payload{tc.data}
+
+		got, err := payload.GetBool(tc.key)
+		if err != nil || got != tc.data[tc.key] {
+			t.Errorf("Payload.GetBool(%q) = %v, %v, want %v, nil",
+				tc.key, got, err, tc.data[tc.key])
+		}
+
+		// encode and then decode task messsage.
+		in := h.NewTaskMessage("testing", tc.data)
+		encoded, err := base.EncodeMessage(in)
+		if err != nil {
+			t.Fatal(err)
+		}
+		out, err := base.DecodeMessage(encoded)
+		if err != nil {
+			t.Fatal(err)
+		}
+		payload = Payload{out.Payload}
+		got, err = payload.GetBool(tc.key)
+		if err != nil || got != tc.data[tc.key] {
+			t.Errorf("With Marshaling: Payload.GetBool(%q) = %v, %v, want %v, nil",
+				tc.key, got, err, tc.data[tc.key])
+		}
+
+		// access non-existent key.
+		got, err = payload.GetBool(tc.nonkey)
+		if err == nil || got != false {
+			t.Errorf("Payload.GetBool(%q) = %v, %v; want false, error",
+				tc.key, got, err)
+		}
+	}
+}
+
+func TestPayloadStringSlice(t *testing.T) {
+	tests := []payloadTest{
+		{
+			data:   map[string]interface{}{"names": []string{"luke", "rey", "anakin"}},
+			key:    "names",
+			nonkey: "unknown",
+		},
+	}
+
+	for _, tc := range tests {
+		payload := Payload{tc.data}
+
+		got, err := payload.GetStringSlice(tc.key)
+		diff := cmp.Diff(got, tc.data[tc.key])
+		if err != nil || diff != "" {
+			t.Errorf("Payload.GetStringSlice(%q) = %v, %v, want %v, nil",
+				tc.key, got, err, tc.data[tc.key])
+		}
+
+		// encode and then decode task messsage.
+		in := h.NewTaskMessage("testing", tc.data)
+		encoded, err := base.EncodeMessage(in)
+		if err != nil {
+			t.Fatal(err)
+		}
+		out, err := base.DecodeMessage(encoded)
+		if err != nil {
+			t.Fatal(err)
+		}
+		payload = Payload{out.Payload}
+		got, err = payload.GetStringSlice(tc.key)
+		diff = cmp.Diff(got, tc.data[tc.key])
+		if err != nil || diff != "" {
+			t.Errorf("With Marshaling: Payload.GetStringSlice(%q) = %v, %v, want %v, nil",
+				tc.key, got, err, tc.data[tc.key])
+		}
+
+		// access non-existent key.
+		got, err = payload.GetStringSlice(tc.nonkey)
+		if err == nil || got != nil {
+			t.Errorf("Payload.GetStringSlice(%q) = %v, %v; want nil, error",
+				tc.key, got, err)
+		}
+	}
+}
+
+func TestPayloadIntSlice(t *testing.T) {
+	tests := []payloadTest{
+		{
+			data:   map[string]interface{}{"nums": []int{9, 8, 7}},
+			key:    "nums",
+			nonkey: "unknown",
+		},
+	}
+
+	for _, tc := range tests {
+		payload := Payload{tc.data}
+
+		got, err := payload.GetIntSlice(tc.key)
+		diff := cmp.Diff(got, tc.data[tc.key])
+		if err != nil || diff != "" {
+			t.Errorf("Payload.GetIntSlice(%q) = %v, %v, want %v, nil",
+				tc.key, got, err, tc.data[tc.key])
+		}
+
+		// encode and then decode task messsage.
+		in := h.NewTaskMessage("testing", tc.data)
+		encoded, err := base.EncodeMessage(in)
+		if err != nil {
+			t.Fatal(err)
+		}
+		out, err := base.DecodeMessage(encoded)
+		if err != nil {
+			t.Fatal(err)
+		}
+		payload = Payload{out.Payload}
+		got, err = payload.GetIntSlice(tc.key)
+		diff = cmp.Diff(got, tc.data[tc.key])
+		if err != nil || diff != "" {
+			t.Errorf("With Marshaling: Payload.GetIntSlice(%q) = %v, %v, want %v, nil",
+				tc.key, got, err, tc.data[tc.key])
+		}
+
+		// access non-existent key.
+		got, err = payload.GetIntSlice(tc.nonkey)
+		if err == nil || got != nil {
+			t.Errorf("Payload.GetIntSlice(%q) = %v, %v; want nil, error",
+				tc.key, got, err)
+		}
+	}
+}
+
+func TestPayloadStringMap(t *testing.T) {
+	tests := []payloadTest{
+		{
+			data:   map[string]interface{}{"user": map[string]interface{}{"name": "Jon Doe", "score": 2.2}},
+			key:    "user",
+			nonkey: "unknown",
+		},
+	}
+
+	for _, tc := range tests {
+		payload := Payload{tc.data}
+
+		got, err := payload.GetStringMap(tc.key)
+		diff := cmp.Diff(got, tc.data[tc.key])
+		if err != nil || diff != "" {
+			t.Errorf("Payload.GetStringMap(%q) = %v, %v, want %v, nil",
+				tc.key, got, err, tc.data[tc.key])
+		}
+
+		// encode and then decode task messsage.
+		in := h.NewTaskMessage("testing", tc.data)
+		encoded, err := base.EncodeMessage(in)
+		if err != nil {
+			t.Fatal(err)
+		}
+		out, err := base.DecodeMessage(encoded)
+		if err != nil {
+			t.Fatal(err)
+		}
+		payload = Payload{out.Payload}
+		got, err = payload.GetStringMap(tc.key)
+		ignoreOpt := cmpopts.IgnoreMapEntries(func(key string, val interface{}) bool {
+			switch val.(type) {
+			case json.Number:
+				return true
+			default:
+				return false
+			}
+		})
+		diff = cmp.Diff(got, tc.data[tc.key], ignoreOpt)
+		if err != nil || diff != "" {
+			t.Errorf("With Marshaling: Payload.GetStringMap(%q) = %v, %v, want %v, nil;(-want,+got)\n%s",
+				tc.key, got, err, tc.data[tc.key], diff)
+		}
+
+		// access non-existent key.
+		got, err = payload.GetStringMap(tc.nonkey)
+		if err == nil || got != nil {
+			t.Errorf("Payload.GetStringMap(%q) = %v, %v; want nil, error",
+				tc.key, got, err)
+		}
+	}
+}
+
+func TestPayloadStringMapString(t *testing.T) {
+	tests := []payloadTest{
+		{
+			data:   map[string]interface{}{"address": map[string]string{"line": "123 Main St", "city": "San Francisco", "state": "CA"}},
+			key:    "address",
+			nonkey: "unknown",
+		},
+	}
+
+	for _, tc := range tests {
+		payload := Payload{tc.data}
+
+		got, err := payload.GetStringMapString(tc.key)
+		diff := cmp.Diff(got, tc.data[tc.key])
+		if err != nil || diff != "" {
+			t.Errorf("Payload.GetStringMapString(%q) = %v, %v, want %v, nil",
+				tc.key, got, err, tc.data[tc.key])
+		}
+
+		// encode and then decode task messsage.
+		in := h.NewTaskMessage("testing", tc.data)
+		encoded, err := base.EncodeMessage(in)
+		if err != nil {
+			t.Fatal(err)
+		}
+		out, err := base.DecodeMessage(encoded)
+		if err != nil {
+			t.Fatal(err)
+		}
+		payload = Payload{out.Payload}
+		got, err = payload.GetStringMapString(tc.key)
+		diff = cmp.Diff(got, tc.data[tc.key])
+		if err != nil || diff != "" {
+			t.Errorf("With Marshaling: Payload.GetStringMapString(%q) = %v, %v, want %v, nil",
+				tc.key, got, err, tc.data[tc.key])
+		}
+
+		// access non-existent key.
+		got, err = payload.GetStringMapString(tc.nonkey)
+		if err == nil || got != nil {
+			t.Errorf("Payload.GetStringMapString(%q) = %v, %v; want nil, error",
+				tc.key, got, err)
+		}
+	}
+}
+
+func TestPayloadStringMapStringSlice(t *testing.T) {
+	favs := map[string][]string{
+		"movies":   {"forrest gump", "star wars"},
+		"tv_shows": {"game of thrones", "HIMYM", "breaking bad"},
+	}
+	tests := []payloadTest{
+		{
+			data:   map[string]interface{}{"favorites": favs},
+			key:    "favorites",
+			nonkey: "unknown",
+		},
+	}
+
+	for _, tc := range tests {
+		payload := Payload{tc.data}
+
+		got, err := payload.GetStringMapStringSlice(tc.key)
+		diff := cmp.Diff(got, tc.data[tc.key])
+		if err != nil || diff != "" {
+			t.Errorf("Payload.GetStringMapStringSlice(%q) = %v, %v, want %v, nil",
+				tc.key, got, err, tc.data[tc.key])
+		}
+
+		// encode and then decode task messsage.
+		in := h.NewTaskMessage("testing", tc.data)
+		encoded, err := base.EncodeMessage(in)
+		if err != nil {
+			t.Fatal(err)
+		}
+		out, err := base.DecodeMessage(encoded)
+		if err != nil {
+			t.Fatal(err)
+		}
+		payload = Payload{out.Payload}
+		got, err = payload.GetStringMapStringSlice(tc.key)
+		diff = cmp.Diff(got, tc.data[tc.key])
+		if err != nil || diff != "" {
+			t.Errorf("With Marshaling: Payload.GetStringMapStringSlice(%q) = %v, %v, want %v, nil",
+				tc.key, got, err, tc.data[tc.key])
+		}
+
+		// access non-existent key.
+		got, err = payload.GetStringMapStringSlice(tc.nonkey)
+		if err == nil || got != nil {
+			t.Errorf("Payload.GetStringMapStringSlice(%q) = %v, %v; want nil, error",
+				tc.key, got, err)
+		}
+	}
+}
+
+func TestPayloadStringMapInt(t *testing.T) {
+	counter := map[string]int{
+		"a": 1,
+		"b": 101,
+		"c": 42,
+	}
+	tests := []payloadTest{
+		{
+			data:   map[string]interface{}{"counts": counter},
+			key:    "counts",
+			nonkey: "unknown",
+		},
+	}
+
+	for _, tc := range tests {
+		payload := Payload{tc.data}
+
+		got, err := payload.GetStringMapInt(tc.key)
+		diff := cmp.Diff(got, tc.data[tc.key])
+		if err != nil || diff != "" {
+			t.Errorf("Payload.GetStringMapInt(%q) = %v, %v, want %v, nil",
+				tc.key, got, err, tc.data[tc.key])
+		}
+
+		// encode and then decode task messsage.
+		in := h.NewTaskMessage("testing", tc.data)
+		encoded, err := base.EncodeMessage(in)
+		if err != nil {
+			t.Fatal(err)
+		}
+		out, err := base.DecodeMessage(encoded)
+		if err != nil {
+			t.Fatal(err)
+		}
+		payload = Payload{out.Payload}
+		got, err = payload.GetStringMapInt(tc.key)
+		diff = cmp.Diff(got, tc.data[tc.key])
+		if err != nil || diff != "" {
+			t.Errorf("With Marshaling: Payload.GetStringMapInt(%q) = %v, %v, want %v, nil",
+				tc.key, got, err, tc.data[tc.key])
+		}
+
+		// access non-existent key.
+		got, err = payload.GetStringMapInt(tc.nonkey)
+		if err == nil || got != nil {
+			t.Errorf("Payload.GetStringMapInt(%q) = %v, %v; want nil, error",
+				tc.key, got, err)
+		}
+	}
+}
+
+func TestPayloadStringMapBool(t *testing.T) {
+	features := map[string]bool{
+		"A": false,
+		"B": true,
+		"C": true,
+	}
+	tests := []payloadTest{
+		{
+			data:   map[string]interface{}{"features": features},
+			key:    "features",
+			nonkey: "unknown",
+		},
+	}
+
+	for _, tc := range tests {
+		payload := Payload{tc.data}
+
+		got, err := payload.GetStringMapBool(tc.key)
+		diff := cmp.Diff(got, tc.data[tc.key])
+		if err != nil || diff != "" {
+			t.Errorf("Payload.GetStringMapBool(%q) = %v, %v, want %v, nil",
+				tc.key, got, err, tc.data[tc.key])
+		}
+
+		// encode and then decode task messsage.
+		in := h.NewTaskMessage("testing", tc.data)
+		encoded, err := base.EncodeMessage(in)
+		if err != nil {
+			t.Fatal(err)
+		}
+		out, err := base.DecodeMessage(encoded)
+		if err != nil {
+			t.Fatal(err)
+		}
+		payload = Payload{out.Payload}
+		got, err = payload.GetStringMapBool(tc.key)
+		diff = cmp.Diff(got, tc.data[tc.key])
+		if err != nil || diff != "" {
+			t.Errorf("With Marshaling: Payload.GetStringMapBool(%q) = %v, %v, want %v, nil",
+				tc.key, got, err, tc.data[tc.key])
+		}
+
+		// access non-existent key.
+		got, err = payload.GetStringMapBool(tc.nonkey)
+		if err == nil || got != nil {
+			t.Errorf("Payload.GetStringMapBool(%q) = %v, %v; want nil, error",
+				tc.key, got, err)
+		}
+	}
+}
+
+func TestPayloadTime(t *testing.T) {
+	tests := []payloadTest{
+		{
+			data:   map[string]interface{}{"current": time.Now()},
+			key:    "current",
+			nonkey: "unknown",
+		},
+	}
+
+	for _, tc := range tests {
+		payload := Payload{tc.data}
+
+		got, err := payload.GetTime(tc.key)
+		diff := cmp.Diff(got, tc.data[tc.key])
+		if err != nil || diff != "" {
+			t.Errorf("Payload.GetTime(%q) = %v, %v, want %v, nil",
+				tc.key, got, err, tc.data[tc.key])
+		}
+
+		// encode and then decode task messsage.
+		in := h.NewTaskMessage("testing", tc.data)
+		encoded, err := base.EncodeMessage(in)
+		if err != nil {
+			t.Fatal(err)
+		}
+		out, err := base.DecodeMessage(encoded)
+		if err != nil {
+			t.Fatal(err)
+		}
+		payload = Payload{out.Payload}
+		got, err = payload.GetTime(tc.key)
+		diff = cmp.Diff(got, tc.data[tc.key])
+		if err != nil || diff != "" {
+			t.Errorf("With Marshaling: Payload.GetTime(%q) = %v, %v, want %v, nil",
+				tc.key, got, err, tc.data[tc.key])
+		}
+
+		// access non-existent key.
+		got, err = payload.GetTime(tc.nonkey)
+		if err == nil || !got.IsZero() {
+			t.Errorf("Payload.GetTime(%q) = %v, %v; want %v, error",
+				tc.key, got, err, time.Time{})
+		}
+	}
+}
+
+func TestPayloadDuration(t *testing.T) {
+	tests := []payloadTest{
+		{
+			data:   map[string]interface{}{"duration": 15 * time.Minute},
+			key:    "duration",
+			nonkey: "unknown",
+		},
+	}
+
+	for _, tc := range tests {
+		payload := Payload{tc.data}
+
+		got, err := payload.GetDuration(tc.key)
+		diff := cmp.Diff(got, tc.data[tc.key])
+		if err != nil || diff != "" {
+			t.Errorf("Payload.GetDuration(%q) = %v, %v, want %v, nil",
+				tc.key, got, err, tc.data[tc.key])
+		}
+
+		// encode and then decode task messsage.
+		in := h.NewTaskMessage("testing", tc.data)
+		encoded, err := base.EncodeMessage(in)
+		if err != nil {
+			t.Fatal(err)
+		}
+		out, err := base.DecodeMessage(encoded)
+		if err != nil {
+			t.Fatal(err)
+		}
+		payload = Payload{out.Payload}
+		got, err = payload.GetDuration(tc.key)
+		diff = cmp.Diff(got, tc.data[tc.key])
+		if err != nil || diff != "" {
+			t.Errorf("With Marshaling: Payload.GetDuration(%q) = %v, %v, want %v, nil",
+				tc.key, got, err, tc.data[tc.key])
+		}
+
+		// access non-existent key.
+		got, err = payload.GetDuration(tc.nonkey)
+		if err == nil || got != 0 {
+			t.Errorf("Payload.GetDuration(%q) = %v, %v; want %v, error",
+				tc.key, got, err, time.Duration(0))
+		}
+	}
+}
+
+func TestPayloadHas(t *testing.T) {
+	payload := Payload{map[string]interface{}{
+		"user_id": 123,
+	}}
+
+	if !payload.Has("user_id") {
+		t.Errorf("Payload.Has(%q) = false, want true", "user_id")
+	}
+	if payload.Has("name") {
+		t.Errorf("Payload.Has(%q) = true, want false", "name")
+	}
+}

periodic_task_manager.go

@@ -1,243 +0,0 @@
-// Copyright 2022 Kentaro Hibino. All rights reserved.
-// Use of this source code is governed by a MIT license
-// that can be found in the LICENSE file.
-
-package asynq
-
-import (
-	"crypto/sha256"
-	"fmt"
-	"io"
-	"sort"
-	"sync"
-	"time"
-)
-
-// PeriodicTaskManager manages scheduling of periodic tasks.
-// It syncs scheduler's entries by calling the config provider periodically.
-type PeriodicTaskManager struct {
-	s            *Scheduler
-	p            PeriodicTaskConfigProvider
-	syncInterval time.Duration
-	done         chan (struct{})
-	wg           sync.WaitGroup
-	m            map[string]string // map[hash]entryID
-}
-
-type PeriodicTaskManagerOpts struct {
-	// Required: must be non nil
-	PeriodicTaskConfigProvider PeriodicTaskConfigProvider
-
-	// Required: must be non nil
-	RedisConnOpt RedisConnOpt
-
-	// Optional: scheduler options
-	*SchedulerOpts
-
-	// Optional: default is 3m
-	SyncInterval time.Duration
-}
-
-const defaultSyncInterval = 3 * time.Minute
-
-// NewPeriodicTaskManager returns a new PeriodicTaskManager instance.
-// The given opts should specify the RedisConnOp and PeriodicTaskConfigProvider at minimum.
-func NewPeriodicTaskManager(opts PeriodicTaskManagerOpts) (*PeriodicTaskManager, error) {
-	if opts.PeriodicTaskConfigProvider == nil {
-		return nil, fmt.Errorf("PeriodicTaskConfigProvider cannot be nil")
-	}
-	if opts.RedisConnOpt == nil {
-		return nil, fmt.Errorf("RedisConnOpt cannot be nil")
-	}
-	scheduler := NewScheduler(opts.RedisConnOpt, opts.SchedulerOpts)
-	syncInterval := opts.SyncInterval
-	if syncInterval == 0 {
-		syncInterval = defaultSyncInterval
-	}
-	return &PeriodicTaskManager{
-		s:            scheduler,
-		p:            opts.PeriodicTaskConfigProvider,
-		syncInterval: syncInterval,
-		done:         make(chan struct{}),
-		m:            make(map[string]string),
-	}, nil
-}
-
-// PeriodicTaskConfigProvider provides configs for periodic tasks.
-// GetConfigs will be called by a PeriodicTaskManager periodically to
-// sync the scheduler's entries with the configs returned by the provider.
-type PeriodicTaskConfigProvider interface {
-	GetConfigs() ([]*PeriodicTaskConfig, error)
-}
-
-// PeriodicTaskConfig specifies the details of a periodic task.
-type PeriodicTaskConfig struct {
-	Cronspec string   // required: must be non empty string
-	Task     *Task    // required: must be non nil
-	Opts     []Option // optional: can be nil
-}
-
-func (c *PeriodicTaskConfig) hash() string {
-	h := sha256.New()
-	io.WriteString(h, c.Cronspec)
-	io.WriteString(h, c.Task.Type())
-	h.Write(c.Task.Payload())
-	opts := stringifyOptions(c.Opts)
-	sort.Strings(opts)
-	for _, opt := range opts {
-		io.WriteString(h, opt)
-	}
-	return fmt.Sprintf("%x", h.Sum(nil))
-}
-
-func validatePeriodicTaskConfig(c *PeriodicTaskConfig) error {
-	if c == nil {
-		return fmt.Errorf("PeriodicTaskConfig cannot be nil")
-	}
-	if c.Task == nil {
-		return fmt.Errorf("PeriodicTaskConfig.Task cannot be nil")
-	}
-	if c.Cronspec == "" {
-		return fmt.Errorf("PeriodicTaskConfig.Cronspec cannot be empty")
-	}
-	return nil
-}
-
-// Start starts a scheduler and background goroutine to sync the scheduler with the configs
-// returned by the provider.
-//
-// Start returns any error encountered at start up time.
-func (mgr *PeriodicTaskManager) Start() error {
-	if mgr.s == nil || mgr.p == nil {
-		panic("asynq: cannot start uninitialized PeriodicTaskManager; use NewPeriodicTaskManager to initialize")
-	}
-	if err := mgr.initialSync(); err != nil {
-		return fmt.Errorf("asynq: %v", err)
-	}
-	if err := mgr.s.Start(); err != nil {
-		return fmt.Errorf("asynq: %v", err)
-	}
-	mgr.wg.Add(1)
-	go func() {
-		defer mgr.wg.Done()
-		ticker := time.NewTicker(mgr.syncInterval)
-		for {
-			select {
-			case <-mgr.done:
-				mgr.s.logger.Debugf("Stopping syncer goroutine")
-				ticker.Stop()
-				return
-			case <-ticker.C:
-				mgr.sync()
-			}
-		}
-	}()
-	return nil
-}
-
-// Shutdown gracefully shuts down the manager.
-// It notifies a background syncer goroutine to stop and stops scheduler.
-func (mgr *PeriodicTaskManager) Shutdown() {
-	close(mgr.done)
-	mgr.wg.Wait()
-	mgr.s.Shutdown()
-}
-
-// Run starts the manager and blocks until an os signal to exit the program is received.
-// Once it receives a signal, it gracefully shuts down the manager.
-func (mgr *PeriodicTaskManager) Run() error {
-	if err := mgr.Start(); err != nil {
-		return err
-	}
-	mgr.s.waitForSignals()
-	mgr.Shutdown()
-	mgr.s.logger.Debugf("PeriodicTaskManager exiting")
-	return nil
-}
-
-func (mgr *PeriodicTaskManager) initialSync() error {
-	configs, err := mgr.p.GetConfigs()
-	if err != nil {
-		return fmt.Errorf("initial call to GetConfigs failed: %v", err)
-	}
-	for _, c := range configs {
-		if err := validatePeriodicTaskConfig(c); err != nil {
-			return fmt.Errorf("initial call to GetConfigs contained an invalid config: %v", err)
-		}
-	}
-	mgr.add(configs)
-	return nil
-}
-
-func (mgr *PeriodicTaskManager) add(configs []*PeriodicTaskConfig) {
-	for _, c := range configs {
-		entryID, err := mgr.s.Register(c.Cronspec, c.Task, c.Opts...)
-		if err != nil {
-			mgr.s.logger.Errorf("Failed to register periodic task: cronspec=%q task=%q",
-				c.Cronspec, c.Task.Type())
-			continue
-		}
-		mgr.m[c.hash()] = entryID
-		mgr.s.logger.Infof("Successfully registered periodic task: cronspec=%q task=%q, entryID=%s",
-			c.Cronspec, c.Task.Type(), entryID)
-	}
-}
-
-func (mgr *PeriodicTaskManager) remove(removed map[string]string) {
-	for hash, entryID := range removed {
-		if err := mgr.s.Unregister(entryID); err != nil {
-			mgr.s.logger.Errorf("Failed to unregister periodic task: %v", err)
-			continue
-		}
-		delete(mgr.m, hash)
-		mgr.s.logger.Infof("Successfully unregistered periodic task: entryID=%s", entryID)
-	}
-}
-
-func (mgr *PeriodicTaskManager) sync() {
-	configs, err := mgr.p.GetConfigs()
-	if err != nil {
-		mgr.s.logger.Errorf("Failed to get periodic task configs: %v", err)
-		return
-	}
-	for _, c := range configs {
-		if err := validatePeriodicTaskConfig(c); err != nil {
-			mgr.s.logger.Errorf("Failed to sync: GetConfigs returned an invalid config: %v", err)
-			return
-		}
-	}
-	// Diff and only register/unregister the newly added/removed entries.
-	removed := mgr.diffRemoved(configs)
-	added := mgr.diffAdded(configs)
-	mgr.remove(removed)
-	mgr.add(added)
-}
-
-// diffRemoved diffs the incoming configs with the registered config and returns
-// a map containing hash and entryID of each config that was removed.
-func (mgr *PeriodicTaskManager) diffRemoved(configs []*PeriodicTaskConfig) map[string]string {
-	newConfigs := make(map[string]string)
-	for _, c := range configs {
-		newConfigs[c.hash()] = "" // empty value since we don't have entryID yet
-	}
-	removed := make(map[string]string)
-	for k, v := range mgr.m {
-		// test whether existing config is present in the incoming configs
-		if _, found := newConfigs[k]; !found {
-			removed[k] = v
-		}
-	}
-	return removed
-}
-
-// diffAdded diffs the incoming configs with the registered configs and returns
-// a list of configs that were added.
-func (mgr *PeriodicTaskManager) diffAdded(configs []*PeriodicTaskConfig) []*PeriodicTaskConfig {
-	var added []*PeriodicTaskConfig
-	for _, c := range configs {
-		if _, found := mgr.m[c.hash()]; !found {
-			added = append(added, c)
-		}
-	}
-	return added
-}

periodic_task_manager_test.go

@@ -1,343 +0,0 @@
-// Copyright 2022 Kentaro Hibino. All rights reserved.
-// Use of this source code is governed by a MIT license
-// that can be found in the LICENSE file.
-
-package asynq
-
-import (
-	"sort"
-	"sync"
-	"testing"
-	"time"
-
-	"github.com/google/go-cmp/cmp"
-)
-
-// Trivial implementation of PeriodicTaskConfigProvider for testing purpose.
-type FakeConfigProvider struct {
-	mu   sync.Mutex
-	cfgs []*PeriodicTaskConfig
-}
-
-func (p *FakeConfigProvider) SetConfigs(cfgs []*PeriodicTaskConfig) {
-	p.mu.Lock()
-	defer p.mu.Unlock()
-	p.cfgs = cfgs
-}
-
-func (p *FakeConfigProvider) GetConfigs() ([]*PeriodicTaskConfig, error) {
-	p.mu.Lock()
-	defer p.mu.Unlock()
-	return p.cfgs, nil
-}
-
-func TestNewPeriodicTaskManager(t *testing.T) {
-	cfgs := []*PeriodicTaskConfig{
-		{Cronspec: "* * * * *", Task: NewTask("foo", nil)},
-		{Cronspec: "* * * * *", Task: NewTask("bar", nil)},
-	}
-	tests := []struct {
-		desc string
-		opts PeriodicTaskManagerOpts
-	}{
-		{
-			desc: "with provider and redisConnOpt",
-			opts: PeriodicTaskManagerOpts{
-				RedisConnOpt:               RedisClientOpt{Addr: ":6379"},
-				PeriodicTaskConfigProvider: &FakeConfigProvider{cfgs: cfgs},
-			},
-		},
-		{
-			desc: "with sync option",
-			opts: PeriodicTaskManagerOpts{
-				RedisConnOpt:               RedisClientOpt{Addr: ":6379"},
-				PeriodicTaskConfigProvider: &FakeConfigProvider{cfgs: cfgs},
-				SyncInterval:               5 * time.Minute,
-			},
-		},
-		{
-			desc: "with scheduler option",
-			opts: PeriodicTaskManagerOpts{
-				RedisConnOpt:               RedisClientOpt{Addr: ":6379"},
-				PeriodicTaskConfigProvider: &FakeConfigProvider{cfgs: cfgs},
-				SyncInterval:               5 * time.Minute,
-				SchedulerOpts: &SchedulerOpts{
-					LogLevel: DebugLevel,
-				},
-			},
-		},
-	}
-
-	for _, tc := range tests {
-		_, err := NewPeriodicTaskManager(tc.opts)
-		if err != nil {
-			t.Errorf("%s; NewPeriodicTaskManager returned error: %v", tc.desc, err)
-		}
-	}
-}
-
-func TestNewPeriodicTaskManagerError(t *testing.T) {
-	cfgs := []*PeriodicTaskConfig{
-		{Cronspec: "* * * * *", Task: NewTask("foo", nil)},
-		{Cronspec: "* * * * *", Task: NewTask("bar", nil)},
-	}
-	tests := []struct {
-		desc string
-		opts PeriodicTaskManagerOpts
-	}{
-		{
-			desc: "without provider",
-			opts: PeriodicTaskManagerOpts{
-				RedisConnOpt: RedisClientOpt{Addr: ":6379"},
-			},
-		},
-		{
-			desc: "without redisConOpt",
-			opts: PeriodicTaskManagerOpts{
-				PeriodicTaskConfigProvider: &FakeConfigProvider{cfgs: cfgs},
-			},
-		},
-	}
-
-	for _, tc := range tests {
-		_, err := NewPeriodicTaskManager(tc.opts)
-		if err == nil {
-			t.Errorf("%s; NewPeriodicTaskManager did not return error", tc.desc)
-		}
-	}
-}
-
-func TestPeriodicTaskConfigHash(t *testing.T) {
-	tests := []struct {
-		desc   string
-		a      *PeriodicTaskConfig
-		b      *PeriodicTaskConfig
-		isSame bool
-	}{
-		{
-			desc: "basic identity test",
-			a: &PeriodicTaskConfig{
-				Cronspec: "* * * * *",
-				Task:     NewTask("foo", nil),
-			},
-			b: &PeriodicTaskConfig{
-				Cronspec: "* * * * *",
-				Task:     NewTask("foo", nil),
-			},
-			isSame: true,
-		},
-		{
-			desc: "with a option",
-			a: &PeriodicTaskConfig{
-				Cronspec: "* * * * *",
-				Task:     NewTask("foo", nil),
-				Opts:     []Option{Queue("myqueue")},
-			},
-			b: &PeriodicTaskConfig{
-				Cronspec: "* * * * *",
-				Task:     NewTask("foo", nil),
-				Opts:     []Option{Queue("myqueue")},
-			},
-			isSame: true,
-		},
-		{
-			desc: "with multiple options (different order)",
-			a: &PeriodicTaskConfig{
-				Cronspec: "* * * * *",
-				Task:     NewTask("foo", nil),
-				Opts:     []Option{Unique(5 * time.Minute), Queue("myqueue")},
-			},
-			b: &PeriodicTaskConfig{
-				Cronspec: "* * * * *",
-				Task:     NewTask("foo", nil),
-				Opts:     []Option{Queue("myqueue"), Unique(5 * time.Minute)},
-			},
-			isSame: true,
-		},
-		{
-			desc: "with payload",
-			a: &PeriodicTaskConfig{
-				Cronspec: "* * * * *",
-				Task:     NewTask("foo", []byte("hello world!")),
-				Opts:     []Option{Queue("myqueue")},
-			},
-			b: &PeriodicTaskConfig{
-				Cronspec: "* * * * *",
-				Task:     NewTask("foo", []byte("hello world!")),
-				Opts:     []Option{Queue("myqueue")},
-			},
-			isSame: true,
-		},
-		{
-			desc: "with different cronspecs",
-			a: &PeriodicTaskConfig{
-				Cronspec: "* * * * *",
-				Task:     NewTask("foo", nil),
-			},
-			b: &PeriodicTaskConfig{
-				Cronspec: "5 * * * *",
-				Task:     NewTask("foo", nil),
-			},
-			isSame: false,
-		},
-		{
-			desc: "with different task type",
-			a: &PeriodicTaskConfig{
-				Cronspec: "* * * * *",
-				Task:     NewTask("foo", nil),
-			},
-			b: &PeriodicTaskConfig{
-				Cronspec: "* * * * *",
-				Task:     NewTask("bar", nil),
-			},
-			isSame: false,
-		},
-		{
-			desc: "with different options",
-			a: &PeriodicTaskConfig{
-				Cronspec: "* * * * *",
-				Task:     NewTask("foo", nil),
-				Opts:     []Option{Queue("myqueue")},
-			},
-			b: &PeriodicTaskConfig{
-				Cronspec: "* * * * *",
-				Task:     NewTask("foo", nil),
-				Opts:     []Option{Unique(10 * time.Minute)},
-			},
-			isSame: false,
-		},
-		{
-			desc: "with different options (one is subset of the other)",
-			a: &PeriodicTaskConfig{
-				Cronspec: "* * * * *",
-				Task:     NewTask("foo", nil),
-				Opts:     []Option{Queue("myqueue")},
-			},
-			b: &PeriodicTaskConfig{
-				Cronspec: "* * * * *",
-				Task:     NewTask("foo", nil),
-				Opts:     []Option{Queue("myqueue"), Unique(10 * time.Minute)},
-			},
-			isSame: false,
-		},
-		{
-			desc: "with different payload",
-			a: &PeriodicTaskConfig{
-				Cronspec: "* * * * *",
-				Task:     NewTask("foo", []byte("hello!")),
-				Opts:     []Option{Queue("myqueue")},
-			},
-			b: &PeriodicTaskConfig{
-				Cronspec: "* * * * *",
-				Task:     NewTask("foo", []byte("HELLO!")),
-				Opts:     []Option{Queue("myqueue"), Unique(10 * time.Minute)},
-			},
-			isSame: false,
-		},
-	}
-
-	for _, tc := range tests {
-		if tc.isSame && tc.a.hash() != tc.b.hash() {
-			t.Errorf("%s: a.hash=%s b.hash=%s expected to be equal",
-				tc.desc, tc.a.hash(), tc.b.hash())
-		}
-		if !tc.isSame && tc.a.hash() == tc.b.hash() {
-			t.Errorf("%s: a.hash=%s b.hash=%s expected to be not equal",
-				tc.desc, tc.a.hash(), tc.b.hash())
-		}
-	}
-}
-
-// Things to test.
-// - Run the manager
-// - Change provider to return new configs
-// - Verify that the scheduler synced with the new config
-func TestPeriodicTaskManager(t *testing.T) {
-	// Note: In this test, we'll use task type as an ID for each config.
-	cfgs := []*PeriodicTaskConfig{
-		{Task: NewTask("task1", nil), Cronspec: "* * * * 1"},
-		{Task: NewTask("task2", nil), Cronspec: "* * * * 2"},
-	}
-	const syncInterval = 3 * time.Second
-	provider := &FakeConfigProvider{cfgs: cfgs}
-	mgr, err := NewPeriodicTaskManager(PeriodicTaskManagerOpts{
-		RedisConnOpt:               getRedisConnOpt(t),
-		PeriodicTaskConfigProvider: provider,
-		SyncInterval:               syncInterval,
-	})
-	if err != nil {
-		t.Fatalf("Failed to initialize PeriodicTaskManager: %v", err)
-	}
-
-	if err := mgr.Start(); err != nil {
-		t.Fatalf("Failed to start PeriodicTaskManager: %v", err)
-	}
-	defer mgr.Shutdown()
-
-	got := extractCronEntries(mgr.s)
-	want := []*cronEntry{
-		{Cronspec: "* * * * 1", TaskType: "task1"},
-		{Cronspec: "* * * * 2", TaskType: "task2"},
-	}
-	if diff := cmp.Diff(want, got, sortCronEntry); diff != "" {
-		t.Errorf("Diff found in scheduler's registered entries: %s", diff)
-	}
-
-	// Change the underlying configs
-	// - task2 removed
-	// - task3 added
-	provider.SetConfigs([]*PeriodicTaskConfig{
-		{Task: NewTask("task1", nil), Cronspec: "* * * * 1"},
-		{Task: NewTask("task3", nil), Cronspec: "* * * * 3"},
-	})
-
-	// Wait for the next sync
-	time.Sleep(syncInterval * 2)
-
-	// Verify the entries are synced
-	got = extractCronEntries(mgr.s)
-	want = []*cronEntry{
-		{Cronspec: "* * * * 1", TaskType: "task1"},
-		{Cronspec: "* * * * 3", TaskType: "task3"},
-	}
-	if diff := cmp.Diff(want, got, sortCronEntry); diff != "" {
-		t.Errorf("Diff found in scheduler's registered entries: %s", diff)
-	}
-
-	// Change the underlying configs
-	// All configs removed, empty set.
-	provider.SetConfigs([]*PeriodicTaskConfig{})
-
-	// Wait for the next sync
-	time.Sleep(syncInterval * 2)
-
-	// Verify the entries are synced
-	got = extractCronEntries(mgr.s)
-	want = []*cronEntry{}
-	if diff := cmp.Diff(want, got, sortCronEntry); diff != "" {
-		t.Errorf("Diff found in scheduler's registered entries: %s", diff)
-	}
-}
-
-func extractCronEntries(s *Scheduler) []*cronEntry {
-	var out []*cronEntry
-	for _, e := range s.cron.Entries() {
-		job := e.Job.(*enqueueJob)
-		out = append(out, &cronEntry{Cronspec: job.cronspec, TaskType: job.task.Type()})
-	}
-	return out
-}
-
-var sortCronEntry = cmp.Transformer("sortCronEntry", func(in []*cronEntry) []*cronEntry {
-	out := append([]*cronEntry(nil), in...)
-	sort.Slice(out, func(i, j int) bool {
-		return out[i].TaskType < out[j].TaskType
-	})
-	return out
-})
-
-// A simple struct to allow for simpler comparison in test.
-type cronEntry struct {
-	Cronspec string
-	TaskType string
-}

processor.go

@@ -8,17 +8,13 @@ import (
 	"context"
 	"fmt"
 	"math/rand"
-	"runtime"
-	"runtime/debug"
 	"sort"
-	"strings"
 	"sync"
 	"time"
 
 	"github.com/hibiken/asynq/internal/base"
-	asynqcontext "github.com/hibiken/asynq/internal/context"
-	"github.com/hibiken/asynq/internal/errors"
 	"github.com/hibiken/asynq/internal/log"
+	"github.com/hibiken/asynq/internal/rdb"
 	"golang.org/x/time/rate"
 )
 
@@ -33,8 +29,7 @@ type processor struct {
 	// orderedQueues is set only in strict-priority mode.
 	orderedQueues []string
 
-	retryDelayFunc RetryDelayFunc
+	retryDelayFunc retryDelayFunc
-	isFailureFunc  func(error) bool
 
 	errHandler ErrorHandler
 
@@ -61,18 +56,19 @@ type processor struct {
 	// abort channel communicates to the in-flight worker goroutines to stop.
 	abort chan struct{}
 
-	// cancelations is a set of cancel functions for all active tasks.
+	// cancelations is a set of cancel functions for all in-progress tasks.
 	cancelations *base.Cancelations
 
-	starting chan<- *workerInfo
+	starting chan<- *base.TaskMessage
 	finished chan<- *base.TaskMessage
 }
 
+type retryDelayFunc func(n int, err error, task *Task) time.Duration
+
 type processorParams struct {
 	logger          *log.Logger
 	broker          base.Broker
-	retryDelayFunc  RetryDelayFunc
+	retryDelayFunc  retryDelayFunc
-	isFailureFunc   func(error) bool
 	syncCh          chan<- *syncRequest
 	cancelations    *base.Cancelations
 	concurrency     int
@@ -80,7 +76,7 @@ type processorParams struct {
 	strictPriority  bool
 	errHandler      ErrorHandler
 	shutdownTimeout time.Duration
-	starting        chan<- *workerInfo
+	starting        chan<- *base.TaskMessage
 	finished        chan<- *base.TaskMessage
 }
 
@@ -97,7 +93,6 @@ func newProcessor(params processorParams) *processor {
 		queueConfig:    queues,
 		orderedQueues:  orderedQueues,
 		retryDelayFunc: params.retryDelayFunc,
-		isFailureFunc:   params.isFailureFunc,
 		syncRequestCh:  params.syncCh,
 		cancelations:   params.cancelations,
 		errLogLimiter:  rate.NewLimiter(rate.Every(3*time.Second), 1),
@@ -107,7 +102,6 @@ func newProcessor(params processorParams) *processor {
 		abort:          make(chan struct{}),
 		errHandler:     params.errHandler,
 		handler:        HandlerFunc(func(ctx context.Context, t *Task) error { return fmt.Errorf("handler not set") }),
-		shutdownTimeout: params.shutdownTimeout,
 		starting:       params.starting,
 		finished:       params.finished,
 	}
@@ -126,8 +120,8 @@ func (p *processor) stop() {
 	})
 }
 
-// NOTE: once shutdown, processor cannot be re-started.
+// NOTE: once terminated, processor cannot be re-started.
-func (p *processor) shutdown() {
+func (p *processor) terminate() {
 	p.stop()
 
 	time.AfterFunc(p.shutdownTimeout, func() { close(p.abort) })
@@ -166,7 +160,7 @@ func (p *processor) exec() {
 		qnames := p.queues()
 		msg, deadline, err := p.broker.Dequeue(qnames...)
 		switch {
-		case errors.Is(err, errors.ErrNoProcessableTask):
+		case err == rdb.ErrNoProcessableTask:
 			p.logger.Debug("All queues are empty")
 			// Queues are empty, this is a normal behavior.
 			// Sleep to avoid slamming redis and let scheduler move tasks into queues.
@@ -183,43 +177,23 @@ func (p *processor) exec() {
 			return
 		}
 
-		p.starting <- &workerInfo{msg, time.Now(), deadline}
+		p.starting <- msg
 		go func() {
 			defer func() {
 				p.finished <- msg
 				<-p.sema // release token
 			}()
 
-			ctx, cancel := asynqcontext.New(msg, deadline)
+			ctx, cancel := createContext(msg, deadline)
-			p.cancelations.Add(msg.ID, cancel)
+			p.cancelations.Add(msg.ID.String(), cancel)
 			defer func() {
 				cancel()
-				p.cancelations.Delete(msg.ID)
+				p.cancelations.Delete(msg.ID.String())
 			}()
 
-			// check context before starting a worker goroutine.
-			select {
-			case <-ctx.Done():
-				// already canceled (e.g. deadline exceeded).
-				p.handleFailedMessage(ctx, msg, ctx.Err())
-				return
-			default:
-			}
-
 			resCh := make(chan error, 1)
-			go func() {
+			task := NewTask(msg.Type, msg.Payload)
-				task := newTask(
+			go func() { resCh <- perform(ctx, task, p.handler) }()
-					msg.Type,
-					msg.Payload,
-					&ResultWriter{
-						id:     msg.ID,
-						qname:  msg.Queue,
-						broker: p.broker,
-						ctx:    ctx,
-					},
-				)
-				resCh <- p.perform(ctx, task)
-			}()
 
 			select {
 			case <-p.abort:
@@ -228,14 +202,22 @@ func (p *processor) exec() {
 				p.requeue(msg)
 				return
 			case <-ctx.Done():
-				p.handleFailedMessage(ctx, msg, ctx.Err())
+				p.logger.Debugf("Retrying task. task id=%s", msg.ID) // TODO: Improve this log message and above
+				p.retryOrKill(ctx, msg, ctx.Err())
 				return
 			case resErr := <-resCh:
+				// Note: One of three things should happen.
+				// 1) Done  -> Removes the message from InProgress
+				// 2) Retry -> Removes the message from InProgress & Adds the message to Retry
+				// 3) Kill  -> Removes the message from InProgress & Adds the message to Dead
 				if resErr != nil {
-					p.handleFailedMessage(ctx, msg, resErr)
+					if p.errHandler != nil {
+						p.errHandler.HandleError(ctx, task, resErr)
+					}
+					p.retryOrKill(ctx, msg, resErr)
 					return
 				}
-				p.handleSucceededMessage(ctx, msg)
+				p.markAsDone(ctx, msg)
 			}
 		}()
 	}
@@ -250,38 +232,10 @@ func (p *processor) requeue(msg *base.TaskMessage) {
 	}
 }
 
-func (p *processor) handleSucceededMessage(ctx context.Context, msg *base.TaskMessage) {
-	if msg.Retention > 0 {
-		p.markAsComplete(ctx, msg)
-	} else {
-		p.markAsDone(ctx, msg)
-	}
-}
-
-func (p *processor) markAsComplete(ctx context.Context, msg *base.TaskMessage) {
-	err := p.broker.MarkAsComplete(msg)
-	if err != nil {
-		errMsg := fmt.Sprintf("Could not move task id=%s type=%q from %q to %q:  %+v",
-			msg.ID, msg.Type, base.ActiveKey(msg.Queue), base.CompletedKey(msg.Queue), err)
-		deadline, ok := ctx.Deadline()
-		if !ok {
-			panic("asynq: internal error: missing deadline in context")
-		}
-		p.logger.Warnf("%s; Will retry syncing", errMsg)
-		p.syncRequestCh <- &syncRequest{
-			fn: func() error {
-				return p.broker.MarkAsComplete(msg)
-			},
-			errMsg:   errMsg,
-			deadline: deadline,
-		}
-	}
-}
-
 func (p *processor) markAsDone(ctx context.Context, msg *base.TaskMessage) {
 	err := p.broker.Done(msg)
 	if err != nil {
-		errMsg := fmt.Sprintf("Could not remove task id=%s type=%q from %q err: %+v", msg.ID, msg.Type, base.ActiveKey(msg.Queue), err)
+		errMsg := fmt.Sprintf("Could not remove task id=%s type=%q from %q err: %+v", msg.ID, msg.Type, base.InProgressQueue, err)
 		deadline, ok := ctx.Deadline()
 		if !ok {
 			panic("asynq: internal error: missing deadline in context")
@@ -297,33 +251,20 @@ func (p *processor) markAsDone(ctx context.Context, msg *base.TaskMessage) {
 	}
 }
 
-// SkipRetry is used as a return value from Handler.ProcessTask to indicate that
+func (p *processor) retryOrKill(ctx context.Context, msg *base.TaskMessage, err error) {
-// the task should not be retried and should be archived instead.
+	if msg.Retried >= msg.Retry {
-var SkipRetry = errors.New("skip retry for the task")
+		p.kill(ctx, msg, err)
-
-func (p *processor) handleFailedMessage(ctx context.Context, msg *base.TaskMessage, err error) {
-	if p.errHandler != nil {
-		p.errHandler.HandleError(ctx, NewTask(msg.Type, msg.Payload), err)
-	}
-	if !p.isFailureFunc(err) {
-		// retry the task without marking it as failed
-		p.retry(ctx, msg, err, false /*isFailure*/)
-		return
-	}
-	if msg.Retried >= msg.Retry || errors.Is(err, SkipRetry) {
-		p.logger.Warnf("Retry exhausted for task id=%s", msg.ID)
-		p.archive(ctx, msg, err)
 	} else {
-		p.retry(ctx, msg, err, true /*isFailure*/)
+		p.retry(ctx, msg, err)
 	}
 }
 
-func (p *processor) retry(ctx context.Context, msg *base.TaskMessage, e error, isFailure bool) {
+func (p *processor) retry(ctx context.Context, msg *base.TaskMessage, e error) {
 	d := p.retryDelayFunc(msg.Retried, e, NewTask(msg.Type, msg.Payload))
 	retryAt := time.Now().Add(d)
-	err := p.broker.Retry(msg, retryAt, e.Error(), isFailure)
+	err := p.broker.Retry(msg, retryAt, e.Error())
 	if err != nil {
-		errMsg := fmt.Sprintf("Could not move task id=%s from %q to %q", msg.ID, base.ActiveKey(msg.Queue), base.RetryKey(msg.Queue))
+		errMsg := fmt.Sprintf("Could not move task id=%s from %q to %q", msg.ID, base.InProgressQueue, base.RetryQueue)
 		deadline, ok := ctx.Deadline()
 		if !ok {
 			panic("asynq: internal error: missing deadline in context")
@@ -331,7 +272,7 @@ func (p *processor) retry(ctx context.Context, msg *base.TaskMessage, e error, i
 		p.logger.Warnf("%s; Will retry syncing", errMsg)
 		p.syncRequestCh <- &syncRequest{
 			fn: func() error {
-				return p.broker.Retry(msg, retryAt, e.Error(), isFailure)
+				return p.broker.Retry(msg, retryAt, e.Error())
 			},
 			errMsg:   errMsg,
 			deadline: deadline,
@@ -339,10 +280,11 @@ func (p *processor) retry(ctx context.Context, msg *base.TaskMessage, e error, i
 	}
 }
 
-func (p *processor) archive(ctx context.Context, msg *base.TaskMessage, e error) {
+func (p *processor) kill(ctx context.Context, msg *base.TaskMessage, e error) {
-	err := p.broker.Archive(msg, e.Error())
+	p.logger.Warnf("Retry exhausted for task id=%s", msg.ID)
+	err := p.broker.Kill(msg, e.Error())
 	if err != nil {
-		errMsg := fmt.Sprintf("Could not move task id=%s from %q to %q", msg.ID, base.ActiveKey(msg.Queue), base.ArchivedKey(msg.Queue))
+		errMsg := fmt.Sprintf("Could not move task id=%s from %q to %q", msg.ID, base.InProgressQueue, base.DeadQueue)
 		deadline, ok := ctx.Deadline()
 		if !ok {
 			panic("asynq: internal error: missing deadline in context")
@@ -350,7 +292,7 @@ func (p *processor) archive(ctx context.Context, msg *base.TaskMessage, e error)
 		p.logger.Warnf("%s; Will retry syncing", errMsg)
 		p.syncRequestCh <- &syncRequest{
 			fn: func() error {
-				return p.broker.Archive(msg, e.Error())
+				return p.broker.Kill(msg, e.Error())
 			},
 			errMsg:   errMsg,
 			deadline: deadline,
@@ -388,26 +330,13 @@ func (p *processor) queues() []string {
 // perform calls the handler with the given task.
 // If the call returns without panic, it simply returns the value,
 // otherwise, it recovers from panic and returns an error.
-func (p *processor) perform(ctx context.Context, task *Task) (err error) {
+func perform(ctx context.Context, task *Task, h Handler) (err error) {
 	defer func() {
 		if x := recover(); x != nil {
-			p.logger.Errorf("recovering from panic. See the stack trace below for details:\n%s", string(debug.Stack()))
-			_, file, line, ok := runtime.Caller(1) // skip the first frame (panic itself)
-			if ok && strings.Contains(file, "runtime/") {
-				// The panic came from the runtime, most likely due to incorrect
-				// map/slice usage. The parent frame should have the real trigger.
-				_, file, line, ok = runtime.Caller(2)
-			}
-
-			// Include the file and line number info in the error, if runtime.Caller returned ok.
-			if ok {
-				err = fmt.Errorf("panic [%s:%d]: %v", file, line, x)
-			} else {
 			err = fmt.Errorf("panic: %v", x)
 		}
-		}
 	}()
-	return p.handler.ProcessTask(ctx, task)
+	return h.ProcessTask(ctx, task)
 }
 
 // uniq dedupes elements and returns a slice of unique names of length l.

processor_test.go

@@ -6,7 +6,6 @@ package asynq
 
 import (
 	"context"
-	"encoding/json"
 	"fmt"
 	"sort"
 	"sync"
@@ -20,14 +19,8 @@ import (
 	"github.com/hibiken/asynq/internal/rdb"
 )
 
-var taskCmpOpts = []cmp.Option{
-	sortTaskOpt,                               // sort the tasks
-	cmp.AllowUnexported(Task{}),               // allow typename, payload fields to be compared
-	cmpopts.IgnoreFields(Task{}, "opts", "w"), // ignore opts, w fields
-}
-
 // fakeHeartbeater receives from starting and finished channels and do nothing.
-func fakeHeartbeater(starting <-chan *workerInfo, finished <-chan *base.TaskMessage, done <-chan struct{}) {
+func fakeHeartbeater(starting, finished <-chan *base.TaskMessage, done <-chan struct{}) {
 	for {
 		select {
 		case <-starting:
@@ -49,43 +42,14 @@ func fakeSyncer(syncCh <-chan *syncRequest, done <-chan struct{}) {
 	}
 }
 
-// Returns a processor instance configured for testing purpose.
+func TestProcessorSuccess(t *testing.T) {
-func newProcessorForTest(t *testing.T, r *rdb.RDB, h Handler) *processor {
-	starting := make(chan *workerInfo)
-	finished := make(chan *base.TaskMessage)
-	syncCh := make(chan *syncRequest)
-	done := make(chan struct{})
-	t.Cleanup(func() { close(done) })
-	go fakeHeartbeater(starting, finished, done)
-	go fakeSyncer(syncCh, done)
-	p := newProcessor(processorParams{
-		logger:          testLogger,
-		broker:          r,
-		retryDelayFunc:  DefaultRetryDelayFunc,
-		isFailureFunc:   defaultIsFailureFunc,
-		syncCh:          syncCh,
-		cancelations:    base.NewCancelations(),
-		concurrency:     10,
-		queues:          defaultQueueConfig,
-		strictPriority:  false,
-		errHandler:      nil,
-		shutdownTimeout: defaultShutdownTimeout,
-		starting:        starting,
-		finished:        finished,
-	})
-	p.handler = h
-	return p
-}
-
-func TestProcessorSuccessWithSingleQueue(t *testing.T) {
 	r := setup(t)
-	defer r.Close()
 	rdbClient := rdb.NewRDB(r)
 
-	m1 := h.NewTaskMessage("task1", nil)
+	m1 := h.NewTaskMessage("send_email", nil)
-	m2 := h.NewTaskMessage("task2", nil)
+	m2 := h.NewTaskMessage("gen_thumbnail", nil)
-	m3 := h.NewTaskMessage("task3", nil)
+	m3 := h.NewTaskMessage("reindex", nil)
-	m4 := h.NewTaskMessage("task4", nil)
+	m4 := h.NewTaskMessage("sync", nil)
 
 	t1 := NewTask(m1.Type, m1.Payload)
 	t2 := NewTask(m2.Type, m2.Payload)
@@ -93,17 +57,17 @@ func TestProcessorSuccessWithSingleQueue(t *testing.T) {
 	t4 := NewTask(m4.Type, m4.Payload)
 
 	tests := []struct {
-		pending       []*base.TaskMessage // initial default queue state
+		enqueued      []*base.TaskMessage // initial default queue state
 		incoming      []*base.TaskMessage // tasks to be enqueued during run
 		wantProcessed []*Task             // tasks to be processed at the end
 	}{
 		{
-			pending:       []*base.TaskMessage{m1},
+			enqueued:      []*base.TaskMessage{m1},
 			incoming:      []*base.TaskMessage{m2, m3, m4},
 			wantProcessed: []*Task{t1, t2, t3, t4},
 		},
 		{
-			pending:       []*base.TaskMessage{},
+			enqueued:      []*base.TaskMessage{},
 			incoming:      []*base.TaskMessage{m1},
 			wantProcessed: []*Task{t1},
 		},
@@ -111,7 +75,7 @@ func TestProcessorSuccessWithSingleQueue(t *testing.T) {
 
 	for _, tc := range tests {
 		h.FlushDB(t, r)                        // clean up db before each test case.
-		h.SeedPendingQueue(t, r, tc.pending, base.DefaultQueueName) // initialize default queue.
+		h.SeedEnqueuedQueue(t, r, tc.enqueued) // initialize default queue.
 
 		// instantiate a new processor
 		var mu sync.Mutex
@@ -122,97 +86,45 @@ func TestProcessorSuccessWithSingleQueue(t *testing.T) {
 			processed = append(processed, task)
 			return nil
 		}
-		p := newProcessorForTest(t, rdbClient, HandlerFunc(handler))
+		starting := make(chan *base.TaskMessage)
+		finished := make(chan *base.TaskMessage)
+		syncCh := make(chan *syncRequest)
+		done := make(chan struct{})
+		defer func() { close(done) }()
+		go fakeHeartbeater(starting, finished, done)
+		go fakeSyncer(syncCh, done)
+		p := newProcessor(processorParams{
+			logger:          testLogger,
+			broker:          rdbClient,
+			retryDelayFunc:  defaultDelayFunc,
+			syncCh:          syncCh,
+			cancelations:    base.NewCancelations(),
+			concurrency:     10,
+			queues:          defaultQueueConfig,
+			strictPriority:  false,
+			errHandler:      nil,
+			shutdownTimeout: defaultShutdownTimeout,
+			starting:        starting,
+			finished:        finished,
+		})
+		p.handler = HandlerFunc(handler)
 
 		p.start(&sync.WaitGroup{})
 		for _, msg := range tc.incoming {
-			err := rdbClient.Enqueue(context.Background(), msg)
+			err := rdbClient.Enqueue(msg)
 			if err != nil {
-				p.shutdown()
+				p.terminate()
 				t.Fatal(err)
 			}
 		}
-		time.Sleep(2 * time.Second) // wait for two second to allow all pending tasks to be processed.
+		time.Sleep(2 * time.Second) // wait for two second to allow all enqueued tasks to be processed.
-		if l := r.LLen(context.Background(), base.ActiveKey(base.DefaultQueueName)).Val(); l != 0 {
+		if l := r.LLen(base.InProgressQueue).Val(); l != 0 {
-			t.Errorf("%q has %d tasks, want 0", base.ActiveKey(base.DefaultQueueName), l)
+			t.Errorf("%q has %d tasks, want 0", base.InProgressQueue, l)
 		}
-		p.shutdown()
+		p.terminate()
 
 		mu.Lock()
-		if diff := cmp.Diff(tc.wantProcessed, processed, taskCmpOpts...); diff != "" {
+		if diff := cmp.Diff(tc.wantProcessed, processed, sortTaskOpt, cmp.AllowUnexported(Payload{})); diff != "" {
-			t.Errorf("mismatch found in processed tasks; (-want, +got)\n%s", diff)
-		}
-		mu.Unlock()
-	}
-}
-
-func TestProcessorSuccessWithMultipleQueues(t *testing.T) {
-	var (
-		r         = setup(t)
-		rdbClient = rdb.NewRDB(r)
-
-		m1 = h.NewTaskMessage("task1", nil)
-		m2 = h.NewTaskMessage("task2", nil)
-		m3 = h.NewTaskMessageWithQueue("task3", nil, "high")
-		m4 = h.NewTaskMessageWithQueue("task4", nil, "low")
-
-		t1 = NewTask(m1.Type, m1.Payload)
-		t2 = NewTask(m2.Type, m2.Payload)
-		t3 = NewTask(m3.Type, m3.Payload)
-		t4 = NewTask(m4.Type, m4.Payload)
-	)
-	defer r.Close()
-
-	tests := []struct {
-		pending       map[string][]*base.TaskMessage
-		queues        []string // list of queues to consume the tasks from
-		wantProcessed []*Task  // tasks to be processed at the end
-	}{
-		{
-			pending: map[string][]*base.TaskMessage{
-				"default": {m1, m2},
-				"high":    {m3},
-				"low":     {m4},
-			},
-			queues:        []string{"default", "high", "low"},
-			wantProcessed: []*Task{t1, t2, t3, t4},
-		},
-	}
-
-	for _, tc := range tests {
-		// Set up test case.
-		h.FlushDB(t, r)
-		h.SeedAllPendingQueues(t, r, tc.pending)
-
-		// Instantiate a new processor.
-		var mu sync.Mutex
-		var processed []*Task
-		handler := func(ctx context.Context, task *Task) error {
-			mu.Lock()
-			defer mu.Unlock()
-			processed = append(processed, task)
-			return nil
-		}
-		p := newProcessorForTest(t, rdbClient, HandlerFunc(handler))
-		p.queueConfig = map[string]int{
-			"default": 2,
-			"high":    3,
-			"low":     1,
-		}
-
-		p.start(&sync.WaitGroup{})
-		// Wait for two second to allow all pending tasks to be processed.
-		time.Sleep(2 * time.Second)
-		// Make sure no messages are stuck in active list.
-		for _, qname := range tc.queues {
-			if l := r.LLen(context.Background(), base.ActiveKey(qname)).Val(); l != 0 {
-				t.Errorf("%q has %d tasks, want 0", base.ActiveKey(qname), l)
-			}
-		}
-		p.shutdown()
-
-		mu.Lock()
-		if diff := cmp.Diff(tc.wantProcessed, processed, taskCmpOpts...); diff != "" {
 			t.Errorf("mismatch found in processed tasks; (-want, +got)\n%s", diff)
 		}
 		mu.Unlock()
@@ -222,54 +134,70 @@ func TestProcessorSuccessWithMultipleQueues(t *testing.T) {
 // https://github.com/hibiken/asynq/issues/166
 func TestProcessTasksWithLargeNumberInPayload(t *testing.T) {
 	r := setup(t)
-	defer r.Close()
 	rdbClient := rdb.NewRDB(r)
 
-	m1 := h.NewTaskMessage("large_number", h.JSON(map[string]interface{}{"data": 111111111111111111}))
+	m1 := h.NewTaskMessage("large_number", map[string]interface{}{"data": 111111111111111111})
 	t1 := NewTask(m1.Type, m1.Payload)
 
 	tests := []struct {
-		pending       []*base.TaskMessage // initial default queue state
+		enqueued      []*base.TaskMessage // initial default queue state
 		wantProcessed []*Task             // tasks to be processed at the end
 	}{
 		{
-			pending:       []*base.TaskMessage{m1},
+			enqueued:      []*base.TaskMessage{m1},
 			wantProcessed: []*Task{t1},
 		},
 	}
 
 	for _, tc := range tests {
 		h.FlushDB(t, r)                        // clean up db before each test case.
-		h.SeedPendingQueue(t, r, tc.pending, base.DefaultQueueName) // initialize default queue.
+		h.SeedEnqueuedQueue(t, r, tc.enqueued) // initialize default queue.
 
 		var mu sync.Mutex
 		var processed []*Task
 		handler := func(ctx context.Context, task *Task) error {
 			mu.Lock()
 			defer mu.Unlock()
-			var payload map[string]int
+			if data, err := task.Payload.GetInt("data"); err != nil {
-			if err := json.Unmarshal(task.Payload(), &payload); err != nil {
+				t.Errorf("coult not get data from payload: %v", err)
-				t.Errorf("coult not decode payload: %v", err)
-			}
-			if data, ok := payload["data"]; ok {
-				t.Logf("data == %d", data)
 			} else {
-				t.Errorf("could not get data from payload")
+				t.Logf("data == %d", data)
 			}
 			processed = append(processed, task)
 			return nil
 		}
-		p := newProcessorForTest(t, rdbClient, HandlerFunc(handler))
+		starting := make(chan *base.TaskMessage)
+		finished := make(chan *base.TaskMessage)
+		syncCh := make(chan *syncRequest)
+		done := make(chan struct{})
+		defer func() { close(done) }()
+		go fakeHeartbeater(starting, finished, done)
+		go fakeSyncer(syncCh, done)
+		p := newProcessor(processorParams{
+			logger:          testLogger,
+			broker:          rdbClient,
+			retryDelayFunc:  defaultDelayFunc,
+			syncCh:          syncCh,
+			cancelations:    base.NewCancelations(),
+			concurrency:     10,
+			queues:          defaultQueueConfig,
+			strictPriority:  false,
+			errHandler:      nil,
+			shutdownTimeout: defaultShutdownTimeout,
+			starting:        starting,
+			finished:        finished,
+		})
+		p.handler = HandlerFunc(handler)
 
 		p.start(&sync.WaitGroup{})
-		time.Sleep(2 * time.Second) // wait for two second to allow all pending tasks to be processed.
+		time.Sleep(2 * time.Second) // wait for two second to allow all enqueued tasks to be processed.
-		if l := r.LLen(context.Background(), base.ActiveKey(base.DefaultQueueName)).Val(); l != 0 {
+		if l := r.LLen(base.InProgressQueue).Val(); l != 0 {
-			t.Errorf("%q has %d tasks, want 0", base.ActiveKey(base.DefaultQueueName), l)
+			t.Errorf("%q has %d tasks, want 0", base.InProgressQueue, l)
 		}
-		p.shutdown()
+		p.terminate()
 
 		mu.Lock()
-		if diff := cmp.Diff(tc.wantProcessed, processed, taskCmpOpts...); diff != "" {
+		if diff := cmp.Diff(tc.wantProcessed, processed, sortTaskOpt, cmpopts.IgnoreUnexported(Payload{})); diff != "" {
 			t.Errorf("mismatch found in processed tasks; (-want, +got)\n%s", diff)
 		}
 		mu.Unlock()
@@ -278,7 +206,6 @@ func TestProcessTasksWithLargeNumberInPayload(t *testing.T) {
 
 func TestProcessorRetry(t *testing.T) {
 	r := setup(t)
-	defer r.Close()
 	rdbClient := rdb.NewRDB(r)
 
 	m1 := h.NewTaskMessage("send_email", nil)
@@ -288,63 +215,39 @@ func TestProcessorRetry(t *testing.T) {
 	m4 := h.NewTaskMessage("sync", nil)
 
 	errMsg := "something went wrong"
-	wrappedSkipRetry := fmt.Errorf("%s:%w", errMsg, SkipRetry)
+	now := time.Now()
 
 	tests := []struct {
-		desc         string              // test description
+		enqueued     []*base.TaskMessage // initial default queue state
-		pending      []*base.TaskMessage // initial default queue state
+		incoming     []*base.TaskMessage // tasks to be enqueued during run
 		delay        time.Duration       // retry delay duration
 		handler      Handler             // task handler
 		wait         time.Duration       // wait duration between starting and stopping processor for this test case
-		wantErrMsg   string              // error message the task should record
+		wantRetry    []h.ZSetEntry       // tasks in retry queue at the end
-		wantRetry    []*base.TaskMessage // tasks in retry queue at the end
+		wantDead     []*base.TaskMessage // tasks in dead queue at the end
-		wantArchived []*base.TaskMessage // tasks in archived queue at the end
 		wantErrCount int                 // number of times error handler should be called
 	}{
 		{
-			desc:    "Should automatically retry errored tasks",
+			enqueued: []*base.TaskMessage{m1, m2},
-			pending: []*base.TaskMessage{m1, m2, m3, m4},
+			incoming: []*base.TaskMessage{m3, m4},
 			delay:    time.Minute,
 			handler: HandlerFunc(func(ctx context.Context, task *Task) error {
 				return fmt.Errorf(errMsg)
 			}),
 			wait: 2 * time.Second,
-			wantErrMsg:   errMsg,
+			wantRetry: []h.ZSetEntry{
-			wantRetry:    []*base.TaskMessage{m2, m3, m4},
+				{Msg: h.TaskMessageAfterRetry(*m2, errMsg), Score: float64(now.Add(time.Minute).Unix())},
-			wantArchived: []*base.TaskMessage{m1},
+				{Msg: h.TaskMessageAfterRetry(*m3, errMsg), Score: float64(now.Add(time.Minute).Unix())},
+				{Msg: h.TaskMessageAfterRetry(*m4, errMsg), Score: float64(now.Add(time.Minute).Unix())},
+			},
+			wantDead:     []*base.TaskMessage{h.TaskMessageWithError(*m1, errMsg)},
 			wantErrCount: 4,
 		},
-		{
-			desc:    "Should skip retry errored tasks",
-			pending: []*base.TaskMessage{m1, m2},
-			delay:   time.Minute,
-			handler: HandlerFunc(func(ctx context.Context, task *Task) error {
-				return SkipRetry // return SkipRetry without wrapping
-			}),
-			wait:         2 * time.Second,
-			wantErrMsg:   SkipRetry.Error(),
-			wantRetry:    []*base.TaskMessage{},
-			wantArchived: []*base.TaskMessage{m1, m2},
-			wantErrCount: 2, // ErrorHandler should still be called with SkipRetry error
-		},
-		{
-			desc:    "Should skip retry errored tasks (with error wrapping)",
-			pending: []*base.TaskMessage{m1, m2},
-			delay:   time.Minute,
-			handler: HandlerFunc(func(ctx context.Context, task *Task) error {
-				return wrappedSkipRetry
-			}),
-			wait:         2 * time.Second,
-			wantErrMsg:   wrappedSkipRetry.Error(),
-			wantRetry:    []*base.TaskMessage{},
-			wantArchived: []*base.TaskMessage{m1, m2},
-			wantErrCount: 2, // ErrorHandler should still be called with SkipRetry error
-		},
 	}
 
 	for _, tc := range tests {
 		h.FlushDB(t, r)                        // clean up db before each test case.
-		h.SeedPendingQueue(t, r, tc.pending, base.DefaultQueueName) // initialize default queue.
+		h.SeedEnqueuedQueue(t, r, tc.enqueued) // initialize default queue.
 
 		// instantiate a new processor
 		delayFunc := func(n int, e error, t *Task) time.Duration {
@@ -359,44 +262,51 @@ func TestProcessorRetry(t *testing.T) {
 			defer mu.Unlock()
 			n++
 		}
-		p := newProcessorForTest(t, rdbClient, tc.handler)
+		starting := make(chan *base.TaskMessage)
-		p.errHandler = ErrorHandlerFunc(errHandler)
+		finished := make(chan *base.TaskMessage)
-		p.retryDelayFunc = delayFunc
+		done := make(chan struct{})
+		defer func() { close(done) }()
+		go fakeHeartbeater(starting, finished, done)
+		p := newProcessor(processorParams{
+			logger:          testLogger,
+			broker:          rdbClient,
+			retryDelayFunc:  delayFunc,
+			syncCh:          nil,
+			cancelations:    base.NewCancelations(),
+			concurrency:     10,
+			queues:          defaultQueueConfig,
+			strictPriority:  false,
+			errHandler:      ErrorHandlerFunc(errHandler),
+			shutdownTimeout: defaultShutdownTimeout,
+			starting:        starting,
+			finished:        finished,
+		})
+		p.handler = tc.handler
 
 		p.start(&sync.WaitGroup{})
-		runTime := time.Now() // time when processor is running
+		for _, msg := range tc.incoming {
+			err := rdbClient.Enqueue(msg)
+			if err != nil {
+				p.terminate()
+				t.Fatal(err)
+			}
+		}
 		time.Sleep(tc.wait) // FIXME: This makes test flaky.
-		p.shutdown()
+		p.terminate()
 
-		cmpOpt := h.EquateInt64Approx(int64(tc.wait.Seconds())) // allow up to a wait-second difference in zset score
+		cmpOpt := cmpopts.EquateApprox(0, float64(time.Second)) // allow up to a second difference in zset score
-		gotRetry := h.GetRetryEntries(t, r, base.DefaultQueueName)
+		gotRetry := h.GetRetryEntries(t, r)
-		var wantRetry []base.Z // Note: construct wantRetry here since `LastFailedAt` and ZSCORE is relative to each test run.
+		if diff := cmp.Diff(tc.wantRetry, gotRetry, h.SortZSetEntryOpt, cmpOpt); diff != "" {
-		for _, msg := range tc.wantRetry {
+			t.Errorf("mismatch found in %q after running processor; (-want, +got)\n%s", base.RetryQueue, diff)
-			wantRetry = append(wantRetry,
-				base.Z{
-					Message: h.TaskMessageAfterRetry(*msg, tc.wantErrMsg, runTime),
-					Score:   runTime.Add(tc.delay).Unix(),
-				})
-		}
-		if diff := cmp.Diff(wantRetry, gotRetry, h.SortZSetEntryOpt, cmpOpt); diff != "" {
-			t.Errorf("%s: mismatch found in %q after running processor; (-want, +got)\n%s", tc.desc, base.RetryKey(base.DefaultQueueName), diff)
 		}
 
-		gotArchived := h.GetArchivedEntries(t, r, base.DefaultQueueName)
+		gotDead := h.GetDeadMessages(t, r)
-		var wantArchived []base.Z // Note: construct wantArchived here since `LastFailedAt` and ZSCORE is relative to each test run.
+		if diff := cmp.Diff(tc.wantDead, gotDead, h.SortMsgOpt); diff != "" {
-		for _, msg := range tc.wantArchived {
+			t.Errorf("mismatch found in %q after running processor; (-want, +got)\n%s", base.DeadQueue, diff)
-			wantArchived = append(wantArchived,
-				base.Z{
-					Message: h.TaskMessageWithError(*msg, tc.wantErrMsg, runTime),
-					Score:   runTime.Unix(),
-				})
-		}
-		if diff := cmp.Diff(wantArchived, gotArchived, h.SortZSetEntryOpt, cmpOpt); diff != "" {
-			t.Errorf("%s: mismatch found in %q after running processor; (-want, +got)\n%s", tc.desc, base.ArchivedKey(base.DefaultQueueName), diff)
 		}
 
-		if l := r.LLen(context.Background(), base.ActiveKey(base.DefaultQueueName)).Val(); l != 0 {
+		if l := r.LLen(base.InProgressQueue).Val(); l != 0 {
-			t.Errorf("%s: %q has %d tasks, want 0", base.ActiveKey(base.DefaultQueueName), tc.desc, l)
+			t.Errorf("%q has %d tasks, want 0", base.InProgressQueue, l)
 		}
 
 		if n != tc.wantErrCount {
@@ -405,81 +315,6 @@ func TestProcessorRetry(t *testing.T) {
 	}
 }
 
-func TestProcessorMarkAsComplete(t *testing.T) {
-	r := setup(t)
-	defer r.Close()
-	rdbClient := rdb.NewRDB(r)
-
-	msg1 := h.NewTaskMessage("one", nil)
-	msg2 := h.NewTaskMessage("two", nil)
-	msg3 := h.NewTaskMessageWithQueue("three", nil, "custom")
-	msg1.Retention = 3600
-	msg3.Retention = 7200
-
-	handler := func(ctx context.Context, task *Task) error { return nil }
-
-	tests := []struct {
-		pending       map[string][]*base.TaskMessage
-		completed     map[string][]base.Z
-		queueCfg      map[string]int
-		wantPending   map[string][]*base.TaskMessage
-		wantCompleted func(completedAt time.Time) map[string][]base.Z
-	}{
-		{
-			pending: map[string][]*base.TaskMessage{
-				"default": {msg1, msg2},
-				"custom":  {msg3},
-			},
-			completed: map[string][]base.Z{
-				"default": {},
-				"custom":  {},
-			},
-			queueCfg: map[string]int{
-				"default": 1,
-				"custom":  1,
-			},
-			wantPending: map[string][]*base.TaskMessage{
-				"default": {},
-				"custom":  {},
-			},
-			wantCompleted: func(completedAt time.Time) map[string][]base.Z {
-				return map[string][]base.Z{
-					"default": {{Message: h.TaskMessageWithCompletedAt(*msg1, completedAt), Score: completedAt.Unix() + msg1.Retention}},
-					"custom":  {{Message: h.TaskMessageWithCompletedAt(*msg3, completedAt), Score: completedAt.Unix() + msg3.Retention}},
-				}
-			},
-		},
-	}
-
-	for _, tc := range tests {
-		h.FlushDB(t, r)
-		h.SeedAllPendingQueues(t, r, tc.pending)
-		h.SeedAllCompletedQueues(t, r, tc.completed)
-
-		p := newProcessorForTest(t, rdbClient, HandlerFunc(handler))
-		p.queueConfig = tc.queueCfg
-
-		p.start(&sync.WaitGroup{})
-		runTime := time.Now() // time when processor is running
-		time.Sleep(2 * time.Second)
-		p.shutdown()
-
-		for qname, want := range tc.wantPending {
-			gotPending := h.GetPendingMessages(t, r, qname)
-			if diff := cmp.Diff(want, gotPending, cmpopts.EquateEmpty()); diff != "" {
-				t.Errorf("diff found in %q pending set; want=%v, got=%v\n%s", qname, want, gotPending, diff)
-			}
-		}
-
-		for qname, want := range tc.wantCompleted(runTime) {
-			gotCompleted := h.GetCompletedEntries(t, r, qname)
-			if diff := cmp.Diff(want, gotCompleted, cmpopts.EquateEmpty()); diff != "" {
-				t.Errorf("diff found in %q completed set; want=%v, got=%v\n%s", qname, want, gotCompleted, diff)
-			}
-		}
-	}
-}
-
 func TestProcessorQueues(t *testing.T) {
 	sortOpt := cmp.Transformer("SortStrings", func(in []string) []string {
 		out := append([]string(nil), in...) // Copy input to avoid mutating it
@@ -508,10 +343,25 @@ func TestProcessorQueues(t *testing.T) {
 	}
 
 	for _, tc := range tests {
-		// Note: rdb and handler not needed for this test.
+		starting := make(chan *base.TaskMessage)
-		p := newProcessorForTest(t, nil, nil)
+		finished := make(chan *base.TaskMessage)
-		p.queueConfig = tc.queueCfg
+		done := make(chan struct{})
-
+		defer func() { close(done) }()
+		go fakeHeartbeater(starting, finished, done)
+		p := newProcessor(processorParams{
+			logger:          testLogger,
+			broker:          nil,
+			retryDelayFunc:  defaultDelayFunc,
+			syncCh:          nil,
+			cancelations:    base.NewCancelations(),
+			concurrency:     10,
+			queues:          tc.queueCfg,
+			strictPriority:  false,
+			errHandler:      nil,
+			shutdownTimeout: defaultShutdownTimeout,
+			starting:        starting,
+			finished:        finished,
+		})
 		got := p.queues()
 		if diff := cmp.Diff(tc.want, got, sortOpt); diff != "" {
 			t.Errorf("with queue config: %v\n(*processor).queues() = %v, want %v\n(-want,+got):\n%s",
@@ -521,42 +371,36 @@ func TestProcessorQueues(t *testing.T) {
 }
 
 func TestProcessorWithStrictPriority(t *testing.T) {
-	var (
+	r := setup(t)
-		r = setup(t)
+	rdbClient := rdb.NewRDB(r)
 
-		rdbClient = rdb.NewRDB(r)
+	m1 := h.NewTaskMessage("send_email", nil)
+	m2 := h.NewTaskMessage("send_email", nil)
+	m3 := h.NewTaskMessage("send_email", nil)
+	m4 := h.NewTaskMessage("gen_thumbnail", nil)
+	m5 := h.NewTaskMessage("gen_thumbnail", nil)
+	m6 := h.NewTaskMessage("sync", nil)
+	m7 := h.NewTaskMessage("sync", nil)
 
-		m1 = h.NewTaskMessageWithQueue("task1", nil, "critical")
+	t1 := NewTask(m1.Type, m1.Payload)
-		m2 = h.NewTaskMessageWithQueue("task2", nil, "critical")
+	t2 := NewTask(m2.Type, m2.Payload)
-		m3 = h.NewTaskMessageWithQueue("task3", nil, "critical")
+	t3 := NewTask(m3.Type, m3.Payload)
-		m4 = h.NewTaskMessageWithQueue("task4", nil, base.DefaultQueueName)
+	t4 := NewTask(m4.Type, m4.Payload)
-		m5 = h.NewTaskMessageWithQueue("task5", nil, base.DefaultQueueName)
+	t5 := NewTask(m5.Type, m5.Payload)
-		m6 = h.NewTaskMessageWithQueue("task6", nil, "low")
+	t6 := NewTask(m6.Type, m6.Payload)
-		m7 = h.NewTaskMessageWithQueue("task7", nil, "low")
+	t7 := NewTask(m7.Type, m7.Payload)
-
-		t1 = NewTask(m1.Type, m1.Payload)
-		t2 = NewTask(m2.Type, m2.Payload)
-		t3 = NewTask(m3.Type, m3.Payload)
-		t4 = NewTask(m4.Type, m4.Payload)
-		t5 = NewTask(m5.Type, m5.Payload)
-		t6 = NewTask(m6.Type, m6.Payload)
-		t7 = NewTask(m7.Type, m7.Payload)
-	)
-	defer r.Close()
 
 	tests := []struct {
-		pending       map[string][]*base.TaskMessage // initial queues state
+		enqueued      map[string][]*base.TaskMessage // initial queues state
-		queues        []string                       // list of queues to consume tasks from
 		wait          time.Duration                  // wait duration between starting and stopping processor for this test case
 		wantProcessed []*Task                        // tasks to be processed at the end
 	}{
 		{
-			pending: map[string][]*base.TaskMessage{
+			enqueued: map[string][]*base.TaskMessage{
 				base.DefaultQueueName: {m4, m5},
 				"critical":            {m1, m2, m3},
 				"low":                 {m6, m7},
 			},
-			queues:        []string{base.DefaultQueueName, "critical", "low"},
 			wait:          time.Second,
 			wantProcessed: []*Task{t1, t2, t3, t4, t5, t6, t7},
 		},
@@ -564,8 +408,8 @@ func TestProcessorWithStrictPriority(t *testing.T) {
 
 	for _, tc := range tests {
 		h.FlushDB(t, r) // clean up db before each test case.
-		for qname, msgs := range tc.pending {
+		for qname, msgs := range tc.enqueued {
-			h.SeedPendingQueue(t, r, msgs, qname)
+			h.SeedEnqueuedQueue(t, r, msgs, qname)
 		}
 
 		// instantiate a new processor
@@ -578,23 +422,20 @@ func TestProcessorWithStrictPriority(t *testing.T) {
 			return nil
 		}
 		queueCfg := map[string]int{
-			base.DefaultQueueName: 2,
 			"critical":            3,
+			base.DefaultQueueName: 2,
 			"low":                 1,
 		}
-		starting := make(chan *workerInfo)
+		starting := make(chan *base.TaskMessage)
 		finished := make(chan *base.TaskMessage)
-		syncCh := make(chan *syncRequest)
 		done := make(chan struct{})
 		defer func() { close(done) }()
 		go fakeHeartbeater(starting, finished, done)
-		go fakeSyncer(syncCh, done)
 		p := newProcessor(processorParams{
 			logger:          testLogger,
 			broker:          rdbClient,
-			retryDelayFunc:  DefaultRetryDelayFunc,
+			retryDelayFunc:  defaultDelayFunc,
-			isFailureFunc:   defaultIsFailureFunc,
+			syncCh:          nil,
-			syncCh:          syncCh,
 			cancelations:    base.NewCancelations(),
 			concurrency:     1, // Set concurrency to 1 to make sure tasks are processed one at a time.
 			queues:          queueCfg,
@@ -608,22 +449,19 @@ func TestProcessorWithStrictPriority(t *testing.T) {
 
 		p.start(&sync.WaitGroup{})
 		time.Sleep(tc.wait)
-		// Make sure no tasks are stuck in active list.
+		p.terminate()
-		for _, qname := range tc.queues {
-			if l := r.LLen(context.Background(), base.ActiveKey(qname)).Val(); l != 0 {
-				t.Errorf("%q has %d tasks, want 0", base.ActiveKey(qname), l)
-			}
-		}
-		p.shutdown()
 
-		if diff := cmp.Diff(tc.wantProcessed, processed, taskCmpOpts...); diff != "" {
+		if diff := cmp.Diff(tc.wantProcessed, processed, cmp.AllowUnexported(Payload{})); diff != "" {
 			t.Errorf("mismatch found in processed tasks; (-want, +got)\n%s", diff)
 		}
 
+		if l := r.LLen(base.InProgressQueue).Val(); l != 0 {
+			t.Errorf("%q has %d tasks, want 0", base.InProgressQueue, l)
+		}
 	}
 }
 
-func TestProcessorPerform(t *testing.T) {
+func TestPerform(t *testing.T) {
 	tests := []struct {
 		desc    string
 		handler HandlerFunc
@@ -635,7 +473,7 @@ func TestProcessorPerform(t *testing.T) {
 			handler: func(ctx context.Context, t *Task) error {
 				return nil
 			},
-			task:    NewTask("gen_thumbnail", h.JSON(map[string]interface{}{"src": "some/img/path"})),
+			task:    NewTask("gen_thumbnail", map[string]interface{}{"src": "some/img/path"}),
 			wantErr: false,
 		},
 		{
@@ -643,7 +481,7 @@ func TestProcessorPerform(t *testing.T) {
 			handler: func(ctx context.Context, t *Task) error {
 				return fmt.Errorf("something went wrong")
 			},
-			task:    NewTask("gen_thumbnail", h.JSON(map[string]interface{}{"src": "some/img/path"})),
+			task:    NewTask("gen_thumbnail", map[string]interface{}{"src": "some/img/path"}),
 			wantErr: true,
 		},
 		{
@@ -651,17 +489,13 @@ func TestProcessorPerform(t *testing.T) {
 			handler: func(ctx context.Context, t *Task) error {
 				panic("something went terribly wrong")
 			},
-			task:    NewTask("gen_thumbnail", h.JSON(map[string]interface{}{"src": "some/img/path"})),
+			task:    NewTask("gen_thumbnail", map[string]interface{}{"src": "some/img/path"}),
 			wantErr: true,
 		},
 	}
-	// Note: We don't need to fully initialized the processor since we are only testing
-	// perform method.
-	p := newProcessorForTest(t, nil, nil)
 
 	for _, tc := range tests {
-		p.handler = tc.handler
+		got := perform(context.Background(), tc.task, tc.handler)
-		got := p.perform(context.Background(), tc.task)
 		if !tc.wantErr && got != nil {
 			t.Errorf("%s: perform() = %v, want nil", tc.desc, got)
 			continue

recoverer.go

@@ -5,7 +5,7 @@
 package asynq
 
 import (
-	"context"
+	"fmt"
 	"sync"
 	"time"
 
@@ -16,15 +16,11 @@ import (
 type recoverer struct {
 	logger         *log.Logger
 	broker         base.Broker
-	retryDelayFunc RetryDelayFunc
+	retryDelayFunc retryDelayFunc
-	isFailureFunc  func(error) bool
 
 	// channel to communicate back to the long running "recoverer" goroutine.
 	done chan struct{}
 
-	// list of queues to check for deadline.
-	queues []string
-
 	// poll interval.
 	interval time.Duration
 }
@@ -32,10 +28,8 @@ type recoverer struct {
 type recovererParams struct {
 	logger         *log.Logger
 	broker         base.Broker
-	queues         []string
 	interval       time.Duration
-	retryDelayFunc RetryDelayFunc
+	retryDelayFunc retryDelayFunc
-	isFailureFunc  func(error) bool
 }
 
 func newRecoverer(params recovererParams) *recoverer {
@@ -43,14 +37,12 @@ func newRecoverer(params recovererParams) *recoverer {
 		logger:         params.logger,
 		broker:         params.broker,
 		done:           make(chan struct{}),
-		queues:         params.queues,
 		interval:       params.interval,
 		retryDelayFunc: params.retryDelayFunc,
-		isFailureFunc:  params.isFailureFunc,
 	}
 }
 
-func (r *recoverer) shutdown() {
+func (r *recoverer) terminate() {
 	r.logger.Debug("Recoverer shutting down...")
 	// Signal the recoverer goroutine to stop polling.
 	r.done <- struct{}{}
@@ -60,7 +52,6 @@ func (r *recoverer) start(wg *sync.WaitGroup) {
 	wg.Add(1)
 	go func() {
 		defer wg.Done()
-		r.recover()
 		timer := time.NewTimer(r.interval)
 		for {
 			select {
@@ -69,40 +60,37 @@ func (r *recoverer) start(wg *sync.WaitGroup) {
 				timer.Stop()
 				return
 			case <-timer.C:
-				r.recover()
+				// Get all tasks which have expired 30 seconds ago or earlier.
-				timer.Reset(r.interval)
+				deadline := time.Now().Add(-30 * time.Second)
+				msgs, err := r.broker.ListDeadlineExceeded(deadline)
+				if err != nil {
+					r.logger.Warn("recoverer: could not list deadline exceeded tasks")
+					continue
+				}
+				const errMsg = "deadline exceeded" // TODO: better error message
+				for _, msg := range msgs {
+					if msg.Retried >= msg.Retry {
+						r.kill(msg, errMsg)
+					} else {
+						r.retry(msg, errMsg)
+					}
+				}
+
 			}
 		}
 	}()
 }
 
-func (r *recoverer) recover() {
+func (r *recoverer) retry(msg *base.TaskMessage, errMsg string) {
-	// Get all tasks which have expired 30 seconds ago or earlier.
+	delay := r.retryDelayFunc(msg.Retried, fmt.Errorf(errMsg), NewTask(msg.Type, msg.Payload))
-	deadline := time.Now().Add(-30 * time.Second)
-	msgs, err := r.broker.ListDeadlineExceeded(deadline, r.queues...)
-	if err != nil {
-		r.logger.Warn("recoverer: could not list deadline exceeded tasks")
-		return
-	}
-	for _, msg := range msgs {
-		if msg.Retried >= msg.Retry {
-			r.archive(msg, context.DeadlineExceeded)
-		} else {
-			r.retry(msg, context.DeadlineExceeded)
-		}
-	}
-}
-
-func (r *recoverer) retry(msg *base.TaskMessage, err error) {
-	delay := r.retryDelayFunc(msg.Retried, err, NewTask(msg.Type, msg.Payload))
 	retryAt := time.Now().Add(delay)
-	if err := r.broker.Retry(msg, retryAt, err.Error(), r.isFailureFunc(err)); err != nil {
+	if err := r.broker.Retry(msg, retryAt, errMsg); err != nil {
 		r.logger.Warnf("recoverer: could not retry deadline exceeded task: %v", err)
 	}
 }
 
-func (r *recoverer) archive(msg *base.TaskMessage, err error) {
+func (r *recoverer) kill(msg *base.TaskMessage, errMsg string) {
-	if err := r.broker.Archive(msg, err.Error()); err != nil {
+	if err := r.broker.Kill(msg, errMsg); err != nil {
-		r.logger.Warnf("recoverer: could not move task to archive: %v", err)
+		r.logger.Warnf("recoverer: could not move task to dead queue: %v", err)
 	}
 }

recoverer_test.go

@@ -17,13 +17,12 @@ import (
 
 func TestRecoverer(t *testing.T) {
 	r := setup(t)
-	defer r.Close()
 	rdbClient := rdb.NewRDB(r)
 
-	t1 := h.NewTaskMessageWithQueue("task1", nil, "default")
+	t1 := h.NewTaskMessage("task1", nil)
-	t2 := h.NewTaskMessageWithQueue("task2", nil, "default")
+	t2 := h.NewTaskMessage("task2", nil)
 	t3 := h.NewTaskMessageWithQueue("task3", nil, "critical")
-	t4 := h.NewTaskMessageWithQueue("task4", nil, "default")
+	t4 := h.NewTaskMessage("task4", nil)
 	t4.Retried = t4.Retry // t4 has reached its max retry count
 
 	now := time.Now()
@@ -34,247 +33,130 @@ func TestRecoverer(t *testing.T) {
 
 	tests := []struct {
 		desc           string
-		inProgress    map[string][]*base.TaskMessage
+		inProgress     []*base.TaskMessage
-		deadlines     map[string][]base.Z
+		deadlines      []h.ZSetEntry
-		retry         map[string][]base.Z
+		retry          []h.ZSetEntry
-		archived      map[string][]base.Z
+		dead           []h.ZSetEntry
-		wantActive    map[string][]*base.TaskMessage
+		wantInProgress []*base.TaskMessage
-		wantDeadlines map[string][]base.Z
+		wantDeadlines  []h.ZSetEntry
-		wantRetry     map[string][]*base.TaskMessage
+		wantRetry      []*base.TaskMessage
-		wantArchived  map[string][]*base.TaskMessage
+		wantDead       []*base.TaskMessage
 	}{
 		{
-			desc: "with one active task",
+			desc:       "with one task in-progress",
-			inProgress: map[string][]*base.TaskMessage{
+			inProgress: []*base.TaskMessage{t1},
-				"default": {t1},
+			deadlines: []h.ZSetEntry{
+				{Msg: t1, Score: float64(fiveMinutesAgo.Unix())},
 			},
-			deadlines: map[string][]base.Z{
+			retry:          []h.ZSetEntry{},
-				"default": {{Message: t1, Score: fiveMinutesAgo.Unix()}},
+			dead:           []h.ZSetEntry{},
-			},
+			wantInProgress: []*base.TaskMessage{},
-			retry: map[string][]base.Z{
+			wantDeadlines:  []h.ZSetEntry{},
-				"default": {},
+			wantRetry: []*base.TaskMessage{
-			},
+				h.TaskMessageAfterRetry(*t1, "deadline exceeded"),
-			archived: map[string][]base.Z{
-				"default": {},
-			},
-			wantActive: map[string][]*base.TaskMessage{
-				"default": {},
-			},
-			wantDeadlines: map[string][]base.Z{
-				"default": {},
-			},
-			wantRetry: map[string][]*base.TaskMessage{
-				"default": {t1},
-			},
-			wantArchived: map[string][]*base.TaskMessage{
-				"default": {},
 			},
+			wantDead: []*base.TaskMessage{},
 		},
 		{
 			desc:       "with a task with max-retry reached",
-			inProgress: map[string][]*base.TaskMessage{
+			inProgress: []*base.TaskMessage{t4},
-				"default":  {t4},
+			deadlines: []h.ZSetEntry{
-				"critical": {},
+				{Msg: t4, Score: float64(fiveMinutesAgo.Unix())},
-			},
-			deadlines: map[string][]base.Z{
-				"default":  {{Message: t4, Score: fiveMinutesAgo.Unix()}},
-				"critical": {},
-			},
-			retry: map[string][]base.Z{
-				"default":  {},
-				"critical": {},
-			},
-			archived: map[string][]base.Z{
-				"default":  {},
-				"critical": {},
-			},
-			wantActive: map[string][]*base.TaskMessage{
-				"default":  {},
-				"critical": {},
-			},
-			wantDeadlines: map[string][]base.Z{
-				"default":  {},
-				"critical": {},
-			},
-			wantRetry: map[string][]*base.TaskMessage{
-				"default":  {},
-				"critical": {},
-			},
-			wantArchived: map[string][]*base.TaskMessage{
-				"default":  {t4},
-				"critical": {},
 			},
+			retry:          []h.ZSetEntry{},
+			dead:           []h.ZSetEntry{},
+			wantInProgress: []*base.TaskMessage{},
+			wantDeadlines:  []h.ZSetEntry{},
+			wantRetry:      []*base.TaskMessage{},
+			wantDead:       []*base.TaskMessage{h.TaskMessageWithError(*t4, "deadline exceeded")},
 		},
 		{
-			desc: "with multiple active tasks, and one expired",
+			desc:       "with multiple tasks in-progress, and one expired",
-			inProgress: map[string][]*base.TaskMessage{
+			inProgress: []*base.TaskMessage{t1, t2, t3},
-				"default":  {t1, t2},
+			deadlines: []h.ZSetEntry{
-				"critical": {t3},
+				{Msg: t1, Score: float64(oneHourAgo.Unix())},
+				{Msg: t2, Score: float64(fiveMinutesFromNow.Unix())},
+				{Msg: t3, Score: float64(oneHourFromNow.Unix())},
 			},
-			deadlines: map[string][]base.Z{
+			retry:          []h.ZSetEntry{},
-				"default": {
+			dead:           []h.ZSetEntry{},
-					{Message: t1, Score: oneHourAgo.Unix()},
+			wantInProgress: []*base.TaskMessage{t2, t3},
-					{Message: t2, Score: fiveMinutesFromNow.Unix()},
+			wantDeadlines: []h.ZSetEntry{
+				{Msg: t2, Score: float64(fiveMinutesFromNow.Unix())},
+				{Msg: t3, Score: float64(oneHourFromNow.Unix())},
 			},
-				"critical": {
+			wantRetry: []*base.TaskMessage{
-					{Message: t3, Score: oneHourFromNow.Unix()},
+				h.TaskMessageAfterRetry(*t1, "deadline exceeded"),
-				},
-			},
-			retry: map[string][]base.Z{
-				"default":  {},
-				"critical": {},
-			},
-			archived: map[string][]base.Z{
-				"default":  {},
-				"critical": {},
-			},
-			wantActive: map[string][]*base.TaskMessage{
-				"default":  {t2},
-				"critical": {t3},
-			},
-			wantDeadlines: map[string][]base.Z{
-				"default":  {{Message: t2, Score: fiveMinutesFromNow.Unix()}},
-				"critical": {{Message: t3, Score: oneHourFromNow.Unix()}},
-			},
-			wantRetry: map[string][]*base.TaskMessage{
-				"default":  {t1},
-				"critical": {},
-			},
-			wantArchived: map[string][]*base.TaskMessage{
-				"default":  {},
-				"critical": {},
 			},
+			wantDead: []*base.TaskMessage{},
 		},
 		{
-			desc: "with multiple expired active tasks",
+			desc:       "with multiple expired tasks in-progress",
-			inProgress: map[string][]*base.TaskMessage{
+			inProgress: []*base.TaskMessage{t1, t2, t3},
-				"default":  {t1, t2},
+			deadlines: []h.ZSetEntry{
-				"critical": {t3},
+				{Msg: t1, Score: float64(oneHourAgo.Unix())},
+				{Msg: t2, Score: float64(fiveMinutesAgo.Unix())},
+				{Msg: t3, Score: float64(oneHourFromNow.Unix())},
 			},
-			deadlines: map[string][]base.Z{
+			retry:          []h.ZSetEntry{},
-				"default": {
+			dead:           []h.ZSetEntry{},
-					{Message: t1, Score: oneHourAgo.Unix()},
+			wantInProgress: []*base.TaskMessage{t3},
-					{Message: t2, Score: oneHourFromNow.Unix()},
+			wantDeadlines: []h.ZSetEntry{
+				{Msg: t3, Score: float64(oneHourFromNow.Unix())},
 			},
-				"critical": {
+			wantRetry: []*base.TaskMessage{
-					{Message: t3, Score: fiveMinutesAgo.Unix()},
+				h.TaskMessageAfterRetry(*t1, "deadline exceeded"),
-				},
+				h.TaskMessageAfterRetry(*t2, "deadline exceeded"),
-			},
-			retry: map[string][]base.Z{
-				"default": {},
-				"cricial": {},
-			},
-			archived: map[string][]base.Z{
-				"default": {},
-				"cricial": {},
-			},
-			wantActive: map[string][]*base.TaskMessage{
-				"default":  {t2},
-				"critical": {},
-			},
-			wantDeadlines: map[string][]base.Z{
-				"default": {{Message: t2, Score: oneHourFromNow.Unix()}},
-			},
-			wantRetry: map[string][]*base.TaskMessage{
-				"default":  {t1},
-				"critical": {t3},
-			},
-			wantArchived: map[string][]*base.TaskMessage{
-				"default":  {},
-				"critical": {},
 			},
+			wantDead: []*base.TaskMessage{},
 		},
 		{
-			desc: "with empty active queue",
+			desc:           "with empty in-progress queue",
-			inProgress: map[string][]*base.TaskMessage{
+			inProgress:     []*base.TaskMessage{},
-				"default":  {},
+			deadlines:      []h.ZSetEntry{},
-				"critical": {},
+			retry:          []h.ZSetEntry{},
-			},
+			dead:           []h.ZSetEntry{},
-			deadlines: map[string][]base.Z{
+			wantInProgress: []*base.TaskMessage{},
-				"default":  {},
+			wantDeadlines:  []h.ZSetEntry{},
-				"critical": {},
+			wantRetry:      []*base.TaskMessage{},
-			},
+			wantDead:       []*base.TaskMessage{},
-			retry: map[string][]base.Z{
-				"default":  {},
-				"critical": {},
-			},
-			archived: map[string][]base.Z{
-				"default":  {},
-				"critical": {},
-			},
-			wantActive: map[string][]*base.TaskMessage{
-				"default":  {},
-				"critical": {},
-			},
-			wantDeadlines: map[string][]base.Z{
-				"default":  {},
-				"critical": {},
-			},
-			wantRetry: map[string][]*base.TaskMessage{
-				"default":  {},
-				"critical": {},
-			},
-			wantArchived: map[string][]*base.TaskMessage{
-				"default":  {},
-				"critical": {},
-			},
 		},
 	}
 
 	for _, tc := range tests {
 		h.FlushDB(t, r)
-		h.SeedAllActiveQueues(t, r, tc.inProgress)
+		h.SeedInProgressQueue(t, r, tc.inProgress)
-		h.SeedAllDeadlines(t, r, tc.deadlines)
+		h.SeedDeadlines(t, r, tc.deadlines)
-		h.SeedAllRetryQueues(t, r, tc.retry)
+		h.SeedRetryQueue(t, r, tc.retry)
-		h.SeedAllArchivedQueues(t, r, tc.archived)
+		h.SeedDeadQueue(t, r, tc.dead)
 
 		recoverer := newRecoverer(recovererParams{
 			logger:         testLogger,
 			broker:         rdbClient,
-			queues:         []string{"default", "critical"},
 			interval:       1 * time.Second,
 			retryDelayFunc: func(n int, err error, task *Task) time.Duration { return 30 * time.Second },
-			isFailureFunc:  defaultIsFailureFunc,
 		})
 
 		var wg sync.WaitGroup
 		recoverer.start(&wg)
-		runTime := time.Now() // time when recoverer is running
 		time.Sleep(2 * time.Second)
-		recoverer.shutdown()
+		recoverer.terminate()
 
-		for qname, want := range tc.wantActive {
+		gotInProgress := h.GetInProgressMessages(t, r)
-			gotActive := h.GetActiveMessages(t, r, qname)
+		if diff := cmp.Diff(tc.wantInProgress, gotInProgress, h.SortMsgOpt); diff != "" {
-			if diff := cmp.Diff(want, gotActive, h.SortMsgOpt); diff != "" {
+			t.Errorf("%s; mismatch found in %q; (-want,+got)\n%s", tc.desc, base.InProgressQueue, diff)
-				t.Errorf("%s; mismatch found in %q; (-want,+got)\n%s", tc.desc, base.ActiveKey(qname), diff)
 		}
+		gotDeadlines := h.GetDeadlinesEntries(t, r)
+		if diff := cmp.Diff(tc.wantDeadlines, gotDeadlines, h.SortZSetEntryOpt); diff != "" {
+			t.Errorf("%s; mismatch found in %q; (-want,+got)\n%s", tc.desc, base.KeyDeadlines, diff)
 		}
-		for qname, want := range tc.wantDeadlines {
+		gotRetry := h.GetRetryMessages(t, r)
-			gotDeadlines := h.GetDeadlinesEntries(t, r, qname)
+		if diff := cmp.Diff(tc.wantRetry, gotRetry, h.SortMsgOpt); diff != "" {
-			if diff := cmp.Diff(want, gotDeadlines, h.SortZSetEntryOpt); diff != "" {
+			t.Errorf("%s; mismatch found in %q: (-want, +got)\n%s", tc.desc, base.RetryQueue, diff)
-				t.Errorf("%s; mismatch found in %q; (-want,+got)\n%s", tc.desc, base.DeadlinesKey(qname), diff)
-			}
-		}
-		cmpOpt := h.EquateInt64Approx(2) // allow up to two-second difference in `LastFailedAt`
-		for qname, msgs := range tc.wantRetry {
-			gotRetry := h.GetRetryMessages(t, r, qname)
-			var wantRetry []*base.TaskMessage // Note: construct message here since `LastFailedAt` is relative to each test run
-			for _, msg := range msgs {
-				wantRetry = append(wantRetry, h.TaskMessageAfterRetry(*msg, "context deadline exceeded", runTime))
-			}
-			if diff := cmp.Diff(wantRetry, gotRetry, h.SortMsgOpt, cmpOpt); diff != "" {
-				t.Errorf("%s; mismatch found in %q: (-want, +got)\n%s", tc.desc, base.RetryKey(qname), diff)
-			}
-		}
-		for qname, msgs := range tc.wantArchived {
-			gotArchived := h.GetArchivedMessages(t, r, qname)
-			var wantArchived []*base.TaskMessage
-			for _, msg := range msgs {
-				wantArchived = append(wantArchived, h.TaskMessageWithError(*msg, "context deadline exceeded", runTime))
-			}
-			if diff := cmp.Diff(wantArchived, gotArchived, h.SortMsgOpt, cmpOpt); diff != "" {
-				t.Errorf("%s; mismatch found in %q: (-want, +got)\n%s", tc.desc, base.ArchivedKey(qname), diff)
 		}
+		gotDead := h.GetDeadMessages(t, r)
+		if diff := cmp.Diff(tc.wantDead, gotDead, h.SortMsgOpt); diff != "" {
+			t.Errorf("%s; mismatch found in %q: (-want, +got)\n%s", tc.desc, base.DeadQueue, diff)
 		}
 	}
 }

scheduler.go

@@ -5,295 +5,64 @@
 package asynq
 
 import (
-	"fmt"
-	"os"
 	"sync"
 	"time"
 
-	"github.com/go-redis/redis/v8"
-	"github.com/google/uuid"
 	"github.com/hibiken/asynq/internal/base"
 	"github.com/hibiken/asynq/internal/log"
-	"github.com/hibiken/asynq/internal/rdb"
-	"github.com/robfig/cron/v3"
 )
 
-// A Scheduler kicks off tasks at regular intervals based on the user defined schedule.
+type scheduler struct {
-//
-// Schedulers are safe for concurrent use by multiple goroutines.
-type Scheduler struct {
-	id string
-
-	state *serverState
-
 	logger *log.Logger
-	client     *Client
+	broker base.Broker
-	rdb        *rdb.RDB
+
-	cron       *cron.Cron
+	// channel to communicate back to the long running "scheduler" goroutine.
-	location   *time.Location
 	done chan struct{}
-	wg         sync.WaitGroup
-	errHandler func(task *Task, opts []Option, err error)
 
-	// guards idmap
+	// poll interval on average
-	mu sync.Mutex
+	avgInterval time.Duration
-	// idmap maps Scheduler's entry ID to cron.EntryID
-	// to avoid using cron.EntryID as the public API of
-	// the Scheduler.
-	idmap map[string]cron.EntryID
 }
 
-// NewScheduler returns a new Scheduler instance given the redis connection option.
+type schedulerParams struct {
-// The parameter opts is optional, defaults will be used if opts is set to nil
-func NewScheduler(r RedisConnOpt, opts *SchedulerOpts) *Scheduler {
-	c, ok := r.MakeRedisClient().(redis.UniversalClient)
-	if !ok {
-		panic(fmt.Sprintf("asynq: unsupported RedisConnOpt type %T", r))
-	}
-	if opts == nil {
-		opts = &SchedulerOpts{}
-	}
-
-	logger := log.NewLogger(opts.Logger)
-	loglevel := opts.LogLevel
-	if loglevel == level_unspecified {
-		loglevel = InfoLevel
-	}
-	logger.SetLevel(toInternalLogLevel(loglevel))
-
-	loc := opts.Location
-	if loc == nil {
-		loc = time.UTC
-	}
-
-	return &Scheduler{
-		id:         generateSchedulerID(),
-		state:      &serverState{value: srvStateNew},
-		logger:     logger,
-		client:     NewClient(r),
-		rdb:        rdb.NewRDB(c),
-		cron:       cron.New(cron.WithLocation(loc)),
-		location:   loc,
-		done:       make(chan struct{}),
-		errHandler: opts.EnqueueErrorHandler,
-		idmap:      make(map[string]cron.EntryID),
-	}
-}
-
-func generateSchedulerID() string {
-	host, err := os.Hostname()
-	if err != nil {
-		host = "unknown-host"
-	}
-	return fmt.Sprintf("%s:%d:%v", host, os.Getpid(), uuid.New())
-}
-
-// SchedulerOpts specifies scheduler options.
-type SchedulerOpts struct {
-	// Logger specifies the logger used by the scheduler instance.
-	//
-	// If unset, the default logger is used.
-	Logger Logger
-
-	// LogLevel specifies the minimum log level to enable.
-	//
-	// If unset, InfoLevel is used by default.
-	LogLevel LogLevel
-
-	// Location specifies the time zone location.
-	//
-	// If unset, the UTC time zone (time.UTC) is used.
-	Location *time.Location
-
-	// EnqueueErrorHandler gets called when scheduler cannot enqueue a registered task
-	// due to an error.
-	EnqueueErrorHandler func(task *Task, opts []Option, err error)
-}
-
-// enqueueJob encapsulates the job of enqueing a task and recording the event.
-type enqueueJob struct {
-	id         uuid.UUID
-	cronspec   string
-	task       *Task
-	opts       []Option
-	location   *time.Location
 	logger   *log.Logger
-	client     *Client
+	broker   base.Broker
-	rdb        *rdb.RDB
+	interval time.Duration
-	errHandler func(task *Task, opts []Option, err error)
 }
 
-func (j *enqueueJob) Run() {
+func newScheduler(params schedulerParams) *scheduler {
-	info, err := j.client.Enqueue(j.task, j.opts...)
+	return &scheduler{
-	if err != nil {
+		logger:      params.logger,
-		j.logger.Errorf("scheduler could not enqueue a task %+v: %v", j.task, err)
+		broker:      params.broker,
-		if j.errHandler != nil {
+		done:        make(chan struct{}),
-			j.errHandler(j.task, j.opts, err)
+		avgInterval: params.interval,
-		}
-		return
-	}
-	j.logger.Debugf("scheduler enqueued a task: %+v", info)
-	event := &base.SchedulerEnqueueEvent{
-		TaskID:     info.ID,
-		EnqueuedAt: time.Now().In(j.location),
-	}
-	err = j.rdb.RecordSchedulerEnqueueEvent(j.id.String(), event)
-	if err != nil {
-		j.logger.Errorf("scheduler could not record enqueue event of enqueued task %+v: %v", j.task, err)
 	}
 }
 
-// Register registers a task to be enqueued on the given schedule specified by the cronspec.
+func (s *scheduler) terminate() {
-// It returns an ID of the newly registered entry.
+	s.logger.Debug("Scheduler shutting down...")
-func (s *Scheduler) Register(cronspec string, task *Task, opts ...Option) (entryID string, err error) {
+	// Signal the scheduler goroutine to stop polling.
-	job := &enqueueJob{
+	s.done <- struct{}{}
-		id:         uuid.New(),
-		cronspec:   cronspec,
-		task:       task,
-		opts:       opts,
-		location:   s.location,
-		client:     s.client,
-		rdb:        s.rdb,
-		logger:     s.logger,
-		errHandler: s.errHandler,
-	}
-	cronID, err := s.cron.AddJob(cronspec, job)
-	if err != nil {
-		return "", err
-	}
-	s.mu.Lock()
-	s.idmap[job.id.String()] = cronID
-	s.mu.Unlock()
-	return job.id.String(), nil
 }
 
-// Unregister removes a registered entry by entry ID.
+// start starts the "scheduler" goroutine.
-// Unregister returns a non-nil error if no entries were found for the given entryID.
+func (s *scheduler) start(wg *sync.WaitGroup) {
-func (s *Scheduler) Unregister(entryID string) error {
+	wg.Add(1)
-	s.mu.Lock()
+	go func() {
-	defer s.mu.Unlock()
+		defer wg.Done()
-	cronID, ok := s.idmap[entryID]
-	if !ok {
-		return fmt.Errorf("asynq: no scheduler entry found")
-	}
-	delete(s.idmap, entryID)
-	s.cron.Remove(cronID)
-	return nil
-}
-
-// Run starts the scheduler until an os signal to exit the program is received.
-// It returns an error if scheduler is already running or has been shutdown.
-func (s *Scheduler) Run() error {
-	if err := s.Start(); err != nil {
-		return err
-	}
-	s.waitForSignals()
-	s.Shutdown()
-	return nil
-}
-
-// Start starts the scheduler.
-// It returns an error if the scheduler is already running or has been shutdown.
-func (s *Scheduler) Start() error {
-	if err := s.start(); err != nil {
-		return err
-	}
-	s.logger.Info("Scheduler starting")
-	s.logger.Infof("Scheduler timezone is set to %v", s.location)
-	s.cron.Start()
-	s.wg.Add(1)
-	go s.runHeartbeater()
-	return nil
-}
-
-// Checks server state and returns an error if pre-condition is not met.
-// Otherwise it sets the server state to active.
-func (s *Scheduler) start() error {
-	s.state.mu.Lock()
-	defer s.state.mu.Unlock()
-	switch s.state.value {
-	case srvStateActive:
-		return fmt.Errorf("asynq: the scheduler is already running")
-	case srvStateClosed:
-		return fmt.Errorf("asynq: the scheduler has already been stopped")
-	}
-	s.state.value = srvStateActive
-	return nil
-}
-
-// Shutdown stops and shuts down the scheduler.
-func (s *Scheduler) Shutdown() {
-	s.state.mu.Lock()
-	if s.state.value == srvStateNew || s.state.value == srvStateClosed {
-		// scheduler is not running, do nothing and return.
-		s.state.mu.Unlock()
-		return
-	}
-	s.state.value = srvStateClosed
-	s.state.mu.Unlock()
-
-	s.logger.Info("Scheduler shutting down")
-	close(s.done) // signal heartbeater to stop
-	ctx := s.cron.Stop()
-	<-ctx.Done()
-	s.wg.Wait()
-
-	s.clearHistory()
-	s.client.Close()
-	s.rdb.Close()
-	s.logger.Info("Scheduler stopped")
-}
-
-func (s *Scheduler) runHeartbeater() {
-	defer s.wg.Done()
-	ticker := time.NewTicker(5 * time.Second)
 		for {
 			select {
 			case <-s.done:
-			s.logger.Debugf("Scheduler heatbeater shutting down")
+				s.logger.Debug("Scheduler done")
-			s.rdb.ClearSchedulerEntries(s.id)
 				return
-		case <-ticker.C:
+			case <-time.After(s.avgInterval):
-			s.beat()
+				s.exec()
 			}
 		}
+	}()
 }
 
-// beat writes a snapshot of entries to redis.
+func (s *scheduler) exec() {
-func (s *Scheduler) beat() {
+	if err := s.broker.CheckAndEnqueue(); err != nil {
-	var entries []*base.SchedulerEntry
+		s.logger.Errorf("Could not enqueue scheduled tasks: %v", err)
-	for _, entry := range s.cron.Entries() {
-		job := entry.Job.(*enqueueJob)
-		e := &base.SchedulerEntry{
-			ID:      job.id.String(),
-			Spec:    job.cronspec,
-			Type:    job.task.Type(),
-			Payload: job.task.Payload(),
-			Opts:    stringifyOptions(job.opts),
-			Next:    entry.Next,
-			Prev:    entry.Prev,
-		}
-		entries = append(entries, e)
-	}
-	s.logger.Debugf("Writing entries %v", entries)
-	if err := s.rdb.WriteSchedulerEntries(s.id, entries, 5*time.Second); err != nil {
-		s.logger.Warnf("Scheduler could not write heartbeat data: %v", err)
-	}
-}
-
-func stringifyOptions(opts []Option) []string {
-	var res []string
-	for _, opt := range opts {
-		res = append(res, opt.String())
-	}
-	return res
-}
-
-func (s *Scheduler) clearHistory() {
-	for _, entry := range s.cron.Entries() {
-		job := entry.Job.(*enqueueJob)
-		if err := s.rdb.ClearSchedulerHistory(job.id.String()); err != nil {
-			s.logger.Warnf("Could not clear scheduler history for entry %q: %v", job.id.String(), err)
-		}
 	}
 }

scheduler_test.go

@@ -10,147 +10,88 @@ import (
 	"time"
 
 	"github.com/google/go-cmp/cmp"
-	"github.com/hibiken/asynq/internal/asynqtest"
+	h "github.com/hibiken/asynq/internal/asynqtest"
 	"github.com/hibiken/asynq/internal/base"
+	"github.com/hibiken/asynq/internal/rdb"
 )
 
-func TestSchedulerRegister(t *testing.T) {
+func TestScheduler(t *testing.T) {
+	r := setup(t)
+	rdbClient := rdb.NewRDB(r)
+	const pollInterval = time.Second
+	s := newScheduler(schedulerParams{
+		logger:   testLogger,
+		broker:   rdbClient,
+		interval: pollInterval,
+	})
+	t1 := h.NewTaskMessage("gen_thumbnail", nil)
+	t2 := h.NewTaskMessage("send_email", nil)
+	t3 := h.NewTaskMessage("reindex", nil)
+	t4 := h.NewTaskMessage("sync", nil)
+	now := time.Now()
+
 	tests := []struct {
-		cronspec string
+		initScheduled []h.ZSetEntry       // scheduled queue initial state
-		task     *Task
+		initRetry     []h.ZSetEntry       // retry queue initial state
-		opts     []Option
+		initQueue     []*base.TaskMessage // default queue initial state
-		wait     time.Duration
+		wait          time.Duration       // wait duration before checking for final state
-		queue    string
+		wantScheduled []*base.TaskMessage // schedule queue final state
-		want     []*base.TaskMessage
+		wantRetry     []*base.TaskMessage // retry queue final state
+		wantQueue     []*base.TaskMessage // default queue final state
 	}{
 		{
-			cronspec: "@every 3s",
+			initScheduled: []h.ZSetEntry{
-			task:     NewTask("task1", nil),
+				{Msg: t1, Score: float64(now.Add(time.Hour).Unix())},
-			opts:     []Option{MaxRetry(10)},
+				{Msg: t2, Score: float64(now.Add(-2 * time.Second).Unix())},
-			wait:     10 * time.Second,
+			},
-			queue:    "default",
+			initRetry: []h.ZSetEntry{
-			want: []*base.TaskMessage{
+				{Msg: t3, Score: float64(time.Now().Add(-500 * time.Millisecond).Unix())},
-				{
+			},
-					Type:    "task1",
+			initQueue:     []*base.TaskMessage{t4},
-					Payload: nil,
+			wait:          pollInterval * 2,
-					Retry:   10,
+			wantScheduled: []*base.TaskMessage{t1},
-					Timeout: int64(defaultTimeout.Seconds()),
+			wantRetry:     []*base.TaskMessage{},
-					Queue:   "default",
+			wantQueue:     []*base.TaskMessage{t2, t3, t4},
 		},
 		{
-					Type:    "task1",
+			initScheduled: []h.ZSetEntry{
-					Payload: nil,
+				{Msg: t1, Score: float64(now.Unix())},
-					Retry:   10,
+				{Msg: t2, Score: float64(now.Add(-2 * time.Second).Unix())},
-					Timeout: int64(defaultTimeout.Seconds()),
+				{Msg: t3, Score: float64(now.Add(-500 * time.Millisecond).Unix())},
-					Queue:   "default",
-				},
-				{
-					Type:    "task1",
-					Payload: nil,
-					Retry:   10,
-					Timeout: int64(defaultTimeout.Seconds()),
-					Queue:   "default",
-				},
 			},
+			initRetry:     []h.ZSetEntry{},
+			initQueue:     []*base.TaskMessage{t4},
+			wait:          pollInterval * 2,
+			wantScheduled: []*base.TaskMessage{},
+			wantRetry:     []*base.TaskMessage{},
+			wantQueue:     []*base.TaskMessage{t1, t2, t3, t4},
 		},
 	}
 
-	r := setup(t)
-
 	for _, tc := range tests {
-		scheduler := NewScheduler(getRedisConnOpt(t), nil)
+		h.FlushDB(t, r)                              // clean up db before each test case.
-		if _, err := scheduler.Register(tc.cronspec, tc.task, tc.opts...); err != nil {
+		h.SeedScheduledQueue(t, r, tc.initScheduled) // initialize scheduled queue
-			t.Fatal(err)
+		h.SeedRetryQueue(t, r, tc.initRetry)         // initialize retry queue
-		}
+		h.SeedEnqueuedQueue(t, r, tc.initQueue)      // initialize default queue
 
-		if err := scheduler.Start(); err != nil {
+		var wg sync.WaitGroup
-			t.Fatal(err)
+		s.start(&wg)
-		}
 		time.Sleep(tc.wait)
-		scheduler.Shutdown()
+		s.terminate()
 
-		got := asynqtest.GetPendingMessages(t, r, tc.queue)
+		gotScheduled := h.GetScheduledMessages(t, r)
-		if diff := cmp.Diff(tc.want, got, asynqtest.IgnoreIDOpt); diff != "" {
+		if diff := cmp.Diff(tc.wantScheduled, gotScheduled, h.SortMsgOpt); diff != "" {
-			t.Errorf("mismatch found in queue %q: (-want,+got)\n%s", tc.queue, diff)
+			t.Errorf("mismatch found in %q after running scheduler: (-want, +got)\n%s", base.ScheduledQueue, diff)
-		}
-	}
 		}
 
-func TestSchedulerWhenRedisDown(t *testing.T) {
+		gotRetry := h.GetRetryMessages(t, r)
-	var (
+		if diff := cmp.Diff(tc.wantRetry, gotRetry, h.SortMsgOpt); diff != "" {
-		mu      sync.Mutex
+			t.Errorf("mismatch found in %q after running scheduler: (-want, +got)\n%s", base.RetryQueue, diff)
-		counter int
-	)
-	errorHandler := func(task *Task, opts []Option, err error) {
-		mu.Lock()
-		counter++
-		mu.Unlock()
 		}
 
-	// Connect to non-existent redis instance to simulate a redis server being down.
+		gotEnqueued := h.GetEnqueuedMessages(t, r)
-	scheduler := NewScheduler(
+		if diff := cmp.Diff(tc.wantQueue, gotEnqueued, h.SortMsgOpt); diff != "" {
-		RedisClientOpt{Addr: ":9876"},
+			t.Errorf("mismatch found in %q after running scheduler: (-want, +got)\n%s", base.DefaultQueue, diff)
-		&SchedulerOpts{EnqueueErrorHandler: errorHandler},
-	)
-
-	task := NewTask("test", nil)
-
-	if _, err := scheduler.Register("@every 3s", task); err != nil {
-		t.Fatal(err)
-	}
-
-	if err := scheduler.Start(); err != nil {
-		t.Fatal(err)
-	}
-	// Scheduler should attempt to enqueue the task three times (every 3s).
-	time.Sleep(10 * time.Second)
-	scheduler.Shutdown()
-
-	mu.Lock()
-	if counter != 3 {
-		t.Errorf("EnqueueErrorHandler was called %d times, want 3", counter)
-	}
-	mu.Unlock()
-}
-
-func TestSchedulerUnregister(t *testing.T) {
-	tests := []struct {
-		cronspec string
-		task     *Task
-		opts     []Option
-		wait     time.Duration
-		queue    string
-	}{
-		{
-			cronspec: "@every 3s",
-			task:     NewTask("task1", nil),
-			opts:     []Option{MaxRetry(10)},
-			wait:     10 * time.Second,
-			queue:    "default",
-		},
-	}
-
-	r := setup(t)
-
-	for _, tc := range tests {
-		scheduler := NewScheduler(getRedisConnOpt(t), nil)
-		entryID, err := scheduler.Register(tc.cronspec, tc.task, tc.opts...)
-		if err != nil {
-			t.Fatal(err)
-		}
-		if err := scheduler.Unregister(entryID); err != nil {
-			t.Fatal(err)
-		}
-
-		if err := scheduler.Start(); err != nil {
-			t.Fatal(err)
-		}
-		time.Sleep(tc.wait)
-		scheduler.Shutdown()
-
-		got := asynqtest.GetPendingMessages(t, r, tc.queue)
-		if len(got) != 0 {
-			t.Errorf("%d tasks were enqueued, want zero", len(got))
 		}
 	}
 }

servemux.go

@@ -62,7 +62,7 @@ func (mux *ServeMux) Handler(t *Task) (h Handler, pattern string) {
 	mux.mu.RLock()
 	defer mux.mu.RUnlock()
 
-	h, pattern = mux.match(t.Type())
+	h, pattern = mux.match(t.Type)
 	if h == nil {
 		h, pattern = NotFoundHandler(), ""
 	}
@@ -98,7 +98,7 @@ func (mux *ServeMux) Handle(pattern string, handler Handler) {
 	mux.mu.Lock()
 	defer mux.mu.Unlock()
 
-	if strings.TrimSpace(pattern) == "" {
+	if pattern == "" {
 		panic("asynq: invalid pattern")
 	}
 	if handler == nil {
@@ -151,7 +151,7 @@ func (mux *ServeMux) Use(mws ...MiddlewareFunc) {
 
 // NotFound returns an error indicating that the handler was not found for the given task.
 func NotFound(ctx context.Context, task *Task) error {
-	return fmt.Errorf("handler not found for task %q", task.Type())
+	return fmt.Errorf("handler not found for task %q", task.Type)
 }
 
 // NotFoundHandler returns a simple task handler that returns a ``not found`` error.

servemux_test.go

@@ -68,7 +68,7 @@ func TestServeMux(t *testing.T) {
 		}
 
 		if called != tc.want {
-			t.Errorf("%q handler was called for task %q, want %q to be called", called, task.Type(), tc.want)
+			t.Errorf("%q handler was called for task %q, want %q to be called", called, task.Type, tc.want)
 		}
 	}
 }
@@ -124,7 +124,7 @@ func TestServeMuxNotFound(t *testing.T) {
 		task := NewTask(tc.typename, nil)
 		err := mux.ProcessTask(context.Background(), task)
 		if err == nil {
-			t.Errorf("ProcessTask did not return error for task %q, should return 'not found' error", task.Type())
+			t.Errorf("ProcessTask did not return error for task %q, should return 'not found' error", task.Type)
 		}
 	}
 }
@@ -164,7 +164,7 @@ func TestServeMuxMiddlewares(t *testing.T) {
 		}
 
 		if called != tc.want {
-			t.Errorf("%q handler was called for task %q, want %q to be called", called, task.Type(), tc.want)
+			t.Errorf("%q handler was called for task %q, want %q to be called", called, task.Type, tc.want)
 		}
 	}
 }

server.go

@@ -15,78 +15,38 @@ import (
 	"sync"
 	"time"
 
-	"github.com/go-redis/redis/v8"
 	"github.com/hibiken/asynq/internal/base"
 	"github.com/hibiken/asynq/internal/log"
 	"github.com/hibiken/asynq/internal/rdb"
 )
 
-// Server is responsible for task processing and task lifecycle management.
+// Server is responsible for managing the background-task processing.
 //
 // Server pulls tasks off queues and processes them.
-// If the processing of a task is unsuccessful, server will schedule it for a retry.
+// If the processing of a task is unsuccessful, server will
-//
+// schedule it for a retry.
 // A task will be retried until either the task gets processed successfully
 // or until it reaches its max retry count.
 //
-// If a task exhausts its retries, it will be moved to the archive and
+// If a task exhausts its retries, it will be moved to the "dead" queue and
-// will be kept in the archive set.
+// will be kept in the queue for some time until a certain condition is met
-// Note that the archive size is finite and once it reaches its max size,
+// (e.g., queue size reaches a certain limit, or the task has been in the
-// oldest tasks in the archive will be deleted.
+// queue for a certain amount of time).
 type Server struct {
 	logger *log.Logger
 
 	broker base.Broker
 
-	state *serverState
+	status *base.ServerStatus
 
 	// wait group to wait for all goroutines to finish.
 	wg          sync.WaitGroup
-	forwarder     *forwarder
+	scheduler   *scheduler
 	processor   *processor
 	syncer      *syncer
 	heartbeater *heartbeater
 	subscriber  *subscriber
 	recoverer   *recoverer
-	healthchecker *healthchecker
-	janitor       *janitor
-}
-
-type serverState struct {
-	mu    sync.Mutex
-	value serverStateValue
-}
-
-type serverStateValue int
-
-const (
-	// StateNew represents a new server. Server begins in
-	// this state and then transition to StatusActive when
-	// Start or Run is callled.
-	srvStateNew serverStateValue = iota
-
-	// StateActive indicates the server is up and active.
-	srvStateActive
-
-	// StateStopped indicates the server is up but no longer processing new tasks.
-	srvStateStopped
-
-	// StateClosed indicates the server has been shutdown.
-	srvStateClosed
-)
-
-var serverStates = []string{
-	"new",
-	"active",
-	"stopped",
-	"closed",
-}
-
-func (s serverStateValue) String() string {
-	if srvStateNew <= s && s <= srvStateClosed {
-		return serverStates[s]
-	}
-	return "unknown status"
 }
 
 // Config specifies the server's background-task processing behavior.
@@ -94,21 +54,17 @@ type Config struct {
 	// Maximum number of concurrent processing of tasks.
 	//
 	// If set to a zero or negative value, NewServer will overwrite the value
-	// to the number of CPUs usable by the current process.
+	// to the number of CPUs usable by the currennt process.
 	Concurrency int
 
 	// Function to calculate retry delay for a failed task.
 	//
 	// By default, it uses exponential backoff algorithm to calculate the delay.
-	RetryDelayFunc RetryDelayFunc
-
-	// Predicate function to determine whether the error returned from Handler is a failure.
-	// If the function returns false, Server will not increment the retried counter for the task,
-	// and Server won't record the queue stats (processed and failed stats) to avoid skewing the error
-	// rate of the queue.
 	//
-	// By default, if the given error is non-nil the function returns true.
+	// n is the number of times the task has been retried.
-	IsFailure func(error) bool
+	// e is the error returned by the task handler.
+	// t is the task in question.
+	RetryDelayFunc func(n int, e error, t *Task) time.Duration
 
 	// List of queues to process with given priority value. Keys are the names of the
 	// queues and values are associated priority value.
@@ -118,13 +74,11 @@ type Config struct {
 	// Priority is treated as follows to avoid starving low priority queues.
 	//
 	// Example:
-	//
 	// Queues: map[string]int{
 	//     "critical": 6,
 	//     "default":  3,
 	//     "low":      1,
 	// }
-	//
 	// With the above config and given that all queues are not empty, the tasks
 	// in "critical", "default", "low" should be processed 60%, 30%, 10% of
 	// the time respectively.
@@ -144,10 +98,7 @@ type Config struct {
 	// HandleError is invoked only if the task handler returns a non-nil error.
 	//
 	// Example:
-	//
+	// func reportError(task *asynq.Task, err error, retried, maxRetry int) {
-	//     func reportError(ctx context, task *asynq.Task, err error) {
-	//         retried, _ := asynq.GetRetryCount(ctx)
-	//         maxRetry, _ := asynq.GetMaxRetry(ctx)
 	// 	   if retried >= maxRetry {
 	//         err = fmt.Errorf("retry exhausted for task %s: %w", task.Type, err)
 	// 	   }
@@ -172,24 +123,9 @@ type Config struct {
 	//
 	// If unset or zero, default timeout of 8 seconds is used.
 	ShutdownTimeout time.Duration
-
-	// HealthCheckFunc is called periodically with any errors encountered during ping to the
-	// connected redis server.
-	HealthCheckFunc func(error)
-
-	// HealthCheckInterval specifies the interval between healthchecks.
-	//
-	// If unset or zero, the interval is set to 15 seconds.
-	HealthCheckInterval time.Duration
-
-	// DelayedTaskCheckInterval specifies the interval between checks run on 'scheduled' and 'retry'
-	// tasks, and forwarding them to 'pending' state if they are ready to be processed.
-	//
-	// If unset or zero, the interval is set to 5 seconds.
-	DelayedTaskCheckInterval time.Duration
 }
 
-// An ErrorHandler handles an error occured during task processing.
+// An ErrorHandler handles errors returned by the task handler.
 type ErrorHandler interface {
 	HandleError(ctx context.Context, task *Task, err error)
 }
@@ -203,14 +139,6 @@ func (fn ErrorHandlerFunc) HandleError(ctx context.Context, task *Task, err erro
 	fn(ctx, task, err)
 }
 
-// RetryDelayFunc calculates the retry delay duration for a failed task given
-// the retry count, error, and the task.
-//
-// n is the number of times the task has been retried.
-// e is the error returned by the task handler.
-// t is the task in question.
-type RetryDelayFunc func(n int, e error, t *Task) time.Duration
-
 // Logger supports logging at various log levels.
 type Logger interface {
 	// Debug logs a message at Debug level.
@@ -311,53 +239,32 @@ func toInternalLogLevel(l LogLevel) log.Level {
 	panic(fmt.Sprintf("asynq: unexpected log level: %v", l))
 }
 
-// DefaultRetryDelayFunc is the default RetryDelayFunc used if one is not specified in Config.
-// It uses exponential back-off strategy to calculate the retry delay.
-func DefaultRetryDelayFunc(n int, e error, t *Task) time.Duration {
-	r := rand.New(rand.NewSource(time.Now().UnixNano()))
 // Formula taken from https://github.com/mperham/sidekiq.
+func defaultDelayFunc(n int, e error, t *Task) time.Duration {
+	r := rand.New(rand.NewSource(time.Now().UnixNano()))
 	s := int(math.Pow(float64(n), 4)) + 15 + (r.Intn(30) * (n + 1))
 	return time.Duration(s) * time.Second
 }
 
-func defaultIsFailureFunc(err error) bool { return err != nil }
-
 var defaultQueueConfig = map[string]int{
 	base.DefaultQueueName: 1,
 }
 
-const (
+const defaultShutdownTimeout = 8 * time.Second
-	defaultShutdownTimeout = 8 * time.Second
-
-	defaultHealthCheckInterval = 15 * time.Second
-
-	defaultDelayedTaskCheckInterval = 5 * time.Second
-)
 
 // NewServer returns a new Server given a redis connection option
-// and server configuration.
+// and background processing configuration.
 func NewServer(r RedisConnOpt, cfg Config) *Server {
-	c, ok := r.MakeRedisClient().(redis.UniversalClient)
-	if !ok {
-		panic(fmt.Sprintf("asynq: unsupported RedisConnOpt type %T", r))
-	}
 	n := cfg.Concurrency
 	if n < 1 {
 		n = runtime.NumCPU()
 	}
 	delayFunc := cfg.RetryDelayFunc
 	if delayFunc == nil {
-		delayFunc = DefaultRetryDelayFunc
+		delayFunc = defaultDelayFunc
-	}
-	isFailureFunc := cfg.IsFailure
-	if isFailureFunc == nil {
-		isFailureFunc = defaultIsFailureFunc
 	}
 	queues := make(map[string]int)
 	for qname, p := range cfg.Queues {
-		if err := base.ValidateQueueName(qname); err != nil {
-			continue // ignore invalid queue names
-		}
 		if p > 0 {
 			queues[qname] = p
 		}
@@ -365,18 +272,10 @@ func NewServer(r RedisConnOpt, cfg Config) *Server {
 	if len(queues) == 0 {
 		queues = defaultQueueConfig
 	}
-	var qnames []string
-	for q := range queues {
-		qnames = append(qnames, q)
-	}
 	shutdownTimeout := cfg.ShutdownTimeout
 	if shutdownTimeout == 0 {
 		shutdownTimeout = defaultShutdownTimeout
 	}
-	healthcheckInterval := cfg.HealthCheckInterval
-	if healthcheckInterval == 0 {
-		healthcheckInterval = defaultHealthCheckInterval
-	}
 	logger := log.NewLogger(cfg.Logger)
 	loglevel := cfg.LogLevel
 	if loglevel == level_unspecified {
@@ -384,11 +283,11 @@ func NewServer(r RedisConnOpt, cfg Config) *Server {
 	}
 	logger.SetLevel(toInternalLogLevel(loglevel))
 
-	rdb := rdb.NewRDB(c)
+	rdb := rdb.NewRDB(createRedisClient(r))
-	starting := make(chan *workerInfo)
+	starting := make(chan *base.TaskMessage)
 	finished := make(chan *base.TaskMessage)
 	syncCh := make(chan *syncRequest)
-	srvState := &serverState{value: srvStateNew}
+	status := base.NewServerStatus(base.StatusIdle)
 	cancels := base.NewCancelations()
 
 	syncer := newSyncer(syncerParams{
@@ -403,19 +302,14 @@ func NewServer(r RedisConnOpt, cfg Config) *Server {
 		concurrency:    n,
 		queues:         queues,
 		strictPriority: cfg.StrictPriority,
-		state:          srvState,
+		status:         status,
 		starting:       starting,
 		finished:       finished,
 	})
-	delayedTaskCheckInterval := cfg.DelayedTaskCheckInterval
+	scheduler := newScheduler(schedulerParams{
-	if delayedTaskCheckInterval == 0 {
-		delayedTaskCheckInterval = defaultDelayedTaskCheckInterval
-	}
-	forwarder := newForwarder(forwarderParams{
 		logger:   logger,
 		broker:   rdb,
-		queues:   qnames,
+		interval: 5 * time.Second,
-		interval: delayedTaskCheckInterval,
 	})
 	subscriber := newSubscriber(subscriberParams{
 		logger:       logger,
@@ -426,7 +320,6 @@ func NewServer(r RedisConnOpt, cfg Config) *Server {
 		logger:          logger,
 		broker:          rdb,
 		retryDelayFunc:  delayFunc,
-		isFailureFunc:   isFailureFunc,
 		syncCh:          syncCh,
 		cancelations:    cancels,
 		concurrency:     n,
@@ -441,34 +334,18 @@ func NewServer(r RedisConnOpt, cfg Config) *Server {
 		logger:         logger,
 		broker:         rdb,
 		retryDelayFunc: delayFunc,
-		isFailureFunc:  isFailureFunc,
-		queues:         qnames,
 		interval:       1 * time.Minute,
 	})
-	healthchecker := newHealthChecker(healthcheckerParams{
-		logger:          logger,
-		broker:          rdb,
-		interval:        healthcheckInterval,
-		healthcheckFunc: cfg.HealthCheckFunc,
-	})
-	janitor := newJanitor(janitorParams{
-		logger:   logger,
-		broker:   rdb,
-		queues:   qnames,
-		interval: 8 * time.Second,
-	})
 	return &Server{
 		logger:      logger,
 		broker:      rdb,
-		state:         srvState,
+		status:      status,
-		forwarder:     forwarder,
+		scheduler:   scheduler,
 		processor:   processor,
 		syncer:      syncer,
 		heartbeater: heartbeater,
 		subscriber:  subscriber,
 		recoverer:   recoverer,
-		healthchecker: healthchecker,
-		janitor:       janitor,
 	}
 }
 
@@ -477,13 +354,8 @@ func NewServer(r RedisConnOpt, cfg Config) *Server {
 // ProcessTask should return nil if the processing of a task
 // is successful.
 //
-// If ProcessTask returns a non-nil error or panics, the task
+// If ProcessTask return a non-nil error or panics, the task
-// will be retried after delay if retry-count is remaining,
+// will be retried after delay.
-// otherwise the task will be archived.
-//
-// One exception to this rule is when ProcessTask returns a SkipRetry error.
-// If the returned error is SkipRetry or an error wraps SkipRetry, retry is
-// skipped and the task will be immediately archived instead.
 type Handler interface {
 	ProcessTask(context.Context, *Task) error
 }
@@ -499,121 +371,92 @@ func (fn HandlerFunc) ProcessTask(ctx context.Context, task *Task) error {
 	return fn(ctx, task)
 }
 
-// ErrServerClosed indicates that the operation is now illegal because of the server has been shutdown.
+// ErrServerStopped indicates that the operation is now illegal because of the server being stopped.
-var ErrServerClosed = errors.New("asynq: Server closed")
+var ErrServerStopped = errors.New("asynq: the server has been stopped")
 
-// Run starts the task processing and blocks until
+// Run starts the background-task processing and blocks until
 // an os signal to exit the program is received. Once it receives
 // a signal, it gracefully shuts down all active workers and other
 // goroutines to process the tasks.
 //
-// Run returns any error encountered at server startup time.
+// Run returns any error encountered during server startup time.
-// If the server has already been shutdown, ErrServerClosed is returned.
+// If the server has already been stopped, ErrServerStopped is returned.
 func (srv *Server) Run(handler Handler) error {
 	if err := srv.Start(handler); err != nil {
 		return err
 	}
 	srv.waitForSignals()
-	srv.Shutdown()
+	srv.Stop()
 	return nil
 }
 
 // Start starts the worker server. Once the server has started,
-// it pulls tasks off queues and starts a worker goroutine for each task
+// it pulls tasks off queues and starts a worker goroutine for each task.
-// and then call Handler to process it.
 // Tasks are processed concurrently by the workers  up to the number of
-// concurrency specified in Config.Concurrency.
+// concurrency specified at the initialization time.
 //
-// Start returns any error encountered at server startup time.
+// Start returns any error encountered during server startup time.
-// If the server has already been shutdown, ErrServerClosed is returned.
+// If the server has already been stopped, ErrServerStopped is returned.
 func (srv *Server) Start(handler Handler) error {
 	if handler == nil {
 		return fmt.Errorf("asynq: server cannot run with nil handler")
 	}
+	switch srv.status.Get() {
+	case base.StatusRunning:
+		return fmt.Errorf("asynq: the server is already running")
+	case base.StatusStopped:
+		return ErrServerStopped
+	}
+	srv.status.Set(base.StatusRunning)
 	srv.processor.handler = handler
 
-	if err := srv.start(); err != nil {
-		return err
-	}
 	srv.logger.Info("Starting processing")
 
 	srv.heartbeater.start(&srv.wg)
-	srv.healthchecker.start(&srv.wg)
 	srv.subscriber.start(&srv.wg)
 	srv.syncer.start(&srv.wg)
 	srv.recoverer.start(&srv.wg)
-	srv.forwarder.start(&srv.wg)
+	srv.scheduler.start(&srv.wg)
 	srv.processor.start(&srv.wg)
-	srv.janitor.start(&srv.wg)
 	return nil
 }
 
-// Checks server state and returns an error if pre-condition is not met.
+// Stop stops the worker server.
-// Otherwise it sets the server state to active.
-func (srv *Server) start() error {
-	srv.state.mu.Lock()
-	defer srv.state.mu.Unlock()
-	switch srv.state.value {
-	case srvStateActive:
-		return fmt.Errorf("asynq: the server is already running")
-	case srvStateStopped:
-		return fmt.Errorf("asynq: the server is in the stopped state. Waiting for shutdown.")
-	case srvStateClosed:
-		return ErrServerClosed
-	}
-	srv.state.value = srvStateActive
-	return nil
-}
-
-// Shutdown gracefully shuts down the server.
 // It gracefully closes all active workers. The server will wait for
 // active workers to finish processing tasks for duration specified in Config.ShutdownTimeout.
 // If worker didn't finish processing a task during the timeout, the task will be pushed back to Redis.
-func (srv *Server) Shutdown() {
+func (srv *Server) Stop() {
-	srv.state.mu.Lock()
+	switch srv.status.Get() {
-	if srv.state.value == srvStateNew || srv.state.value == srvStateClosed {
+	case base.StatusIdle, base.StatusStopped:
-		srv.state.mu.Unlock()
 		// server is not running, do nothing and return.
 		return
 	}
-	srv.state.value = srvStateClosed
-	srv.state.mu.Unlock()
 
 	srv.logger.Info("Starting graceful shutdown")
-	// Note: The order of shutdown is important.
+	// Note: The order of termination is important.
 	// Sender goroutines should be terminated before the receiver goroutines.
 	// processor -> syncer (via syncCh)
 	// processor -> heartbeater (via starting, finished channels)
-	srv.forwarder.shutdown()
+	srv.scheduler.terminate()
-	srv.processor.shutdown()
+	srv.processor.terminate()
-	srv.recoverer.shutdown()
+	srv.recoverer.terminate()
-	srv.syncer.shutdown()
+	srv.syncer.terminate()
-	srv.subscriber.shutdown()
+	srv.subscriber.terminate()
-	srv.janitor.shutdown()
+	srv.heartbeater.terminate()
-	srv.healthchecker.shutdown()
+
-	srv.heartbeater.shutdown()
 	srv.wg.Wait()
 
 	srv.broker.Close()
+	srv.status.Set(base.StatusStopped)
+
 	srv.logger.Info("Exiting")
 }
 
-// Stop signals the server to stop pulling new tasks off queues.
+// Quiet signals the server to stop pulling new tasks off queues.
-// Stop can be used before shutting down the server to ensure that all
+// Quiet should be used before stopping the server.
-// currently active tasks are processed before server shutdown.
+func (srv *Server) Quiet() {
-//
-// Stop does not shutdown the server, make sure to call Shutdown before exit.
-func (srv *Server) Stop() {
-	srv.state.mu.Lock()
-	if srv.state.value != srvStateActive {
-		// Invalid calll to Stop, server can only go from Active state to Stopped state.
-		srv.state.mu.Unlock()
-		return
-	}
-	srv.state.value = srvStateStopped
-	srv.state.mu.Unlock()
-
 	srv.logger.Info("Stopping processor")
 	srv.processor.stop()
+	srv.status.Set(base.StatusQuiet)
 	srv.logger.Info("Processor stopped")
 }

server_test.go

@@ -11,7 +11,6 @@ import (
 	"testing"
 	"time"
 
-	"github.com/hibiken/asynq/internal/asynqtest"
 	"github.com/hibiken/asynq/internal/rdb"
 	"github.com/hibiken/asynq/internal/testbroker"
 	"go.uber.org/goleak"
@@ -19,13 +18,15 @@ import (
 
 func TestServer(t *testing.T) {
 	// https://github.com/go-redis/redis/issues/1029
-	ignoreOpt := goleak.IgnoreTopFunction("github.com/go-redis/redis/v8/internal/pool.(*ConnPool).reaper")
+	ignoreOpt := goleak.IgnoreTopFunction("github.com/go-redis/redis/v7/internal/pool.(*ConnPool).reaper")
 	defer goleak.VerifyNoLeaks(t, ignoreOpt)
 
-	redisConnOpt := getRedisConnOpt(t)
+	r := &RedisClientOpt{
-	c := NewClient(redisConnOpt)
+		Addr: "localhost:6379",
-	defer c.Close()
+		DB:   15,
-	srv := NewServer(redisConnOpt, Config{
+	}
+	c := NewClient(r)
+	srv := NewServer(r, Config{
 		Concurrency: 10,
 		LogLevel:    testLogLevel,
 	})
@@ -40,22 +41,22 @@ func TestServer(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	_, err = c.Enqueue(NewTask("send_email", asynqtest.JSON(map[string]interface{}{"recipient_id": 123})))
+	_, err = c.Enqueue(NewTask("send_email", map[string]interface{}{"recipient_id": 123}))
 	if err != nil {
 		t.Errorf("could not enqueue a task: %v", err)
 	}
 
-	_, err = c.Enqueue(NewTask("send_email", asynqtest.JSON(map[string]interface{}{"recipient_id": 456})), ProcessIn(1*time.Hour))
+	_, err = c.EnqueueAt(time.Now().Add(time.Hour), NewTask("send_email", map[string]interface{}{"recipient_id": 456}))
 	if err != nil {
 		t.Errorf("could not enqueue a task: %v", err)
 	}
 
-	srv.Shutdown()
+	srv.Stop()
 }
 
 func TestServerRun(t *testing.T) {
 	// https://github.com/go-redis/redis/issues/1029
-	ignoreOpt := goleak.IgnoreTopFunction("github.com/go-redis/redis/v8/internal/pool.(*ConnPool).reaper")
+	ignoreOpt := goleak.IgnoreTopFunction("github.com/go-redis/redis/v7/internal/pool.(*ConnPool).reaper")
 	defer goleak.VerifyNoLeaks(t, ignoreOpt)
 
 	srv := NewServer(RedisClientOpt{Addr: ":6379"}, Config{LogLevel: testLogLevel})
@@ -71,7 +72,7 @@ func TestServerRun(t *testing.T) {
 	go func() {
 		select {
 		case <-time.After(10 * time.Second):
-			panic("server did not stop after receiving TERM signal")
+			t.Fatal("server did not stop after receiving TERM signal")
 		case <-done:
 		}
 	}()
@@ -82,16 +83,16 @@ func TestServerRun(t *testing.T) {
 	}
 }
 
-func TestServerErrServerClosed(t *testing.T) {
+func TestServerErrServerStopped(t *testing.T) {
 	srv := NewServer(RedisClientOpt{Addr: ":6379"}, Config{LogLevel: testLogLevel})
 	handler := NewServeMux()
 	if err := srv.Start(handler); err != nil {
 		t.Fatal(err)
 	}
-	srv.Shutdown()
+	srv.Stop()
 	err := srv.Start(handler)
-	if err != ErrServerClosed {
+	if err != ErrServerStopped {
-		t.Errorf("Restarting server: (*Server).Start(handler) = %v, want ErrServerClosed error", err)
+		t.Errorf("Restarting server: (*Server).Start(handler) = %v, want ErrServerStopped error", err)
 	}
 }
 
@@ -100,7 +101,7 @@ func TestServerErrNilHandler(t *testing.T) {
 	err := srv.Start(nil)
 	if err == nil {
 		t.Error("Starting server with nil handler: (*Server).Start(nil) did not return error")
-		srv.Shutdown()
+		srv.Stop()
 	}
 }
 
@@ -114,7 +115,7 @@ func TestServerErrServerRunning(t *testing.T) {
 	if err == nil {
 		t.Error("Calling (*Server).Start(handler) on already running server did not return error")
 	}
-	srv.Shutdown()
+	srv.Stop()
 }
 
 func TestServerWithRedisDown(t *testing.T) {
@@ -128,7 +129,7 @@ func TestServerWithRedisDown(t *testing.T) {
 	testBroker := testbroker.NewTestBroker(r)
 	srv := NewServer(RedisClientOpt{Addr: ":6379"}, Config{LogLevel: testLogLevel})
 	srv.broker = testBroker
-	srv.forwarder.broker = testBroker
+	srv.scheduler.broker = testBroker
 	srv.heartbeater.broker = testBroker
 	srv.processor.broker = testBroker
 	srv.subscriber.broker = testBroker
@@ -146,7 +147,7 @@ func TestServerWithRedisDown(t *testing.T) {
 
 	time.Sleep(3 * time.Second)
 
-	srv.Shutdown()
+	srv.Stop()
 }
 
 func TestServerWithFlakyBroker(t *testing.T) {
@@ -158,20 +159,19 @@ func TestServerWithFlakyBroker(t *testing.T) {
 	}()
 	r := rdb.NewRDB(setup(t))
 	testBroker := testbroker.NewTestBroker(r)
-	redisConnOpt := getRedisConnOpt(t)
+	srv := NewServer(RedisClientOpt{Addr: redisAddr, DB: redisDB}, Config{LogLevel: testLogLevel})
-	srv := NewServer(redisConnOpt, Config{LogLevel: testLogLevel})
 	srv.broker = testBroker
-	srv.forwarder.broker = testBroker
+	srv.scheduler.broker = testBroker
 	srv.heartbeater.broker = testBroker
 	srv.processor.broker = testBroker
 	srv.subscriber.broker = testBroker
 
-	c := NewClient(redisConnOpt)
+	c := NewClient(RedisClientOpt{Addr: redisAddr, DB: redisDB})
 
 	h := func(ctx context.Context, task *Task) error {
 		// force task retry.
-		if task.Type() == "bad_task" {
+		if task.Type == "bad_task" {
-			return fmt.Errorf("could not process %q", task.Type())
+			return fmt.Errorf("could not process %q", task.Type)
 		}
 		time.Sleep(2 * time.Second)
 		return nil
@@ -191,7 +191,7 @@ func TestServerWithFlakyBroker(t *testing.T) {
 		if err != nil {
 			t.Fatal(err)
 		}
-		_, err = c.Enqueue(NewTask("scheduled", nil), ProcessIn(time.Duration(i)*time.Second))
+		_, err = c.EnqueueIn(time.Duration(i)*time.Second, NewTask("scheduled", nil))
 		if err != nil {
 			t.Fatal(err)
 		}
@@ -207,7 +207,7 @@ func TestServerWithFlakyBroker(t *testing.T) {
 
 	time.Sleep(3 * time.Second)
 
-	srv.Shutdown()
+	srv.Stop()
 }
 
 func TestLogLevel(t *testing.T) {

signals_unix.go

@@ -22,16 +22,9 @@ func (srv *Server) waitForSignals() {
 	for {
 		sig := <-sigs
 		if sig == unix.SIGTSTP {
-			srv.Stop()
+			srv.Quiet()
 			continue
 		}
 		break
 	}
 }
-
-func (s *Scheduler) waitForSignals() {
-	s.logger.Info("Send signal TERM or INT to stop the scheduler")
-	sigs := make(chan os.Signal, 1)
-	signal.Notify(sigs, unix.SIGTERM, unix.SIGINT)
-	<-sigs
-}

signals_windows.go

@@ -20,10 +20,3 @@ func (srv *Server) waitForSignals() {
 	signal.Notify(sigs, windows.SIGTERM, windows.SIGINT)
 	<-sigs
 }
-
-func (s *Scheduler) waitForSignals() {
-	s.logger.Info("Send signal TERM or INT to stop the scheduler")
-	sigs := make(chan os.Signal, 1)
-	signal.Notify(sigs, windows.SIGTERM, windows.SIGINT)
-	<-sigs
-}

subscriber.go

@@ -8,7 +8,7 @@ import (
 	"sync"
 	"time"
 
-	"github.com/go-redis/redis/v8"
+	"github.com/go-redis/redis/v7"
 	"github.com/hibiken/asynq/internal/base"
 	"github.com/hibiken/asynq/internal/log"
 )
@@ -20,7 +20,7 @@ type subscriber struct {
 	// channel to communicate back to the long running "subscriber" goroutine.
 	done chan struct{}
 
-	// cancelations hold cancel functions for all active tasks.
+	// cancelations hold cancel functions for all in-progress tasks.
 	cancelations *base.Cancelations
 
 	// time to wait before retrying to connect to redis.
@@ -43,7 +43,7 @@ func newSubscriber(params subscriberParams) *subscriber {
 	}
 }
 
-func (s *subscriber) shutdown() {
+func (s *subscriber) terminate() {
 	s.logger.Debug("Subscriber shutting down...")
 	// Signal the subscriber goroutine to stop.
 	s.done <- struct{}{}

subscriber_test.go

@@ -16,7 +16,6 @@ import (
 
 func TestSubscriber(t *testing.T) {
 	r := setup(t)
-	defer r.Close()
 	rdbClient := rdb.NewRDB(r)
 
 	tests := []struct {
@@ -46,7 +45,7 @@ func TestSubscriber(t *testing.T) {
 		})
 		var wg sync.WaitGroup
 		subscriber.start(&wg)
-		defer subscriber.shutdown()
+		defer subscriber.terminate()
 
 		// wait for subscriber to establish connection to pubsub channel
 		time.Sleep(time.Second)
@@ -77,7 +76,6 @@ func TestSubscriberWithRedisDown(t *testing.T) {
 		}
 	}()
 	r := rdb.NewRDB(setup(t))
-	defer r.Close()
 	testBroker := testbroker.NewTestBroker(r)
 
 	cancelations := base.NewCancelations()
@@ -91,7 +89,7 @@ func TestSubscriberWithRedisDown(t *testing.T) {
 	testBroker.Sleep() // simulate a situation where subscriber cannot connect to redis.
 	var wg sync.WaitGroup
 	subscriber.start(&wg)
-	defer subscriber.shutdown()
+	defer subscriber.terminate()
 
 	time.Sleep(2 * time.Second) // subscriber should wait and retry connecting to redis.
 

syncer.go

@@ -46,7 +46,7 @@ func newSyncer(params syncerParams) *syncer {
 	}
 }
 
-func (s *syncer) shutdown() {
+func (s *syncer) terminate() {
 	s.logger.Debug("Syncer shutting down...")
 	// Signal the syncer goroutine to stop.
 	s.done <- struct{}{}

syncer_test.go

@@ -22,9 +22,8 @@ func TestSyncer(t *testing.T) {
 		h.NewTaskMessage("gen_thumbnail", nil),
 	}
 	r := setup(t)
-	defer r.Close()
 	rdbClient := rdb.NewRDB(r)
-	h.SeedActiveQueue(t, r, inProgress, base.DefaultQueueName)
+	h.SeedInProgressQueue(t, r, inProgress)
 
 	const interval = time.Second
 	syncRequestCh := make(chan *syncRequest)
@@ -35,7 +34,7 @@ func TestSyncer(t *testing.T) {
 	})
 	var wg sync.WaitGroup
 	syncer.start(&wg)
-	defer syncer.shutdown()
+	defer syncer.terminate()
 
 	for _, msg := range inProgress {
 		m := msg
@@ -49,9 +48,9 @@ func TestSyncer(t *testing.T) {
 
 	time.Sleep(2 * interval) // ensure that syncer runs at least once
 
-	gotActive := h.GetActiveMessages(t, r, base.DefaultQueueName)
+	gotInProgress := h.GetInProgressMessages(t, r)
-	if l := len(gotActive); l != 0 {
+	if l := len(gotInProgress); l != 0 {
-		t.Errorf("%q has length %d; want 0", base.ActiveKey(base.DefaultQueueName), l)
+		t.Errorf("%q has length %d; want 0", base.InProgressQueue, l)
 	}
 }
 
@@ -66,7 +65,7 @@ func TestSyncerRetry(t *testing.T) {
 
 	var wg sync.WaitGroup
 	syncer.start(&wg)
-	defer syncer.shutdown()
+	defer syncer.terminate()
 
 	var (
 		mu      sync.Mutex
@@ -131,7 +130,7 @@ func TestSyncerDropsStaleRequests(t *testing.T) {
 	}
 
 	time.Sleep(2 * interval) // ensure that syncer runs at least once
-	syncer.shutdown()
+	syncer.terminate()
 
 	mu.Lock()
 	if n != 0 {

tools/asynq/README.md

@@ -1,11 +1,20 @@
 # Asynq CLI
 
-Asynq CLI is a command line tool to monitor the queues and tasks managed by `asynq` package.
+Asynq CLI is a command line tool to monitor the tasks managed by `asynq` package.
 
 ## Table of Contents
 
 - [Installation](#installation)
-- [Usage](#usage)
+- [Quick Start](#quick-start)
+  - [Stats](#stats)
+  - [History](#history)
+  - [Servers](#servers)
+  - [List](#list)
+  - [Enqueue](#enqueue)
+  - [Delete](#delete)
+  - [Kill](#kill)
+  - [Cancel](#cancel)
+  - [Pause](#pause)
 - [Config File](#config-file)
 
 ## Installation
@@ -16,41 +25,144 @@ In order to use the tool, compile it using the following command:
 
 This will create the asynq executable under your `$GOPATH/bin` directory.
 
-## Usage
+## Quickstart
 
-### Commands
+The tool has a few commands to inspect the state of tasks and queues.
 
-To view details on any command, use `asynq help <command> <subcommand>`.
+Run `asynq help` to see all the available commands.
-
-- `asynq stats`
-- `asynq queue [ls inspect history rm pause unpause]`
-- `asynq task [ls cancel delete archive run delete-all archive-all run-all]`
-- `asynq server [ls]`
-
-### Global flags
 
 Asynq CLI needs to connect to a redis-server to inspect the state of queues and tasks. Use flags to specify the options to connect to the redis-server used by your application.
-To connect to a redis cluster, pass `--cluster` and `--cluster_addrs` flags.
 
 By default, CLI will try to connect to a redis server running at `localhost:6379`.
 
-```
+### Stats
-      --config string          config file to set flag defaut values (default is $HOME/.asynq.yaml)
-  -n, --db int                 redis database number (default is 0)
-  -h, --help                   help for asynq
-  -p, --password string        password to use when connecting to redis server
-  -u, --uri string             redis server URI (default "127.0.0.1:6379")
 
-      --cluster                connect to redis cluster
+Stats command gives the overview of the current state of tasks and queues. You can run it in conjunction with `watch` command to repeatedly run `stats`.
-      --cluster_addrs string   list of comma-separated redis server addresses
+
-```
+Example:
+
+    watch -n 3 asynq stats
+
+This will run `asynq stats` command every 3 seconds.
+
+![Gif](/docs/assets/asynq_stats.gif)
+
+### History
+
+History command shows the number of processed and failed tasks from the last x days.
+
+By default, it shows the stats from the last 10 days. Use `--days` to specify the number of days.
+
+Example:
+
+    asynq history --days=30
+
+![Gif](/docs/assets/asynq_history.gif)
+
+### Servers
+
+Servers command shows the list of running worker servers pulling tasks from the given redis instance.
+
+Example:
+
+    asynq servers
+
+### List
+
+List command shows all tasks in the specified state in a table format
+
+Example:
+
+    asynq ls retry
+    asynq ls scheduled
+    asynq ls dead
+    asynq ls enqueued:default
+    asynq ls inprogress
+
+### Enqueue
+
+There are two commands to enqueue tasks.
+
+Command `enq` takes a task ID and moves the task to **Enqueued** state. You can obtain the task ID by running `ls` command.
+
+Example:
+
+    asynq enq d:1575732274:bnogo8gt6toe23vhef0g
+
+Command `enqall` moves all tasks to **Enqueued** state from the specified state.
+
+Example:
+
+    asynq enqall retry
+
+Running the above command will move all **Retry** tasks to **Enqueued** state.
+
+### Delete
+
+There are two commands for task deletion.
+
+Command `del` takes a task ID and deletes the task. You can obtain the task ID by running `ls` command.
+
+Example:
+
+    asynq del r:1575732274:bnogo8gt6toe23vhef0g
+
+Command `delall` deletes all tasks which are in the specified state.
+
+Example:
+
+    asynq delall retry
+
+Running the above command will delete all **Retry** tasks.
+
+### Kill
+
+There are two commands to kill (i.e. move to dead state) tasks.
+
+Command `kill` takes a task ID and kills the task. You can obtain the task ID by running `ls` command.
+
+Example:
+
+    asynq kill r:1575732274:bnogo8gt6toe23vhef0g
+
+Command `killall` kills all tasks which are in the specified state.
+
+Example:
+
+    asynq killall retry
+
+Running the above command will move all **Retry** tasks to **Dead** state.
+
+### Cancel
+
+Command `cancel` takes a task ID and sends a cancelation signal to the goroutine processing the specified task.  
+You can obtain the task ID by running `ls` command.
+
+The task should be in "in-progress" state.
+Handler implementation needs to be context aware in order to actually stop processing.
+
+Example:
+
+    asynq cancel bnogo8gt6toe23vhef0g
+
+### Pause
+
+Command `pause` pauses the spcified queue. Tasks in paused queues are not processed by servers.
+To resume processing from the queue, use `unpause` command.
+To see which queues are currently paused, use `stats` command.
+
+Example:
+
+    asynq pause email
+    asynq unpause email
 
 ## Config File
 
 You can use a config file to set default values for the flags.
+This is useful, for example when you have to connect to a remote redis server.
 
 By default, `asynq` will try to read config file located in
-`$HOME/.asynq.(yml|json)`. You can specify the file location via `--config` flag.
+`$HOME/.asynq.(yaml|json)`. You can specify the file location via `--config` flag.
 
 Config file example:
 

tools/asynq/cmd/cancel.go

@@ -0,0 +1,53 @@
+// Copyright 2020 Kentaro Hibino. All rights reserved.
+// Use of this source code is governed by a MIT license
+// that can be found in the LICENSE file.
+
+package cmd
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/go-redis/redis/v7"
+	"github.com/hibiken/asynq/internal/rdb"
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+)
+
+// cancelCmd represents the cancel command
+var cancelCmd = &cobra.Command{
+	Use:   "cancel [task id]",
+	Short: "Sends a cancelation signal to the goroutine processing the specified task",
+	Long: `Cancel (asynq cancel) will send a cancelation signal to the goroutine processing 
+the specified task. 
+
+The command takes one argument which specifies the task to cancel.
+The task should be in in-progress state.
+Identifier for a task should be obtained by running "asynq ls" command.
+
+Handler implementation needs to be context aware for cancelation signal to
+actually cancel the processing.
+
+Example: asynq cancel bnogo8gt6toe23vhef0g`,
+	Args: cobra.ExactArgs(1),
+	Run:  cancel,
+}
+
+func init() {
+	rootCmd.AddCommand(cancelCmd)
+}
+
+func cancel(cmd *cobra.Command, args []string) {
+	r := rdb.NewRDB(redis.NewClient(&redis.Options{
+		Addr:     viper.GetString("uri"),
+		DB:       viper.GetInt("db"),
+		Password: viper.GetString("password"),
+	}))
+
+	err := r.PublishCancelation(args[0])
+	if err != nil {
+		fmt.Printf("could not send cancelation signal: %v\n", err)
+		os.Exit(1)
+	}
+	fmt.Printf("Successfully sent cancelation siganl for task %s\n", args[0])
+}

tools/asynq/cmd/cron.go

@@ -1,129 +0,0 @@
-// Copyright 2020 Kentaro Hibino. All rights reserved.
-// Use of this source code is governed by a MIT license
-// that can be found in the LICENSE file.
-
-package cmd
-
-import (
-	"fmt"
-	"io"
-	"os"
-	"sort"
-	"time"
-
-	"github.com/hibiken/asynq"
-	"github.com/spf13/cobra"
-)
-
-func init() {
-	rootCmd.AddCommand(cronCmd)
-	cronCmd.AddCommand(cronListCmd)
-	cronCmd.AddCommand(cronHistoryCmd)
-	cronHistoryCmd.Flags().Int("page", 1, "page number")
-	cronHistoryCmd.Flags().Int("size", 30, "page size")
-}
-
-var cronCmd = &cobra.Command{
-	Use:   "cron",
-	Short: "Manage cron",
-}
-
-var cronListCmd = &cobra.Command{
-	Use:   "ls",
-	Short: "List cron entries",
-	Run:   cronList,
-}
-
-var cronHistoryCmd = &cobra.Command{
-	Use:   "history [ENTRY_ID...]",
-	Short: "Show history of each cron tasks",
-	Args:  cobra.MinimumNArgs(1),
-	Run:   cronHistory,
-}
-
-func cronList(cmd *cobra.Command, args []string) {
-	inspector := createInspector()
-
-	entries, err := inspector.SchedulerEntries()
-	if err != nil {
-		fmt.Println(err)
-		os.Exit(1)
-	}
-	if len(entries) == 0 {
-		fmt.Println("No scheduler entries")
-		return
-	}
-
-	// Sort entries by spec.
-	sort.Slice(entries, func(i, j int) bool {
-		x, y := entries[i], entries[j]
-		return x.Spec < y.Spec
-	})
-
-	cols := []string{"EntryID", "Spec", "Type", "Payload", "Options", "Next", "Prev"}
-	printRows := func(w io.Writer, tmpl string) {
-		for _, e := range entries {
-			fmt.Fprintf(w, tmpl, e.ID, e.Spec, e.Task.Type(), sprintBytes(e.Task.Payload()), e.Opts,
-				nextEnqueue(e.Next), prevEnqueue(e.Prev))
-		}
-	}
-	printTable(cols, printRows)
-}
-
-// Returns a string describing when the next enqueue will happen.
-func nextEnqueue(nextEnqueueAt time.Time) string {
-	d := nextEnqueueAt.Sub(time.Now()).Round(time.Second)
-	if d < 0 {
-		return "Now"
-	}
-	return fmt.Sprintf("In %v", d)
-}
-
-// Returns a string describing when the previous enqueue was.
-func prevEnqueue(prevEnqueuedAt time.Time) string {
-	if prevEnqueuedAt.IsZero() {
-		return "N/A"
-	}
-	return fmt.Sprintf("%v ago", time.Since(prevEnqueuedAt).Round(time.Second))
-}
-
-func cronHistory(cmd *cobra.Command, args []string) {
-	pageNum, err := cmd.Flags().GetInt("page")
-	if err != nil {
-		fmt.Println(err)
-		os.Exit(1)
-	}
-	pageSize, err := cmd.Flags().GetInt("size")
-	if err != nil {
-		fmt.Println(err)
-		os.Exit(1)
-	}
-	inspector := createInspector()
-	for i, entryID := range args {
-		if i > 0 {
-			fmt.Printf("\n%s\n", separator)
-		}
-		fmt.Println()
-
-		fmt.Printf("Entry: %s\n\n", entryID)
-
-		events, err := inspector.ListSchedulerEnqueueEvents(
-			entryID, asynq.PageSize(pageSize), asynq.Page(pageNum))
-		if err != nil {
-			fmt.Printf("error: %v\n", err)
-			continue
-		}
-		if len(events) == 0 {
-			fmt.Printf("No scheduler enqueue events found for entry: %s\n", entryID)
-			continue
-		}
-
-		cols := []string{"TaskID", "EnqueuedAt"}
-		printRows := func(w io.Writer, tmpl string) {
-			for _, e := range events {
-				fmt.Fprintf(w, tmpl, e.TaskID, e.EnqueuedAt)
-			}
-		}
-		printTable(cols, printRows)
-	}
-}

tools/asynq/cmd/del.go

@@ -0,0 +1,73 @@
+// Copyright 2020 Kentaro Hibino. All rights reserved.
+// Use of this source code is governed by a MIT license
+// that can be found in the LICENSE file.
+
+package cmd
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/go-redis/redis/v7"
+	"github.com/hibiken/asynq/internal/rdb"
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+)
+
+// delCmd represents the del command
+var delCmd = &cobra.Command{
+	Use:   "del [task id]",
+	Short: "Deletes a task given an identifier",
+	Long: `Del (asynq del) will delete a task given an identifier.
+
+The command takes one argument which specifies the task to delete.
+The task should be in either scheduled, retry or dead state.
+Identifier for a task should be obtained by running "asynq ls" command.
+
+Example: asynq enq d:1575732274:bnogo8gt6toe23vhef0g`,
+	Args: cobra.ExactArgs(1),
+	Run:  del,
+}
+
+func init() {
+	rootCmd.AddCommand(delCmd)
+
+	// Here you will define your flags and configuration settings.
+
+	// Cobra supports Persistent Flags which will work for this command
+	// and all subcommands, e.g.:
+	// delCmd.PersistentFlags().String("foo", "", "A help for foo")
+
+	// Cobra supports local flags which will only run when this command
+	// is called directly, e.g.:
+	// delCmd.Flags().BoolP("toggle", "t", false, "Help message for toggle")
+}
+
+func del(cmd *cobra.Command, args []string) {
+	id, score, qtype, err := parseQueryID(args[0])
+	if err != nil {
+		fmt.Println(err)
+		os.Exit(1)
+	}
+	r := rdb.NewRDB(redis.NewClient(&redis.Options{
+		Addr:     viper.GetString("uri"),
+		DB:       viper.GetInt("db"),
+		Password: viper.GetString("password"),
+	}))
+	switch qtype {
+	case "s":
+		err = r.DeleteScheduledTask(id, score)
+	case "r":
+		err = r.DeleteRetryTask(id, score)
+	case "d":
+		err = r.DeleteDeadTask(id, score)
+	default:
+		fmt.Println("invalid argument")
+		os.Exit(1)
+	}
+	if err != nil {
+		fmt.Println(err)
+		os.Exit(1)
+	}
+	fmt.Printf("Successfully deleted %v\n", args[0])
+}

tools/asynq/cmd/delall.go

@@ -0,0 +1,71 @@
+// Copyright 2020 Kentaro Hibino. All rights reserved.
+// Use of this source code is governed by a MIT license
+// that can be found in the LICENSE file.
+
+package cmd
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/go-redis/redis/v7"
+	"github.com/hibiken/asynq/internal/rdb"
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+)
+
+var delallValidArgs = []string{"scheduled", "retry", "dead"}
+
+// delallCmd represents the delall command
+var delallCmd = &cobra.Command{
+	Use:   "delall [state]",
+	Short: "Deletes all tasks in the specified state",
+	Long: `Delall (asynq delall) will delete all tasks in the specified state.
+
+The argument should be one of "scheduled", "retry", or "dead".
+
+Example: asynq delall dead -> Deletes all dead tasks`,
+	ValidArgs: delallValidArgs,
+	Args:      cobra.ExactValidArgs(1),
+	Run:       delall,
+}
+
+func init() {
+	rootCmd.AddCommand(delallCmd)
+
+	// Here you will define your flags and configuration settings.
+
+	// Cobra supports Persistent Flags which will work for this command
+	// and all subcommands, e.g.:
+	// delallCmd.PersistentFlags().String("foo", "", "A help for foo")
+
+	// Cobra supports local flags which will only run when this command
+	// is called directly, e.g.:
+	// delallCmd.Flags().BoolP("toggle", "t", false, "Help message for toggle")
+}
+
+func delall(cmd *cobra.Command, args []string) {
+	c := redis.NewClient(&redis.Options{
+		Addr:     viper.GetString("uri"),
+		DB:       viper.GetInt("db"),
+		Password: viper.GetString("password"),
+	})
+	r := rdb.NewRDB(c)
+	var err error
+	switch args[0] {
+	case "scheduled":
+		err = r.DeleteAllScheduledTasks()
+	case "retry":
+		err = r.DeleteAllRetryTasks()
+	case "dead":
+		err = r.DeleteAllDeadTasks()
+	default:
+		fmt.Printf("error: `asynq delall [state]` only accepts %v as the argument.\n", delallValidArgs)
+		os.Exit(1)
+	}
+	if err != nil {
+		fmt.Println(err)
+		os.Exit(1)
+	}
+	fmt.Printf("Deleted all tasks in %q state\n", args[0])
+}

tools/asynq/cmd/enq.go

@@ -0,0 +1,76 @@
+// Copyright 2020 Kentaro Hibino. All rights reserved.
+// Use of this source code is governed by a MIT license
+// that can be found in the LICENSE file.
+
+package cmd
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/go-redis/redis/v7"
+	"github.com/hibiken/asynq/internal/rdb"
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+)
+
+// enqCmd represents the enq command
+var enqCmd = &cobra.Command{
+	Use:   "enq [task id]",
+	Short: "Enqueues a task given an identifier",
+	Long: `Enq (asynq enq) will enqueue a task given an identifier.
+
+The command takes one argument which specifies the task to enqueue.
+The task should be in either scheduled, retry or dead state.
+Identifier for a task should be obtained by running "asynq ls" command.
+
+The task enqueued by this command will be processed as soon as the task 
+gets dequeued by a processor.
+
+Example: asynq enq d:1575732274:bnogo8gt6toe23vhef0g`,
+	Args: cobra.ExactArgs(1),
+	Run:  enq,
+}
+
+func init() {
+	rootCmd.AddCommand(enqCmd)
+
+	// Here you will define your flags and configuration settings.
+
+	// Cobra supports Persistent Flags which will work for this command
+	// and all subcommands, e.g.:
+	// enqCmd.PersistentFlags().String("foo", "", "A help for foo")
+
+	// Cobra supports local flags which will only run when this command
+	// is called directly, e.g.:
+	// enqCmd.Flags().BoolP("toggle", "t", false, "Help message for toggle")
+}
+
+func enq(cmd *cobra.Command, args []string) {
+	id, score, qtype, err := parseQueryID(args[0])
+	if err != nil {
+		fmt.Println(err)
+		os.Exit(1)
+	}
+	r := rdb.NewRDB(redis.NewClient(&redis.Options{
+		Addr:     viper.GetString("uri"),
+		DB:       viper.GetInt("db"),
+		Password: viper.GetString("password"),
+	}))
+	switch qtype {
+	case "s":
+		err = r.EnqueueScheduledTask(id, score)
+	case "r":
+		err = r.EnqueueRetryTask(id, score)
+	case "d":
+		err = r.EnqueueDeadTask(id, score)
+	default:
+		fmt.Println("invalid argument")
+		os.Exit(1)
+	}
+	if err != nil {
+		fmt.Println(err)
+		os.Exit(1)
+	}
+	fmt.Printf("Successfully enqueued %v\n", args[0])
+}

tools/asynq/cmd/enqall.go

@@ -0,0 +1,75 @@
+// Copyright 2020 Kentaro Hibino. All rights reserved.
+// Use of this source code is governed by a MIT license
+// that can be found in the LICENSE file.
+
+package cmd
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/go-redis/redis/v7"
+	"github.com/hibiken/asynq/internal/rdb"
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+)
+
+var enqallValidArgs = []string{"scheduled", "retry", "dead"}
+
+// enqallCmd represents the enqall command
+var enqallCmd = &cobra.Command{
+	Use:   "enqall [state]",
+	Short: "Enqueues all tasks in the specified state",
+	Long: `Enqall (asynq enqall) will enqueue all tasks in the specified state.
+
+The argument should be one of "scheduled", "retry", or "dead".
+
+The tasks enqueued by this command will be processed as soon as it
+gets dequeued by a processor.
+
+Example: asynq enqall dead -> Enqueues all dead tasks`,
+	ValidArgs: enqallValidArgs,
+	Args:      cobra.ExactValidArgs(1),
+	Run:       enqall,
+}
+
+func init() {
+	rootCmd.AddCommand(enqallCmd)
+
+	// Here you will define your flags and configuration settings.
+
+	// Cobra supports Persistent Flags which will work for this command
+	// and all subcommands, e.g.:
+	// enqallCmd.PersistentFlags().String("foo", "", "A help for foo")
+
+	// Cobra supports local flags which will only run when this command
+	// is called directly, e.g.:
+	// enqallCmd.Flags().BoolP("toggle", "t", false, "Help message for toggle")
+}
+
+func enqall(cmd *cobra.Command, args []string) {
+	c := redis.NewClient(&redis.Options{
+		Addr:     viper.GetString("uri"),
+		DB:       viper.GetInt("db"),
+		Password: viper.GetString("password"),
+	})
+	r := rdb.NewRDB(c)
+	var n int64
+	var err error
+	switch args[0] {
+	case "scheduled":
+		n, err = r.EnqueueAllScheduledTasks()
+	case "retry":
+		n, err = r.EnqueueAllRetryTasks()
+	case "dead":
+		n, err = r.EnqueueAllDeadTasks()
+	default:
+		fmt.Printf("error: `asynq enqall [state]` only accepts %v as the argument.\n", enqallValidArgs)
+		os.Exit(1)
+	}
+	if err != nil {
+		fmt.Println(err)
+		os.Exit(1)
+	}
+	fmt.Printf("Enqueued %d tasks in %q state\n", n, args[0])
+}

tools/asynq/cmd/history.go

@@ -0,0 +1,71 @@
+// Copyright 2020 Kentaro Hibino. All rights reserved.
+// Use of this source code is governed by a MIT license
+// that can be found in the LICENSE file.
+
+package cmd
+
+import (
+	"fmt"
+	"os"
+	"strings"
+	"text/tabwriter"
+
+	"github.com/go-redis/redis/v7"
+	"github.com/hibiken/asynq/internal/rdb"
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+)
+
+var days int
+
+// historyCmd represents the history command
+var historyCmd = &cobra.Command{
+	Use:   "history",
+	Short: "Shows historical aggregate data",
+	Long: `History (asynq history) will show the number of processed and failed tasks
+from the last x days.
+
+By default, it will show the data from the last 10 days.
+
+Example: asynq history -x=30 -> Shows stats from the last 30 days`,
+	Args: cobra.NoArgs,
+	Run:  history,
+}
+
+func init() {
+	rootCmd.AddCommand(historyCmd)
+	historyCmd.Flags().IntVarP(&days, "days", "x", 10, "show data from last x days")
+}
+
+func history(cmd *cobra.Command, args []string) {
+	c := redis.NewClient(&redis.Options{
+		Addr:     viper.GetString("uri"),
+		DB:       viper.GetInt("db"),
+		Password: viper.GetString("password"),
+	})
+	r := rdb.NewRDB(c)
+
+	stats, err := r.HistoricalStats(days)
+	if err != nil {
+		fmt.Println(err)
+		os.Exit(1)
+	}
+	printDailyStats(stats)
+}
+
+func printDailyStats(stats []*rdb.DailyStats) {
+	format := strings.Repeat("%v\t", 4) + "\n"
+	tw := new(tabwriter.Writer).Init(os.Stdout, 0, 8, 2, ' ', 0)
+	fmt.Fprintf(tw, format, "Date (UTC)", "Processed", "Failed", "Error Rate")
+	fmt.Fprintf(tw, format, "----------", "---------", "------", "----------")
+	for _, s := range stats {
+		var errrate string
+		if s.Processed == 0 {
+			errrate = "N/A"
+		} else {
+			errrate = fmt.Sprintf("%.2f%%", float64(s.Failed)/float64(s.Processed)*100)
+		}
+		fmt.Fprintf(tw, format, s.Time.Format("2006-01-02"), s.Processed, s.Failed, errrate)
+	}
+	tw.Flush()
+}

tools/asynq/cmd/kill.go

@@ -0,0 +1,72 @@
+// Copyright 2020 Kentaro Hibino. All rights reserved.
+// Use of this source code is governed by a MIT license
+// that can be found in the LICENSE file.
+
+package cmd
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/go-redis/redis/v7"
+	"github.com/hibiken/asynq/internal/rdb"
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+)
+
+// killCmd represents the kill command
+var killCmd = &cobra.Command{
+	Use:   "kill [task id]",
+	Short: "Kills a task given an identifier",
+	Long: `Kill (asynq kill) will put a task in dead state given an identifier.
+
+The command takes one argument which specifies the task to kill.
+The task should be in either scheduled or retry state.
+Identifier for a task should be obtained by running "asynq ls" command.
+
+Example: asynq kill r:1575732274:bnogo8gt6toe23vhef0g`,
+	Args: cobra.ExactArgs(1),
+	Run:  kill,
+}
+
+func init() {
+	rootCmd.AddCommand(killCmd)
+
+	// Here you will define your flags and configuration settings.
+
+	// Cobra supports Persistent Flags which will work for this command
+	// and all subcommands, e.g.:
+	// killCmd.PersistentFlags().String("foo", "", "A help for foo")
+
+	// Cobra supports local flags which will only run when this command
+	// is called directly, e.g.:
+	// killCmd.Flags().BoolP("toggle", "t", false, "Help message for toggle")
+}
+
+func kill(cmd *cobra.Command, args []string) {
+	id, score, qtype, err := parseQueryID(args[0])
+	if err != nil {
+		fmt.Println(err)
+		os.Exit(1)
+	}
+	r := rdb.NewRDB(redis.NewClient(&redis.Options{
+		Addr:     viper.GetString("uri"),
+		DB:       viper.GetInt("db"),
+		Password: viper.GetString("password"),
+	}))
+	switch qtype {
+	case "s":
+		err = r.KillScheduledTask(id, score)
+	case "r":
+		err = r.KillRetryTask(id, score)
+	default:
+		fmt.Println("invalid argument")
+		os.Exit(1)
+	}
+	if err != nil {
+		fmt.Println(err)
+		os.Exit(1)
+	}
+	fmt.Printf("Successfully killed %v\n", args[0])
+
+}

tools/asynq/cmd/killall.go

@@ -0,0 +1,70 @@
+// Copyright 2020 Kentaro Hibino. All rights reserved.
+// Use of this source code is governed by a MIT license
+// that can be found in the LICENSE file.
+
+package cmd
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/go-redis/redis/v7"
+	"github.com/hibiken/asynq/internal/rdb"
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+)
+
+var killallValidArgs = []string{"scheduled", "retry"}
+
+// killallCmd represents the killall command
+var killallCmd = &cobra.Command{
+	Use:   "killall [state]",
+	Short: "Kills all tasks in the specified state",
+	Long: `Killall (asynq killall) will update all tasks from the specified state to dead state.
+
+The argument should be either "scheduled" or "retry".
+
+Example: asynq killall retry -> Update all retry tasks to dead tasks`,
+	ValidArgs: killallValidArgs,
+	Args:      cobra.ExactValidArgs(1),
+	Run:       killall,
+}
+
+func init() {
+	rootCmd.AddCommand(killallCmd)
+
+	// Here you will define your flags and configuration settings.
+
+	// Cobra supports Persistent Flags which will work for this command
+	// and all subcommands, e.g.:
+	// killallCmd.PersistentFlags().String("foo", "", "A help for foo")
+
+	// Cobra supports local flags which will only run when this command
+	// is called directly, e.g.:
+	// killallCmd.Flags().BoolP("toggle", "t", false, "Help message for toggle")
+}
+
+func killall(cmd *cobra.Command, args []string) {
+	c := redis.NewClient(&redis.Options{
+		Addr:     viper.GetString("uri"),
+		DB:       viper.GetInt("db"),
+		Password: viper.GetString("password"),
+	})
+	r := rdb.NewRDB(c)
+	var n int64
+	var err error
+	switch args[0] {
+	case "scheduled":
+		n, err = r.KillAllScheduledTasks()
+	case "retry":
+		n, err = r.KillAllRetryTasks()
+	default:
+		fmt.Printf("error: `asynq killall [state]` only accepts %v as the argument.\n", killallValidArgs)
+		os.Exit(1)
+	}
+	if err != nil {
+		fmt.Println(err)
+		os.Exit(1)
+	}
+	fmt.Printf("Successfully updated %d tasks to \"dead\" state\n", n)
+}

tools/asynq/cmd/ls.go

@@ -0,0 +1,229 @@
+// Copyright 2020 Kentaro Hibino. All rights reserved.
+// Use of this source code is governed by a MIT license
+// that can be found in the LICENSE file.
+
+package cmd
+
+import (
+	"fmt"
+	"io"
+	"os"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/go-redis/redis/v7"
+	"github.com/google/uuid"
+	"github.com/hibiken/asynq/internal/rdb"
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+)
+
+var lsValidArgs = []string{"enqueued", "inprogress", "scheduled", "retry", "dead"}
+
+// lsCmd represents the ls command
+var lsCmd = &cobra.Command{
+	Use:   "ls [state]",
+	Short: "Lists tasks in the specified state",
+	Long: `Ls (asynq ls) will list all tasks in the specified state in a table format.
+
+The command takes one argument which specifies the state of tasks.
+The argument value should be one of "enqueued", "inprogress", "scheduled",
+"retry", or "dead".
+
+Example:
+asynq ls dead -> Lists all tasks in dead state
+
+Enqueued tasks requires a queue name after ":"
+Example:
+asynq ls enqueued:default  -> List tasks from default queue
+asynq ls enqueued:critical -> List tasks from critical queue 
+`,
+	Args: cobra.ExactValidArgs(1),
+	Run:  ls,
+}
+
+// Flags
+var pageSize int
+var pageNum int
+
+func init() {
+	rootCmd.AddCommand(lsCmd)
+	lsCmd.Flags().IntVar(&pageSize, "size", 30, "page size")
+	lsCmd.Flags().IntVar(&pageNum, "page", 0, "page number - zero indexed (default 0)")
+}
+
+func ls(cmd *cobra.Command, args []string) {
+	if pageSize < 0 {
+		fmt.Println("page size cannot be negative.")
+		os.Exit(1)
+	}
+	if pageNum < 0 {
+		fmt.Println("page number cannot be negative.")
+		os.Exit(1)
+	}
+	c := redis.NewClient(&redis.Options{
+		Addr:     viper.GetString("uri"),
+		DB:       viper.GetInt("db"),
+		Password: viper.GetString("password"),
+	})
+	r := rdb.NewRDB(c)
+	parts := strings.Split(args[0], ":")
+	switch parts[0] {
+	case "enqueued":
+		if len(parts) != 2 {
+			fmt.Printf("error: Missing queue name\n`asynq ls enqueued:[queue name]`\n")
+			os.Exit(1)
+		}
+		listEnqueued(r, parts[1])
+	case "inprogress":
+		listInProgress(r)
+	case "scheduled":
+		listScheduled(r)
+	case "retry":
+		listRetry(r)
+	case "dead":
+		listDead(r)
+	default:
+		fmt.Printf("error: `asynq ls [state]`\nonly accepts %v as the argument.\n", lsValidArgs)
+		os.Exit(1)
+	}
+}
+
+// queryID returns an identifier used for "enq" command.
+// score is the zset score and queryType should be one
+// of "s", "r" or "d" (scheduled, retry, dead respectively).
+func queryID(id uuid.UUID, score int64, qtype string) string {
+	const format = "%v:%v:%v"
+	return fmt.Sprintf(format, qtype, score, id)
+}
+
+// parseQueryID is a reverse operation of queryID function.
+// It takes a queryID and return each part of id with proper
+// type if valid, otherwise it reports an error.
+func parseQueryID(queryID string) (id uuid.UUID, score int64, qtype string, err error) {
+	parts := strings.Split(queryID, ":")
+	if len(parts) != 3 {
+		return uuid.Nil, 0, "", fmt.Errorf("invalid id")
+	}
+	id, err = uuid.Parse(parts[2])
+	if err != nil {
+		return uuid.Nil, 0, "", fmt.Errorf("invalid id")
+	}
+	score, err = strconv.ParseInt(parts[1], 10, 64)
+	if err != nil {
+		return uuid.Nil, 0, "", fmt.Errorf("invalid id")
+	}
+	qtype = parts[0]
+	if len(qtype) != 1 || !strings.Contains("srd", qtype) {
+		return uuid.Nil, 0, "", fmt.Errorf("invalid id")
+	}
+	return id, score, qtype, nil
+}
+
+func listEnqueued(r *rdb.RDB, qname string) {
+	tasks, err := r.ListEnqueued(qname, rdb.Pagination{Size: pageSize, Page: pageNum})
+	if err != nil {
+		fmt.Println(err)
+		os.Exit(1)
+	}
+	if len(tasks) == 0 {
+		fmt.Printf("No enqueued tasks in %q queue\n", qname)
+		return
+	}
+	cols := []string{"ID", "Type", "Payload", "Queue"}
+	printRows := func(w io.Writer, tmpl string) {
+		for _, t := range tasks {
+			fmt.Fprintf(w, tmpl, t.ID, t.Type, t.Payload, t.Queue)
+		}
+	}
+	printTable(cols, printRows)
+	fmt.Printf("\nShowing %d tasks from page %d\n", len(tasks), pageNum)
+}
+
+func listInProgress(r *rdb.RDB) {
+	tasks, err := r.ListInProgress(rdb.Pagination{Size: pageSize, Page: pageNum})
+	if err != nil {
+		fmt.Println(err)
+		os.Exit(1)
+	}
+	if len(tasks) == 0 {
+		fmt.Println("No in-progress tasks")
+		return
+	}
+	cols := []string{"ID", "Type", "Payload"}
+	printRows := func(w io.Writer, tmpl string) {
+		for _, t := range tasks {
+			fmt.Fprintf(w, tmpl, t.ID, t.Type, t.Payload)
+		}
+	}
+	printTable(cols, printRows)
+	fmt.Printf("\nShowing %d tasks from page %d\n", len(tasks), pageNum)
+}
+
+func listScheduled(r *rdb.RDB) {
+	tasks, err := r.ListScheduled(rdb.Pagination{Size: pageSize, Page: pageNum})
+	if err != nil {
+		fmt.Println(err)
+		os.Exit(1)
+	}
+	if len(tasks) == 0 {
+		fmt.Println("No scheduled tasks")
+		return
+	}
+	cols := []string{"ID", "Type", "Payload", "Process In", "Queue"}
+	printRows := func(w io.Writer, tmpl string) {
+		for _, t := range tasks {
+			processIn := fmt.Sprintf("%.0f seconds", t.ProcessAt.Sub(time.Now()).Seconds())
+			fmt.Fprintf(w, tmpl, queryID(t.ID, t.Score, "s"), t.Type, t.Payload, processIn, t.Queue)
+		}
+	}
+	printTable(cols, printRows)
+	fmt.Printf("\nShowing %d tasks from page %d\n", len(tasks), pageNum)
+}
+
+func listRetry(r *rdb.RDB) {
+	tasks, err := r.ListRetry(rdb.Pagination{Size: pageSize, Page: pageNum})
+	if err != nil {
+		fmt.Println(err)
+		os.Exit(1)
+	}
+	if len(tasks) == 0 {
+		fmt.Println("No retry tasks")
+		return
+	}
+	cols := []string{"ID", "Type", "Payload", "Next Retry", "Last Error", "Retried", "Max Retry", "Queue"}
+	printRows := func(w io.Writer, tmpl string) {
+		for _, t := range tasks {
+			var nextRetry string
+			if d := t.ProcessAt.Sub(time.Now()); d > 0 {
+				nextRetry = fmt.Sprintf("in %v", d.Round(time.Second))
+			} else {
+				nextRetry = "right now"
+			}
+			fmt.Fprintf(w, tmpl, queryID(t.ID, t.Score, "r"), t.Type, t.Payload, nextRetry, t.ErrorMsg, t.Retried, t.Retry, t.Queue)
+		}
+	}
+	printTable(cols, printRows)
+	fmt.Printf("\nShowing %d tasks from page %d\n", len(tasks), pageNum)
+}
+
+func listDead(r *rdb.RDB) {
+	tasks, err := r.ListDead(rdb.Pagination{Size: pageSize, Page: pageNum})
+	if err != nil {
+		fmt.Println(err)
+		os.Exit(1)
+	}
+	if len(tasks) == 0 {
+		fmt.Println("No dead tasks")
+		return
+	}
+	cols := []string{"ID", "Type", "Payload", "Last Failed", "Last Error", "Queue"}
+	printRows := func(w io.Writer, tmpl string) {
+		for _, t := range tasks {
+			fmt.Fprintf(w, tmpl, queryID(t.ID, t.Score, "d"), t.Type, t.Payload, t.LastFailedAt, t.ErrorMsg, t.Queue)
+		}
+	}
+	printTable(cols, printRows)
+	fmt.Printf("\nShowing %d tasks from page %d\n", len(tasks), pageNum)
+}

tools/asynq/cmd/migrate.go

@@ -0,0 +1,212 @@
+// Copyright 2020 Kentaro Hibino. All rights reserved.
+// Use of this source code is governed by a MIT license
+// that can be found in the LICENSE file.
+
+package cmd
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"strings"
+	"time"
+
+	"github.com/go-redis/redis/v7"
+	"github.com/google/uuid"
+	"github.com/hibiken/asynq/internal/base"
+	"github.com/spf13/cast"
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+)
+
+// migrateCmd represents the migrate command
+var migrateCmd = &cobra.Command{
+	Use:   "migrate",
+	Short: fmt.Sprintf("Migrate all tasks to be compatible with asynq@%s", base.Version),
+	Long:  fmt.Sprintf("Migrate (asynq migrate) will convert all tasks in redis to be compatible with asynq@%s.", base.Version),
+	Run:   migrate,
+}
+
+func init() {
+	rootCmd.AddCommand(migrateCmd)
+}
+
+func migrate(cmd *cobra.Command, args []string) {
+	c := redis.NewClient(&redis.Options{
+		Addr:     viper.GetString("uri"),
+		DB:       viper.GetInt("db"),
+		Password: viper.GetString("password"),
+	})
+
+	lists := []string{base.InProgressQueue}
+	allQueues, err := c.SMembers(base.AllQueues).Result()
+	if err != nil {
+		fmt.Printf("error: could not read all queues: %v", err)
+		os.Exit(1)
+	}
+	lists = append(lists, allQueues...)
+	for _, key := range lists {
+		if err := migrateList(c, key); err != nil {
+			fmt.Printf("error: %v", err)
+			os.Exit(1)
+		}
+	}
+
+	zsets := []string{base.ScheduledQueue, base.RetryQueue, base.DeadQueue}
+	for _, key := range zsets {
+		if err := migrateZSet(c, key); err != nil {
+			fmt.Printf("error: %v", err)
+			os.Exit(1)
+		}
+	}
+}
+
+type oldTaskMessage struct {
+	// Unchanged
+	Type      string
+	Payload   map[string]interface{}
+	ID        uuid.UUID
+	Queue     string
+	Retry     int
+	Retried   int
+	ErrorMsg  string
+	UniqueKey string
+
+	// Following fields have changed.
+
+	// Deadline specifies the deadline for the task.
+	// Task won't be processed if it exceeded its deadline.
+	// The string shoulbe be in RFC3339 format.
+	//
+	// time.Time's zero value means no deadline.
+	Timeout string
+
+	// Deadline specifies the deadline for the task.
+	// Task won't be processed if it exceeded its deadline.
+	// The string shoulbe be in RFC3339 format.
+	//
+	// time.Time's zero value means no deadline.
+	Deadline string
+}
+
+var defaultTimeout = 30 * time.Minute
+
+func convertMessage(old *oldTaskMessage) (*base.TaskMessage, error) {
+	timeout, err := time.ParseDuration(old.Timeout)
+	if err != nil {
+		return nil, fmt.Errorf("could not parse Timeout field of %+v", old)
+	}
+	deadline, err := time.Parse(time.RFC3339, old.Deadline)
+	if err != nil {
+		return nil, fmt.Errorf("could not parse Deadline field of %+v", old)
+	}
+	if timeout == 0 && deadline.IsZero() {
+		timeout = defaultTimeout
+	}
+	if deadline.IsZero() {
+		// Zero value used to be time.Time{},
+		// in the new schema zero value is represented by
+		// zero in Unix time.
+		deadline = time.Unix(0, 0)
+	}
+	return &base.TaskMessage{
+		Type:      old.Type,
+		Payload:   old.Payload,
+		ID:        uuid.New(),
+		Queue:     old.Queue,
+		Retry:     old.Retry,
+		Retried:   old.Retried,
+		ErrorMsg:  old.ErrorMsg,
+		UniqueKey: old.UniqueKey,
+		Timeout:   int64(timeout.Seconds()),
+		Deadline:  deadline.Unix(),
+	}, nil
+}
+
+func deserialize(s string) (*base.TaskMessage, error) {
+	// Try deserializing as old message.
+	d := json.NewDecoder(strings.NewReader(s))
+	d.UseNumber()
+	var old *oldTaskMessage
+	if err := d.Decode(&old); err != nil {
+		// Try deserializing as new message.
+		d = json.NewDecoder(strings.NewReader(s))
+		d.UseNumber()
+		var msg *base.TaskMessage
+		if err := d.Decode(&msg); err != nil {
+			return nil, fmt.Errorf("could not deserialize %s into task message: %v", s, err)
+		}
+		return msg, nil
+	}
+	return convertMessage(old)
+}
+
+func migrateZSet(c *redis.Client, key string) error {
+	if c.Exists(key).Val() == 0 {
+		// skip if key doesn't exist.
+		return nil
+	}
+	res, err := c.ZRangeWithScores(key, 0, -1).Result()
+	if err != nil {
+		return err
+	}
+	var msgs []*redis.Z
+	for _, z := range res {
+		s, err := cast.ToStringE(z.Member)
+		if err != nil {
+			return fmt.Errorf("could not cast to string: %v", err)
+		}
+		msg, err := deserialize(s)
+		if err != nil {
+			return err
+		}
+		encoded, err := base.EncodeMessage(msg)
+		if err != nil {
+			return fmt.Errorf("could not encode message from %q: %v", key, err)
+		}
+		msgs = append(msgs, &redis.Z{Score: z.Score, Member: encoded})
+	}
+	if err := c.Rename(key, key+":backup").Err(); err != nil {
+		return fmt.Errorf("could not rename key %q: %v", key, err)
+	}
+	if err := c.ZAdd(key, msgs...).Err(); err != nil {
+		return fmt.Errorf("could not write new messages to %q: %v", key, err)
+	}
+	if err := c.Del(key + ":backup").Err(); err != nil {
+		return fmt.Errorf("could not delete back up key %q: %v", key+":backup", err)
+	}
+	return nil
+}
+
+func migrateList(c *redis.Client, key string) error {
+	if c.Exists(key).Val() == 0 {
+		// skip if key doesn't exist.
+		return nil
+	}
+	res, err := c.LRange(key, 0, -1).Result()
+	if err != nil {
+		return err
+	}
+	var msgs []interface{}
+	for _, s := range res {
+		msg, err := deserialize(s)
+		if err != nil {
+			return err
+		}
+		encoded, err := base.EncodeMessage(msg)
+		if err != nil {
+			return fmt.Errorf("could not encode message from %q: %v", key, err)
+		}
+		msgs = append(msgs, encoded)
+	}
+	if err := c.Rename(key, key+":backup").Err(); err != nil {
+		return fmt.Errorf("could not rename key %q: %v", key, err)
+	}
+	if err := c.LPush(key, msgs...).Err(); err != nil {
+		return fmt.Errorf("could not write new messages to %q: %v", key, err)
+	}
+	if err := c.Del(key + ":backup").Err(); err != nil {
+		return fmt.Errorf("could not delete back up key %q: %v", key+":backup", err)
+	}
+	return nil
+}

tools/asynq/cmd/pause.go

@@ -0,0 +1,47 @@
+// Copyright 2020 Kentaro Hibino. All rights reserved.
+// Use of this source code is governed by a MIT license
+// that can be found in the LICENSE file.
+
+package cmd
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/go-redis/redis/v7"
+	"github.com/hibiken/asynq/internal/rdb"
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+)
+
+// pauseCmd represents the pause command
+var pauseCmd = &cobra.Command{
+	Use:   "pause [queue name]",
+	Short: "Pauses the specified queue",
+	Long: `Pause (asynq pause) will pause the specified queue.
+Asynq servers will not process tasks from paused queues.
+Use the "unpause" command to resume a paused queue.
+
+Example: asynq pause default -> Pause the "default" queue`,
+	Args: cobra.ExactValidArgs(1),
+	Run:  pause,
+}
+
+func init() {
+	rootCmd.AddCommand(pauseCmd)
+}
+
+func pause(cmd *cobra.Command, args []string) {
+	c := redis.NewClient(&redis.Options{
+		Addr:     viper.GetString("uri"),
+		DB:       viper.GetInt("db"),
+		Password: viper.GetString("password"),
+	})
+	r := rdb.NewRDB(c)
+	err := r.Pause(args[0])
+	if err != nil {
+		fmt.Printf("error: %v\n", err)
+		os.Exit(1)
+	}
+	fmt.Printf("Successfully paused queue %q\n", args[0])
+}

tools/asynq/cmd/queue.go

@@ -1,255 +0,0 @@
-// Copyright 2020 Kentaro Hibino. All rights reserved.
-// Use of this source code is governed by a MIT license
-// that can be found in the LICENSE file.
-
-package cmd
-
-import (
-	"fmt"
-	"io"
-	"os"
-
-	"github.com/fatih/color"
-	"github.com/hibiken/asynq"
-	"github.com/hibiken/asynq/internal/errors"
-	"github.com/spf13/cobra"
-)
-
-const separator = "================================================="
-
-func init() {
-	rootCmd.AddCommand(queueCmd)
-	queueCmd.AddCommand(queueListCmd)
-	queueCmd.AddCommand(queueInspectCmd)
-	queueCmd.AddCommand(queueHistoryCmd)
-	queueHistoryCmd.Flags().IntP("days", "x", 10, "show data from last x days")
-
-	queueCmd.AddCommand(queuePauseCmd)
-	queueCmd.AddCommand(queueUnpauseCmd)
-	queueCmd.AddCommand(queueRemoveCmd)
-	queueRemoveCmd.Flags().BoolP("force", "f", false, "remove the queue regardless of its size")
-}
-
-var queueCmd = &cobra.Command{
-	Use:   "queue",
-	Short: "Manage queues",
-}
-
-var queueListCmd = &cobra.Command{
-	Use:   "ls",
-	Short: "List queues",
-	// TODO: Use RunE instead?
-	Run: queueList,
-}
-
-var queueInspectCmd = &cobra.Command{
-	Use:   "inspect QUEUE [QUEUE...]",
-	Short: "Display detailed information on one or more queues",
-	Args:  cobra.MinimumNArgs(1),
-	// TODO: Use RunE instead?
-	Run: queueInspect,
-}
-
-var queueHistoryCmd = &cobra.Command{
-	Use:   "history QUEUE [QUEUE...]",
-	Short: "Display historical aggregate data from one or more queues",
-	Args:  cobra.MinimumNArgs(1),
-	Run:   queueHistory,
-}
-
-var queuePauseCmd = &cobra.Command{
-	Use:   "pause QUEUE [QUEUE...]",
-	Short: "Pause one or more queues",
-	Args:  cobra.MinimumNArgs(1),
-	Run:   queuePause,
-}
-
-var queueUnpauseCmd = &cobra.Command{
-	Use:   "unpause QUEUE [QUEUE...]",
-	Short: "Unpause one or more queues",
-	Args:  cobra.MinimumNArgs(1),
-	Run:   queueUnpause,
-}
-
-var queueRemoveCmd = &cobra.Command{
-	Use:   "rm QUEUE [QUEUE...]",
-	Short: "Remove one or more queues",
-	Args:  cobra.MinimumNArgs(1),
-	Run:   queueRemove,
-}
-
-func queueList(cmd *cobra.Command, args []string) {
-	type queueInfo struct {
-		name    string
-		keyslot int64
-		nodes   []*asynq.ClusterNode
-	}
-	inspector := createInspector()
-	queues, err := inspector.Queues()
-	if err != nil {
-		fmt.Printf("error: Could not fetch list of queues: %v\n", err)
-		os.Exit(1)
-	}
-	var qs []*queueInfo
-	for _, qname := range queues {
-		q := queueInfo{name: qname}
-		if useRedisCluster {
-			keyslot, err := inspector.ClusterKeySlot(qname)
-			if err != nil {
-				fmt.Errorf("error: Could not get cluster keyslot for %q\n", qname)
-				continue
-			}
-			q.keyslot = keyslot
-			nodes, err := inspector.ClusterNodes(qname)
-			if err != nil {
-				fmt.Errorf("error: Could not get cluster nodes for %q\n", qname)
-				continue
-			}
-			q.nodes = nodes
-		}
-		qs = append(qs, &q)
-	}
-	if useRedisCluster {
-		printTable(
-			[]string{"Queue", "Cluster KeySlot", "Cluster Nodes"},
-			func(w io.Writer, tmpl string) {
-				for _, q := range qs {
-					fmt.Fprintf(w, tmpl, q.name, q.keyslot, q.nodes)
-				}
-			},
-		)
-	} else {
-		for _, q := range qs {
-			fmt.Println(q.name)
-		}
-	}
-}
-
-func queueInspect(cmd *cobra.Command, args []string) {
-	inspector := createInspector()
-	for i, qname := range args {
-		if i > 0 {
-			fmt.Printf("\n%s\n\n", separator)
-		}
-		info, err := inspector.GetQueueInfo(qname)
-		if err != nil {
-			fmt.Printf("error: %v\n", err)
-			continue
-		}
-		printQueueInfo(info)
-	}
-}
-
-func printQueueInfo(info *asynq.QueueInfo) {
-	bold := color.New(color.Bold)
-	bold.Println("Queue Info")
-	fmt.Printf("Name:   %s\n", info.Queue)
-	fmt.Printf("Size:   %d\n", info.Size)
-	fmt.Printf("Paused: %t\n\n", info.Paused)
-	bold.Println("Task Count by State")
-	printTable(
-		[]string{"active", "pending", "scheduled", "retry", "archived", "completed"},
-		func(w io.Writer, tmpl string) {
-			fmt.Fprintf(w, tmpl, info.Active, info.Pending, info.Scheduled, info.Retry, info.Archived, info.Completed)
-		},
-	)
-	fmt.Println()
-	bold.Printf("Daily Stats %s UTC\n", info.Timestamp.UTC().Format("2006-01-02"))
-	printTable(
-		[]string{"processed", "failed", "error rate"},
-		func(w io.Writer, tmpl string) {
-			var errRate string
-			if info.Processed == 0 {
-				errRate = "N/A"
-			} else {
-				errRate = fmt.Sprintf("%.2f%%", float64(info.Failed)/float64(info.Processed)*100)
-			}
-			fmt.Fprintf(w, tmpl, info.Processed, info.Failed, errRate)
-		},
-	)
-}
-
-func queueHistory(cmd *cobra.Command, args []string) {
-	days, err := cmd.Flags().GetInt("days")
-	if err != nil {
-		fmt.Printf("error: Internal error: %v\n", err)
-		os.Exit(1)
-	}
-	inspector := createInspector()
-	for i, qname := range args {
-		if i > 0 {
-			fmt.Printf("\n%s\n\n", separator)
-		}
-		fmt.Printf("Queue: %s\n\n", qname)
-		stats, err := inspector.History(qname, days)
-		if err != nil {
-			fmt.Printf("error: %v\n", err)
-			continue
-		}
-		printDailyStats(stats)
-	}
-}
-
-func printDailyStats(stats []*asynq.DailyStats) {
-	printTable(
-		[]string{"date (UTC)", "processed", "failed", "error rate"},
-		func(w io.Writer, tmpl string) {
-			for _, s := range stats {
-				var errRate string
-				if s.Processed == 0 {
-					errRate = "N/A"
-				} else {
-					errRate = fmt.Sprintf("%.2f%%", float64(s.Failed)/float64(s.Processed)*100)
-				}
-				fmt.Fprintf(w, tmpl, s.Date.Format("2006-01-02"), s.Processed, s.Failed, errRate)
-			}
-		},
-	)
-}
-
-func queuePause(cmd *cobra.Command, args []string) {
-	inspector := createInspector()
-	for _, qname := range args {
-		err := inspector.PauseQueue(qname)
-		if err != nil {
-			fmt.Println(err)
-			continue
-		}
-		fmt.Printf("Successfully paused queue %q\n", qname)
-	}
-}
-
-func queueUnpause(cmd *cobra.Command, args []string) {
-	inspector := createInspector()
-	for _, qname := range args {
-		err := inspector.UnpauseQueue(qname)
-		if err != nil {
-			fmt.Println(err)
-			continue
-		}
-		fmt.Printf("Successfully unpaused queue %q\n", qname)
-	}
-}
-
-func queueRemove(cmd *cobra.Command, args []string) {
-	// TODO: Use inspector once RemoveQueue become public API.
-	force, err := cmd.Flags().GetBool("force")
-	if err != nil {
-		fmt.Printf("error: Internal error: %v\n", err)
-		os.Exit(1)
-	}
-
-	r := createRDB()
-	for _, qname := range args {
-		err = r.RemoveQueue(qname, force)
-		if err != nil {
-			if errors.IsQueueNotEmpty(err) {
-				fmt.Printf("error: %v\nIf you are sure you want to delete it, run 'asynq queue rm --force %s'\n", err, qname)
-				continue
-			}
-			fmt.Printf("error: %v\n", err)
-			continue
-		}
-		fmt.Printf("Successfully removed queue %q\n", qname)
-	}
-}

tools/asynq/cmd/rmq.go

@@ -0,0 +1,54 @@
+// Copyright 2020 Kentaro Hibino. All rights reserved.
+// Use of this source code is governed by a MIT license
+// that can be found in the LICENSE file.
+
+package cmd
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/go-redis/redis/v7"
+	"github.com/hibiken/asynq/internal/rdb"
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+)
+
+// rmqCmd represents the rmq command
+var rmqCmd = &cobra.Command{
+	Use:   "rmq [queue name]",
+	Short: "Removes the specified queue",
+	Long: `Rmq (asynq rmq) will remove the specified queue.
+By default, it will remove the queue only if it's empty.
+Use --force option to override this behavior.
+
+Example: asynq rmq low -> Removes "low" queue`,
+	Args: cobra.ExactValidArgs(1),
+	Run:  rmq,
+}
+
+var rmqForce bool
+
+func init() {
+	rootCmd.AddCommand(rmqCmd)
+	rmqCmd.Flags().BoolVarP(&rmqForce, "force", "f", false, "remove the queue regardless of its size")
+}
+
+func rmq(cmd *cobra.Command, args []string) {
+	c := redis.NewClient(&redis.Options{
+		Addr:     viper.GetString("uri"),
+		DB:       viper.GetInt("db"),
+		Password: viper.GetString("password"),
+	})
+	r := rdb.NewRDB(c)
+	err := r.RemoveQueue(args[0], rmqForce)
+	if err != nil {
+		if _, ok := err.(*rdb.ErrQueueNotEmpty); ok {
+			fmt.Printf("error: %v\nIf you are sure you want to delete it, run 'asynq rmq --force %s'\n", err, args[0])
+			os.Exit(1)
+		}
+		fmt.Printf("error: %v", err)
+		os.Exit(1)
+	}
+	fmt.Printf("Successfully removed queue %q\n", args[0])
+}

tools/asynq/cmd/root.go

@@ -5,19 +5,13 @@
 package cmd
 
 import (
-	"crypto/tls"
 	"fmt"
 	"io"
 	"os"
 	"strings"
 	"text/tabwriter"
-	"unicode"
-	"unicode/utf8"
 
-	"github.com/go-redis/redis/v8"
-	"github.com/hibiken/asynq"
 	"github.com/hibiken/asynq/internal/base"
-	"github.com/hibiken/asynq/internal/rdb"
 	"github.com/spf13/cobra"
 
 	homedir "github.com/mitchellh/go-homedir"
@@ -26,16 +20,10 @@ import (
 
 var cfgFile string
 
-// Global flag variables
+// Flags
-var (
+var uri string
-	uri      string
+var db int
-	db       int
+var password string
-	password string
-
-	useRedisCluster bool
-	clusterAddrs    string
-	tlsServerName   string
-)
 
 // rootCmd represents the base command when called without any subcommands
 var rootCmd = &cobra.Command{
@@ -74,19 +62,9 @@ func init() {
 	rootCmd.PersistentFlags().StringVarP(&uri, "uri", "u", "127.0.0.1:6379", "redis server URI")
 	rootCmd.PersistentFlags().IntVarP(&db, "db", "n", 0, "redis database number (default is 0)")
 	rootCmd.PersistentFlags().StringVarP(&password, "password", "p", "", "password to use when connecting to redis server")
-	rootCmd.PersistentFlags().BoolVar(&useRedisCluster, "cluster", false, "connect to redis cluster")
-	rootCmd.PersistentFlags().StringVar(&clusterAddrs, "cluster_addrs",
-		"127.0.0.1:7000,127.0.0.1:7001,127.0.0.1:7002,127.0.0.1:7003,127.0.0.1:7004,127.0.0.1:7005",
-		"list of comma-separated redis server addresses")
-	rootCmd.PersistentFlags().StringVar(&tlsServerName, "tls_server",
-		"", "server name for TLS validation")
-	// Bind flags with config.
 	viper.BindPFlag("uri", rootCmd.PersistentFlags().Lookup("uri"))
 	viper.BindPFlag("db", rootCmd.PersistentFlags().Lookup("db"))
 	viper.BindPFlag("password", rootCmd.PersistentFlags().Lookup("password"))
-	viper.BindPFlag("cluster", rootCmd.PersistentFlags().Lookup("cluster"))
-	viper.BindPFlag("cluster_addrs", rootCmd.PersistentFlags().Lookup("cluster_addrs"))
-	viper.BindPFlag("tls_server", rootCmd.PersistentFlags().Lookup("tls_server"))
 }
 
 // initConfig reads in config file and ENV variables if set.
@@ -115,57 +93,6 @@ func initConfig() {
 	}
 }
 
-// createRDB creates a RDB instance using flag values and returns it.
-func createRDB() *rdb.RDB {
-	var c redis.UniversalClient
-	if useRedisCluster {
-		addrs := strings.Split(viper.GetString("cluster_addrs"), ",")
-		c = redis.NewClusterClient(&redis.ClusterOptions{
-			Addrs:     addrs,
-			Password:  viper.GetString("password"),
-			TLSConfig: getTLSConfig(),
-		})
-	} else {
-		c = redis.NewClient(&redis.Options{
-			Addr:      viper.GetString("uri"),
-			DB:        viper.GetInt("db"),
-			Password:  viper.GetString("password"),
-			TLSConfig: getTLSConfig(),
-		})
-	}
-	return rdb.NewRDB(c)
-}
-
-// createRDB creates a Inspector instance using flag values and returns it.
-func createInspector() *asynq.Inspector {
-	return asynq.NewInspector(getRedisConnOpt())
-}
-
-func getRedisConnOpt() asynq.RedisConnOpt {
-	if useRedisCluster {
-		addrs := strings.Split(viper.GetString("cluster_addrs"), ",")
-		return asynq.RedisClusterClientOpt{
-			Addrs:     addrs,
-			Password:  viper.GetString("password"),
-			TLSConfig: getTLSConfig(),
-		}
-	}
-	return asynq.RedisClientOpt{
-		Addr:      viper.GetString("uri"),
-		DB:        viper.GetInt("db"),
-		Password:  viper.GetString("password"),
-		TLSConfig: getTLSConfig(),
-	}
-}
-
-func getTLSConfig() *tls.Config {
-	tlsServer := viper.GetString("tls_server")
-	if tlsServer == "" {
-		return nil
-	}
-	return &tls.Config{ServerName: tlsServer}
-}
-
 // printTable is a helper function to print data in table format.
 //
 // cols is a list of headers and printRow specifies how to print rows.
@@ -198,28 +125,3 @@ func printTable(cols []string, printRows func(w io.Writer, tmpl string)) {
 	printRows(tw, format)
 	tw.Flush()
 }
-
-// sprintBytes returns a string representation of the given byte slice if data is printable.
-// If data is not printable, it returns a string describing it is not printable.
-func sprintBytes(payload []byte) string {
-	if !isPrintable(payload) {
-		return "non-printable bytes"
-	}
-	return string(payload)
-}
-
-func isPrintable(data []byte) bool {
-	if !utf8.Valid(data) {
-		return false
-	}
-	isAllSpace := true
-	for _, r := range string(data) {
-		if !unicode.IsPrint(r) {
-			return false
-		}
-		if !unicode.IsSpace(r) {
-			isAllSpace = false
-		}
-	}
-	return !isAllSpace
-}

tools/asynq/cmd/servers.go

@@ -12,39 +12,42 @@ import (
 	"strings"
 	"time"
 
+	"github.com/go-redis/redis/v7"
+	"github.com/hibiken/asynq/internal/rdb"
 	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
 )
 
-func init() {
+// serversCmd represents the servers command
-	rootCmd.AddCommand(serverCmd)
+var serversCmd = &cobra.Command{
-	serverCmd.AddCommand(serverListCmd)
+	Use:   "servers",
-}
+	Short: "Shows all running worker servers",
-
+	Long: `Servers (asynq servers) will show all running worker servers
-var serverCmd = &cobra.Command{
+pulling tasks from the specified redis instance.
-	Use:   "server",
-	Short: "Manage servers",
-}
-
-var serverListCmd = &cobra.Command{
-	Use:   "ls",
-	Short: "List servers",
-	Long: `Server list (asynq server ls) shows all running worker servers
-pulling tasks from the given redis instance.
 
 The command shows the following for each server:
 * Host and PID of the process in which the server is running
 * Number of active workers out of worker pool
 * Queue configuration
-* State of the worker server ("active" | "stopped")
+* State of the worker server ("running" | "quiet")
 * Time the server was started
 
-A "active" server is pulling tasks from queues and processing them.
+A "running" server is pulling tasks from queues and processing them.
-A "stopped" server is no longer pulling new tasks from queues`,
+A "quiet" server is no longer pulling new tasks from queues`,
-	Run: serverList,
+	Args: cobra.NoArgs,
+	Run:  servers,
 }
 
-func serverList(cmd *cobra.Command, args []string) {
+func init() {
-	r := createRDB()
+	rootCmd.AddCommand(serversCmd)
+}
+
+func servers(cmd *cobra.Command, args []string) {
+	r := rdb.NewRDB(redis.NewClient(&redis.Options{
+		Addr:     viper.GetString("uri"),
+		DB:       viper.GetInt("db"),
+		Password: viper.GetString("password"),
+	}))
 
 	servers, err := r.ListServers()
 	if err != nil {
@@ -78,6 +81,12 @@ func serverList(cmd *cobra.Command, args []string) {
 	printTable(cols, printRows)
 }
 
+// timeAgo takes a time and returns a string of the format "<duration> ago".
+func timeAgo(since time.Time) string {
+	d := time.Since(since).Round(time.Second)
+	return fmt.Sprintf("%v ago", d)
+}
+
 func formatQueues(qmap map[string]int) string {
 	// sort queues by priority and name
 	type queue struct {
@@ -107,9 +116,3 @@ func formatQueues(qmap map[string]int) string {
 	}
 	return b.String()
 }
-
-// timeAgo takes a time and returns a string of the format "<duration> ago".
-func timeAgo(since time.Time) string {
-	d := time.Since(since).Round(time.Second)
-	return fmt.Sprintf("%v ago", d)
-}

tools/asynq/cmd/stats.go

@@ -5,27 +5,23 @@
 package cmd
 
 import (
-	"encoding/json"
 	"fmt"
-	"io"
-	"math"
 	"os"
 	"strconv"
 	"strings"
 	"text/tabwriter"
-	"time"
-	"unicode/utf8"
 
-	"github.com/fatih/color"
+	"github.com/go-redis/redis/v7"
 	"github.com/hibiken/asynq/internal/rdb"
 	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
 )
 
 // statsCmd represents the stats command
 var statsCmd = &cobra.Command{
 	Use:   "stats",
 	Short: "Shows current state of the tasks and queues",
-	Long: `Stats (aysnq stats) will show the overview of tasks and queues at that instant.
+	Long: `Stats (aysnqmon stats) will show the overview of tasks and queues at that instant.
 
 Specifically, the command shows the following:
 * Number of tasks in each state
@@ -41,11 +37,8 @@ Example: watch -n 3 asynq stats -> Shows current state of tasks every three seco
 	Run:  stats,
 }
 
-var jsonFlag bool
-
 func init() {
 	rootCmd.AddCommand(statsCmd)
-	statsCmd.Flags().BoolVar(&jsonFlag, "json", false, "Output stats in JSON format.")
 
 	// Here you will define your flags and configuration settings.
 
@@ -58,146 +51,57 @@ func init() {
 	// statsCmd.Flags().BoolP("toggle", "t", false, "Help message for toggle")
 }
 
-type AggregateStats struct {
-	Active    int       `json:"active"`
-	Pending   int       `json:"pending"`
-	Scheduled int       `json:"scheduled"`
-	Retry     int       `json:"retry"`
-	Archived  int       `json:"archived"`
-	Completed int       `json:"completed"`
-	Processed int       `json:"processed"`
-	Failed    int       `json:"failed"`
-	Timestamp time.Time `json:"timestamp"`
-}
-
-type FullStats struct {
-	Aggregate  AggregateStats    `json:"aggregate"`
-	QueueStats []*rdb.Stats      `json:"queues"`
-	RedisInfo  map[string]string `json:"redis"`
-}
-
 func stats(cmd *cobra.Command, args []string) {
-	r := createRDB()
+	c := redis.NewClient(&redis.Options{
-
+		Addr:     viper.GetString("uri"),
-	queues, err := r.AllQueues()
+		DB:       viper.GetInt("db"),
-	if err != nil {
+		Password: viper.GetString("password"),
-		fmt.Println(err)
-		os.Exit(1)
-	}
-
-	var aggStats AggregateStats
-	var stats []*rdb.Stats
-	for _, qname := range queues {
-		s, err := r.CurrentStats(qname)
-		if err != nil {
-			fmt.Println(err)
-			os.Exit(1)
-		}
-		aggStats.Active += s.Active
-		aggStats.Pending += s.Pending
-		aggStats.Scheduled += s.Scheduled
-		aggStats.Retry += s.Retry
-		aggStats.Archived += s.Archived
-		aggStats.Completed += s.Completed
-		aggStats.Processed += s.Processed
-		aggStats.Failed += s.Failed
-		aggStats.Timestamp = s.Timestamp
-		stats = append(stats, s)
-	}
-	var info map[string]string
-	if useRedisCluster {
-		info, err = r.RedisClusterInfo()
-	} else {
-		info, err = r.RedisInfo()
-	}
-	if err != nil {
-		fmt.Println(err)
-		os.Exit(1)
-	}
-
-	if jsonFlag {
-		statsJSON, err := json.Marshal(FullStats{
-			Aggregate:  aggStats,
-			QueueStats: stats,
-			RedisInfo:  info,
 	})
+	r := rdb.NewRDB(c)
 
+	stats, err := r.CurrentStats()
 	if err != nil {
 		fmt.Println(err)
 		os.Exit(1)
 	}
-
+	info, err := r.RedisInfo()
-		fmt.Println(string(statsJSON))
+	if err != nil {
-		return
+		fmt.Println(err)
+		os.Exit(1)
 	}
-
+	fmt.Println("STATES")
-	bold := color.New(color.Bold)
+	printStates(stats)
-	bold.Println("Task Count by State")
-	printStatsByState(&aggStats)
 	fmt.Println()
 
-	bold.Println("Task Count by Queue")
+	fmt.Println("QUEUES")
-	printStatsByQueue(stats)
+	printQueues(stats.Queues)
 	fmt.Println()
 
-	bold.Printf("Daily Stats %s UTC\n", aggStats.Timestamp.UTC().Format("2006-01-02"))
+	fmt.Printf("STATS FOR %s UTC\n", stats.Timestamp.UTC().Format("2006-01-02"))
-	printSuccessFailureStats(&aggStats)
+	printStats(stats)
 	fmt.Println()
 
-	if useRedisCluster {
+	fmt.Println("REDIS INFO")
-		bold.Println("Redis Cluster Info")
-		printClusterInfo(info)
-	} else {
-		bold.Println("Redis Info")
 	printInfo(info)
-	}
 	fmt.Println()
 }
 
-func printStatsByState(s *AggregateStats) {
+func printStates(s *rdb.Stats) {
-	format := strings.Repeat("%v\t", 6) + "\n"
+	format := strings.Repeat("%v\t", 5) + "\n"
 	tw := new(tabwriter.Writer).Init(os.Stdout, 0, 8, 2, ' ', 0)
-	fmt.Fprintf(tw, format, "active", "pending", "scheduled", "retry", "archived", "completed")
+	fmt.Fprintf(tw, format, "InProgress", "Enqueued", "Scheduled", "Retry", "Dead")
-	width := maxInt(9 /* defaultWidth */, maxWidthOf(s.Active, s.Pending, s.Scheduled, s.Retry, s.Archived, s.Completed)) // length of widest column
+	fmt.Fprintf(tw, format, "----------", "--------", "---------", "-----", "----")
-	sep := strings.Repeat("-", width)
+	fmt.Fprintf(tw, format, s.InProgress, s.Enqueued, s.Scheduled, s.Retry, s.Dead)
-	fmt.Fprintf(tw, format, sep, sep, sep, sep, sep, sep)
-	fmt.Fprintf(tw, format, s.Active, s.Pending, s.Scheduled, s.Retry, s.Archived, s.Completed)
 	tw.Flush()
 }
 
-// numDigits returns the number of digits in n.
+func printQueues(queues []*rdb.Queue) {
-func numDigits(n int) int {
-	return len(strconv.Itoa(n))
-}
-
-// maxWidthOf returns the max number of digits amount the provided vals.
-func maxWidthOf(vals ...int) int {
-	max := 0
-	for _, v := range vals {
-		if vw := numDigits(v); vw > max {
-			max = vw
-		}
-	}
-	return max
-}
-
-func maxInt(a, b int) int {
-	return int(math.Max(float64(a), float64(b)))
-}
-
-func printStatsByQueue(stats []*rdb.Stats) {
 	var headers, seps, counts []string
-	maxHeaderWidth := 0
+	for _, q := range queues {
-	for _, s := range stats {
+		title := queueTitle(q)
-		title := queueTitle(s)
 		headers = append(headers, title)
-		if w := utf8.RuneCountInString(title); w > maxHeaderWidth {
+		seps = append(seps, strings.Repeat("-", len(title)))
-			maxHeaderWidth = w
+		counts = append(counts, strconv.Itoa(q.Size))
-		}
-		counts = append(counts, strconv.Itoa(s.Size))
-	}
-	for i := 0; i < len(headers); i++ {
-		seps = append(seps, strings.Repeat("-", maxHeaderWidth))
 	}
 	format := strings.Repeat("%v\t", len(headers)) + "\n"
 	tw := new(tabwriter.Writer).Init(os.Stdout, 0, 8, 2, ' ', 0)
@@ -207,19 +111,19 @@ func printStatsByQueue(stats []*rdb.Stats) {
 	tw.Flush()
 }
 
-func queueTitle(s *rdb.Stats) string {
+func queueTitle(q *rdb.Queue) string {
 	var b strings.Builder
-	b.WriteString(s.Queue)
+	b.WriteString(strings.Title(q.Name))
-	if s.Paused {
+	if q.Paused {
-		b.WriteString(" (paused)")
+		b.WriteString(" (Paused)")
 	}
 	return b.String()
 }
 
-func printSuccessFailureStats(s *AggregateStats) {
+func printStats(s *rdb.Stats) {
 	format := strings.Repeat("%v\t", 3) + "\n"
 	tw := new(tabwriter.Writer).Init(os.Stdout, 0, 8, 2, ' ', 0)
-	fmt.Fprintf(tw, format, "processed", "failed", "error rate")
+	fmt.Fprintf(tw, format, "Processed", "Failed", "Error Rate")
 	fmt.Fprintf(tw, format, "---------", "------", "----------")
 	var errrate string
 	if s.Processed == 0 {
@@ -234,7 +138,7 @@ func printSuccessFailureStats(s *AggregateStats) {
 func printInfo(info map[string]string) {
 	format := strings.Repeat("%v\t", 5) + "\n"
 	tw := new(tabwriter.Writer).Init(os.Stdout, 0, 8, 2, ' ', 0)
-	fmt.Fprintf(tw, format, "version", "uptime", "connections", "memory usage", "peak memory usage")
+	fmt.Fprintf(tw, format, "Version", "Uptime", "Connections", "Memory Usage", "Peak Memory Usage")
 	fmt.Fprintf(tw, format, "-------", "------", "-----------", "------------", "-----------------")
 	fmt.Fprintf(tw, format,
 		info["redis_version"],
@@ -246,19 +150,6 @@ func printInfo(info map[string]string) {
 	tw.Flush()
 }
 
-func printClusterInfo(info map[string]string) {
-	printTable(
-		[]string{"State", "Known Nodes", "Cluster Size"},
-		func(w io.Writer, tmpl string) {
-			fmt.Fprintf(w, tmpl,
-				strings.ToUpper(info["cluster_state"]),
-				info["cluster_known_nodes"],
-				info["cluster_size"],
-			)
-		},
-	)
-}
-
 func toInterfaceSlice(strs []string) []interface{} {
 	var res []interface{}
 	for _, s := range strs {

tools/asynq/cmd/task.go

@@ -1,566 +0,0 @@
-// Copyright 2020 Kentaro Hibino. All rights reserved.
-// Use of this source code is governed by a MIT license
-// that can be found in the LICENSE file.
-
-package cmd
-
-import (
-	"fmt"
-	"io"
-	"os"
-	"time"
-
-	"github.com/fatih/color"
-	"github.com/hibiken/asynq"
-	"github.com/spf13/cobra"
-)
-
-func init() {
-	rootCmd.AddCommand(taskCmd)
-	taskCmd.AddCommand(taskListCmd)
-	taskListCmd.Flags().StringP("queue", "q", "", "queue to inspect")
-	taskListCmd.Flags().StringP("state", "s", "", "state of the tasks to inspect")
-	taskListCmd.Flags().Int("page", 1, "page number")
-	taskListCmd.Flags().Int("size", 30, "page size")
-	taskListCmd.MarkFlagRequired("queue")
-	taskListCmd.MarkFlagRequired("state")
-
-	taskCmd.AddCommand(taskCancelCmd)
-
-	taskCmd.AddCommand(taskInspectCmd)
-	taskInspectCmd.Flags().StringP("queue", "q", "", "queue to which the task belongs")
-	taskInspectCmd.Flags().StringP("id", "i", "", "id of the task")
-	taskInspectCmd.MarkFlagRequired("queue")
-	taskInspectCmd.MarkFlagRequired("id")
-
-	taskCmd.AddCommand(taskArchiveCmd)
-	taskArchiveCmd.Flags().StringP("queue", "q", "", "queue to which the task belongs")
-	taskArchiveCmd.Flags().StringP("id", "i", "", "id of the task")
-	taskArchiveCmd.MarkFlagRequired("queue")
-	taskArchiveCmd.MarkFlagRequired("id")
-
-	taskCmd.AddCommand(taskDeleteCmd)
-	taskDeleteCmd.Flags().StringP("queue", "q", "", "queue to which the task belongs")
-	taskDeleteCmd.Flags().StringP("id", "i", "", "id of the task")
-	taskDeleteCmd.MarkFlagRequired("queue")
-	taskDeleteCmd.MarkFlagRequired("id")
-
-	taskCmd.AddCommand(taskRunCmd)
-	taskRunCmd.Flags().StringP("queue", "q", "", "queue to which the task belongs")
-	taskRunCmd.Flags().StringP("id", "i", "", "id of the task")
-	taskRunCmd.MarkFlagRequired("queue")
-	taskRunCmd.MarkFlagRequired("id")
-
-	taskCmd.AddCommand(taskArchiveAllCmd)
-	taskArchiveAllCmd.Flags().StringP("queue", "q", "", "queue to which the tasks belong")
-	taskArchiveAllCmd.Flags().StringP("state", "s", "", "state of the tasks")
-	taskArchiveAllCmd.MarkFlagRequired("queue")
-	taskArchiveAllCmd.MarkFlagRequired("state")
-
-	taskCmd.AddCommand(taskDeleteAllCmd)
-	taskDeleteAllCmd.Flags().StringP("queue", "q", "", "queue to which the tasks belong")
-	taskDeleteAllCmd.Flags().StringP("state", "s", "", "state of the tasks")
-	taskDeleteAllCmd.MarkFlagRequired("queue")
-	taskDeleteAllCmd.MarkFlagRequired("state")
-
-	taskCmd.AddCommand(taskRunAllCmd)
-	taskRunAllCmd.Flags().StringP("queue", "q", "", "queue to which the tasks belong")
-	taskRunAllCmd.Flags().StringP("state", "s", "", "state of the tasks")
-	taskRunAllCmd.MarkFlagRequired("queue")
-	taskRunAllCmd.MarkFlagRequired("state")
-}
-
-var taskCmd = &cobra.Command{
-	Use:   "task",
-	Short: "Manage tasks",
-}
-
-var taskListCmd = &cobra.Command{
-	Use:   "ls --queue=QUEUE --state=STATE",
-	Short: "List tasks",
-	Long: `List tasks of the given state from the specified queue.
-
-The value for the state flag should be one of:
-- active
-- pending
-- scheduled
-- retry
-- archived
-- completed
-
-List opeartion paginates the result set.
-By default, the command fetches the first 30 tasks.
-Use --page and --size flags to specify the page number and size.
-
-Example: 
-To list pending tasks from "default" queue, run
-  asynq task ls --queue=default --state=pending
-
-To list the tasks from the second page, run
-  asynq task ls --queue=default --state=pending --page=1`,
-	Run: taskList,
-}
-
-var taskInspectCmd = &cobra.Command{
-	Use:   "inspect --queue=QUEUE --id=TASK_ID",
-	Short: "Display detailed information on the specified task",
-	Args:  cobra.NoArgs,
-	Run:   taskInspect,
-}
-
-var taskCancelCmd = &cobra.Command{
-	Use:   "cancel TASK_ID [TASK_ID...]",
-	Short: "Cancel one or more active tasks",
-	Args:  cobra.MinimumNArgs(1),
-	Run:   taskCancel,
-}
-
-var taskArchiveCmd = &cobra.Command{
-	Use:   "archive --queue=QUEUE --id=TASK_ID",
-	Short: "Archive a task with the given id",
-	Args:  cobra.NoArgs,
-	Run:   taskArchive,
-}
-
-var taskDeleteCmd = &cobra.Command{
-	Use:   "delete --queue=QUEUE --id=TASK_ID",
-	Short: "Delete a task with the given id",
-	Args:  cobra.NoArgs,
-	Run:   taskDelete,
-}
-
-var taskRunCmd = &cobra.Command{
-	Use:   "run --queue=QUEUE --id=TASK_ID",
-	Short: "Run a task with the given id",
-	Args:  cobra.NoArgs,
-	Run:   taskRun,
-}
-
-var taskArchiveAllCmd = &cobra.Command{
-	Use:   "archiveall --queue=QUEUE --state=STATE",
-	Short: "Archive all tasks in the given state",
-	Args:  cobra.NoArgs,
-	Run:   taskArchiveAll,
-}
-
-var taskDeleteAllCmd = &cobra.Command{
-	Use:   "deleteall --queue=QUEUE --state=STATE",
-	Short: "Delete all tasks in the given state",
-	Args:  cobra.NoArgs,
-	Run:   taskDeleteAll,
-}
-
-var taskRunAllCmd = &cobra.Command{
-	Use:   "runall --queue=QUEUE --state=STATE",
-	Short: "Run all tasks in the given state",
-	Args:  cobra.NoArgs,
-	Run:   taskRunAll,
-}
-
-func taskList(cmd *cobra.Command, args []string) {
-	qname, err := cmd.Flags().GetString("queue")
-	if err != nil {
-		fmt.Println(err)
-		os.Exit(1)
-	}
-	state, err := cmd.Flags().GetString("state")
-	if err != nil {
-		fmt.Println(err)
-		os.Exit(1)
-	}
-	pageNum, err := cmd.Flags().GetInt("page")
-	if err != nil {
-		fmt.Println(err)
-		os.Exit(1)
-	}
-	pageSize, err := cmd.Flags().GetInt("size")
-	if err != nil {
-		fmt.Println(err)
-		os.Exit(1)
-	}
-
-	switch state {
-	case "active":
-		listActiveTasks(qname, pageNum, pageSize)
-	case "pending":
-		listPendingTasks(qname, pageNum, pageSize)
-	case "scheduled":
-		listScheduledTasks(qname, pageNum, pageSize)
-	case "retry":
-		listRetryTasks(qname, pageNum, pageSize)
-	case "archived":
-		listArchivedTasks(qname, pageNum, pageSize)
-	case "completed":
-		listCompletedTasks(qname, pageNum, pageSize)
-	default:
-		fmt.Printf("error: state=%q is not supported\n", state)
-		os.Exit(1)
-	}
-}
-
-func listActiveTasks(qname string, pageNum, pageSize int) {
-	i := createInspector()
-	tasks, err := i.ListActiveTasks(qname, asynq.PageSize(pageSize), asynq.Page(pageNum))
-	if err != nil {
-		fmt.Println(err)
-		os.Exit(1)
-	}
-	if len(tasks) == 0 {
-		fmt.Printf("No active tasks in %q queue\n", qname)
-		return
-	}
-	printTable(
-		[]string{"ID", "Type", "Payload"},
-		func(w io.Writer, tmpl string) {
-			for _, t := range tasks {
-				fmt.Fprintf(w, tmpl, t.ID, t.Type, sprintBytes(t.Payload))
-			}
-		},
-	)
-}
-
-func listPendingTasks(qname string, pageNum, pageSize int) {
-	i := createInspector()
-	tasks, err := i.ListPendingTasks(qname, asynq.PageSize(pageSize), asynq.Page(pageNum))
-	if err != nil {
-		fmt.Println(err)
-		os.Exit(1)
-	}
-	if len(tasks) == 0 {
-		fmt.Printf("No pending tasks in %q queue\n", qname)
-		return
-	}
-	printTable(
-		[]string{"ID", "Type", "Payload"},
-		func(w io.Writer, tmpl string) {
-			for _, t := range tasks {
-				fmt.Fprintf(w, tmpl, t.ID, t.Type, sprintBytes(t.Payload))
-			}
-		},
-	)
-}
-
-func listScheduledTasks(qname string, pageNum, pageSize int) {
-	i := createInspector()
-	tasks, err := i.ListScheduledTasks(qname, asynq.PageSize(pageSize), asynq.Page(pageNum))
-	if err != nil {
-		fmt.Println(err)
-		os.Exit(1)
-	}
-	if len(tasks) == 0 {
-		fmt.Printf("No scheduled tasks in %q queue\n", qname)
-		return
-	}
-	printTable(
-		[]string{"ID", "Type", "Payload", "Process In"},
-		func(w io.Writer, tmpl string) {
-			for _, t := range tasks {
-				fmt.Fprintf(w, tmpl, t.ID, t.Type, sprintBytes(t.Payload), formatProcessAt(t.NextProcessAt))
-			}
-		},
-	)
-}
-
-// formatProcessAt formats next process at time to human friendly string.
-// If processAt time is in the past, returns "right now".
-// If processAt time is in the future, returns "in xxx" where xxx is the duration from now.
-func formatProcessAt(processAt time.Time) string {
-	d := processAt.Sub(time.Now())
-	if d < 0 {
-		return "right now"
-	}
-	return fmt.Sprintf("in %v", d.Round(time.Second))
-}
-
-func listRetryTasks(qname string, pageNum, pageSize int) {
-	i := createInspector()
-	tasks, err := i.ListRetryTasks(qname, asynq.PageSize(pageSize), asynq.Page(pageNum))
-	if err != nil {
-		fmt.Println(err)
-		os.Exit(1)
-	}
-	if len(tasks) == 0 {
-		fmt.Printf("No retry tasks in %q queue\n", qname)
-		return
-	}
-	printTable(
-		[]string{"ID", "Type", "Payload", "Next Retry", "Last Error", "Last Failed", "Retried", "Max Retry"},
-		func(w io.Writer, tmpl string) {
-			for _, t := range tasks {
-				fmt.Fprintf(w, tmpl, t.ID, t.Type, sprintBytes(t.Payload), formatProcessAt(t.NextProcessAt),
-					t.LastErr, formatPastTime(t.LastFailedAt), t.Retried, t.MaxRetry)
-			}
-		},
-	)
-}
-
-func listArchivedTasks(qname string, pageNum, pageSize int) {
-	i := createInspector()
-	tasks, err := i.ListArchivedTasks(qname, asynq.PageSize(pageSize), asynq.Page(pageNum))
-	if err != nil {
-		fmt.Println(err)
-		os.Exit(1)
-	}
-	if len(tasks) == 0 {
-		fmt.Printf("No archived tasks in %q queue\n", qname)
-		return
-	}
-	printTable(
-		[]string{"ID", "Type", "Payload", "Last Failed", "Last Error"},
-		func(w io.Writer, tmpl string) {
-			for _, t := range tasks {
-				fmt.Fprintf(w, tmpl, t.ID, t.Type, sprintBytes(t.Payload), formatPastTime(t.LastFailedAt), t.LastErr)
-			}
-		})
-}
-
-func listCompletedTasks(qname string, pageNum, pageSize int) {
-	i := createInspector()
-	tasks, err := i.ListCompletedTasks(qname, asynq.PageSize(pageSize), asynq.Page(pageNum))
-	if err != nil {
-		fmt.Println(err)
-		os.Exit(1)
-	}
-	if len(tasks) == 0 {
-		fmt.Printf("No completed tasks in %q queue\n", qname)
-		return
-	}
-	printTable(
-		[]string{"ID", "Type", "Payload", "CompletedAt", "Result"},
-		func(w io.Writer, tmpl string) {
-			for _, t := range tasks {
-				fmt.Fprintf(w, tmpl, t.ID, t.Type, sprintBytes(t.Payload), formatPastTime(t.CompletedAt), sprintBytes(t.Result))
-			}
-		})
-}
-
-func taskCancel(cmd *cobra.Command, args []string) {
-	i := createInspector()
-	for _, id := range args {
-		if err := i.CancelProcessing(id); err != nil {
-			fmt.Printf("error: could not send cancelation signal: %v\n", err)
-			continue
-		}
-		fmt.Printf("Sent cancelation signal for task %s\n", id)
-	}
-}
-
-func taskInspect(cmd *cobra.Command, args []string) {
-	qname, err := cmd.Flags().GetString("queue")
-	if err != nil {
-		fmt.Printf("error: %v\n", err)
-		os.Exit(1)
-	}
-	id, err := cmd.Flags().GetString("id")
-	if err != nil {
-		fmt.Printf("error: %v\n", err)
-		os.Exit(1)
-	}
-
-	i := createInspector()
-	info, err := i.GetTaskInfo(qname, id)
-	if err != nil {
-		fmt.Printf("error: %v\n", err)
-		os.Exit(1)
-	}
-	printTaskInfo(info)
-}
-
-func printTaskInfo(info *asynq.TaskInfo) {
-	bold := color.New(color.Bold)
-	bold.Println("Task Info")
-	fmt.Printf("Queue:   %s\n", info.Queue)
-	fmt.Printf("ID:      %s\n", info.ID)
-	fmt.Printf("Type:    %s\n", info.Type)
-	fmt.Printf("State:   %v\n", info.State)
-	fmt.Printf("Retried: %d/%d\n", info.Retried, info.MaxRetry)
-	fmt.Println()
-	fmt.Printf("Next process time: %s\n", formatNextProcessAt(info.NextProcessAt))
-	if len(info.LastErr) != 0 {
-		fmt.Println()
-		bold.Println("Last Failure")
-		fmt.Printf("Failed at:     %s\n", formatPastTime(info.LastFailedAt))
-		fmt.Printf("Error message: %s\n", info.LastErr)
-	}
-}
-
-func formatNextProcessAt(processAt time.Time) string {
-	if processAt.IsZero() || processAt.Unix() == 0 {
-		return "n/a"
-	}
-	if processAt.Before(time.Now()) {
-		return "now"
-	}
-	return fmt.Sprintf("%s (in %v)", processAt.Format(time.UnixDate), processAt.Sub(time.Now()).Round(time.Second))
-}
-
-// formatPastTime takes t which is time in the past and returns a user-friendly string.
-func formatPastTime(t time.Time) string {
-	if t.IsZero() || t.Unix() == 0 {
-		return ""
-	}
-	return t.Format(time.UnixDate)
-}
-
-func taskArchive(cmd *cobra.Command, args []string) {
-	qname, err := cmd.Flags().GetString("queue")
-	if err != nil {
-		fmt.Printf("error: %v\n", err)
-		os.Exit(1)
-	}
-	id, err := cmd.Flags().GetString("id")
-	if err != nil {
-		fmt.Printf("error: %v\n", err)
-		os.Exit(1)
-	}
-
-	i := createInspector()
-	err = i.ArchiveTask(qname, id)
-	if err != nil {
-		fmt.Printf("error: %v\n", err)
-		os.Exit(1)
-	}
-	fmt.Println("task archived")
-}
-
-func taskDelete(cmd *cobra.Command, args []string) {
-	qname, err := cmd.Flags().GetString("queue")
-	if err != nil {
-		fmt.Printf("error: %v\n", err)
-		os.Exit(1)
-	}
-	id, err := cmd.Flags().GetString("id")
-	if err != nil {
-		fmt.Printf("error: %v\n", err)
-		os.Exit(1)
-	}
-
-	i := createInspector()
-	err = i.DeleteTask(qname, id)
-	if err != nil {
-		fmt.Printf("error: %v\n", err)
-		os.Exit(1)
-	}
-	fmt.Println("task deleted")
-}
-
-func taskRun(cmd *cobra.Command, args []string) {
-	qname, err := cmd.Flags().GetString("queue")
-	if err != nil {
-		fmt.Printf("error: %v\n", err)
-		os.Exit(1)
-	}
-	id, err := cmd.Flags().GetString("id")
-	if err != nil {
-		fmt.Printf("error: %v\n", err)
-		os.Exit(1)
-	}
-
-	i := createInspector()
-	err = i.RunTask(qname, id)
-	if err != nil {
-		fmt.Printf("error: %v\n", err)
-		os.Exit(1)
-	}
-	fmt.Println("task is now pending")
-}
-
-func taskArchiveAll(cmd *cobra.Command, args []string) {
-	qname, err := cmd.Flags().GetString("queue")
-	if err != nil {
-		fmt.Printf("error: %v\n", err)
-		os.Exit(1)
-	}
-	state, err := cmd.Flags().GetString("state")
-	if err != nil {
-		fmt.Printf("error: %v\n", err)
-		os.Exit(1)
-	}
-
-	i := createInspector()
-	var n int
-	switch state {
-	case "pending":
-		n, err = i.ArchiveAllPendingTasks(qname)
-	case "scheduled":
-		n, err = i.ArchiveAllScheduledTasks(qname)
-	case "retry":
-		n, err = i.ArchiveAllRetryTasks(qname)
-	default:
-		fmt.Printf("error: unsupported state %q\n", state)
-		os.Exit(1)
-	}
-	if err != nil {
-		fmt.Printf("error: %v\n", err)
-		os.Exit(1)
-	}
-	fmt.Printf("%d tasks archived\n", n)
-}
-
-func taskDeleteAll(cmd *cobra.Command, args []string) {
-	qname, err := cmd.Flags().GetString("queue")
-	if err != nil {
-		fmt.Printf("error: %v\n", err)
-		os.Exit(1)
-	}
-	state, err := cmd.Flags().GetString("state")
-	if err != nil {
-		fmt.Printf("error: %v\n", err)
-		os.Exit(1)
-	}
-
-	i := createInspector()
-	var n int
-	switch state {
-	case "pending":
-		n, err = i.DeleteAllPendingTasks(qname)
-	case "scheduled":
-		n, err = i.DeleteAllScheduledTasks(qname)
-	case "retry":
-		n, err = i.DeleteAllRetryTasks(qname)
-	case "archived":
-		n, err = i.DeleteAllArchivedTasks(qname)
-	case "completed":
-		n, err = i.DeleteAllCompletedTasks(qname)
-	default:
-		fmt.Printf("error: unsupported state %q\n", state)
-		os.Exit(1)
-	}
-	if err != nil {
-		fmt.Printf("error: %v\n", err)
-		os.Exit(1)
-	}
-	fmt.Printf("%d tasks deleted\n", n)
-}
-
-func taskRunAll(cmd *cobra.Command, args []string) {
-	qname, err := cmd.Flags().GetString("queue")
-	if err != nil {
-		fmt.Printf("error: %v\n", err)
-		os.Exit(1)
-	}
-	state, err := cmd.Flags().GetString("state")
-	if err != nil {
-		fmt.Printf("error: %v\n", err)
-		os.Exit(1)
-	}
-
-	i := createInspector()
-	var n int
-	switch state {
-	case "scheduled":
-		n, err = i.RunAllScheduledTasks(qname)
-	case "retry":
-		n, err = i.RunAllRetryTasks(qname)
-	case "archived":
-		n, err = i.RunAllArchivedTasks(qname)
-	default:
-		fmt.Printf("error: unsupported state %q\n", state)
-		os.Exit(1)
-	}
-	if err != nil {
-		fmt.Printf("error: %v\n", err)
-		os.Exit(1)
-	}
-	fmt.Printf("%d tasks are now pending\n", n)
-}

tools/asynq/cmd/unpause.go

@@ -0,0 +1,46 @@
+// Copyright 2020 Kentaro Hibino. All rights reserved.
+// Use of this source code is governed by a MIT license
+// that can be found in the LICENSE file.
+
+package cmd
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/go-redis/redis/v7"
+	"github.com/hibiken/asynq/internal/rdb"
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+)
+
+// unpauseCmd represents the unpause command
+var unpauseCmd = &cobra.Command{
+	Use:   "unpause [queue name]",
+	Short: "Unpauses the specified queue",
+	Long: `Unpause (asynq unpause) will unpause the specified queue.
+Asynq servers will process tasks from unpaused/resumed queues.
+
+Example: asynq unpause default -> Resume the "default" queue`,
+	Args: cobra.ExactValidArgs(1),
+	Run:  unpause,
+}
+
+func init() {
+	rootCmd.AddCommand(unpauseCmd)
+}
+
+func unpause(cmd *cobra.Command, args []string) {
+	c := redis.NewClient(&redis.Options{
+		Addr:     viper.GetString("uri"),
+		DB:       viper.GetInt("db"),
+		Password: viper.GetString("password"),
+	})
+	r := rdb.NewRDB(c)
+	err := r.Unpause(args[0])
+	if err != nil {
+		fmt.Printf("error: %v\n", err)
+		os.Exit(1)
+	}
+	fmt.Printf("Successfully resumed queue %q\n", args[0])
+}

tools/asynq/cmd/workers.go

@@ -0,0 +1,75 @@
+// Copyright 2020 Kentaro Hibino. All rights reserved.
+// Use of this source code is governed by a MIT license
+// that can be found in the LICENSE file.
+
+package cmd
+
+import (
+	"fmt"
+	"io"
+	"os"
+	"sort"
+
+	"github.com/go-redis/redis/v7"
+	"github.com/hibiken/asynq/internal/rdb"
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+)
+
+// workersCmd represents the workers command
+var workersCmd = &cobra.Command{
+	Use:   "workers",
+	Short: "Shows all running workers information",
+	Long: `Workers (asynq workers) will show all running workers information.
+
+The command shows the following for each worker:
+* Process in which the worker is running
+* ID of the task worker is processing
+* Type of the task worker is processing
+* Payload of the task worker is processing
+* Queue that the task was pulled from.
+* Time the worker started processing the task`,
+	Args: cobra.NoArgs,
+	Run:  workers,
+}
+
+func init() {
+	rootCmd.AddCommand(workersCmd)
+}
+
+func workers(cmd *cobra.Command, args []string) {
+	r := rdb.NewRDB(redis.NewClient(&redis.Options{
+		Addr:     viper.GetString("uri"),
+		DB:       viper.GetInt("db"),
+		Password: viper.GetString("password"),
+	}))
+
+	workers, err := r.ListWorkers()
+	if err != nil {
+		fmt.Println(err)
+		os.Exit(1)
+	}
+
+	if len(workers) == 0 {
+		fmt.Println("No workers")
+		return
+	}
+
+	// sort by started timestamp or ID.
+	sort.Slice(workers, func(i, j int) bool {
+		x, y := workers[i], workers[j]
+		if x.Started != y.Started {
+			return x.Started.Before(y.Started)
+		}
+		return x.ID < y.ID
+	})
+
+	cols := []string{"Process", "ID", "Type", "Payload", "Queue", "Started"}
+	printRows := func(w io.Writer, tmpl string) {
+		for _, wk := range workers {
+			fmt.Fprintf(w, tmpl,
+				fmt.Sprintf("%s:%d", wk.Host, wk.PID), wk.ID, wk.Type, wk.Payload, wk.Queue, timeAgo(wk.Started))
+		}
+	}
+	printTable(cols, printRows)
+}

tools/go.mod

@@ -3,18 +3,13 @@ module github.com/hibiken/asynq/tools
 go 1.13
 
 require (
-	github.com/fatih/color v1.9.0
+	github.com/go-redis/redis/v7 v7.2.0
-	github.com/go-redis/redis/v8 v8.11.4
+	github.com/google/uuid v1.1.1
-	github.com/google/uuid v1.3.0
+	github.com/hibiken/asynq v0.4.0
-	github.com/hibiken/asynq v0.19.0
-	github.com/hibiken/asynq/x v0.0.0-00010101000000-000000000000
 	github.com/mitchellh/go-homedir v1.1.0
-	github.com/prometheus/client_golang v1.11.0
+	github.com/spf13/cast v1.3.1
-	github.com/spf13/cobra v1.1.1
+	github.com/spf13/cobra v0.0.5
-	github.com/spf13/viper v1.7.0
+	github.com/spf13/viper v1.6.2
 )
 
-replace (
+replace github.com/hibiken/asynq => ./..
-	github.com/hibiken/asynq => ./..
-	github.com/hibiken/asynq/x => ./../x
-)

tools/go.sum

@@ -1,262 +1,106 @@
 cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
-cloud.google.com/go v0.34.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
-cloud.google.com/go v0.38.0/go.mod h1:990N+gfupTy94rShfmMCWGDn0LpTmnzTp2qbd1dvSRU=
-cloud.google.com/go v0.44.1/go.mod h1:iSa0KzasP4Uvy3f1mN/7PiObzGgflwredwwASm/v6AU=
-cloud.google.com/go v0.44.2/go.mod h1:60680Gw3Yr4ikxnPRS/oxxkBccT6SA1yMk63TGekxKY=
-cloud.google.com/go v0.45.1/go.mod h1:RpBamKRgapWJb87xiFSdk4g1CME7QZg3uwTez+TSTjc=
-cloud.google.com/go v0.46.3/go.mod h1:a6bKKbmY7er1mI7TEI4lsAkts/mkhTSZK8w33B4RAg0=
-cloud.google.com/go/bigquery v1.0.1/go.mod h1:i/xbL2UlR5RvWAURpBYZTtm/cXjCha9lbfbpx4poX+o=
-cloud.google.com/go/datastore v1.0.0/go.mod h1:LXYbyblFSglQ5pkeyhO+Qmw7ukd3C+pD7TKLgZqpHYE=
-cloud.google.com/go/firestore v1.1.0/go.mod h1:ulACoGHTpvq5r8rxGJ4ddJZBZqakUQqClKRT5SZwBmk=
-cloud.google.com/go/pubsub v1.0.1/go.mod h1:R0Gpsv3s54REJCy4fxDixWD93lHJMoZTyQ2kNxGRt3I=
-cloud.google.com/go/storage v1.0.0/go.mod h1:IhtSnM/ZTZV8YYJWCY8RULGVqBDmpoyjwiyrjsg+URw=
-dmitri.shuralyov.com/gpu/mtl v0.0.0-20190408044501-666a987793e9/go.mod h1:H6x//7gZCb22OMCxBHrMx7a5I7Hp++hsVxbQ4BYO7hU=
 github.com/BurntSushi/toml v0.3.1 h1:WXkYYl6Yr3qBf1K79EBnL4mak0OimBfB0XUf9Vl28OQ=
 github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
-github.com/BurntSushi/xgb v0.0.0-20160522181843-27f122750802/go.mod h1:IVnqGOEym/WlBOVXweHU+Q+/VP0lqqI8lqeDx9IjBqo=
 github.com/OneOfOne/xxhash v1.2.2/go.mod h1:HSdplMjZKSmBqAxg5vPj2TmRDmfkzw+cTzAElWljhcU=
 github.com/alecthomas/template v0.0.0-20160405071501-a0175ee3bccc/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc=
-github.com/alecthomas/template v0.0.0-20190718012654-fb15b899a751/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc=
 github.com/alecthomas/units v0.0.0-20151022065526-2efee857e7cf/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0=
-github.com/alecthomas/units v0.0.0-20190717042225-c3de453c63f4/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0=
+github.com/armon/consul-api v0.0.0-20180202201655-eb2c6b5be1b6/go.mod h1:grANhF5doyWs3UAsr3K4I6qtAmlQcZDesFNEHPZAzj8=
-github.com/alecthomas/units v0.0.0-20190924025748-f65c72e2690d/go.mod h1:rBZYJk541a8SKzHPHnH3zbiI+7dagKZ0cgpgrD7Fyho=
-github.com/armon/circbuf v0.0.0-20150827004946-bbbad097214e/go.mod h1:3U/XgcO3hCbHZ8TKRvWD2dDTCfh9M9ya+I9JpbB7O8o=
-github.com/armon/go-metrics v0.0.0-20180917152333-f0300d1749da/go.mod h1:Q73ZrmVTwzkszR9V5SSuryQ31EELlFMUz1kKyl939pY=
-github.com/armon/go-radix v0.0.0-20180808171621-7fddfc383310/go.mod h1:ufUuZ+zHj4x4TnLV4JWEpy2hxWSpsRywHrMgIH9cCH8=
 github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q=
-github.com/beorn7/perks v1.0.0 h1:HWo1m869IqiPhD389kmkxeTalrjNbbJTC8LXupb+sl0=
 github.com/beorn7/perks v1.0.0/go.mod h1:KWe93zE9D1o94FZ5RNwFwVgaQK1VOXiVxmqh+CedLV8=
-github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM=
-github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw=
-github.com/bgentry/speakeasy v0.1.0/go.mod h1:+zsyZBPWlz7T6j88CTgSN5bM796AkVf0kBD4zp0CCIs=
-github.com/bketelsen/crypt v0.0.3-0.20200106085610-5cbc8cc4026c/go.mod h1:MKsuJmJgSg28kpZDP6UIiPt0e0Oz0kqKNGyRaWEPv84=
-github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU=
-github.com/cespare/xxhash v1.1.0 h1:a6HrQnmkObjyL+Gs60czilIUGqrzKutQD6XZog3p+ko=
 github.com/cespare/xxhash v1.1.0/go.mod h1:XrSqR1VqqWfGrhpAt58auRo0WTKS1nRRg3ghfAqPWnc=
-github.com/cespare/xxhash/v2 v2.1.1 h1:6MnRN8NT7+YBpUIWxHtefFZOKTAPgGjpQSxqLNn0+qY=
-github.com/cespare/xxhash/v2 v2.1.1/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
-github.com/cespare/xxhash/v2 v2.1.2 h1:YRXhKfTDauu4ajMg1TPgFO5jnlC2HCbmLXMcTG5cbYE=
-github.com/cespare/xxhash/v2 v2.1.2/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
 github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw=
 github.com/coreos/bbolt v1.3.2/go.mod h1:iRUV2dpdMOn7Bo10OQBFzIJO9kkE559Wcmn+qkEiiKk=
-github.com/coreos/etcd v3.3.13+incompatible/go.mod h1:uF7uidLiAD3TWHmW31ZFd/JWoc32PjwdhPthX9715RE=
+github.com/coreos/etcd v3.3.10+incompatible/go.mod h1:uF7uidLiAD3TWHmW31ZFd/JWoc32PjwdhPthX9715RE=
-github.com/coreos/go-semver v0.3.0/go.mod h1:nnelYz7RCh+5ahJtPPxZlU+153eP4D4r3EedlOD2RNk=
+github.com/coreos/go-etcd v2.0.0+incompatible/go.mod h1:Jez6KQU2B/sWsbdaef3ED8NzMklzPG4d5KIOhIy30Tk=
+github.com/coreos/go-semver v0.2.0/go.mod h1:nnelYz7RCh+5ahJtPPxZlU+153eP4D4r3EedlOD2RNk=
 github.com/coreos/go-systemd v0.0.0-20190321100706-95778dfbb74e/go.mod h1:F5haX7vjVVG0kc13fIWeqUViNPyEJxv/OmvnBo0Yme4=
 github.com/coreos/pkg v0.0.0-20180928190104-399ea9e2e55f/go.mod h1:E3G3o1h8I7cfcXa63jLwjI0eiQQMgzzUDFVpN/nH/eA=
-github.com/cpuguy83/go-md2man/v2 v2.0.0/go.mod h1:maD7wRr/U5Z6m/iR4s+kqSMx2CaBsrgA7czyZG/E6dU=
+github.com/cpuguy83/go-md2man v1.0.10/go.mod h1:SmD6nW6nTyfqj6ABTjUi3V3JVMnlJmwcJI5acqYI6dE=
-github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/dgrijalva/jwt-go v3.2.0+incompatible/go.mod h1:E3ru+11k8xSBh+hMPgOLZmtrrCbhqsmaPHjLKYnJCaQ=
-github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f h1:lO4WD4F/rVNCu3HqELle0jiPLLBs70cWOduZpkS1E78=
-github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f/go.mod h1:cuUVRXasLTGF7a8hSLbxyZXjz+1KgoB3wDUb6vlszIc=
 github.com/dgryski/go-sip13 v0.0.0-20181026042036-e10d5fee7954/go.mod h1:vAd38F8PWV+bWy6jNmig1y/TA+kYO4g3RSRF0IAv0no=
-github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
+github.com/fsnotify/fsnotify v1.4.7 h1:IXs+QLmnXW2CcXuY+8Mzv/fWEsPGWxqefPtCP5CnV9I=
-github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c=
-github.com/fatih/color v1.7.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4=
-github.com/fatih/color v1.9.0 h1:8xPHl4/q1VyqGIPif1F+1V3Y3lSmrq01EabUW3CoW5s=
-github.com/fatih/color v1.9.0/go.mod h1:eQcE1qtQxscV5RaZvpXrrb8Drkc3/DdQ+uUYCNjL+zU=
 github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
-github.com/fsnotify/fsnotify v1.4.9 h1:hsms1Qyu0jgnwNXIxa+/V/PDsU6CfLf6CNO8H7IWoS4=
-github.com/fsnotify/fsnotify v1.4.9/go.mod h1:znqG4EE+3YCdAaPaxE2ZRY/06pZUdp0tY4IgpuI1SZQ=
 github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04=
-github.com/go-gl/glfw v0.0.0-20190409004039-e6da0acd62b1/go.mod h1:vR7hzQXu2zJy9AVAgeJqvqgH9Q5CA+iKCZ2gyEVpxRU=
 github.com/go-kit/kit v0.8.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as=
-github.com/go-kit/kit v0.9.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as=
-github.com/go-kit/log v0.1.0/go.mod h1:zbhenjAZHb184qTLMA9ZjW7ThYL0H2mk7Q6pNt4vbaY=
 github.com/go-logfmt/logfmt v0.3.0/go.mod h1:Qt1PoO58o5twSAckw1HlFXLmHsOX5/0LbT9GBnD5lWE=
 github.com/go-logfmt/logfmt v0.4.0/go.mod h1:3RMwSq7FuexP4Kalkev3ejPJsZTpXXBr9+V4qmtdjCk=
-github.com/go-logfmt/logfmt v0.5.0/go.mod h1:wCYkCAKZfumFQihp8CzCvQ3paCTfi41vtzG1KdI/P7A=
+github.com/go-redis/redis/v7 v7.2.0 h1:CrCexy/jYWZjW0AyVoHlcJUeZN19VWlbepTh1Vq6dJs=
-github.com/go-redis/redis/v8 v8.11.2 h1:WqlSpAwz8mxDSMCvbyz1Mkiqe0LE5OY4j3lgkvu1Ts0=
+github.com/go-redis/redis/v7 v7.2.0/go.mod h1:JDNMw23GTyLNC4GZu9njt15ctBQVn7xjRfnwdHj/Dcg=
-github.com/go-redis/redis/v8 v8.11.2/go.mod h1:DLomh7y2e3ggQXQLd1YgmvIfecPJoFl7WU5SOQ/r06M=
-github.com/go-redis/redis/v8 v8.11.4 h1:kHoYkfZP6+pe04aFTnhDH6GDROa5yJdHJVNxV3F46Tg=
-github.com/go-redis/redis/v8 v8.11.4/go.mod h1:2Z2wHZXdQpCDXEGzqMockDpNyYvi2l4Pxt6RJr792+w=
 github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY=
-github.com/go-task/slim-sprig v0.0.0-20210107165309-348f09dbbbc0/go.mod h1:fyg7847qk6SyHyPtNmDHnmrv/HOrqktSC+C9fM+CJOE=
 github.com/gogo/protobuf v1.1.1/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ=
 github.com/gogo/protobuf v1.2.1/go.mod h1:hp+jE20tsWTFYpLwKvXlhS1hjn+gTNwPg2I6zVXpSg4=
 github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q=
 github.com/golang/groupcache v0.0.0-20190129154638-5b532d6fd5ef/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
 github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
-github.com/golang/mock v1.2.0/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
-github.com/golang/mock v1.3.1/go.mod h1:sBzyDLLjw3U8JLTeZvSv8jJB+tU5PVekmnlKIyFUx0Y=
 github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
 github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/golang/protobuf v1.3.2 h1:6nsPYzhq5kReh6QImI3k5qWzO4PEbvbIW2cwSfR/6xs=
 github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
-github.com/golang/protobuf v1.4.0-rc.1/go.mod h1:ceaxUfeHdC40wWswd/P6IGgMaK3YpKi5j83Wpe3EHw8=
-github.com/golang/protobuf v1.4.0-rc.1.0.20200221234624-67d41d38c208/go.mod h1:xKAWHe0F5eneWXFV3EuXVDTCmh+JuBKY0li0aMyXATA=
-github.com/golang/protobuf v1.4.0-rc.2/go.mod h1:LlEzMj4AhA7rCAGe4KMBDvJI+AwstrUpVNzEA03Pprs=
-github.com/golang/protobuf v1.4.0-rc.4.0.20200313231945-b860323f09d0/go.mod h1:WU3c8KckQ9AFe+yFwt9sWVRKCVIyN9cPHBJSNnbL67w=
-github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvqG2KuDX0=
-github.com/golang/protobuf v1.4.1/go.mod h1:U8fpvMrcmy5pZrNK1lt4xCsGvpyWQ/VVv6QDs8UjoX8=
-github.com/golang/protobuf v1.4.2 h1:+Z5KGCizgyZCbGh1KZqA0fcLLkwbsjIzS4aV2v7wJX0=
-github.com/golang/protobuf v1.4.2/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
-github.com/golang/protobuf v1.4.3/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
-github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk=
-github.com/golang/protobuf v1.5.2 h1:ROPKBNFfQgOUMifHyP+KYbvpjbdoFNs+aK7DXlji0Tw=
-github.com/golang/protobuf v1.5.2/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY=
-github.com/google/btree v0.0.0-20180813153112-4030bb1f1f0c/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
 github.com/google/btree v1.0.0/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
 github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M=
-github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
+github.com/google/go-cmp v0.4.0 h1:xsAVV57WRhGj6kEIi8ReJzQlHHqcBYCElAvkovg3B/4=
-github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
 github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/google/go-cmp v0.5.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/uuid v1.1.1 h1:Gkbcsh/GbpXz7lPftLA3P6TYMwjCLYm83jiFQZF/3gY=
-github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/uuid v1.1.1/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
-github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ=
-github.com/google/go-cmp v0.5.6/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
-github.com/google/martian v2.1.0+incompatible/go.mod h1:9I4somxYTbIHy5NJKHRl3wXiIaQGbYVAs8BPL6v8lEs=
-github.com/google/pprof v0.0.0-20181206194817-3ea8567a2e57/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc=
-github.com/google/pprof v0.0.0-20190515194954-54271f7e092f/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc=
-github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm40UhjYkI=
-github.com/google/uuid v1.2.0 h1:qJYtXnJRWmpe7m/3XlyhrsLrEURqHRM2kxzoxXqyUDs=
-github.com/google/uuid v1.2.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
-github.com/google/uuid v1.3.0 h1:t6JiXgmwXMjEs8VusXIJk2BXHsn+wx8BZdTaoZ5fu7I=
-github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
-github.com/googleapis/gax-go/v2 v2.0.4/go.mod h1:0Wqv26UfaUD9n4G6kQubkQ+KchISgw+vpHVxEJEs9eg=
-github.com/googleapis/gax-go/v2 v2.0.5/go.mod h1:DWXyrwAJ9X0FpwwEdw+IPEYBICEFu5mhpdKc/us6bOk=
 github.com/gopherjs/gopherjs v0.0.0-20181017120253-0766667cb4d1 h1:EGx4pi6eqNxGaHF6qqu48+N2wcFQ5qg5FXgOdqsJ5d8=
 github.com/gopherjs/gopherjs v0.0.0-20181017120253-0766667cb4d1/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY=
-github.com/gorilla/websocket v1.4.2/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
+github.com/gorilla/websocket v1.4.0/go.mod h1:E7qHFY5m1UJ88s3WnNqhKjPHQ0heANvMoAMk2YaljkQ=
 github.com/grpc-ecosystem/go-grpc-middleware v1.0.0/go.mod h1:FiyG127CGDf3tlThmgyCl78X/SZQqEOJBCDaAfeWzPs=
 github.com/grpc-ecosystem/go-grpc-prometheus v1.2.0/go.mod h1:8NvIoxWQoOIhqOTXgfV/d3M/q6VIi02HzZEHgUlZvzk=
 github.com/grpc-ecosystem/grpc-gateway v1.9.0/go.mod h1:vNeuVxBJEsws4ogUvrchl83t/GYV9WGTSLVdBhOQFDY=
-github.com/hashicorp/consul/api v1.1.0/go.mod h1:VmuI/Lkw1nC05EYQWNKwWGbkg+FbDBtguAZLlVdkD9Q=
-github.com/hashicorp/consul/sdk v0.1.1/go.mod h1:VKf9jXwCTEY1QZP2MOLRhb5i/I/ssyNV1vwHyQBF0x8=
-github.com/hashicorp/errwrap v1.0.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4=
-github.com/hashicorp/go-cleanhttp v0.5.1/go.mod h1:JpRdi6/HCYpAwUzNwuwqhbovhLtngrth3wmdIIUrZ80=
-github.com/hashicorp/go-immutable-radix v1.0.0/go.mod h1:0y9vanUI8NX6FsYoO3zeMjhV/C5i9g4Q3DwcSNZ4P60=
-github.com/hashicorp/go-msgpack v0.5.3/go.mod h1:ahLV/dePpqEmjfWmKiqvPkv/twdG7iPBM1vqhUKIvfM=
-github.com/hashicorp/go-multierror v1.0.0/go.mod h1:dHtQlpGsu+cZNNAkkCN/P3hoUDHhCYQXV3UM06sGGrk=
-github.com/hashicorp/go-rootcerts v1.0.0/go.mod h1:K6zTfqpRlCUIjkwsN4Z+hiSfzSTQa6eBIzfwKfwNnHU=
-github.com/hashicorp/go-sockaddr v1.0.0/go.mod h1:7Xibr9yA9JjQq1JpNB2Vw7kxv8xerXegt+ozgdvDeDU=
-github.com/hashicorp/go-syslog v1.0.0/go.mod h1:qPfqrKkXGihmCqbJM2mZgkZGvKG1dFdvsLplgctolz4=
-github.com/hashicorp/go-uuid v1.0.0/go.mod h1:6SBZvOh/SIDV7/2o3Jml5SYk/TvGqwFJ/bN7x4byOro=
-github.com/hashicorp/go-uuid v1.0.1/go.mod h1:6SBZvOh/SIDV7/2o3Jml5SYk/TvGqwFJ/bN7x4byOro=
-github.com/hashicorp/go.net v0.0.1/go.mod h1:hjKkEWcCURg++eb33jQU7oqQcI9XDCnUzHA0oac0k90=
-github.com/hashicorp/golang-lru v0.5.0/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
-github.com/hashicorp/golang-lru v0.5.1/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
 github.com/hashicorp/hcl v1.0.0 h1:0Anlzjpi4vEasTeNFn2mLJgTSwt0+6sfsiTG8qcWGx4=
 github.com/hashicorp/hcl v1.0.0/go.mod h1:E5yfLk+7swimpb2L/Alb/PJmXilQ/rhwaUYs4T20WEQ=
-github.com/hashicorp/logutils v1.0.0/go.mod h1:QIAnNjmIWmVIIkWDTG1z5v++HQmx9WQRO+LraFDTW64=
+github.com/hpcloud/tail v1.0.0 h1:nfCOvKYfkgYP8hkirhJocXT2+zOD8yUNjXaWfTlyFKI=
-github.com/hashicorp/mdns v1.0.0/go.mod h1:tL+uN++7HEJ6SQLQ2/p+z2pH24WQKWjBPkE0mNTz8vQ=
-github.com/hashicorp/memberlist v0.1.3/go.mod h1:ajVTdAv/9Im8oMAAj5G31PhhMCZJV2pPBoIllUwCN7I=
-github.com/hashicorp/serf v0.8.2/go.mod h1:6hOLApaqBFA1NXqRQAsxw9QxuDEvNxSQRwA/JwenrHc=
 github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU=
 github.com/inconshreveable/mousetrap v1.0.0 h1:Z8tu5sraLXCXIcARxBp/8cbvlwVa7Z1NHg9XEKhtSvM=
 github.com/inconshreveable/mousetrap v1.0.0/go.mod h1:PxqpIevigyE2G7u3NXJIT2ANytuPF1OarO4DADm73n8=
 github.com/jonboulle/clockwork v0.1.0/go.mod h1:Ii8DK3G1RaLaWxj9trq07+26W01tbo22gdxWY5EU2bo=
-github.com/jpillora/backoff v1.0.0/go.mod h1:J/6gKK9jxlEcS3zixgDgUAsiuZ7yrSoa/FX5e0EB2j4=
-github.com/json-iterator/go v1.1.6/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCVDaaPEHmU=
-github.com/json-iterator/go v1.1.10/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
-github.com/json-iterator/go v1.1.11/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
-github.com/jstemmer/go-junit-report v0.0.0-20190106144839-af01ea7f8024/go.mod h1:6v2b51hI/fHJwM22ozAgKL4VKDeJcHhJFhtBdhmNjmU=
 github.com/jtolds/gls v4.20.0+incompatible h1:xdiiI2gbIgH/gLH7ADydsJ1uDOEzR8yvV7C0MuV77Wo=
 github.com/jtolds/gls v4.20.0+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU=
 github.com/julienschmidt/httprouter v1.2.0/go.mod h1:SYymIcj16QtmaHHD7aYtjjsJG7VTCxuUUipMqKk8s4w=
-github.com/julienschmidt/httprouter v1.3.0/go.mod h1:JR6WtHb+2LUe8TCKY3cZOxFyyO8IZAc4RVcycCCAKdM=
 github.com/kisielk/errcheck v1.1.0/go.mod h1:EZBBE59ingxPouuu3KfxchcWSUPOHkagtvWXihfKN4Q=
 github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
 github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
-github.com/konsorten/go-windows-terminal-sequences v1.0.3/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
 github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515/go.mod h1:+0opPa2QZZtGFBFZlji/RkVcI2GknAs/DXo4wKdlNEc=
 github.com/kr/pretty v0.1.0 h1:L/CwN0zerZDmRFUapSPitk6f+Q3+0za1rQkzVuMiMFI=
 github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
 github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
 github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE=
 github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
+github.com/magiconair/properties v1.8.0/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ=
 github.com/magiconair/properties v1.8.1 h1:ZC2Vc7/ZFkGmsVC9KvOjumD+G5lXy2RtTKyzRKO2BQ4=
 github.com/magiconair/properties v1.8.1/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ=
-github.com/mattn/go-colorable v0.0.9/go.mod h1:9vuHe8Xs5qXnSaW/c/ABM9alt+Vo+STaOChaDxuIBZU=
-github.com/mattn/go-colorable v0.1.4 h1:snbPLB8fVfU9iwbbo30TPtbLRzwWu6aJS6Xh4eaaviA=
-github.com/mattn/go-colorable v0.1.4/go.mod h1:U0ppj6V5qS13XJ6of8GYAs25YV2eR4EVcfRqFIhoBtE=
-github.com/mattn/go-isatty v0.0.3/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4=
-github.com/mattn/go-isatty v0.0.8/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s=
-github.com/mattn/go-isatty v0.0.11 h1:FxPOTFNqGkuDUGi3H/qkUbQO4ZiBa2brKq5r0l8TGeM=
-github.com/mattn/go-isatty v0.0.11/go.mod h1:PhnuNfih5lzO57/f3n+odYbM4JtupLOxQOAqxQCu2WE=
-github.com/matttproud/golang_protobuf_extensions v1.0.1 h1:4hp9jkHxhMHkqkrB3Ix0jegS5sx/RkqARlsWZ6pIwiU=
 github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0=
-github.com/miekg/dns v1.0.14/go.mod h1:W1PPwlIAgtquWBMBEV9nkV9Cazfe8ScdGz/Lj7v3Nrg=
-github.com/mitchellh/cli v1.0.0/go.mod h1:hNIlj7HEI86fIcpObd7a0FcrxTWetlwJDGcceTlRvqc=
-github.com/mitchellh/go-homedir v1.0.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0=
 github.com/mitchellh/go-homedir v1.1.0 h1:lukF9ziXFxDFPkA1vsr5zpc1XuPDn/wFntq5mG+4E0Y=
 github.com/mitchellh/go-homedir v1.1.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0=
-github.com/mitchellh/go-testing-interface v1.0.0/go.mod h1:kRemZodwjscx+RGhAo8eIhFbs2+BFgRtFPeD/KE+zxI=
-github.com/mitchellh/gox v0.4.0/go.mod h1:Sd9lOJ0+aimLBi73mGofS1ycjY8lL3uZM3JPS42BGNg=
-github.com/mitchellh/iochan v1.0.0/go.mod h1:JwYml1nuB7xOzsp52dPpHFffvOCDupsG0QubkSMEySY=
-github.com/mitchellh/mapstructure v0.0.0-20160808181253-ca63d7c062ee/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y=
 github.com/mitchellh/mapstructure v1.1.2 h1:fmNYVwqnSfB9mZU6OS2O6GsXM+wcskZDuKQzvN1EDeE=
 github.com/mitchellh/mapstructure v1.1.2/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y=
-github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
-github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
-github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
-github.com/modern-go/reflect2 v1.0.1/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
 github.com/mwitkow/go-conntrack v0.0.0-20161129095857-cc309e4a2223/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U=
-github.com/mwitkow/go-conntrack v0.0.0-20190716064945-2f068394615f/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U=
-github.com/nxadm/tail v1.4.4 h1:DQuhQpB1tVlglWS2hLQ5OV6B5r8aGxSrPc5Qo6uTN78=
-github.com/nxadm/tail v1.4.4/go.mod h1:kenIhsEOeOJmVchQTgglprH7qJGnHDVpk1VPCcaMI8A=
-github.com/nxadm/tail v1.4.8/go.mod h1:+ncqLTQzXmGhMZNUePPaPqPvBxHAIsmXswZKocGu+AU=
 github.com/oklog/ulid v1.3.1/go.mod h1:CirwcVhetQ6Lv90oh/F+FBtV6XMibvdAFo93nm5qn4U=
 github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
-github.com/onsi/ginkgo v1.12.1/go.mod h1:zj2OWP4+oCPe1qIXoGWkgMRwljMUYCdkwsT2108oapk=
+github.com/onsi/ginkgo v1.10.1 h1:q/mM8GF/n0shIN8SaAZ0V+jnLPzen6WIVZdiwrRlMlo=
-github.com/onsi/ginkgo v1.15.0 h1:1V1NfVQR87RtWAgp1lv9JZJ5Jap+XFGKPi00andXGi4=
+github.com/onsi/ginkgo v1.10.1/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
-github.com/onsi/ginkgo v1.15.0/go.mod h1:hF8qUzuuC8DJGygJH3726JnCZX4MYbRB8yFfISqnKUg=
+github.com/onsi/gomega v1.7.0 h1:XPnZz8VVBHjVsy1vzJmRwIcSwiUO+JFfrv/xGiigmME=
-github.com/onsi/ginkgo v1.16.4/go.mod h1:dX+/inL/fNMqNlz0e9LfyB9TswhZpCVdJM/Z6Vvnwo0=
+github.com/onsi/gomega v1.7.0/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY=
-github.com/onsi/gomega v1.7.1/go.mod h1:XdKZgCCFLUoM/7CFJVPcG8C1xQ1AJ0vpAezJrB7JYyY=
-github.com/onsi/gomega v1.10.1/go.mod h1:iN09h71vgCQne3DLsj+A5owkum+a2tYe+TOCB1ybHNo=
-github.com/onsi/gomega v1.10.5 h1:7n6FEkpFmfCoo2t+YYqXH0evK+a9ICQz0xcAy9dYcaQ=
-github.com/onsi/gomega v1.10.5/go.mod h1:gza4q3jKQJijlu05nKWRCW/GavJumGt8aNRxWg7mt48=
-github.com/onsi/gomega v1.16.0/go.mod h1:HnhC7FXeEQY45zxNK3PPoIUhzk/80Xly9PcubAlGdZY=
-github.com/pascaldekloe/goe v0.0.0-20180627143212-57f6aae5913c/go.mod h1:lzWF7FIEvWOWxwDKqyGYQf6ZUaNfKdP144TG7ZOy1lc=
 github.com/pelletier/go-toml v1.2.0 h1:T5zMGML61Wp+FlcbWjRDT7yAxhJNAiPPLOFECq181zc=
 github.com/pelletier/go-toml v1.2.0/go.mod h1:5z9KED0ma1S8pY6P1sdut58dfprrGBbd/94hg7ilaic=
 github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
-github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
-github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/posener/complete v1.1.1/go.mod h1:em0nMJCgc9GFtwrmVmEMR/ZL6WyhyjMBndrE9hABlRI=
 github.com/prometheus/client_golang v0.9.1/go.mod h1:7SWBe2y4D6OKWSNQJUaRYU/AaXPKyh/dDVn+NZz0KFw=
-github.com/prometheus/client_golang v0.9.3 h1:9iH4JKXLzFbOAdtqv/a+j8aewx2Y8lAjAydhbaScPF8=
 github.com/prometheus/client_golang v0.9.3/go.mod h1:/TN21ttK/J9q6uSwhBd54HahCDft0ttaMvbicHlPoso=
-github.com/prometheus/client_golang v1.0.0/go.mod h1:db9x61etRT2tGnBNRi70OPL5FsnadC4Ky3P0J6CfImo=
-github.com/prometheus/client_golang v1.7.1/go.mod h1:PY5Wy2awLA44sXw4AOSfFBetzPP4j5+D6mVACh+pe2M=
-github.com/prometheus/client_golang v1.11.0 h1:HNkLOAEQMIDv/K+04rukrLx6ch7msSRwf3/SASFAGtQ=
-github.com/prometheus/client_golang v1.11.0/go.mod h1:Z6t4BnS23TR94PD6BsDNk8yVqroYurpAkEiz0P2BEV0=
 github.com/prometheus/client_model v0.0.0-20180712105110-5c3871d89910/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo=
 github.com/prometheus/client_model v0.0.0-20190129233127-fd36f4220a90/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
-github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4 h1:gQz4mCbXsO+nc9n1hCxHcGA3Zx3Eo+UHZoInFGUIXNM=
-github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
-github.com/prometheus/client_model v0.2.0 h1:uq5h0d+GuxiXLJLNABMgp2qUWDPiLvgCzz2dUR+/W/M=
-github.com/prometheus/client_model v0.2.0/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
 github.com/prometheus/common v0.0.0-20181113130724-41aa239b4cce/go.mod h1:daVV7qP5qjZbuso7PdcryaAu0sAZbrN9i7WWcTMWvro=
-github.com/prometheus/common v0.4.0 h1:7etb9YClo3a6HjLzfl6rIQaU+FDfi0VSX39io3aQ+DM=
 github.com/prometheus/common v0.4.0/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4=
-github.com/prometheus/common v0.4.1/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4=
-github.com/prometheus/common v0.10.0/go.mod h1:Tlit/dnDKsSWFlCLTWaA1cyBgKHSMdTB80sz/V91rCo=
-github.com/prometheus/common v0.26.0 h1:iMAkS2TDoNWnKM+Kopnx/8tnEStIfpYA0ur0xQzzhMQ=
-github.com/prometheus/common v0.26.0/go.mod h1:M7rCNAaPfAosfx8veZJCuw84e35h3Cfd9VFqTh1DIvc=
 github.com/prometheus/procfs v0.0.0-20181005140218-185b4288413d/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
-github.com/prometheus/procfs v0.0.0-20190507164030-5867b95ac084 h1:sofwID9zm4tzrgykg80hfFph1mryUeLRsUfoocVVmRY=
 github.com/prometheus/procfs v0.0.0-20190507164030-5867b95ac084/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsTZCD3I8kEA=
-github.com/prometheus/procfs v0.0.2/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsTZCD3I8kEA=
-github.com/prometheus/procfs v0.1.3/go.mod h1:lV6e/gmhEcM9IjHGsFOCxxuZ+z1YqCvr4OA4YeYWdaU=
-github.com/prometheus/procfs v0.6.0 h1:mxy4L2jP6qMonqmq+aTtOx1ifVWUgG/TAmntgbh3xv4=
-github.com/prometheus/procfs v0.6.0/go.mod h1:cz+aTbrPOrUb4q7XlbU9ygM+/jj0fzG6c1xBZuNvfVA=
 github.com/prometheus/tsdb v0.7.1/go.mod h1:qhTCs0VvXwvX/y3TZrWD7rabWM+ijKTux40TwIPHuXU=
-github.com/robfig/cron/v3 v3.0.1 h1:WdRxkvbJztn8LMz/QEvLN5sBU+xKpSqwwUO1Pjr4qDs=
-github.com/robfig/cron/v3 v3.0.1/go.mod h1:eQICP3HwyT7UooqI/z+Ov+PtYAWygg1TEWWzGIFLtro=
 github.com/rogpeppe/fastuuid v0.0.0-20150106093220-6724a57986af/go.mod h1:XWv6SoW27p1b0cqNHllgS5HIMJraePCO15w5zCzIWYg=
-github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4=
+github.com/russross/blackfriday v1.5.2/go.mod h1:JO/DiYxRf+HjHt06OyowR9PTA263kcR/rfWxYHBV53g=
-github.com/russross/blackfriday/v2 v2.0.1/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
-github.com/ryanuber/columnize v0.0.0-20160712163229-9b3edd62028f/go.mod h1:sm1tb6uqfes/u+d4ooFouqFdy9/2g9QGwK3SQygK0Ts=
-github.com/sean-/seed v0.0.0-20170313163322-e2103e2c3529/go.mod h1:DxrIzT+xaE7yg65j358z/aeFdxmN0P9QXhEzd20vsDc=
-github.com/shurcooL/sanitized_anchor_name v1.0.0/go.mod h1:1NzhyTcUVG4SuEtjjoZeVRXNmyL/1OwPU0+IJeTBvfc=
 github.com/sirupsen/logrus v1.2.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPxbbu5VWo=
-github.com/sirupsen/logrus v1.4.2/go.mod h1:tLMulIdttU9McNUspp0xgXVQah82FyeX6MwdIuYE2rE=
-github.com/sirupsen/logrus v1.6.0/go.mod h1:7uNnSEd1DgxDLC74fIahvMZmmYsHGZGEOFrfsX/uA88=
 github.com/smartystreets/assertions v0.0.0-20180927180507-b2de0cb4f26d h1:zE9ykElWQ6/NYmHa3jpm/yHnI4xSofP+UP6SpjHcSeM=
 github.com/smartystreets/assertions v0.0.0-20180927180507-b2de0cb4f26d/go.mod h1:OnSkiWE9lh6wB0YB77sQom3nweQdgAjqCqsofrRNTgc=
 github.com/smartystreets/goconvey v1.6.4 h1:fv0U8FUIMPNf1L9lnHLvLhgicrIVChEkdzIKYqbNC9s=
@@ -268,205 +112,78 @@ github.com/spf13/afero v1.1.2/go.mod h1:j4pytiNVoe2o6bmDsKpLACNPDBIoEAkihy7loJ1B
 github.com/spf13/cast v1.3.0/go.mod h1:Qx5cxh0v+4UWYiBimWS+eyWzqEqokIECu5etghLkUJE=
 github.com/spf13/cast v1.3.1 h1:nFm6S0SMdyzrzcmThSipiEubIDy8WEXKNZ0UOgiRpng=
 github.com/spf13/cast v1.3.1/go.mod h1:Qx5cxh0v+4UWYiBimWS+eyWzqEqokIECu5etghLkUJE=
-github.com/spf13/cobra v1.1.1 h1:KfztREH0tPxJJ+geloSLaAkaPkr4ki2Er5quFV1TDo4=
+github.com/spf13/cobra v0.0.5 h1:f0B+LkLX6DtmRH1isoNA9VTtNUK9K8xYd28JNNfOv/s=
-github.com/spf13/cobra v1.1.1/go.mod h1:WnodtKOvamDL/PwE2M4iKs8aMDBZ5Q5klgD3qfVJQMI=
+github.com/spf13/cobra v0.0.5/go.mod h1:3K3wKZymM7VvHMDS9+Akkh4K60UwM26emMESw8tLCHU=
 github.com/spf13/jwalterweatherman v1.0.0 h1:XHEdyB+EcvlqZamSM4ZOMGlc93t6AcsBEu9Gc1vn7yk=
 github.com/spf13/jwalterweatherman v1.0.0/go.mod h1:cQK4TGJAtQXfYWX+Ddv3mKDzgVb68N+wFjFa4jdeBTo=
+github.com/spf13/pflag v1.0.3 h1:zPAT6CGy6wXeQ7NtTnaTerfKOsV6V6F8agHXFiazDkg=
 github.com/spf13/pflag v1.0.3/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4=
-github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA=
+github.com/spf13/viper v1.3.2/go.mod h1:ZiWeW+zYFKm7srdB9IoDzzZXaJaI5eL9QjNiN/DMA2s=
-github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
+github.com/spf13/viper v1.6.2 h1:7aKfF+e8/k68gda3LOjo5RxiUqddoFxVq4BKBPrxk5E=
-github.com/spf13/viper v1.7.0 h1:xVKxvI7ouOI5I+U9s2eeiUfMaWBVoXA3AWskkrqK0VM=
+github.com/spf13/viper v1.6.2/go.mod h1:t3iDnF5Jlj76alVNuyFBk5oUMCvsrkbvZK0WQdfDi5k=
-github.com/spf13/viper v1.7.0/go.mod h1:8WkrPz2fc9jxqZNCJI/76HCieCp4Q8HaLFoCha5qpdg=
-github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/testify v1.2.2 h1:bSDNvY7ZPG5RlJ8otE/7V6gMiyenm9RtJ7IUVIAoJ1w=
 github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
-github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
-github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
-github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA=
-github.com/stretchr/testify v1.6.1 h1:hDPOHmpOpP40lSULcqw7IrRb/u7w6RpDC9399XyoNd0=
-github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 github.com/subosito/gotenv v1.2.0 h1:Slr1R9HxAlEKefgq5jn9U+DnETlIUa6HfgEzj0g5d7s=
 github.com/subosito/gotenv v1.2.0/go.mod h1:N0PQaV/YGNqwC0u51sEeR/aUtSLEXKX9iv69rRypqCw=
 github.com/tmc/grpc-websocket-proxy v0.0.0-20190109142713-0ad062ec5ee5/go.mod h1:ncp9v5uamzpCO7NfCPTXjqaC+bZgJeR0sMTm6dMHP7U=
+github.com/ugorji/go v1.1.4/go.mod h1:uQMGLiO92mf5W77hV/PUCpI3pbzQx3CRekS0kk+RGrc=
+github.com/ugorji/go/codec v0.0.0-20181204163529-d75b2dcb6bc8/go.mod h1:VFNgLljTbGfSG7qAOspJ7OScBnGdDN/yBr0sguwnwf0=
 github.com/xiang90/probing v0.0.0-20190116061207-43a291ad63a2/go.mod h1:UETIi67q53MR2AWcXfiuqkDkRtnGDLqkBTpCHuJHxtU=
-github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
+github.com/xordataexchange/crypt v0.0.3-0.20170626215501-b2862e3d0a77/go.mod h1:aYKd//L2LvnjZzWKhF00oedf4jCCReLcmhLdhm1A27Q=
 go.etcd.io/bbolt v1.3.2/go.mod h1:IbVyRI1SCnLcuJnV2u8VeU0CEYM7e686BmAb1XKL+uU=
-go.opencensus.io v0.21.0/go.mod h1:mSImk1erAIZhrmZN+AvHh14ztQfjbGwt4TtuofqLduU=
-go.opencensus.io v0.22.0/go.mod h1:+kGneAE2xo2IficOXnaByMWTGM9T73dGwxeWcUqIpI8=
 go.uber.org/atomic v1.4.0/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE=
-go.uber.org/goleak v0.10.0 h1:G3eWbSNIskeRqtsN/1uI5B+eP73y3JUuBsv9AZjehb4=
 go.uber.org/goleak v0.10.0/go.mod h1:VCZuO8V8mFPlL0F5J5GK1rtHV3DrFcQ1R8ryq7FK0aI=
 go.uber.org/multierr v1.1.0/go.mod h1:wR5kodmAFQ0UK8QlbwjlSNy0Z68gJhDJUG5sjR94q/0=
 go.uber.org/zap v1.10.0/go.mod h1:vwi/ZaCAaUcBkycHslxD9B2zi4UTXhF60s6SWpuDF0Q=
 golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
-golang.org/x/crypto v0.0.0-20181029021203-45a5f77698d3/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
+golang.org/x/crypto v0.0.0-20181203042331-505ab145d0a9/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
-golang.org/x/crypto v0.0.0-20190510104115-cbcb75029529/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
-golang.org/x/crypto v0.0.0-20190605123033-f99c8df09eb5/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
-golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
-golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
-golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
-golang.org/x/exp v0.0.0-20190306152737-a1d7652674e8/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
-golang.org/x/exp v0.0.0-20190510132918-efd6b22b2522/go.mod h1:ZjyILWgesfNpC6sMxTJOJm9Kp84zZh5NQWvqDGG3Qr8=
-golang.org/x/exp v0.0.0-20190829153037-c13cbed26979/go.mod h1:86+5VVa7VpoJ4kLfm080zCjGlMRFzhUhsZKEZO7MGek=
-golang.org/x/exp v0.0.0-20191030013958-a1ab85dbe136/go.mod h1:JXzH8nQsPlswgeRAPE3MuO9GYsAcnJvJ4vnMwN/5qkY=
-golang.org/x/image v0.0.0-20190227222117-0694c2d4d067/go.mod h1:kZ7UVZpmo3dzQBMxlp+ypCbDeSB+sBbTgSJuh5dn5js=
-golang.org/x/image v0.0.0-20190802002840-cff245a6509b/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0=
 golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
-golang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvxsM5YxQ5yQlVC4a0KAMCusXpPoU=
-golang.org/x/lint v0.0.0-20190301231843-5614ed5bae6f/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
 golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
-golang.org/x/lint v0.0.0-20190409202823-959b441ac422/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
-golang.org/x/lint v0.0.0-20190909230951-414d861bb4ac/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
-golang.org/x/lint v0.0.0-20190930215403-16217165b5de/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
-golang.org/x/mobile v0.0.0-20190312151609-d3739f865fa6/go.mod h1:z+o9i4GpDbdi3rU15maQ/Ox0txvL9dWGYEHz965HBQE=
-golang.org/x/mobile v0.0.0-20190719004257-d2bd2a29d028/go.mod h1:E/iHnbuqvinMTCcRqshq8CkpyQDoeVncDDYHnLhea+o=
-golang.org/x/mod v0.0.0-20190513183733-4bf6d317e70e/go.mod h1:mXi4GBBbnImb6dmsKGUJ2LatrhH/nqhxcFungHvyanc=
-golang.org/x/mod v0.1.0/go.mod h1:0QHyrYULN0/3qlju5TqG8bIK38QM8yzMo5ekMj3DlcY=
-golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
-golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-golang.org/x/net v0.0.0-20181023162649-9b4f9f5ad519/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20181114220301-adae6a3d119a/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-golang.org/x/net v0.0.0-20181201002055-351d144fa1fc/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20181220203305-927f97764cc3/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-golang.org/x/net v0.0.0-20190108225652-1e06a53dbb7e/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
-golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190522155817-f3200d17e092/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks=
-golang.org/x/net v0.0.0-20190501004415-9ce7a6920f09/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190923162816-aa69164e4478 h1:l5EDrHhldLYb3ZRHDUhXF7Om7MvYXnkV9/iQNo1lX6g=
-golang.org/x/net v0.0.0-20190503192946-f4e77d36d62c/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190923162816-aa69164e4478/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20190603091049-60506f45cf65/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks=
-golang.org/x/net v0.0.0-20190613194153-d28f0bde5980/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20200520004742-59133d7f0dd7/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
-golang.org/x/net v0.0.0-20200625001655-4c5254603344/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
-golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
-golang.org/x/net v0.0.0-20201202161906-c7110b5ffcbb h1:eBmm0M9fYhWpKZLjQUUKka/LtIxf46G4fxeEz5KJr9U=
-golang.org/x/net v0.0.0-20201202161906-c7110b5ffcbb/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
-golang.org/x/net v0.0.0-20210428140749-89ef3d95e781/go.mod h1:OJAsFXCWl8Ukc7SiCT/9KSuxbyM7479/AVlXFRxuMCk=
 golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
-golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
-golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
 golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20190227155943-e225da77a7e6/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20201207232520-09787c993a3a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sys v0.0.0-20180823144017-11551d06cbcc/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20181026203630-95b1ffbd15a5/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20181107165924-66b7b1311ac8/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20181116152217-5ac8a444bdc5/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20181205085412-a5c9d58dba9a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20190222072716-a9d3bda3a223/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20191010194322-b09406accb47/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190312061237-fead79001313/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191204072324-ce4227a45e2e h1:9vRrk9YW2BTzLP0VCB9ZDjU4cPqkg+IDWL7XgxA1yxQ=
-golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191204072324-ce4227a45e2e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190422165155-953cdadca894/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190502145724-3ef323f4f1fd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190507160741-ecd444e8653b/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190606165138-5da285871e9c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190624142023-c5567b49c5d0/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190904154756-749cb33beabd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20191005200804-aed5e4c7ecf9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20191120155948-bd437916bb0e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200106162015-b016eb3dc98e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200615200032-f1bc736245b1/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200625212154-ddb9806d33ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210112080510-489259a85091 h1:DMyOG0U+gKfu8JZzg2UQe9MeaC1X+xQWlAKcRnjxjCw=
-golang.org/x/sys v0.0.0-20210112080510-489259a85091/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210124154548-22da62e12c0c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210603081109-ebe580a85c40 h1:JWgyZ1qgdTaF3N3oxC+MdTV7qvEEgHo3otj+HB5CM7Q=
-golang.org/x/sys v0.0.0-20210603081109-ebe580a85c40/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
-golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/text v0.3.2 h1:tW2bmiBqwgJj/UpqtC8EpXEZVYOwU0yG4iWbprSVAcs=
 golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
-golang.org/x/text v0.3.3 h1:cokOdA+Jmi5PJGXLlLllQSgYigAEfHXJAERHVMaCc2k=
-golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
-golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
-golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
-golang.org/x/time v0.0.0-20190308202827-9d24e82272b4 h1:SvFZT6jyqRaOeXpc5h/JSfZenJ2O330aBsf7JfSUXmQ=
 golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/tools v0.0.0-20180221164845-07fd8470d635/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
-golang.org/x/tools v0.0.0-20190226205152-f727befe758c/go.mod h1:9Yl7xja0Znq3iFh3HoIrodX9oNMXvdceNzlUR8zjMvY=
 golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
-golang.org/x/tools v0.0.0-20190312151545-0bb0c0a6e846/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
-golang.org/x/tools v0.0.0-20190312170243-e65039ee4138/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
 golang.org/x/tools v0.0.0-20190328211700-ab21143f2384/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
-golang.org/x/tools v0.0.0-20190425150028-36563e24a262/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4=
-golang.org/x/tools v0.0.0-20190506145303-2d16b83fe98c/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
-golang.org/x/tools v0.0.0-20190524140312-2c0ae7006135/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
-golang.org/x/tools v0.0.0-20190606124116-d0a3d012864b/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc=
-golang.org/x/tools v0.0.0-20190621195816-6e04913cbbac/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc=
-golang.org/x/tools v0.0.0-20190628153133-6cdbf07be9d0/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc=
-golang.org/x/tools v0.0.0-20190816200558-6889da9d5479/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.0.0-20190911174233-4f2ddba30aff/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.0.0-20191012152004-8de300cfc20a/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.0.0-20191112195655-aa38f8e97acc/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.0.0-20201224043029-2b0845dc783e/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
-golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 h1:go1bK/D/BFZV2I8cIQd1NKEZ+0owSTG1fDTci4IqFcE=
-golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-google.golang.org/api v0.4.0/go.mod h1:8k5glujaEP+g9n7WNsDg8QP6cUVNI86fCNMcbazEtwE=
-google.golang.org/api v0.7.0/go.mod h1:WtwebWUNSVBH/HAw79HIFXZNqEvBhG+Ra+ax0hx3E3M=
-google.golang.org/api v0.8.0/go.mod h1:o4eAsZoiT+ibD93RtjEohWalFOjRDx6CVaqeizhEnKg=
-google.golang.org/api v0.9.0/go.mod h1:o4eAsZoiT+ibD93RtjEohWalFOjRDx6CVaqeizhEnKg=
-google.golang.org/api v0.13.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI=
 google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM=
-google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
-google.golang.org/appengine v1.5.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
-google.golang.org/appengine v1.6.1/go.mod h1:i06prIuMbXzDqacNJfV5OdTW448YApPu5ww/cMBSeb0=
 google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc=
-google.golang.org/genproto v0.0.0-20190307195333-5fe7a883aa19/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
-google.golang.org/genproto v0.0.0-20190418145605-e7d98fc518a7/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
-google.golang.org/genproto v0.0.0-20190425155659-357c62f0e4bb/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
-google.golang.org/genproto v0.0.0-20190502173448-54afdca5d873/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
-google.golang.org/genproto v0.0.0-20190801165951-fa694d86fc64/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc=
-google.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc=
-google.golang.org/genproto v0.0.0-20190911173649-1774047e7e51/go.mod h1:IbNlFCBrqXvoKpeg0TB2l7cyZUmoaFKYIwrEpbDKLA8=
-google.golang.org/genproto v0.0.0-20191108220845-16a3f7862a1a/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
-google.golang.org/genproto v0.0.0-20200526211855-cb27e3aa2013/go.mod h1:NbSheEEYHJ7i3ixzK3sjbqSGDJWnxyFXZblF3eUsNvo=
 google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c=
-google.golang.org/grpc v1.20.1/go.mod h1:10oTOabMzJvdu6/UiuZezV6QK5dSlG84ov/aaiqXj38=
+google.golang.org/grpc v1.21.0/go.mod h1:oYelfM1adQP15Ek0mdvEgi9Df8B9CZIaU1084ijfRaM=
-google.golang.org/grpc v1.21.1/go.mod h1:oYelfM1adQP15Ek0mdvEgi9Df8B9CZIaU1084ijfRaM=
-google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg=
-google.golang.org/grpc v1.27.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk=
-google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8=
-google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0=
-google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM=
-google.golang.org/protobuf v1.20.1-0.20200309200217-e05f789c0967/go.mod h1:A+miEFZTKqfCUM6K7xSMQL9OKL/b6hQv+e19PK+JZNE=
-google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo=
-google.golang.org/protobuf v1.22.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
-google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
-google.golang.org/protobuf v1.23.1-0.20200526195155-81db48ad09cc/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
-google.golang.org/protobuf v1.25.0 h1:Ejskq+SyPohKW+1uil0JJMtmHCgJPJ/qWTxr8qp+R4c=
-google.golang.org/protobuf v1.25.0/go.mod h1:9JNX74DMeImyA3h4bdi1ymwjUzf21/xIlbajtzgsN7c=
-google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=
-google.golang.org/protobuf v1.26.0 h1:bxAC2xTBsZGibn2RTntX0oH50xLsqy1OxA9tTL3p/lk=
-google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
 gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15 h1:YR8cESwS4TdDjEe65xsg0ogRM/Nc3DYOhEAlW+xobZo=
 gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI=
+gopkg.in/fsnotify.v1 v1.4.7 h1:xOHLXZwVvI9hhs+cLKq5+I5onOuwQLhQwiu63xxlHs4=
 gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys=
 gopkg.in/ini.v1 v1.51.0 h1:AQvPpx3LzTDM0AjnIRlVFwFFGC+npRopjZxLJj6gdno=
 gopkg.in/ini.v1 v1.51.0/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k=
@@ -477,16 +194,6 @@ gopkg.in/yaml.v2 v2.0.0-20170812160011-eb3733d160e7/go.mod h1:JAlM8MvJe8wmxCU4Bl
 gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v2 v2.2.5/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.2.7 h1:VUgggvou5XRW9mHwD/yXxIYSMtY0zoKQf/v226p2nyo=
-gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.2.7/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v2 v2.3.0 h1:clyUAQHOM3G0M3f5vQj7LuJrETvjVot3Z5el9nffUtU=
-gopkg.in/yaml.v2 v2.3.0/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
-gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c h1:dUUwHk2QECo/6vqA44rthZ8ie2QXMNeKRTHCNY2nXvo=
-gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
-honnef.co/go/tools v0.0.0-20190106161140-3f1c8253044a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
-honnef.co/go/tools v0.0.0-20190418001031-e561f6794a2a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
-honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
-honnef.co/go/tools v0.0.1-2019.2.3/go.mod h1:a3bituU0lyd329TUQxRnasdCoJDkEUEAqEt0JzvZhAg=
-rsc.io/binaryregexp v0.2.0/go.mod h1:qTv7/COck+e2FymRvadv62gMdZztPaShugOCi3I+8D8=

tools/metrics_exporter/main.go

@@ -1,56 +0,0 @@
-package main
-
-import (
-	"flag"
-	"fmt"
-	"log"
-	"net/http"
-
-	"github.com/hibiken/asynq"
-	"github.com/hibiken/asynq/x/metrics"
-	"github.com/prometheus/client_golang/prometheus"
-	"github.com/prometheus/client_golang/prometheus/collectors"
-	"github.com/prometheus/client_golang/prometheus/promhttp"
-)
-
-// Declare command-line flags.
-// These variables are binded to flags in init().
-var (
-	flagRedisAddr     string
-	flagRedisDB       int
-	flagRedisPassword string
-	flagRedisUsername string
-	flagPort          int
-)
-
-func init() {
-	flag.StringVar(&flagRedisAddr, "redis-addr", "127.0.0.1:6379", "host:port of redis server to connect to")
-	flag.IntVar(&flagRedisDB, "redis-db", 0, "redis DB number to use")
-	flag.StringVar(&flagRedisPassword, "redis-password", "", "password used to connect to redis server")
-	flag.StringVar(&flagRedisUsername, "redis-username", "", "username used to connect to redis server")
-	flag.IntVar(&flagPort, "port", 9876, "port to use for the HTTP server")
-}
-
-func main() {
-	flag.Parse()
-	// Using NewPedanticRegistry here to test the implementation of Collectors and Metrics.
-	reg := prometheus.NewPedanticRegistry()
-
-	inspector := asynq.NewInspector(asynq.RedisClientOpt{
-		Addr:     flagRedisAddr,
-		DB:       flagRedisDB,
-		Password: flagRedisPassword,
-		Username: flagRedisUsername,
-	})
-
-	reg.MustRegister(
-		metrics.NewQueueMetricsCollector(inspector),
-		// Add the standard process and go metrics to the registry
-		collectors.NewProcessCollector(collectors.ProcessCollectorOpts{}),
-		collectors.NewGoCollector(),
-	)
-
-	http.Handle("/metrics", promhttp.HandlerFor(reg, promhttp.HandlerOpts{}))
-	log.Printf("exporter server is listening on port: %d\n", flagPort)
-	log.Fatal(http.ListenAndServe(fmt.Sprintf(":%d", flagPort), nil))
-}

x/go.mod

@@ -1,12 +0,0 @@
-module github.com/hibiken/asynq/x
-
-go 1.16
-
-require (
-	github.com/go-redis/redis/v8 v8.11.4
-	github.com/google/uuid v1.3.0
-	github.com/hibiken/asynq v0.19.0
-	github.com/prometheus/client_golang v1.11.0
-)
-
-replace github.com/hibiken/asynq => ./..

x/go.sum

@@ -1,256 +0,0 @@
-cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
-cloud.google.com/go v0.34.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
-github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
-github.com/alecthomas/template v0.0.0-20160405071501-a0175ee3bccc/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc=
-github.com/alecthomas/template v0.0.0-20190718012654-fb15b899a751/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc=
-github.com/alecthomas/units v0.0.0-20151022065526-2efee857e7cf/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0=
-github.com/alecthomas/units v0.0.0-20190717042225-c3de453c63f4/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0=
-github.com/alecthomas/units v0.0.0-20190924025748-f65c72e2690d/go.mod h1:rBZYJk541a8SKzHPHnH3zbiI+7dagKZ0cgpgrD7Fyho=
-github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q=
-github.com/beorn7/perks v1.0.0/go.mod h1:KWe93zE9D1o94FZ5RNwFwVgaQK1VOXiVxmqh+CedLV8=
-github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM=
-github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw=
-github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU=
-github.com/cespare/xxhash/v2 v2.1.1/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
-github.com/cespare/xxhash/v2 v2.1.2 h1:YRXhKfTDauu4ajMg1TPgFO5jnlC2HCbmLXMcTG5cbYE=
-github.com/cespare/xxhash/v2 v2.1.2/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
-github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw=
-github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
-github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f h1:lO4WD4F/rVNCu3HqELle0jiPLLBs70cWOduZpkS1E78=
-github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f/go.mod h1:cuUVRXasLTGF7a8hSLbxyZXjz+1KgoB3wDUb6vlszIc=
-github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
-github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c=
-github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
-github.com/fsnotify/fsnotify v1.4.9 h1:hsms1Qyu0jgnwNXIxa+/V/PDsU6CfLf6CNO8H7IWoS4=
-github.com/fsnotify/fsnotify v1.4.9/go.mod h1:znqG4EE+3YCdAaPaxE2ZRY/06pZUdp0tY4IgpuI1SZQ=
-github.com/go-kit/kit v0.8.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as=
-github.com/go-kit/kit v0.9.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as=
-github.com/go-kit/log v0.1.0/go.mod h1:zbhenjAZHb184qTLMA9ZjW7ThYL0H2mk7Q6pNt4vbaY=
-github.com/go-logfmt/logfmt v0.3.0/go.mod h1:Qt1PoO58o5twSAckw1HlFXLmHsOX5/0LbT9GBnD5lWE=
-github.com/go-logfmt/logfmt v0.4.0/go.mod h1:3RMwSq7FuexP4Kalkev3ejPJsZTpXXBr9+V4qmtdjCk=
-github.com/go-logfmt/logfmt v0.5.0/go.mod h1:wCYkCAKZfumFQihp8CzCvQ3paCTfi41vtzG1KdI/P7A=
-github.com/go-redis/redis/v8 v8.11.2/go.mod h1:DLomh7y2e3ggQXQLd1YgmvIfecPJoFl7WU5SOQ/r06M=
-github.com/go-redis/redis/v8 v8.11.4 h1:kHoYkfZP6+pe04aFTnhDH6GDROa5yJdHJVNxV3F46Tg=
-github.com/go-redis/redis/v8 v8.11.4/go.mod h1:2Z2wHZXdQpCDXEGzqMockDpNyYvi2l4Pxt6RJr792+w=
-github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY=
-github.com/go-task/slim-sprig v0.0.0-20210107165309-348f09dbbbc0/go.mod h1:fyg7847qk6SyHyPtNmDHnmrv/HOrqktSC+C9fM+CJOE=
-github.com/gogo/protobuf v1.1.1/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ=
-github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q=
-github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
-github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
-github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
-github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
-github.com/golang/protobuf v1.4.0-rc.1/go.mod h1:ceaxUfeHdC40wWswd/P6IGgMaK3YpKi5j83Wpe3EHw8=
-github.com/golang/protobuf v1.4.0-rc.1.0.20200221234624-67d41d38c208/go.mod h1:xKAWHe0F5eneWXFV3EuXVDTCmh+JuBKY0li0aMyXATA=
-github.com/golang/protobuf v1.4.0-rc.2/go.mod h1:LlEzMj4AhA7rCAGe4KMBDvJI+AwstrUpVNzEA03Pprs=
-github.com/golang/protobuf v1.4.0-rc.4.0.20200313231945-b860323f09d0/go.mod h1:WU3c8KckQ9AFe+yFwt9sWVRKCVIyN9cPHBJSNnbL67w=
-github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvqG2KuDX0=
-github.com/golang/protobuf v1.4.1/go.mod h1:U8fpvMrcmy5pZrNK1lt4xCsGvpyWQ/VVv6QDs8UjoX8=
-github.com/golang/protobuf v1.4.2/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
-github.com/golang/protobuf v1.4.3/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
-github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk=
-github.com/golang/protobuf v1.5.2 h1:ROPKBNFfQgOUMifHyP+KYbvpjbdoFNs+aK7DXlji0Tw=
-github.com/golang/protobuf v1.5.2/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY=
-github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M=
-github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
-github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
-github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/google/go-cmp v0.5.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ=
-github.com/google/go-cmp v0.5.6/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
-github.com/google/uuid v1.2.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
-github.com/google/uuid v1.3.0 h1:t6JiXgmwXMjEs8VusXIJk2BXHsn+wx8BZdTaoZ5fu7I=
-github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
-github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU=
-github.com/jpillora/backoff v1.0.0/go.mod h1:J/6gKK9jxlEcS3zixgDgUAsiuZ7yrSoa/FX5e0EB2j4=
-github.com/json-iterator/go v1.1.6/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCVDaaPEHmU=
-github.com/json-iterator/go v1.1.10/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
-github.com/json-iterator/go v1.1.11/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
-github.com/julienschmidt/httprouter v1.2.0/go.mod h1:SYymIcj16QtmaHHD7aYtjjsJG7VTCxuUUipMqKk8s4w=
-github.com/julienschmidt/httprouter v1.3.0/go.mod h1:JR6WtHb+2LUe8TCKY3cZOxFyyO8IZAc4RVcycCCAKdM=
-github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
-github.com/konsorten/go-windows-terminal-sequences v1.0.3/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
-github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515/go.mod h1:+0opPa2QZZtGFBFZlji/RkVcI2GknAs/DXo4wKdlNEc=
-github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
-github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
-github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
-github.com/matttproud/golang_protobuf_extensions v1.0.1 h1:4hp9jkHxhMHkqkrB3Ix0jegS5sx/RkqARlsWZ6pIwiU=
-github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0=
-github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
-github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
-github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
-github.com/modern-go/reflect2 v1.0.1/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
-github.com/mwitkow/go-conntrack v0.0.0-20161129095857-cc309e4a2223/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U=
-github.com/mwitkow/go-conntrack v0.0.0-20190716064945-2f068394615f/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U=
-github.com/nxadm/tail v1.4.4/go.mod h1:kenIhsEOeOJmVchQTgglprH7qJGnHDVpk1VPCcaMI8A=
-github.com/nxadm/tail v1.4.8 h1:nPr65rt6Y5JFSKQO7qToXr7pePgD6Gwiw05lkbyAQTE=
-github.com/nxadm/tail v1.4.8/go.mod h1:+ncqLTQzXmGhMZNUePPaPqPvBxHAIsmXswZKocGu+AU=
-github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
-github.com/onsi/ginkgo v1.12.1/go.mod h1:zj2OWP4+oCPe1qIXoGWkgMRwljMUYCdkwsT2108oapk=
-github.com/onsi/ginkgo v1.15.0/go.mod h1:hF8qUzuuC8DJGygJH3726JnCZX4MYbRB8yFfISqnKUg=
-github.com/onsi/ginkgo v1.16.4 h1:29JGrr5oVBm5ulCWet69zQkzWipVXIol6ygQUe/EzNc=
-github.com/onsi/ginkgo v1.16.4/go.mod h1:dX+/inL/fNMqNlz0e9LfyB9TswhZpCVdJM/Z6Vvnwo0=
-github.com/onsi/gomega v1.7.1/go.mod h1:XdKZgCCFLUoM/7CFJVPcG8C1xQ1AJ0vpAezJrB7JYyY=
-github.com/onsi/gomega v1.10.1/go.mod h1:iN09h71vgCQne3DLsj+A5owkum+a2tYe+TOCB1ybHNo=
-github.com/onsi/gomega v1.10.5/go.mod h1:gza4q3jKQJijlu05nKWRCW/GavJumGt8aNRxWg7mt48=
-github.com/onsi/gomega v1.16.0 h1:6gjqkI8iiRHMvdccRJM8rVKjCWk6ZIm6FTm3ddIe4/c=
-github.com/onsi/gomega v1.16.0/go.mod h1:HnhC7FXeEQY45zxNK3PPoIUhzk/80Xly9PcubAlGdZY=
-github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
-github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
-github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
-github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
-github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/prometheus/client_golang v0.9.1/go.mod h1:7SWBe2y4D6OKWSNQJUaRYU/AaXPKyh/dDVn+NZz0KFw=
-github.com/prometheus/client_golang v1.0.0/go.mod h1:db9x61etRT2tGnBNRi70OPL5FsnadC4Ky3P0J6CfImo=
-github.com/prometheus/client_golang v1.7.1/go.mod h1:PY5Wy2awLA44sXw4AOSfFBetzPP4j5+D6mVACh+pe2M=
-github.com/prometheus/client_golang v1.11.0 h1:HNkLOAEQMIDv/K+04rukrLx6ch7msSRwf3/SASFAGtQ=
-github.com/prometheus/client_golang v1.11.0/go.mod h1:Z6t4BnS23TR94PD6BsDNk8yVqroYurpAkEiz0P2BEV0=
-github.com/prometheus/client_model v0.0.0-20180712105110-5c3871d89910/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo=
-github.com/prometheus/client_model v0.0.0-20190129233127-fd36f4220a90/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
-github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
-github.com/prometheus/client_model v0.2.0 h1:uq5h0d+GuxiXLJLNABMgp2qUWDPiLvgCzz2dUR+/W/M=
-github.com/prometheus/client_model v0.2.0/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
-github.com/prometheus/common v0.4.1/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4=
-github.com/prometheus/common v0.10.0/go.mod h1:Tlit/dnDKsSWFlCLTWaA1cyBgKHSMdTB80sz/V91rCo=
-github.com/prometheus/common v0.26.0 h1:iMAkS2TDoNWnKM+Kopnx/8tnEStIfpYA0ur0xQzzhMQ=
-github.com/prometheus/common v0.26.0/go.mod h1:M7rCNAaPfAosfx8veZJCuw84e35h3Cfd9VFqTh1DIvc=
-github.com/prometheus/procfs v0.0.0-20181005140218-185b4288413d/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
-github.com/prometheus/procfs v0.0.2/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsTZCD3I8kEA=
-github.com/prometheus/procfs v0.1.3/go.mod h1:lV6e/gmhEcM9IjHGsFOCxxuZ+z1YqCvr4OA4YeYWdaU=
-github.com/prometheus/procfs v0.6.0 h1:mxy4L2jP6qMonqmq+aTtOx1ifVWUgG/TAmntgbh3xv4=
-github.com/prometheus/procfs v0.6.0/go.mod h1:cz+aTbrPOrUb4q7XlbU9ygM+/jj0fzG6c1xBZuNvfVA=
-github.com/robfig/cron/v3 v3.0.1 h1:WdRxkvbJztn8LMz/QEvLN5sBU+xKpSqwwUO1Pjr4qDs=
-github.com/robfig/cron/v3 v3.0.1/go.mod h1:eQICP3HwyT7UooqI/z+Ov+PtYAWygg1TEWWzGIFLtro=
-github.com/sirupsen/logrus v1.2.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPxbbu5VWo=
-github.com/sirupsen/logrus v1.4.2/go.mod h1:tLMulIdttU9McNUspp0xgXVQah82FyeX6MwdIuYE2rE=
-github.com/sirupsen/logrus v1.6.0/go.mod h1:7uNnSEd1DgxDLC74fIahvMZmmYsHGZGEOFrfsX/uA88=
-github.com/spf13/cast v1.3.1 h1:nFm6S0SMdyzrzcmThSipiEubIDy8WEXKNZ0UOgiRpng=
-github.com/spf13/cast v1.3.1/go.mod h1:Qx5cxh0v+4UWYiBimWS+eyWzqEqokIECu5etghLkUJE=
-github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
-github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
-github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
-github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA=
-github.com/stretchr/testify v1.6.1 h1:hDPOHmpOpP40lSULcqw7IrRb/u7w6RpDC9399XyoNd0=
-github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
-go.uber.org/goleak v0.10.0 h1:G3eWbSNIskeRqtsN/1uI5B+eP73y3JUuBsv9AZjehb4=
-go.uber.org/goleak v0.10.0/go.mod h1:VCZuO8V8mFPlL0F5J5GK1rtHV3DrFcQ1R8ryq7FK0aI=
-golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
-golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
-golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
-golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
-golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
-golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
-golang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvxsM5YxQ5yQlVC4a0KAMCusXpPoU=
-golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
-golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
-golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-golang.org/x/net v0.0.0-20181114220301-adae6a3d119a/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-golang.org/x/net v0.0.0-20190108225652-1e06a53dbb7e/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
-golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
-golang.org/x/net v0.0.0-20190613194153-d28f0bde5980/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20200520004742-59133d7f0dd7/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
-golang.org/x/net v0.0.0-20200625001655-4c5254603344/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
-golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
-golang.org/x/net v0.0.0-20201202161906-c7110b5ffcbb/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
-golang.org/x/net v0.0.0-20210428140749-89ef3d95e781 h1:DzZ89McO9/gWPsQXS/FVKAlG02ZjaQ6AlZRBimEYOd0=
-golang.org/x/net v0.0.0-20210428140749-89ef3d95e781/go.mod h1:OJAsFXCWl8Ukc7SiCT/9KSuxbyM7479/AVlXFRxuMCk=
-golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
-golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
-golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20201207232520-09787c993a3a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20181116152217-5ac8a444bdc5/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190422165155-953cdadca894/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190904154756-749cb33beabd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20191005200804-aed5e4c7ecf9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20191120155948-bd437916bb0e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200106162015-b016eb3dc98e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200615200032-f1bc736245b1/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200625212154-ddb9806d33ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210112080510-489259a85091/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210124154548-22da62e12c0c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210603081109-ebe580a85c40 h1:JWgyZ1qgdTaF3N3oxC+MdTV7qvEEgHo3otj+HB5CM7Q=
-golang.org/x/sys v0.0.0-20210603081109-ebe580a85c40/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
-golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
-golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
-golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
-golang.org/x/text v0.3.6 h1:aRYxNxv6iGQlyVaZmk6ZgYEDa+Jg18DxebPSrd6bg1M=
-golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
-golang.org/x/time v0.0.0-20190308202827-9d24e82272b4 h1:SvFZT6jyqRaOeXpc5h/JSfZenJ2O330aBsf7JfSUXmQ=
-golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
-golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
-golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
-golang.org/x/tools v0.0.0-20190226205152-f727befe758c/go.mod h1:9Yl7xja0Znq3iFh3HoIrodX9oNMXvdceNzlUR8zjMvY=
-golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
-golang.org/x/tools v0.0.0-20190524140312-2c0ae7006135/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
-golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.0.0-20201224043029-2b0845dc783e/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
-golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 h1:go1bK/D/BFZV2I8cIQd1NKEZ+0owSTG1fDTci4IqFcE=
-golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM=
-google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
-google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc=
-google.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc=
-google.golang.org/genproto v0.0.0-20200526211855-cb27e3aa2013/go.mod h1:NbSheEEYHJ7i3ixzK3sjbqSGDJWnxyFXZblF3eUsNvo=
-google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c=
-google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg=
-google.golang.org/grpc v1.27.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk=
-google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8=
-google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0=
-google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM=
-google.golang.org/protobuf v1.20.1-0.20200309200217-e05f789c0967/go.mod h1:A+miEFZTKqfCUM6K7xSMQL9OKL/b6hQv+e19PK+JZNE=
-google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo=
-google.golang.org/protobuf v1.22.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
-google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
-google.golang.org/protobuf v1.23.1-0.20200526195155-81db48ad09cc/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
-google.golang.org/protobuf v1.25.0/go.mod h1:9JNX74DMeImyA3h4bdi1ymwjUzf21/xIlbajtzgsN7c=
-google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=
-google.golang.org/protobuf v1.26.0 h1:bxAC2xTBsZGibn2RTntX0oH50xLsqy1OxA9tTL3p/lk=
-google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
-gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw=
-gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys=
-gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 h1:uRGJdciOHaEIrze2W8Q3AKkepLTh2hOroT7a+7czfdQ=
-gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw=
-gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v2 v2.2.5/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v2 v2.3.0/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY=
-gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
-gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c h1:dUUwHk2QECo/6vqA44rthZ8ie2QXMNeKRTHCNY2nXvo=
-gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
-honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
-honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=

x/metrics/metrics.go

@@ -1,190 +0,0 @@
-// Package metrics provides implementations of prometheus.Collector to collect Asynq queue metrics.
-package metrics
-
-import (
-	"fmt"
-	"log"
-
-	"github.com/hibiken/asynq"
-	"github.com/prometheus/client_golang/prometheus"
-)
-
-// Namespace used in fully-qualified metrics names.
-const namespace = "asynq"
-
-// QueueMetricsCollector gathers queue metrics.
-// It implements prometheus.Collector interface.
-//
-// All metrics exported from this collector have prefix "asynq".
-type QueueMetricsCollector struct {
-	inspector *asynq.Inspector
-}
-
-// collectQueueInfo gathers QueueInfo of all queues.
-// Since this operation is expensive, it must be called once per collection.
-func (qmc *QueueMetricsCollector) collectQueueInfo() ([]*asynq.QueueInfo, error) {
-	qnames, err := qmc.inspector.Queues()
-	if err != nil {
-		return nil, fmt.Errorf("failed to get queue names: %v", err)
-	}
-	infos := make([]*asynq.QueueInfo, len(qnames))
-	for i, qname := range qnames {
-		qinfo, err := qmc.inspector.GetQueueInfo(qname)
-		if err != nil {
-			return nil, fmt.Errorf("failed to get queue info: %v", err)
-		}
-		infos[i] = qinfo
-	}
-	return infos, nil
-}
-
-// Descriptors used by QueueMetricsCollector
-var (
-	tasksQueuedDesc = prometheus.NewDesc(
-		prometheus.BuildFQName(namespace, "", "tasks_enqueued_total"),
-		"Number of tasks enqueued; broken down by queue and state.",
-		[]string{"queue", "state"}, nil,
-	)
-
-	queueSizeDesc = prometheus.NewDesc(
-		prometheus.BuildFQName(namespace, "", "queue_size"),
-		"Number of tasks in a queue",
-		[]string{"queue"}, nil,
-	)
-
-	queueLatencyDesc = prometheus.NewDesc(
-		prometheus.BuildFQName(namespace, "", "queue_latency_seconds"),
-		"Number of seconds the oldest pending task is waiting in pending state to be processed.",
-		[]string{"queue"}, nil,
-	)
-
-	queueMemUsgDesc = prometheus.NewDesc(
-		prometheus.BuildFQName(namespace, "", "queue_memory_usage_approx_bytes"),
-		"Number of memory used by a given queue (approximated number by sampling).",
-		[]string{"queue"}, nil,
-	)
-
-	tasksProcessedTotalDesc = prometheus.NewDesc(
-		prometheus.BuildFQName(namespace, "", "tasks_processed_total"),
-		"Number of tasks processed (both succeeded and failed); broken down by queue",
-		[]string{"queue"}, nil,
-	)
-
-	tasksFailedTotalDesc = prometheus.NewDesc(
-		prometheus.BuildFQName(namespace, "", "tasks_failed_total"),
-		"Number of tasks failed; broken down by queue",
-		[]string{"queue"}, nil,
-	)
-
-	pausedQueues = prometheus.NewDesc(
-		prometheus.BuildFQName(namespace, "", "queue_paused_total"),
-		"Number of queues paused",
-		[]string{"queue"}, nil,
-	)
-)
-
-func (qmc *QueueMetricsCollector) Describe(ch chan<- *prometheus.Desc) {
-	prometheus.DescribeByCollect(qmc, ch)
-}
-
-func (qmc *QueueMetricsCollector) Collect(ch chan<- prometheus.Metric) {
-	queueInfos, err := qmc.collectQueueInfo()
-	if err != nil {
-		log.Printf("Failed to collect metrics data: %v", err)
-	}
-	for _, info := range queueInfos {
-		ch <- prometheus.MustNewConstMetric(
-			tasksQueuedDesc,
-			prometheus.GaugeValue,
-			float64(info.Active),
-			info.Queue,
-			"active",
-		)
-		ch <- prometheus.MustNewConstMetric(
-			tasksQueuedDesc,
-			prometheus.GaugeValue,
-			float64(info.Pending),
-			info.Queue,
-			"pending",
-		)
-		ch <- prometheus.MustNewConstMetric(
-			tasksQueuedDesc,
-			prometheus.GaugeValue,
-			float64(info.Scheduled),
-			info.Queue,
-			"scheduled",
-		)
-		ch <- prometheus.MustNewConstMetric(
-			tasksQueuedDesc,
-			prometheus.GaugeValue,
-			float64(info.Retry),
-			info.Queue,
-			"retry",
-		)
-		ch <- prometheus.MustNewConstMetric(
-			tasksQueuedDesc,
-			prometheus.GaugeValue,
-			float64(info.Archived),
-			info.Queue,
-			"archived",
-		)
-		ch <- prometheus.MustNewConstMetric(
-			tasksQueuedDesc,
-			prometheus.GaugeValue,
-			float64(info.Completed),
-			info.Queue,
-			"completed",
-		)
-
-		ch <- prometheus.MustNewConstMetric(
-			queueSizeDesc,
-			prometheus.GaugeValue,
-			float64(info.Size),
-			info.Queue,
-		)
-
-		ch <- prometheus.MustNewConstMetric(
-			queueLatencyDesc,
-			prometheus.GaugeValue,
-			info.Latency.Seconds(),
-			info.Queue,
-		)
-
-		ch <- prometheus.MustNewConstMetric(
-			queueMemUsgDesc,
-			prometheus.GaugeValue,
-			float64(info.MemoryUsage),
-			info.Queue,
-		)
-
-		ch <- prometheus.MustNewConstMetric(
-			tasksProcessedTotalDesc,
-			prometheus.CounterValue,
-			float64(info.ProcessedTotal),
-			info.Queue,
-		)
-
-		ch <- prometheus.MustNewConstMetric(
-			tasksFailedTotalDesc,
-			prometheus.CounterValue,
-			float64(info.FailedTotal),
-			info.Queue,
-		)
-
-		pausedValue := 0 // zero to indicate "not paused"
-		if info.Paused {
-			pausedValue = 1
-		}
-		ch <- prometheus.MustNewConstMetric(
-			pausedQueues,
-			prometheus.GaugeValue,
-			float64(pausedValue),
-			info.Queue,
-		)
-	}
-}
-
-// NewQueueMetricsCollector returns a collector that exports metrics about Asynq queues.
-func NewQueueMetricsCollector(inspector *asynq.Inspector) *QueueMetricsCollector {
-	return &QueueMetricsCollector{inspector: inspector}
-}

x/rate/example_test.go

@@ -1,40 +0,0 @@
-package rate_test
-
-import (
-	"context"
-	"fmt"
-	"time"
-
-	"github.com/hibiken/asynq"
-	"github.com/hibiken/asynq/x/rate"
-)
-
-type RateLimitError struct {
-	RetryIn time.Duration
-}
-
-func (e *RateLimitError) Error() string {
-	return fmt.Sprintf("rate limited (retry in  %v)", e.RetryIn)
-}
-
-func ExampleNewSemaphore() {
-	redisConnOpt := asynq.RedisClientOpt{Addr: ":6379"}
-	sema := rate.NewSemaphore(redisConnOpt, "my_queue", 10)
-	// call sema.Close() when appropriate
-
-	_ = asynq.HandlerFunc(func(ctx context.Context, task *asynq.Task) error {
-		ok, err := sema.Acquire(ctx)
-		if err != nil {
-			return err
-		}
-		if !ok {
-			return &RateLimitError{RetryIn: 30 * time.Second}
-		}
-
-		// Make sure to release the token once we're done.
-		defer sema.Release(ctx)
-
-		// Process task
-		return nil
-	})
-}

x/rate/semaphore.go

@@ -1,114 +0,0 @@
-// Package rate contains rate limiting strategies for asynq.Handler(s).
-package rate
-
-import (
-	"context"
-	"fmt"
-	"strings"
-	"time"
-
-	"github.com/go-redis/redis/v8"
-	"github.com/hibiken/asynq"
-	asynqcontext "github.com/hibiken/asynq/internal/context"
-)
-
-// NewSemaphore creates a counting Semaphore for the given scope with the given number of tokens.
-func NewSemaphore(rco asynq.RedisConnOpt, scope string, maxTokens int) *Semaphore {
-	rc, ok := rco.MakeRedisClient().(redis.UniversalClient)
-	if !ok {
-		panic(fmt.Sprintf("rate.NewSemaphore: unsupported RedisConnOpt type %T", rco))
-	}
-
-	if maxTokens < 1 {
-		panic("rate.NewSemaphore: maxTokens cannot be less than 1")
-	}
-
-	if len(strings.TrimSpace(scope)) == 0 {
-		panic("rate.NewSemaphore: scope should not be empty")
-	}
-
-	return &Semaphore{
-		rc:        rc,
-		scope:     scope,
-		maxTokens: maxTokens,
-	}
-}
-
-// Semaphore is a distributed counting semaphore which can be used to set maxTokens across multiple asynq servers.
-type Semaphore struct {
-	rc        redis.UniversalClient
-	maxTokens int
-	scope     string
-}
-
-// KEYS[1] -> asynq:sema:<scope>
-// ARGV[1] -> max concurrency
-// ARGV[2] -> current time in unix time
-// ARGV[3] -> deadline in unix time
-// ARGV[4] -> task ID
-var acquireCmd = redis.NewScript(`
-redis.call("ZREMRANGEBYSCORE", KEYS[1], "-inf", tonumber(ARGV[2])-1)
-local count = redis.call("ZCARD", KEYS[1])
-
-if (count < tonumber(ARGV[1])) then
-     redis.call("ZADD", KEYS[1], ARGV[3], ARGV[4])
-     return 'true'
-else
-     return 'false'
-end
-`)
-
-// Acquire attempts to acquire a token from the semaphore.
-// - Returns (true, nil), iff semaphore key exists and current value is less than maxTokens
-// - Returns (false, nil) when token cannot be acquired
-// - Returns (false, error) otherwise
-//
-// The context.Context passed to Acquire must have a deadline set,
-// this ensures that token is released if the job goroutine crashes and does not call Release.
-func (s *Semaphore) Acquire(ctx context.Context) (bool, error) {
-	d, ok := ctx.Deadline()
-	if !ok {
-		return false, fmt.Errorf("provided context must have a deadline")
-	}
-
-	taskID, ok := asynqcontext.GetTaskID(ctx)
-	if !ok {
-		return false, fmt.Errorf("provided context is missing task ID value")
-	}
-
-	return acquireCmd.Run(ctx, s.rc,
-		[]string{semaphoreKey(s.scope)},
-		s.maxTokens,
-		time.Now().Unix(),
-		d.Unix(),
-		taskID,
-	).Bool()
-}
-
-// Release will release the token on the counting semaphore.
-func (s *Semaphore) Release(ctx context.Context) error {
-	taskID, ok := asynqcontext.GetTaskID(ctx)
-	if !ok {
-		return fmt.Errorf("provided context is missing task ID value")
-	}
-
-	n, err := s.rc.ZRem(ctx, semaphoreKey(s.scope), taskID).Result()
-	if err != nil {
-		return fmt.Errorf("redis command failed: %v", err)
-	}
-
-	if n == 0 {
-		return fmt.Errorf("no token found for task %q", taskID)
-	}
-
-	return nil
-}
-
-// Close closes the connection to redis.
-func (s *Semaphore) Close() error {
-	return s.rc.Close()
-}
-
-func semaphoreKey(scope string) string {
-	return fmt.Sprintf("asynq:sema:%s", scope)
-}