feat: rename task to job

internal/tasks/constants.go → internal/job/constants.go

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package tasks
+package job
 
 // Queue Name
 const (
@@ -23,7 +23,7 @@ const (
 	CDNsQueue       = Queue("cdns")
 )
 
-// Task Name
+// Job Name
 const (
-	PreheatTask = "preheat"
+	PreheatJob = "preheat"
 )

internal/tasks/tasks.go → internal/job/job.go

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package tasks
+package job
 
 import (
 	"encoding/json"
@@ -41,13 +41,13 @@ type Config struct {
 	BackendDB int
 }
 
-type Tasks struct {
+type Job struct {
 	Server *machinery.Server
 	Worker *machinery.Worker
 	Queue  Queue
 }
 
-func New(cfg *Config, queue Queue) (*Tasks, error) {
+func New(cfg *Config, queue Queue) (*Job, error) {
 	broker := fmt.Sprintf("redis://%s@%s:%d/%d", cfg.Password, cfg.Host, cfg.Port, cfg.BrokerDB)
 	backend := fmt.Sprintf("redis://%s@%s:%d/%d", cfg.Password, cfg.Host, cfg.Port, cfg.BackendDB)
 
@@ -63,61 +63,61 @@ func New(cfg *Config, queue Queue) (*Tasks, error) {
 		return nil, err
 	}
 
-	return &Tasks{
+	return &Job{
 		Server: server,
 		Queue:  queue,
 	}, nil
 }
 
-func (t *Tasks) RegisterTasks(namedTaskFuncs map[string]interface{}) error {
-	return t.Server.RegisterTasks(namedTaskFuncs)
+func (t *Job) RegisterJob(namedJobFuncs map[string]interface{}) error {
+	return t.Server.RegisterTasks(namedJobFuncs)
 }
 
-func (t *Tasks) LaunchWorker(consumerTag string, concurrency int) error {
+func (t *Job) LaunchWorker(consumerTag string, concurrency int) error {
 	t.Worker = t.Server.NewWorker(consumerTag, concurrency)
 	return t.Worker.Launch()
 }
 
-type GroupTaskState struct {
+type GroupJobState struct {
 	GroupUUID string
 	State     string
 	CreatedAt time.Time
 }
 
-func (t *Tasks) GetGroupTaskState(groupUUID string) (*GroupTaskState, error) {
-	taskStates, err := t.Server.GetBackend().GroupTaskStates(groupUUID, 0)
+func (t *Job) GetGroupJobState(groupUUID string) (*GroupJobState, error) {
+	jobStates, err := t.Server.GetBackend().GroupTaskStates(groupUUID, 0)
 	if err != nil {
 		return nil, err
 	}
 
-	if len(taskStates) == 0 {
-		return nil, errors.New("empty group task")
+	if len(jobStates) == 0 {
+		return nil, errors.New("empty group job")
 	}
 
-	for _, taskState := range taskStates {
-		if taskState.IsFailure() {
-			return &GroupTaskState{
+	for _, jobState := range jobStates {
+		if jobState.IsFailure() {
+			return &GroupJobState{
 				GroupUUID: groupUUID,
 				State:     machineryv1tasks.StateFailure,
-				CreatedAt: taskState.CreatedAt,
+				CreatedAt: jobState.CreatedAt,
 			}, nil
 		}
 	}
 
-	for _, taskState := range taskStates {
-		if !taskState.IsSuccess() {
-			return &GroupTaskState{
+	for _, jobState := range jobStates {
+		if !jobState.IsSuccess() {
+			return &GroupJobState{
 				GroupUUID: groupUUID,
 				State:     machineryv1tasks.StatePending,
-				CreatedAt: taskState.CreatedAt,
+				CreatedAt: jobState.CreatedAt,
 			}, nil
 		}
 	}
 
-	return &GroupTaskState{
+	return &GroupJobState{
 		GroupUUID: groupUUID,
 		State:     machineryv1tasks.StateSuccess,
-		CreatedAt: taskStates[0].CreatedAt,
+		CreatedAt: jobStates[0].CreatedAt,
 	}, nil
 }
 

internal/tasks/tasks_test.go → internal/job/job_test.go

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package tasks
+package job
 
 import (
 	"reflect"
@@ -25,7 +25,7 @@ import (
 	machineryv1tasks "github.com/RichardKnop/machinery/v1/tasks"
 )
 
-func TestTaskMarshal(t *testing.T) {
+func TestJobMarshal(t *testing.T) {
 	tests := []struct {
 		name   string
 		value  interface{}
@@ -111,7 +111,7 @@ func TestTaskMarshal(t *testing.T) {
 	}
 }
 
-func TestTaskUnmarshal(t *testing.T) {
+func TestJobUnmarshal(t *testing.T) {
 	tests := []struct {
 		name   string
 		data   []reflect.Value

internal/tasks/queue.go → internal/job/queue.go

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package tasks
+package job
 
 import (
 	"fmt"

internal/tasks/queue_test.go → internal/job/queue_test.go

@@ -14,15 +14,15 @@
  * limitations under the License.
  */
 
-package tasks
+package job
 
 import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
 )
 
-func TestTaskGetSchedulerQueue(t *testing.T) {
+func TestJobGetSchedulerQueue(t *testing.T) {
 	tests := []struct {
 		name     string
 		hostname string
@@ -54,7 +54,7 @@ func TestTaskGetSchedulerQueue(t *testing.T) {
 	}
 }
 
-func TestTaskGetCDNQueue(t *testing.T) {
+func TestJobGetCDNQueue(t *testing.T) {
 	tests := []struct {
 		name     string
 		hostname string

internal/tasks/types.go → internal/job/types.go

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package tasks
+package job
 
 type PreheatRequest struct {
 	URL     string            `json:"url" validate:"required,url"`

manager/tasks/tasks.go → manager/job/job.go

@@ -14,32 +14,32 @@
  * limitations under the License.
  */
 
-package tasks
+package job
 
 import (
-	internaltasks "d7y.io/dragonfly/v2/internal/tasks"
+	internaljob "d7y.io/dragonfly/v2/internal/job"
 	"d7y.io/dragonfly/v2/manager/config"
 	"d7y.io/dragonfly/v2/manager/types"
 )
 
-type Task interface {
+type Job interface {
 	CreatePreheat([]string, types.CreatePreheatRequest) (*types.Preheat, error)
 	GetPreheat(string) (*types.Preheat, error)
 }
 
-type task struct {
-	*internaltasks.Tasks
+type job struct {
+	*internaljob.Job
 	Preheat Preheat
 }
 
-func New(cfg *config.Config) (Task, error) {
-	t, err := internaltasks.New(&internaltasks.Config{
+func New(cfg *config.Config) (Job, error) {
+	t, err := internaljob.New(&internaljob.Config{
 		Host:      cfg.Database.Redis.Host,
 		Port:      cfg.Database.Redis.Port,
 		Password:  cfg.Database.Redis.Password,
 		BrokerDB:  cfg.Database.Redis.BrokerDB,
 		BackendDB: cfg.Database.Redis.BackendDB,
-	}, internaltasks.GlobalQueue)
+	}, internaljob.GlobalQueue)
 	if err != nil {
 		return nil, err
 	}
@@ -49,25 +49,25 @@ func New(cfg *config.Config) (Task, error) {
 		return nil, err
 	}
 
-	return &task{
-		Tasks:   t,
+	return &job{
+		Job:     t,
 		Preheat: p,
 	}, nil
 }
 
-func (t *task) CreatePreheat(hostnames []string, json types.CreatePreheatRequest) (*types.Preheat, error) {
+func (t *job) CreatePreheat(hostnames []string, json types.CreatePreheatRequest) (*types.Preheat, error) {
 	return t.Preheat.CreatePreheat(hostnames, json)
 }
 
-func (t *task) GetPreheat(id string) (*types.Preheat, error) {
-	groupTaskState, err := t.GetGroupTaskState(id)
+func (t *job) GetPreheat(id string) (*types.Preheat, error) {
+	groupJobState, err := t.GetGroupJobState(id)
 	if err != nil {
 		return nil, err
 	}
 
 	return &types.Preheat{
-		ID:        groupTaskState.GroupUUID,
-		Status:    groupTaskState.State,
-		CreatedAt: groupTaskState.CreatedAt,
+		ID:        groupJobState.GroupUUID,
+		Status:    groupJobState.State,
+		CreatedAt: groupJobState.CreatedAt,
 	}, nil
 }