repo_description: Simple, reliable, and efficient distributed task queue in Go
repo_topics: asynchronous-tasks background-jobs go golang redis task-queue worker-pool
code: // 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 provides a framework for Redis based distrubted task queue.
  
  Asynq uses Redis as a message broker. To connect to redis,
  specify the connection using one of RedisConnOpt types.
  
  	redisConnOpt = asynq.RedisClientOpt{
  	    Addr:     "127.0.0.1:6379",
  	    Password: "xxxxx",
  	    DB:       2,
  	}
  
  The Client is used to enqueue a task.
  
  	client := asynq.NewClient(redisConnOpt)
  
  	// Task is created with two parameters: its type and payload.
  	// Payload data is simply an array of bytes. It can be encoded in JSON, Protocol Buffer, Gob, etc.
  	b, err := json.Marshal(ExamplePayload{UserID: 42})
  	if err != nil {
  	    log.Fatal(err)
  	}
  
  	task := asynq.NewTask("example", b)
  
  	// Enqueue the task to be processed immediately.
  	info, err := client.Enqueue(task)
  
  	// Schedule the task to be processed after one minute.
  	info, err = client.Enqueue(t, asynq.ProcessIn(1*time.Minute))
  
  The Server is used to run the task processing workers with a given
  handler.
  
  	srv := asynq.NewServer(redisConnOpt, asynq.Config{
  	    Concurrency: 10,
  	})
  
  	if err := srv.Run(handler); err != nil {
  	    log.Fatal(err)
  	}
  
  Handler is an interface type with a method which
  takes a task and returns an error. Handler should return nil if
  the processing is successful, otherwise return a non-nil error.
  If handler panics or returns a non-nil error, the task will be retried in the future.
  
  Example of a type that implements the Handler interface.
  
  	type TaskHandler struct {
  	    // ...
  	}
  
  	func (h *TaskHandler) ProcessTask(ctx context.Context, task *asynq.Task) error {
  	    switch task.Type {
  	    case "example":
  	        var data ExamplePayload
  	        if err := json.Unmarshal(task.Payload(), &data); err != nil {
  	            return err
  	        }
  	        // perform task with the data
  
  	    default:
  	        return fmt.Errorf("unexpected task type %q", task.Type)
  	    }
  	    return nil
  	}
  */
  package asynq
  