mirror of
https://github.com/hibiken/asynq.git
synced 2024-12-25 07:12:17 +08:00
104 lines
2.2 KiB
Go
104 lines
2.2 KiB
Go
package asynq
|
|
|
|
import (
|
|
"fmt"
|
|
"log"
|
|
"os"
|
|
"os/signal"
|
|
"sync"
|
|
"time"
|
|
|
|
"github.com/hibiken/asynq/internal/rdb"
|
|
)
|
|
|
|
// Background is a top-level entity for the background-task processing.
|
|
type Background struct {
|
|
mu sync.Mutex
|
|
running bool
|
|
|
|
rdb *rdb.RDB
|
|
poller *poller
|
|
processor *processor
|
|
}
|
|
|
|
// NewBackground returns a new Background instance.
|
|
func NewBackground(numWorkers int, config *RedisConfig) *Background {
|
|
r := rdb.NewRDB(newRedisClient(config))
|
|
poller := newPoller(r, 5*time.Second)
|
|
processor := newProcessor(r, numWorkers, nil)
|
|
return &Background{
|
|
rdb: r,
|
|
poller: poller,
|
|
processor: processor,
|
|
}
|
|
}
|
|
|
|
// A Handler processes a task.
|
|
//
|
|
// ProcessTask should return nil if the processing of a task
|
|
// is successful.
|
|
//
|
|
// If ProcessTask return a non-nil error or panics, the task
|
|
// will be retried after delay.
|
|
type Handler interface {
|
|
ProcessTask(*Task) error
|
|
}
|
|
|
|
// The HandlerFunc type is an adapter to allow the use of
|
|
// ordinary functions as a Handler. If f is a function
|
|
// with the appropriate signature, HandlerFunc(f) is a
|
|
// Handler that calls f.
|
|
type HandlerFunc func(*Task) error
|
|
|
|
// ProcessTask calls fn(task)
|
|
func (fn HandlerFunc) ProcessTask(task *Task) error {
|
|
return fn(task)
|
|
}
|
|
|
|
// 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 pending workers and other
|
|
// goroutines to process the tasks.
|
|
func (bg *Background) Run(handler Handler) {
|
|
bg.start(handler)
|
|
defer bg.stop()
|
|
|
|
// Wait for a signal to exit.
|
|
sigs := make(chan os.Signal, 1)
|
|
signal.Notify(sigs, os.Interrupt, os.Kill)
|
|
<-sigs
|
|
fmt.Println()
|
|
log.Println("[INFO] Starting graceful shutdown...")
|
|
}
|
|
|
|
// starts the background-task processing.
|
|
func (bg *Background) start(handler Handler) {
|
|
bg.mu.Lock()
|
|
defer bg.mu.Unlock()
|
|
if bg.running {
|
|
return
|
|
}
|
|
|
|
bg.running = true
|
|
bg.processor.handler = handler
|
|
|
|
bg.poller.start()
|
|
bg.processor.start()
|
|
}
|
|
|
|
// stops the background-task processing.
|
|
func (bg *Background) stop() {
|
|
bg.mu.Lock()
|
|
defer bg.mu.Unlock()
|
|
if !bg.running {
|
|
return
|
|
}
|
|
|
|
bg.poller.terminate()
|
|
bg.processor.terminate()
|
|
|
|
bg.rdb.Close()
|
|
bg.processor.handler = nil
|
|
bg.running = false
|
|
}
|