From 34b6553d7dbe60aa2df58240d7e0842a8eebaa7c Mon Sep 17 00:00:00 2001 From: Ken Hibino Date: Tue, 12 Jan 2021 11:59:44 -0800 Subject: [PATCH] Rename DeadTask to ArchivedTask, and action Kill to Archive --- conversion_helpers.go | 16 +- main.go | 26 +- task_handlers.go | 54 +-- ui/package.json | 2 +- ui/src/actions/tasksActions.ts | 543 +++++++++++----------- ui/src/api.ts | 70 +-- ui/src/components/ArchivedTasksTable.tsx | 389 ++++++++++++++++ ui/src/components/DeadTasksTable.tsx | 68 +-- ui/src/components/QueueSizeChart.tsx | 4 +- ui/src/components/QueuesOverviewTable.tsx | 27 +- ui/src/components/RetryTasksTable.tsx | 38 +- ui/src/components/ScheduledTasksTable.tsx | 38 +- ui/src/components/TasksTable.tsx | 18 +- ui/src/reducers/queuesReducer.ts | 98 ++-- ui/src/reducers/snackbarReducer.ts | 80 ++-- ui/src/reducers/tasksReducer.ts | 236 +++++----- ui/src/views/DashboardView.tsx | 4 +- ui/src/views/TasksView.tsx | 2 +- ui/yarn.lock | 8 +- 19 files changed, 1071 insertions(+), 650 deletions(-) create mode 100644 ui/src/components/ArchivedTasksTable.tsx diff --git a/conversion_helpers.go b/conversion_helpers.go index 96c82aa..45c9920 100644 --- a/conversion_helpers.go +++ b/conversion_helpers.go @@ -22,7 +22,7 @@ type QueueStateSnapshot struct { Pending int `json:"pending"` Scheduled int `json:"scheduled"` Retry int `json:"retry"` - Dead int `json:"dead"` + Archived int `json:"archived"` // Total number of tasks processed during the given date. // The number includes both succeeded and failed tasks. @@ -45,7 +45,7 @@ func toQueueStateSnapshot(s *asynq.QueueStats) *QueueStateSnapshot { Pending: s.Pending, Scheduled: s.Scheduled, Retry: s.Retry, - Dead: s.Dead, + Archived: s.Archived, Processed: s.Processed, Succeeded: s.Processed - s.Failed, Failed: s.Failed, @@ -193,7 +193,7 @@ func toRetryTasks(in []*asynq.RetryTask) []*RetryTask { return out } -type DeadTask struct { +type ArchivedTask struct { *BaseTask Key string `json:"key"` MaxRetry int `json:"max_retry"` @@ -202,14 +202,14 @@ type DeadTask struct { LastFailedAt time.Time `json:"last_failed_at"` } -func toDeadTask(t *asynq.DeadTask) *DeadTask { +func toArchivedTask(t *asynq.ArchivedTask) *ArchivedTask { base := &BaseTask{ ID: t.ID, Type: t.Type, Payload: t.Payload, Queue: t.Queue, } - return &DeadTask{ + return &ArchivedTask{ BaseTask: base, Key: t.Key(), MaxRetry: t.MaxRetry, @@ -219,10 +219,10 @@ func toDeadTask(t *asynq.DeadTask) *DeadTask { } } -func toDeadTasks(in []*asynq.DeadTask) []*DeadTask { - out := make([]*DeadTask, len(in)) +func toArchivedTasks(in []*asynq.ArchivedTask) []*ArchivedTask { + out := make([]*ArchivedTask, len(in)) for i, t := range in { - out[i] = toDeadTask(t) + out[i] = toArchivedTask(t) } return out } diff --git a/main.go b/main.go index 186dfb3..3b65575 100644 --- a/main.go +++ b/main.go @@ -138,9 +138,9 @@ func main() { api.HandleFunc("/queues/{qname}/scheduled_tasks/{task_key}:run", newRunTaskHandlerFunc(inspector)).Methods("POST") api.HandleFunc("/queues/{qname}/scheduled_tasks:run_all", newRunAllScheduledTasksHandlerFunc(inspector)).Methods("POST") api.HandleFunc("/queues/{qname}/scheduled_tasks:batch_run", newBatchRunTasksHandlerFunc(inspector)).Methods("POST") - api.HandleFunc("/queues/{qname}/scheduled_tasks/{task_key}:kill", newKillTaskHandlerFunc(inspector)).Methods("POST") - api.HandleFunc("/queues/{qname}/scheduled_tasks:kill_all", newKillAllScheduledTasksHandlerFunc(inspector)).Methods("POST") - api.HandleFunc("/queues/{qname}/scheduled_tasks:batch_kill", newBatchKillTasksHandlerFunc(inspector)).Methods("POST") + api.HandleFunc("/queues/{qname}/scheduled_tasks/{task_key}:archive", newArchiveTaskHandlerFunc(inspector)).Methods("POST") + api.HandleFunc("/queues/{qname}/scheduled_tasks:archive_all", newArchiveAllScheduledTasksHandlerFunc(inspector)).Methods("POST") + api.HandleFunc("/queues/{qname}/scheduled_tasks:batch_archive", newBatchArchiveTasksHandlerFunc(inspector)).Methods("POST") api.HandleFunc("/queues/{qname}/retry_tasks", newListRetryTasksHandlerFunc(inspector)).Methods("GET") api.HandleFunc("/queues/{qname}/retry_tasks/{task_key}", newDeleteTaskHandlerFunc(inspector)).Methods("DELETE") api.HandleFunc("/queues/{qname}/retry_tasks:delete_all", newDeleteAllRetryTasksHandlerFunc(inspector)).Methods("DELETE") @@ -148,16 +148,16 @@ func main() { api.HandleFunc("/queues/{qname}/retry_tasks/{task_key}:run", newRunTaskHandlerFunc(inspector)).Methods("POST") api.HandleFunc("/queues/{qname}/retry_tasks:run_all", newRunAllRetryTasksHandlerFunc(inspector)).Methods("POST") api.HandleFunc("/queues/{qname}/retry_tasks:batch_run", newBatchRunTasksHandlerFunc(inspector)).Methods("POST") - api.HandleFunc("/queues/{qname}/retry_tasks/{task_key}:kill", newKillTaskHandlerFunc(inspector)).Methods("POST") - api.HandleFunc("/queues/{qname}/retry_tasks:kill_all", newKillAllRetryTasksHandlerFunc(inspector)).Methods("POST") - api.HandleFunc("/queues/{qname}/retry_tasks:batch_kill", newBatchKillTasksHandlerFunc(inspector)).Methods("POST") - api.HandleFunc("/queues/{qname}/dead_tasks", newListDeadTasksHandlerFunc(inspector)).Methods("GET") - api.HandleFunc("/queues/{qname}/dead_tasks/{task_key}", newDeleteTaskHandlerFunc(inspector)).Methods("DELETE") - api.HandleFunc("/queues/{qname}/dead_tasks:delete_all", newDeleteAllDeadTasksHandlerFunc(inspector)).Methods("DELETE") - api.HandleFunc("/queues/{qname}/dead_tasks:batch_delete", newBatchDeleteTasksHandlerFunc(inspector)).Methods("POST") - api.HandleFunc("/queues/{qname}/dead_tasks/{task_key}:run", newRunTaskHandlerFunc(inspector)).Methods("POST") - api.HandleFunc("/queues/{qname}/dead_tasks:run_all", newRunAllDeadTasksHandlerFunc(inspector)).Methods("POST") - api.HandleFunc("/queues/{qname}/dead_tasks:batch_run", newBatchRunTasksHandlerFunc(inspector)).Methods("POST") + api.HandleFunc("/queues/{qname}/retry_tasks/{task_key}:archive", newArchiveTaskHandlerFunc(inspector)).Methods("POST") + api.HandleFunc("/queues/{qname}/retry_tasks:archive_all", newArchiveAllRetryTasksHandlerFunc(inspector)).Methods("POST") + api.HandleFunc("/queues/{qname}/retry_tasks:batch_archive", newBatchArchiveTasksHandlerFunc(inspector)).Methods("POST") + api.HandleFunc("/queues/{qname}/archived_tasks", newListArchivedTasksHandlerFunc(inspector)).Methods("GET") + api.HandleFunc("/queues/{qname}/archived_tasks/{task_key}", newDeleteTaskHandlerFunc(inspector)).Methods("DELETE") + api.HandleFunc("/queues/{qname}/archived_tasks:delete_all", newDeleteAllArchivedTasksHandlerFunc(inspector)).Methods("DELETE") + api.HandleFunc("/queues/{qname}/archived_tasks:batch_delete", newBatchDeleteTasksHandlerFunc(inspector)).Methods("POST") + api.HandleFunc("/queues/{qname}/archived_tasks/{task_key}:run", newRunTaskHandlerFunc(inspector)).Methods("POST") + api.HandleFunc("/queues/{qname}/archived_tasks:run_all", newRunAllArchivedTasksHandlerFunc(inspector)).Methods("POST") + api.HandleFunc("/queues/{qname}/archived_tasks:batch_run", newBatchRunTasksHandlerFunc(inspector)).Methods("POST") // Servers endpoints. api.HandleFunc("/servers", newListServersHandlerFunc(inspector)).Methods("GET") diff --git a/task_handlers.go b/task_handlers.go index 62fad42..d54d0a6 100644 --- a/task_handlers.go +++ b/task_handlers.go @@ -217,12 +217,12 @@ func newListRetryTasksHandlerFunc(inspector *asynq.Inspector) http.HandlerFunc { } } -func newListDeadTasksHandlerFunc(inspector *asynq.Inspector) http.HandlerFunc { +func newListArchivedTasksHandlerFunc(inspector *asynq.Inspector) http.HandlerFunc { return func(w http.ResponseWriter, r *http.Request) { vars := mux.Vars(r) qname := vars["qname"] pageSize, pageNum := getPageOptions(r) - tasks, err := inspector.ListDeadTasks( + tasks, err := inspector.ListArchivedTasks( qname, asynq.PageSize(pageSize), asynq.Page(pageNum)) if err != nil { http.Error(w, err.Error(), http.StatusInternalServerError) @@ -236,9 +236,9 @@ func newListDeadTasksHandlerFunc(inspector *asynq.Inspector) http.HandlerFunc { payload := make(map[string]interface{}) if len(tasks) == 0 { // avoid nil for the tasks field in json output. - payload["tasks"] = make([]*DeadTask, 0) + payload["tasks"] = make([]*ArchivedTask, 0) } else { - payload["tasks"] = toDeadTasks(tasks) + payload["tasks"] = toArchivedTasks(tasks) } payload["stats"] = toQueueStateSnapshot(stats) if err := json.NewEncoder(w).Encode(payload); err != nil { @@ -282,7 +282,7 @@ func newRunTaskHandlerFunc(inspector *asynq.Inspector) http.HandlerFunc { } } -func newKillTaskHandlerFunc(inspector *asynq.Inspector) http.HandlerFunc { +func newArchiveTaskHandlerFunc(inspector *asynq.Inspector) http.HandlerFunc { return func(w http.ResponseWriter, r *http.Request) { vars := mux.Vars(r) qname, key := vars["qname"], vars["task_key"] @@ -290,7 +290,7 @@ func newKillTaskHandlerFunc(inspector *asynq.Inspector) http.HandlerFunc { http.Error(w, "route parameters should not be empty", http.StatusBadRequest) return } - if err := inspector.KillTaskByKey(qname, key); err != nil { + if err := inspector.ArchiveTaskByKey(qname, key); err != nil { // TODO: Handle task not found error and return 404 http.Error(w, err.Error(), http.StatusInternalServerError) return @@ -321,10 +321,10 @@ func newDeleteAllRetryTasksHandlerFunc(inspector *asynq.Inspector) http.HandlerF } } -func newDeleteAllDeadTasksHandlerFunc(inspector *asynq.Inspector) http.HandlerFunc { +func newDeleteAllArchivedTasksHandlerFunc(inspector *asynq.Inspector) http.HandlerFunc { return func(w http.ResponseWriter, r *http.Request) { qname := mux.Vars(r)["qname"] - if _, err := inspector.DeleteAllDeadTasks(qname); err != nil { + if _, err := inspector.DeleteAllArchivedTasks(qname); err != nil { http.Error(w, err.Error(), http.StatusInternalServerError) return } @@ -354,10 +354,10 @@ func newRunAllRetryTasksHandlerFunc(inspector *asynq.Inspector) http.HandlerFunc } } -func newRunAllDeadTasksHandlerFunc(inspector *asynq.Inspector) http.HandlerFunc { +func newRunAllArchivedTasksHandlerFunc(inspector *asynq.Inspector) http.HandlerFunc { return func(w http.ResponseWriter, r *http.Request) { qname := mux.Vars(r)["qname"] - if _, err := inspector.RunAllDeadTasks(qname); err != nil { + if _, err := inspector.RunAllArchivedTasks(qname); err != nil { http.Error(w, err.Error(), http.StatusInternalServerError) return } @@ -365,10 +365,10 @@ func newRunAllDeadTasksHandlerFunc(inspector *asynq.Inspector) http.HandlerFunc } } -func newKillAllScheduledTasksHandlerFunc(inspector *asynq.Inspector) http.HandlerFunc { +func newArchiveAllScheduledTasksHandlerFunc(inspector *asynq.Inspector) http.HandlerFunc { return func(w http.ResponseWriter, r *http.Request) { qname := mux.Vars(r)["qname"] - if _, err := inspector.KillAllScheduledTasks(qname); err != nil { + if _, err := inspector.ArchiveAllScheduledTasks(qname); err != nil { http.Error(w, err.Error(), http.StatusInternalServerError) return } @@ -376,10 +376,10 @@ func newKillAllScheduledTasksHandlerFunc(inspector *asynq.Inspector) http.Handle } } -func newKillAllRetryTasksHandlerFunc(inspector *asynq.Inspector) http.HandlerFunc { +func newArchiveAllRetryTasksHandlerFunc(inspector *asynq.Inspector) http.HandlerFunc { return func(w http.ResponseWriter, r *http.Request) { qname := mux.Vars(r)["qname"] - if _, err := inspector.KillAllRetryTasks(qname); err != nil { + if _, err := inspector.ArchiveAllRetryTasks(qname); err != nil { http.Error(w, err.Error(), http.StatusInternalServerError) return } @@ -485,41 +485,41 @@ func newBatchRunTasksHandlerFunc(inspector *asynq.Inspector) http.HandlerFunc { } } -type batchKillTasksRequest struct { +type batchArchiveTasksRequest struct { TaskKeys []string `json:"task_keys"` } -type batchKillTasksResponse struct { - // task keys that were successfully moved to the dead state. - DeadKeys []string `json:"dead_keys"` - // task keys that were not able to move to the dead state. +type batchArchiveTasksResponse struct { + // task keys that were successfully moved to the archived state. + ArchivedKeys []string `json:"archived_keys"` + // task keys that were not able to move to the archived state. ErrorKeys []string `json:"error_keys"` } -func newBatchKillTasksHandlerFunc(inspector *asynq.Inspector) http.HandlerFunc { +func newBatchArchiveTasksHandlerFunc(inspector *asynq.Inspector) http.HandlerFunc { return func(w http.ResponseWriter, r *http.Request) { r.Body = http.MaxBytesReader(w, r.Body, maxRequestBodySize) dec := json.NewDecoder(r.Body) dec.DisallowUnknownFields() - var req batchKillTasksRequest + var req batchArchiveTasksRequest if err := dec.Decode(&req); err != nil { http.Error(w, err.Error(), http.StatusBadRequest) return } qname := mux.Vars(r)["qname"] - resp := batchKillTasksResponse{ + resp := batchArchiveTasksResponse{ // avoid null in the json response - DeadKeys: make([]string, 0), - ErrorKeys: make([]string, 0), + ArchivedKeys: make([]string, 0), + ErrorKeys: make([]string, 0), } for _, key := range req.TaskKeys { - if err := inspector.KillTaskByKey(qname, key); err != nil { - log.Printf("error: could not kill task with key %q: %v", key, err) + if err := inspector.ArchiveTaskByKey(qname, key); err != nil { + log.Printf("error: could not archive task with key %q: %v", key, err) resp.ErrorKeys = append(resp.ErrorKeys, key) } else { - resp.DeadKeys = append(resp.DeadKeys, key) + resp.ArchivedKeys = append(resp.ArchivedKeys, key) } } if err := json.NewEncoder(w).Encode(resp); err != nil { diff --git a/ui/package.json b/ui/package.json index f8b38f7..75dfed0 100644 --- a/ui/package.json +++ b/ui/package.json @@ -46,7 +46,7 @@ "browserslist": { "production": [ ">0.2%", - "not dead", + "not archived", "not op_mini all" ], "development": [ diff --git a/ui/src/actions/tasksActions.ts b/ui/src/actions/tasksActions.ts index e9ed28d..0911ab2 100644 --- a/ui/src/actions/tasksActions.ts +++ b/ui/src/actions/tasksActions.ts @@ -1,33 +1,33 @@ import { batchCancelActiveTasks, BatchCancelTasksResponse, - batchDeleteDeadTasks, + batchDeleteArchivedTasks, batchDeleteRetryTasks, batchDeleteScheduledTasks, BatchDeleteTasksResponse, - batchKillRetryTasks, - batchKillScheduledTasks, - BatchKillTasksResponse, - batchRunDeadTasks, + batchArchiveRetryTasks, + batchArchiveScheduledTasks, + BatchArchiveTasksResponse, + batchRunArchivedTasks, batchRunRetryTasks, batchRunScheduledTasks, BatchRunTasksResponse, cancelActiveTask, cancelAllActiveTasks, - deleteAllDeadTasks, + deleteAllArchivedTasks, deleteAllRetryTasks, deleteAllScheduledTasks, - deleteDeadTask, + deleteArchivedTask, deleteRetryTask, deleteScheduledTask, - killAllRetryTasks, - killAllScheduledTasks, - killRetryTask, - killScheduledTask, + archiveAllRetryTasks, + archiveAllScheduledTasks, + archiveRetryTask, + archiveScheduledTask, listActiveTasks, ListActiveTasksResponse, - listDeadTasks, - ListDeadTasksResponse, + listArchivedTasks, + ListArchivedTasksResponse, listPendingTasks, ListPendingTasksResponse, listRetryTasks, @@ -35,10 +35,10 @@ import { listScheduledTasks, ListScheduledTasksResponse, PaginationOptions, - runAllDeadTasks, + runAllArchivedTasks, runAllRetryTasks, runAllScheduledTasks, - runDeadTask, + runArchivedTask, runRetryTask, runScheduledTask, } from "../api"; @@ -57,9 +57,9 @@ export const LIST_SCHEDULED_TASKS_ERROR = "LIST_SCHEDULED_TASKS_ERROR"; export const LIST_RETRY_TASKS_BEGIN = "LIST_RETRY_TASKS_BEGIN"; export const LIST_RETRY_TASKS_SUCCESS = "LIST_RETRY_TASKS_SUCCESS"; export const LIST_RETRY_TASKS_ERROR = "LIST_RETRY_TASKS_ERROR"; -export const LIST_DEAD_TASKS_BEGIN = "LIST_DEAD_TASKS_BEGIN"; -export const LIST_DEAD_TASKS_SUCCESS = "LIST_DEAD_TASKS_SUCCESS"; -export const LIST_DEAD_TASKS_ERROR = "LIST_DEAD_TASKS_ERROR"; +export const LIST_ARCHIVED_TASKS_BEGIN = "LIST_ARCHIVED_TASKS_BEGIN"; +export const LIST_ARCHIVED_TASKS_SUCCESS = "LIST_ARCHIVED_TASKS_SUCCESS"; +export const LIST_ARCHIVED_TASKS_ERROR = "LIST_ARCHIVED_TASKS_ERROR"; export const CANCEL_ACTIVE_TASK_BEGIN = "CANCEL_ACTIVE_TASK_BEGIN"; export const CANCEL_ACTIVE_TASK_SUCCESS = "CANCEL_ACTIVE_TASK_SUCCESS"; export const CANCEL_ACTIVE_TASK_ERROR = "CANCEL_ACTIVE_TASK_ERROR"; @@ -73,35 +73,35 @@ export const BATCH_CANCEL_ACTIVE_TASKS_SUCCESS = "BATCH_CANCEL_ACTIVE_TASKS_SUCCESS"; export const BATCH_CANCEL_ACTIVE_TASKS_ERROR = "BATCH_CANCEL_ACTIVE_TASKS_ERROR"; -export const RUN_SCHEDULED_TASK_BEGIN = "RUN_DEAD_TASK_BEGIN"; -export const RUN_SCHEDULED_TASK_SUCCESS = "RUN_DEAD_TASK_SUCCESS"; -export const RUN_SCHEDULED_TASK_ERROR = "RUN_DEAD_TASK_ERROR"; +export const RUN_SCHEDULED_TASK_BEGIN = "RUN_ARCHIVED_TASK_BEGIN"; +export const RUN_SCHEDULED_TASK_SUCCESS = "RUN_ARCHIVED_TASK_SUCCESS"; +export const RUN_SCHEDULED_TASK_ERROR = "RUN_ARCHIVED_TASK_ERROR"; export const RUN_RETRY_TASK_BEGIN = "RUN_RETRY_TASK_BEGIN"; export const RUN_RETRY_TASK_SUCCESS = "RUN_RETRY_TASK_SUCCESS"; export const RUN_RETRY_TASK_ERROR = "RUN_RETRY_TASK_ERROR"; -export const RUN_DEAD_TASK_BEGIN = "RUN_DEAD_TASK_BEGIN"; -export const RUN_DEAD_TASK_SUCCESS = "RUN_DEAD_TASK_SUCCESS"; -export const RUN_DEAD_TASK_ERROR = "RUN_DEAD_TASK_ERROR"; +export const RUN_ARCHIVED_TASK_BEGIN = "RUN_ARCHIVED_TASK_BEGIN"; +export const RUN_ARCHIVED_TASK_SUCCESS = "RUN_ARCHIVED_TASK_SUCCESS"; +export const RUN_ARCHIVED_TASK_ERROR = "RUN_ARCHIVED_TASK_ERROR"; export const DELETE_SCHEDULED_TASK_BEGIN = "DELETE_SCHEDULED_TASK_BEGIN"; export const DELETE_SCHEDULED_TASK_SUCCESS = "DELETE_SCHEDULED_TASK_SUCCESS"; export const DELETE_SCHEDULED_TASK_ERROR = "DELETE_SCHEDULED_TASK_ERROR"; -export const KILL_SCHEDULED_TASK_BEGIN = "KILL_DEAD_TASK_BEGIN"; -export const KILL_SCHEDULED_TASK_SUCCESS = "KILL_DEAD_TASK_SUCCESS"; -export const KILL_SCHEDULED_TASK_ERROR = "KILL_DEAD_TASK_ERROR"; -export const KILL_RETRY_TASK_BEGIN = "KILL_RETRY_TASK_BEGIN"; -export const KILL_RETRY_TASK_SUCCESS = "KILL_RETRY_TASK_SUCCESS"; -export const KILL_RETRY_TASK_ERROR = "KILL_RETRY_TASK_ERROR"; +export const ARCHIVE_SCHEDULED_TASK_BEGIN = "ARCHIVE_ARCHIVED_TASK_BEGIN"; +export const ARCHIVE_SCHEDULED_TASK_SUCCESS = "ARCHIVE_ARCHIVED_TASK_SUCCESS"; +export const ARCHIVE_SCHEDULED_TASK_ERROR = "ARCHIVE_ARCHIVED_TASK_ERROR"; +export const ARCHIVE_RETRY_TASK_BEGIN = "ARCHIVE_RETRY_TASK_BEGIN"; +export const ARCHIVE_RETRY_TASK_SUCCESS = "ARCHIVE_RETRY_TASK_SUCCESS"; +export const ARCHIVE_RETRY_TASK_ERROR = "ARCHIVE_RETRY_TASK_ERROR"; export const BATCH_RUN_SCHEDULED_TASKS_BEGIN = "BATCH_RUN_SCHEDULED_TASKS_BEGIN"; export const BATCH_RUN_SCHEDULED_TASKS_SUCCESS = "BATCH_RUN_SCHEDULED_TASKS_SUCCESS"; export const BATCH_RUN_SCHEDULED_TASKS_ERROR = "BATCH_RUN_SCHEDULED_TASKS_ERROR"; -export const BATCH_KILL_SCHEDULED_TASKS_BEGIN = - "BATCH_KILL_SCHEDULED_TASKS_BEGIN"; -export const BATCH_KILL_SCHEDULED_TASKS_SUCCESS = - "BATCH_KILL_SCHEDULED_TASKS_SUCCESS"; -export const BATCH_KILL_SCHEDULED_TASKS_ERROR = +export const BATCH_ARCHIVE_SCHEDULED_TASKS_BEGIN = + "BATCH_ARCHIVE_SCHEDULED_TASKS_BEGIN"; +export const BATCH_ARCHIVE_SCHEDULED_TASKS_SUCCESS = + "BATCH_ARCHIVE_SCHEDULED_TASKS_SUCCESS"; +export const BATCH_ARCHIVE_SCHEDULED_TASKS_ERROR = "BATCH_RUN_SCHEDULED_TASKS_ERROR"; export const BATCH_DELETE_SCHEDULED_TASKS_BEGIN = "BATCH_DELETE_SCHEDULED_TASKS_BEGIN"; @@ -113,10 +113,12 @@ export const RUN_ALL_SCHEDULED_TASKS_BEGIN = "RUN_ALL_SCHEDULED_TASKS_BEGIN"; export const RUN_ALL_SCHEDULED_TASKS_SUCCESS = "RUN_ALL_SCHEDULED_TASKS_SUCCESS"; export const RUN_ALL_SCHEDULED_TASKS_ERROR = "RUN_ALL_SCHEDULED_TASKS_ERROR"; -export const KILL_ALL_SCHEDULED_TASKS_BEGIN = "KILL_ALL_SCHEDULED_TASKS_BEGIN"; -export const KILL_ALL_SCHEDULED_TASKS_SUCCESS = - "KILL_ALL_SCHEDULED_TASKS_SUCCESS"; -export const KILL_ALL_SCHEDULED_TASKS_ERROR = "KILL_ALL_SCHEDULED_TASKS_ERROR"; +export const ARCHIVE_ALL_SCHEDULED_TASKS_BEGIN = + "ARCHIVE_ALL_SCHEDULED_TASKS_BEGIN"; +export const ARCHIVE_ALL_SCHEDULED_TASKS_SUCCESS = + "ARCHIVE_ALL_SCHEDULED_TASKS_SUCCESS"; +export const ARCHIVE_ALL_SCHEDULED_TASKS_ERROR = + "ARCHIVE_ALL_SCHEDULED_TASKS_ERROR"; export const DELETE_ALL_SCHEDULED_TASKS_BEGIN = "DELETE_ALL_SCHEDULED_TASKS_BEGIN"; export const DELETE_ALL_SCHEDULED_TASKS_SUCCESS = @@ -129,9 +131,12 @@ export const DELETE_RETRY_TASK_ERROR = "DELETE_RETRY_TASK_ERROR"; export const BATCH_RUN_RETRY_TASKS_BEGIN = "BATCH_RUN_RETRY_TASKS_BEGIN"; export const BATCH_RUN_RETRY_TASKS_SUCCESS = "BATCH_RUN_RETRY_TASKS_SUCCESS"; export const BATCH_RUN_RETRY_TASKS_ERROR = "BATCH_RUN_RETRY_TASKS_ERROR"; -export const BATCH_KILL_RETRY_TASKS_BEGIN = "BATCH_KILL_RETRY_TASKS_BEGIN"; -export const BATCH_KILL_RETRY_TASKS_SUCCESS = "BATCH_KILL_RETRY_TASKS_SUCCESS"; -export const BATCH_KILL_RETRY_TASKS_ERROR = "BATCH_KILL_RETRY_TASKS_ERROR"; +export const BATCH_ARCHIVE_RETRY_TASKS_BEGIN = + "BATCH_ARCHIVE_RETRY_TASKS_BEGIN"; +export const BATCH_ARCHIVE_RETRY_TASKS_SUCCESS = + "BATCH_ARCHIVE_RETRY_TASKS_SUCCESS"; +export const BATCH_ARCHIVE_RETRY_TASKS_ERROR = + "BATCH_ARCHIVE_RETRY_TASKS_ERROR"; export const BATCH_DELETE_RETRY_TASKS_BEGIN = "BATCH_DELETE_RETRY_TASKS_BEGIN"; export const BATCH_DELETE_RETRY_TASKS_SUCCESS = "BATCH_DELETE_RETRY_TASKS_SUCCESS"; @@ -139,28 +144,35 @@ export const BATCH_DELETE_RETRY_TASKS_ERROR = "BATCH_DELETE_RETRY_TASKS_ERROR"; export const RUN_ALL_RETRY_TASKS_BEGIN = "RUN_ALL_RETRY_TASKS_BEGIN"; export const RUN_ALL_RETRY_TASKS_SUCCESS = "RUN_ALL_RETRY_TASKS_SUCCESS"; export const RUN_ALL_RETRY_TASKS_ERROR = "RUN_ALL_RETRY_TASKS_ERROR"; -export const KILL_ALL_RETRY_TASKS_BEGIN = "KILL_ALL_RETRY_TASKS_BEGIN"; -export const KILL_ALL_RETRY_TASKS_SUCCESS = "KILL_ALL_RETRY_TASKS_SUCCESS"; -export const KILL_ALL_RETRY_TASKS_ERROR = "KILL_ALL_RETRY_TASKS_ERROR"; +export const ARCHIVE_ALL_RETRY_TASKS_BEGIN = "ARCHIVE_ALL_RETRY_TASKS_BEGIN"; +export const ARCHIVE_ALL_RETRY_TASKS_SUCCESS = + "ARCHIVE_ALL_RETRY_TASKS_SUCCESS"; +export const ARCHIVE_ALL_RETRY_TASKS_ERROR = "ARCHIVE_ALL_RETRY_TASKS_ERROR"; export const DELETE_ALL_RETRY_TASKS_BEGIN = "DELETE_ALL_RETRY_TASKS_BEGIN"; export const DELETE_ALL_RETRY_TASKS_SUCCESS = "DELETE_ALL_RETRY_TASKS_SUCCESS"; export const DELETE_ALL_RETRY_TASKS_ERROR = "DELETE_ALL_RETRY_TASKS_ERROR"; -export const DELETE_DEAD_TASK_BEGIN = "DELETE_DEAD_TASK_BEGIN"; -export const DELETE_DEAD_TASK_SUCCESS = "DELETE_DEAD_TASK_SUCCESS"; -export const DELETE_DEAD_TASK_ERROR = "DELETE_DEAD_TASK_ERROR"; -export const BATCH_RUN_DEAD_TASKS_BEGIN = "BATCH_RUN_DEAD_TASKS_BEGIN"; -export const BATCH_RUN_DEAD_TASKS_SUCCESS = "BATCH_RUN_DEAD_TASKS_SUCCESS"; -export const BATCH_RUN_DEAD_TASKS_ERROR = "BATCH_RUN_DEAD_TASKS_ERROR"; -export const BATCH_DELETE_DEAD_TASKS_BEGIN = "BATCH_DELETE_DEAD_TASKS_BEGIN"; -export const BATCH_DELETE_DEAD_TASKS_SUCCESS = - "BATCH_DELETE_DEAD_TASKS_SUCCESS"; -export const BATCH_DELETE_DEAD_TASKS_ERROR = "BATCH_DELETE_DEAD_TASKS_ERROR"; -export const RUN_ALL_DEAD_TASKS_BEGIN = "RUN_ALL_DEAD_TASKS_BEGIN"; -export const RUN_ALL_DEAD_TASKS_SUCCESS = "RUN_ALL_DEAD_TASKS_SUCCESS"; -export const RUN_ALL_DEAD_TASKS_ERROR = "RUN_ALL_DEAD_TASKS_ERROR"; -export const DELETE_ALL_DEAD_TASKS_BEGIN = "DELETE_ALL_DEAD_TASKS_BEGIN"; -export const DELETE_ALL_DEAD_TASKS_SUCCESS = "DELETE_ALL_DEAD_TASKS_SUCCESS"; -export const DELETE_ALL_DEAD_TASKS_ERROR = "DELETE_ALL_DEAD_TASKS_ERROR"; +export const DELETE_ARCHIVED_TASK_BEGIN = "DELETE_ARCHIVED_TASK_BEGIN"; +export const DELETE_ARCHIVED_TASK_SUCCESS = "DELETE_ARCHIVED_TASK_SUCCESS"; +export const DELETE_ARCHIVED_TASK_ERROR = "DELETE_ARCHIVED_TASK_ERROR"; +export const BATCH_RUN_ARCHIVED_TASKS_BEGIN = "BATCH_RUN_ARCHIVED_TASKS_BEGIN"; +export const BATCH_RUN_ARCHIVED_TASKS_SUCCESS = + "BATCH_RUN_ARCHIVED_TASKS_SUCCESS"; +export const BATCH_RUN_ARCHIVED_TASKS_ERROR = "BATCH_RUN_ARCHIVED_TASKS_ERROR"; +export const BATCH_DELETE_ARCHIVED_TASKS_BEGIN = + "BATCH_DELETE_ARCHIVED_TASKS_BEGIN"; +export const BATCH_DELETE_ARCHIVED_TASKS_SUCCESS = + "BATCH_DELETE_ARCHIVED_TASKS_SUCCESS"; +export const BATCH_DELETE_ARCHIVED_TASKS_ERROR = + "BATCH_DELETE_ARCHIVED_TASKS_ERROR"; +export const RUN_ALL_ARCHIVED_TASKS_BEGIN = "RUN_ALL_ARCHIVED_TASKS_BEGIN"; +export const RUN_ALL_ARCHIVED_TASKS_SUCCESS = "RUN_ALL_ARCHIVED_TASKS_SUCCESS"; +export const RUN_ALL_ARCHIVED_TASKS_ERROR = "RUN_ALL_ARCHIVED_TASKS_ERROR"; +export const DELETE_ALL_ARCHIVED_TASKS_BEGIN = + "DELETE_ALL_ARCHIVED_TASKS_BEGIN"; +export const DELETE_ALL_ARCHIVED_TASKS_SUCCESS = + "DELETE_ALL_ARCHIVED_TASKS_SUCCESS"; +export const DELETE_ALL_ARCHIVED_TASKS_ERROR = + "DELETE_ALL_ARCHIVED_TASKS_ERROR"; interface ListActiveTasksBeginAction { type: typeof LIST_ACTIVE_TASKS_BEGIN; @@ -230,19 +242,19 @@ interface ListRetryTasksErrorAction { error: string; // error description } -interface ListDeadTasksBeginAction { - type: typeof LIST_DEAD_TASKS_BEGIN; +interface ListArchivedTasksBeginAction { + type: typeof LIST_ARCHIVED_TASKS_BEGIN; queue: string; } -interface ListDeadTasksSuccessAction { - type: typeof LIST_DEAD_TASKS_SUCCESS; +interface ListArchivedTasksSuccessAction { + type: typeof LIST_ARCHIVED_TASKS_SUCCESS; queue: string; - payload: ListDeadTasksResponse; + payload: ListArchivedTasksResponse; } -interface ListDeadTasksErrorAction { - type: typeof LIST_DEAD_TASKS_ERROR; +interface ListArchivedTasksErrorAction { + type: typeof LIST_ARCHIVED_TASKS_ERROR; queue: string; error: string; // error description } @@ -320,20 +332,20 @@ interface RunScheduledTaskErrorAction { error: string; } -interface KillScheduledTaskBeginAction { - type: typeof KILL_SCHEDULED_TASK_BEGIN; +interface ArchiveScheduledTaskBeginAction { + type: typeof ARCHIVE_SCHEDULED_TASK_BEGIN; queue: string; taskKey: string; } -interface KillScheduledTaskSuccessAction { - type: typeof KILL_SCHEDULED_TASK_SUCCESS; +interface ArchiveScheduledTaskSuccessAction { + type: typeof ARCHIVE_SCHEDULED_TASK_SUCCESS; queue: string; taskKey: string; } -interface KillScheduledTaskErrorAction { - type: typeof KILL_SCHEDULED_TASK_ERROR; +interface ArchiveScheduledTaskErrorAction { + type: typeof ARCHIVE_SCHEDULED_TASK_ERROR; queue: string; taskKey: string; error: string; @@ -358,39 +370,39 @@ interface RunRetryTaskErrorAction { error: string; } -interface KillRetryTaskBeginAction { - type: typeof KILL_RETRY_TASK_BEGIN; +interface ArchiveRetryTaskBeginAction { + type: typeof ARCHIVE_RETRY_TASK_BEGIN; queue: string; taskKey: string; } -interface KillRetryTaskSuccessAction { - type: typeof KILL_RETRY_TASK_SUCCESS; +interface ArchiveRetryTaskSuccessAction { + type: typeof ARCHIVE_RETRY_TASK_SUCCESS; queue: string; taskKey: string; } -interface KillRetryTaskErrorAction { - type: typeof KILL_RETRY_TASK_ERROR; +interface ArchiveRetryTaskErrorAction { + type: typeof ARCHIVE_RETRY_TASK_ERROR; queue: string; taskKey: string; error: string; } -interface RunDeadTaskBeginAction { - type: typeof RUN_DEAD_TASK_BEGIN; +interface RunArchivedTaskBeginAction { + type: typeof RUN_ARCHIVED_TASK_BEGIN; queue: string; taskKey: string; } -interface RunDeadTaskSuccessAction { - type: typeof RUN_DEAD_TASK_SUCCESS; +interface RunArchivedTaskSuccessAction { + type: typeof RUN_ARCHIVED_TASK_SUCCESS; queue: string; taskKey: string; } -interface RunDeadTaskErrorAction { - type: typeof RUN_DEAD_TASK_ERROR; +interface RunArchivedTaskErrorAction { + type: typeof RUN_ARCHIVED_TASK_ERROR; queue: string; taskKey: string; error: string; @@ -469,37 +481,37 @@ interface RunAllScheduledTasksErrorAction { error: string; } -interface BatchKillScheduledTasksBeginAction { - type: typeof BATCH_KILL_SCHEDULED_TASKS_BEGIN; +interface BatchArchiveScheduledTasksBeginAction { + type: typeof BATCH_ARCHIVE_SCHEDULED_TASKS_BEGIN; queue: string; taskKeys: string[]; } -interface BatchKillScheduledTasksSuccessAction { - type: typeof BATCH_KILL_SCHEDULED_TASKS_SUCCESS; +interface BatchArchiveScheduledTasksSuccessAction { + type: typeof BATCH_ARCHIVE_SCHEDULED_TASKS_SUCCESS; queue: string; - payload: BatchKillTasksResponse; + payload: BatchArchiveTasksResponse; } -interface BatchKillScheduledTasksErrorAction { - type: typeof BATCH_KILL_SCHEDULED_TASKS_ERROR; +interface BatchArchiveScheduledTasksErrorAction { + type: typeof BATCH_ARCHIVE_SCHEDULED_TASKS_ERROR; queue: string; taskKeys: string[]; error: string; } -interface KillAllScheduledTasksBeginAction { - type: typeof KILL_ALL_SCHEDULED_TASKS_BEGIN; +interface ArchiveAllScheduledTasksBeginAction { + type: typeof ARCHIVE_ALL_SCHEDULED_TASKS_BEGIN; queue: string; } -interface KillAllScheduledTasksSuccessAction { - type: typeof KILL_ALL_SCHEDULED_TASKS_SUCCESS; +interface ArchiveAllScheduledTasksSuccessAction { + type: typeof ARCHIVE_ALL_SCHEDULED_TASKS_SUCCESS; queue: string; } -interface KillAllScheduledTasksErrorAction { - type: typeof KILL_ALL_SCHEDULED_TASKS_ERROR; +interface ArchiveAllScheduledTasksErrorAction { + type: typeof ARCHIVE_ALL_SCHEDULED_TASKS_ERROR; queue: string; error: string; } @@ -593,37 +605,37 @@ interface RunAllRetryTasksErrorAction { error: string; } -interface BatchKillRetryTasksBeginAction { - type: typeof BATCH_KILL_RETRY_TASKS_BEGIN; +interface BatchArchiveRetryTasksBeginAction { + type: typeof BATCH_ARCHIVE_RETRY_TASKS_BEGIN; queue: string; taskKeys: string[]; } -interface BatchKillRetryTasksSuccessAction { - type: typeof BATCH_KILL_RETRY_TASKS_SUCCESS; +interface BatchArchiveRetryTasksSuccessAction { + type: typeof BATCH_ARCHIVE_RETRY_TASKS_SUCCESS; queue: string; - payload: BatchKillTasksResponse; + payload: BatchArchiveTasksResponse; } -interface BatchKillRetryTasksErrorAction { - type: typeof BATCH_KILL_RETRY_TASKS_ERROR; +interface BatchArchiveRetryTasksErrorAction { + type: typeof BATCH_ARCHIVE_RETRY_TASKS_ERROR; queue: string; taskKeys: string[]; error: string; } -interface KillAllRetryTasksBeginAction { - type: typeof KILL_ALL_RETRY_TASKS_BEGIN; +interface ArchiveAllRetryTasksBeginAction { + type: typeof ARCHIVE_ALL_RETRY_TASKS_BEGIN; queue: string; } -interface KillAllRetryTasksSuccessAction { - type: typeof KILL_ALL_RETRY_TASKS_SUCCESS; +interface ArchiveAllRetryTasksSuccessAction { + type: typeof ARCHIVE_ALL_RETRY_TASKS_SUCCESS; queue: string; } -interface KillAllRetryTasksErrorAction { - type: typeof KILL_ALL_RETRY_TASKS_ERROR; +interface ArchiveAllRetryTasksErrorAction { + type: typeof ARCHIVE_ALL_RETRY_TASKS_ERROR; queue: string; error: string; } @@ -644,91 +656,91 @@ interface DeleteAllRetryTasksErrorAction { error: string; } -interface DeleteDeadTaskBeginAction { - type: typeof DELETE_DEAD_TASK_BEGIN; +interface DeleteArchivedTaskBeginAction { + type: typeof DELETE_ARCHIVED_TASK_BEGIN; queue: string; taskKey: string; } -interface DeleteDeadTaskSuccessAction { - type: typeof DELETE_DEAD_TASK_SUCCESS; +interface DeleteArchivedTaskSuccessAction { + type: typeof DELETE_ARCHIVED_TASK_SUCCESS; queue: string; taskKey: string; } -interface DeleteDeadTaskErrorAction { - type: typeof DELETE_DEAD_TASK_ERROR; +interface DeleteArchivedTaskErrorAction { + type: typeof DELETE_ARCHIVED_TASK_ERROR; queue: string; taskKey: string; error: string; } -interface BatchDeleteDeadTasksBeginAction { - type: typeof BATCH_DELETE_DEAD_TASKS_BEGIN; +interface BatchDeleteArchivedTasksBeginAction { + type: typeof BATCH_DELETE_ARCHIVED_TASKS_BEGIN; queue: string; taskKeys: string[]; } -interface BatchDeleteDeadTasksSuccessAction { - type: typeof BATCH_DELETE_DEAD_TASKS_SUCCESS; +interface BatchDeleteArchivedTasksSuccessAction { + type: typeof BATCH_DELETE_ARCHIVED_TASKS_SUCCESS; queue: string; payload: BatchDeleteTasksResponse; } -interface BatchDeleteDeadTasksErrorAction { - type: typeof BATCH_DELETE_DEAD_TASKS_ERROR; +interface BatchDeleteArchivedTasksErrorAction { + type: typeof BATCH_DELETE_ARCHIVED_TASKS_ERROR; queue: string; taskKeys: string[]; error: string; } -interface BatchRunDeadTasksBeginAction { - type: typeof BATCH_RUN_DEAD_TASKS_BEGIN; +interface BatchRunArchivedTasksBeginAction { + type: typeof BATCH_RUN_ARCHIVED_TASKS_BEGIN; queue: string; taskKeys: string[]; } -interface BatchRunDeadTasksSuccessAction { - type: typeof BATCH_RUN_DEAD_TASKS_SUCCESS; +interface BatchRunArchivedTasksSuccessAction { + type: typeof BATCH_RUN_ARCHIVED_TASKS_SUCCESS; queue: string; payload: BatchRunTasksResponse; } -interface BatchRunDeadTasksErrorAction { - type: typeof BATCH_RUN_DEAD_TASKS_ERROR; +interface BatchRunArchivedTasksErrorAction { + type: typeof BATCH_RUN_ARCHIVED_TASKS_ERROR; queue: string; taskKeys: string[]; error: string; } -interface RunAllDeadTasksBeginAction { - type: typeof RUN_ALL_DEAD_TASKS_BEGIN; +interface RunAllArchivedTasksBeginAction { + type: typeof RUN_ALL_ARCHIVED_TASKS_BEGIN; queue: string; } -interface RunAllDeadTasksSuccessAction { - type: typeof RUN_ALL_DEAD_TASKS_SUCCESS; +interface RunAllArchivedTasksSuccessAction { + type: typeof RUN_ALL_ARCHIVED_TASKS_SUCCESS; queue: string; } -interface RunAllDeadTasksErrorAction { - type: typeof RUN_ALL_DEAD_TASKS_ERROR; +interface RunAllArchivedTasksErrorAction { + type: typeof RUN_ALL_ARCHIVED_TASKS_ERROR; queue: string; error: string; } -interface DeleteAllDeadTasksBeginAction { - type: typeof DELETE_ALL_DEAD_TASKS_BEGIN; +interface DeleteAllArchivedTasksBeginAction { + type: typeof DELETE_ALL_ARCHIVED_TASKS_BEGIN; queue: string; } -interface DeleteAllDeadTasksSuccessAction { - type: typeof DELETE_ALL_DEAD_TASKS_SUCCESS; +interface DeleteAllArchivedTasksSuccessAction { + type: typeof DELETE_ALL_ARCHIVED_TASKS_SUCCESS; queue: string; } -interface DeleteAllDeadTasksErrorAction { - type: typeof DELETE_ALL_DEAD_TASKS_ERROR; +interface DeleteAllArchivedTasksErrorAction { + type: typeof DELETE_ALL_ARCHIVED_TASKS_ERROR; queue: string; error: string; } @@ -747,9 +759,9 @@ export type TasksActionTypes = | ListRetryTasksBeginAction | ListRetryTasksSuccessAction | ListRetryTasksErrorAction - | ListDeadTasksBeginAction - | ListDeadTasksSuccessAction - | ListDeadTasksErrorAction + | ListArchivedTasksBeginAction + | ListArchivedTasksSuccessAction + | ListArchivedTasksErrorAction | CancelActiveTaskBeginAction | CancelActiveTaskSuccessAction | CancelActiveTaskErrorAction @@ -765,15 +777,15 @@ export type TasksActionTypes = | RunRetryTaskBeginAction | RunRetryTaskSuccessAction | RunRetryTaskErrorAction - | RunDeadTaskBeginAction - | RunDeadTaskSuccessAction - | RunDeadTaskErrorAction - | KillScheduledTaskBeginAction - | KillScheduledTaskSuccessAction - | KillScheduledTaskErrorAction - | KillRetryTaskBeginAction - | KillRetryTaskSuccessAction - | KillRetryTaskErrorAction + | RunArchivedTaskBeginAction + | RunArchivedTaskSuccessAction + | RunArchivedTaskErrorAction + | ArchiveScheduledTaskBeginAction + | ArchiveScheduledTaskSuccessAction + | ArchiveScheduledTaskErrorAction + | ArchiveRetryTaskBeginAction + | ArchiveRetryTaskSuccessAction + | ArchiveRetryTaskErrorAction | DeleteScheduledTaskBeginAction | DeleteScheduledTaskSuccessAction | DeleteScheduledTaskErrorAction @@ -786,12 +798,12 @@ export type TasksActionTypes = | RunAllScheduledTasksBeginAction | RunAllScheduledTasksSuccessAction | RunAllScheduledTasksErrorAction - | BatchKillScheduledTasksBeginAction - | BatchKillScheduledTasksSuccessAction - | BatchKillScheduledTasksErrorAction - | KillAllScheduledTasksBeginAction - | KillAllScheduledTasksSuccessAction - | KillAllScheduledTasksErrorAction + | BatchArchiveScheduledTasksBeginAction + | BatchArchiveScheduledTasksSuccessAction + | BatchArchiveScheduledTasksErrorAction + | ArchiveAllScheduledTasksBeginAction + | ArchiveAllScheduledTasksSuccessAction + | ArchiveAllScheduledTasksErrorAction | DeleteAllScheduledTasksBeginAction | DeleteAllScheduledTasksSuccessAction | DeleteAllScheduledTasksErrorAction @@ -807,30 +819,30 @@ export type TasksActionTypes = | RunAllRetryTasksBeginAction | RunAllRetryTasksSuccessAction | RunAllRetryTasksErrorAction - | BatchKillRetryTasksBeginAction - | BatchKillRetryTasksSuccessAction - | BatchKillRetryTasksErrorAction - | KillAllRetryTasksBeginAction - | KillAllRetryTasksSuccessAction - | KillAllRetryTasksErrorAction + | BatchArchiveRetryTasksBeginAction + | BatchArchiveRetryTasksSuccessAction + | BatchArchiveRetryTasksErrorAction + | ArchiveAllRetryTasksBeginAction + | ArchiveAllRetryTasksSuccessAction + | ArchiveAllRetryTasksErrorAction | DeleteAllRetryTasksBeginAction | DeleteAllRetryTasksSuccessAction | DeleteAllRetryTasksErrorAction - | DeleteDeadTaskBeginAction - | DeleteDeadTaskSuccessAction - | DeleteDeadTaskErrorAction - | BatchDeleteDeadTasksBeginAction - | BatchDeleteDeadTasksSuccessAction - | BatchDeleteDeadTasksErrorAction - | BatchRunDeadTasksBeginAction - | BatchRunDeadTasksSuccessAction - | BatchRunDeadTasksErrorAction - | RunAllDeadTasksBeginAction - | RunAllDeadTasksSuccessAction - | RunAllDeadTasksErrorAction - | DeleteAllDeadTasksBeginAction - | DeleteAllDeadTasksSuccessAction - | DeleteAllDeadTasksErrorAction; + | DeleteArchivedTaskBeginAction + | DeleteArchivedTaskSuccessAction + | DeleteArchivedTaskErrorAction + | BatchDeleteArchivedTasksBeginAction + | BatchDeleteArchivedTasksSuccessAction + | BatchDeleteArchivedTasksErrorAction + | BatchRunArchivedTasksBeginAction + | BatchRunArchivedTasksSuccessAction + | BatchRunArchivedTasksErrorAction + | RunAllArchivedTasksBeginAction + | RunAllArchivedTasksSuccessAction + | RunAllArchivedTasksErrorAction + | DeleteAllArchivedTasksBeginAction + | DeleteAllArchivedTasksSuccessAction + | DeleteAllArchivedTasksErrorAction; export function listActiveTasksAsync( qname: string, @@ -924,24 +936,24 @@ export function listRetryTasksAsync( }; } -export function listDeadTasksAsync( +export function listArchivedTasksAsync( qname: string, pageOpts?: PaginationOptions ) { return async (dispatch: Dispatch) => { - dispatch({ type: LIST_DEAD_TASKS_BEGIN, queue: qname }); + dispatch({ type: LIST_ARCHIVED_TASKS_BEGIN, queue: qname }); try { - const response = await listDeadTasks(qname, pageOpts); + const response = await listArchivedTasks(qname, pageOpts); dispatch({ - type: LIST_DEAD_TASKS_SUCCESS, + type: LIST_ARCHIVED_TASKS_SUCCESS, queue: qname, payload: response, }); } catch { dispatch({ - type: LIST_DEAD_TASKS_ERROR, + type: LIST_ARCHIVED_TASKS_ERROR, queue: qname, - error: `Could not retreive dead tasks data for queue: ${qname}`, + error: `Could not retreive archived tasks data for queue: ${qname}`, }); } }; @@ -1039,17 +1051,17 @@ export function runRetryTaskAsync(queue: string, taskKey: string) { }; } -export function killScheduledTaskAsync(queue: string, taskKey: string) { +export function archiveScheduledTaskAsync(queue: string, taskKey: string) { return async (dispatch: Dispatch) => { - dispatch({ type: KILL_SCHEDULED_TASK_BEGIN, queue, taskKey }); + dispatch({ type: ARCHIVE_SCHEDULED_TASK_BEGIN, queue, taskKey }); try { - await killScheduledTask(queue, taskKey); - dispatch({ type: KILL_SCHEDULED_TASK_SUCCESS, queue, taskKey }); + await archiveScheduledTask(queue, taskKey); + dispatch({ type: ARCHIVE_SCHEDULED_TASK_SUCCESS, queue, taskKey }); } catch (error) { - console.error("killScheduledTaskAsync: ", error); + console.error("archiveScheduledTaskAsync: ", error); dispatch({ - type: KILL_SCHEDULED_TASK_ERROR, - error: `Could not kill task: ${taskKey}`, + type: ARCHIVE_SCHEDULED_TASK_ERROR, + error: `Could not archive task: ${taskKey}`, queue, taskKey, }); @@ -1057,17 +1069,17 @@ export function killScheduledTaskAsync(queue: string, taskKey: string) { }; } -export function killRetryTaskAsync(queue: string, taskKey: string) { +export function archiveRetryTaskAsync(queue: string, taskKey: string) { return async (dispatch: Dispatch) => { - dispatch({ type: KILL_RETRY_TASK_BEGIN, queue, taskKey }); + dispatch({ type: ARCHIVE_RETRY_TASK_BEGIN, queue, taskKey }); try { - await killRetryTask(queue, taskKey); - dispatch({ type: KILL_RETRY_TASK_SUCCESS, queue, taskKey }); + await archiveRetryTask(queue, taskKey); + dispatch({ type: ARCHIVE_RETRY_TASK_SUCCESS, queue, taskKey }); } catch (error) { - console.error("killRetryTaskAsync: ", error); + console.error("archiveRetryTaskAsync: ", error); dispatch({ - type: KILL_RETRY_TASK_ERROR, - error: `Could not kill task: ${taskKey}`, + type: ARCHIVE_RETRY_TASK_ERROR, + error: `Could not archive task: ${taskKey}`, queue, taskKey, }); @@ -1075,16 +1087,16 @@ export function killRetryTaskAsync(queue: string, taskKey: string) { }; } -export function runDeadTaskAsync(queue: string, taskKey: string) { +export function runArchivedTaskAsync(queue: string, taskKey: string) { return async (dispatch: Dispatch) => { - dispatch({ type: RUN_DEAD_TASK_BEGIN, queue, taskKey }); + dispatch({ type: RUN_ARCHIVED_TASK_BEGIN, queue, taskKey }); try { - await runDeadTask(queue, taskKey); - dispatch({ type: RUN_DEAD_TASK_SUCCESS, queue, taskKey }); + await runArchivedTask(queue, taskKey); + dispatch({ type: RUN_ARCHIVED_TASK_SUCCESS, queue, taskKey }); } catch (error) { - console.error("runDeadTaskAsync: ", error); + console.error("runArchivedTaskAsync: ", error); dispatch({ - type: RUN_DEAD_TASK_ERROR, + type: RUN_ARCHIVED_TASK_ERROR, error: `Could not run task: ${taskKey}`, queue, taskKey, @@ -1158,24 +1170,24 @@ export function batchRunScheduledTasksAsync(queue: string, taskKeys: string[]) { }; } -export function batchKillScheduledTasksAsync( +export function batchArchiveScheduledTasksAsync( queue: string, taskKeys: string[] ) { return async (dispatch: Dispatch) => { - dispatch({ type: BATCH_KILL_SCHEDULED_TASKS_BEGIN, queue, taskKeys }); + dispatch({ type: BATCH_ARCHIVE_SCHEDULED_TASKS_BEGIN, queue, taskKeys }); try { - const response = await batchKillScheduledTasks(queue, taskKeys); + const response = await batchArchiveScheduledTasks(queue, taskKeys); dispatch({ - type: BATCH_KILL_SCHEDULED_TASKS_SUCCESS, + type: BATCH_ARCHIVE_SCHEDULED_TASKS_SUCCESS, queue: queue, payload: response, }); } catch (error) { - console.error("batchKillScheduledTasksAsync: ", error); + console.error("batchArchiveScheduledTasksAsync: ", error); dispatch({ - type: BATCH_KILL_SCHEDULED_TASKS_ERROR, - error: `Could not batch kill tasks: ${taskKeys}`, + type: BATCH_ARCHIVE_SCHEDULED_TASKS_ERROR, + error: `Could not batch archive tasks: ${taskKeys}`, queue, taskKeys, }); @@ -1217,17 +1229,17 @@ export function runAllScheduledTasksAsync(queue: string) { }; } -export function killAllScheduledTasksAsync(queue: string) { +export function archiveAllScheduledTasksAsync(queue: string) { return async (dispatch: Dispatch) => { dispatch({ type: RUN_ALL_SCHEDULED_TASKS_BEGIN, queue }); try { - await killAllScheduledTasks(queue); + await archiveAllScheduledTasks(queue); dispatch({ type: RUN_ALL_SCHEDULED_TASKS_SUCCESS, queue }); } catch (error) { - console.error("killAllScheduledTasksAsync: ", error); + console.error("archiveAllScheduledTasksAsync: ", error); dispatch({ type: RUN_ALL_SCHEDULED_TASKS_ERROR, - error: `Could not kill all scheduled tasks`, + error: `Could not archive all scheduled tasks`, queue, }); } @@ -1296,21 +1308,21 @@ export function batchRunRetryTasksAsync(queue: string, taskKeys: string[]) { }; } -export function batchKillRetryTasksAsync(queue: string, taskKeys: string[]) { +export function batchArchiveRetryTasksAsync(queue: string, taskKeys: string[]) { return async (dispatch: Dispatch) => { - dispatch({ type: BATCH_KILL_RETRY_TASKS_BEGIN, queue, taskKeys }); + dispatch({ type: BATCH_ARCHIVE_RETRY_TASKS_BEGIN, queue, taskKeys }); try { - const response = await batchKillRetryTasks(queue, taskKeys); + const response = await batchArchiveRetryTasks(queue, taskKeys); dispatch({ - type: BATCH_KILL_RETRY_TASKS_SUCCESS, + type: BATCH_ARCHIVE_RETRY_TASKS_SUCCESS, queue: queue, payload: response, }); } catch (error) { - console.error("batchKillRetryTasksAsync: ", error); + console.error("batchArchiveRetryTasksAsync: ", error); dispatch({ - type: BATCH_KILL_RETRY_TASKS_ERROR, - error: `Could not batch kill tasks: ${taskKeys}`, + type: BATCH_ARCHIVE_RETRY_TASKS_ERROR, + error: `Could not batch archive tasks: ${taskKeys}`, queue, taskKeys, }); @@ -1352,33 +1364,33 @@ export function runAllRetryTasksAsync(queue: string) { }; } -export function killAllRetryTasksAsync(queue: string) { +export function archiveAllRetryTasksAsync(queue: string) { return async (dispatch: Dispatch) => { - dispatch({ type: KILL_ALL_RETRY_TASKS_BEGIN, queue }); + dispatch({ type: ARCHIVE_ALL_RETRY_TASKS_BEGIN, queue }); try { - await killAllRetryTasks(queue); - dispatch({ type: KILL_ALL_RETRY_TASKS_SUCCESS, queue }); + await archiveAllRetryTasks(queue); + dispatch({ type: ARCHIVE_ALL_RETRY_TASKS_SUCCESS, queue }); } catch (error) { - console.error("killAllRetryTasksAsync: ", error); + console.error("archiveAllRetryTasksAsync: ", error); dispatch({ - type: KILL_ALL_RETRY_TASKS_ERROR, - error: `Could not kill all retry tasks`, + type: ARCHIVE_ALL_RETRY_TASKS_ERROR, + error: `Could not archive all retry tasks`, queue, }); } }; } -export function deleteDeadTaskAsync(queue: string, taskKey: string) { +export function deleteArchivedTaskAsync(queue: string, taskKey: string) { return async (dispatch: Dispatch) => { - dispatch({ type: DELETE_DEAD_TASK_BEGIN, queue, taskKey }); + dispatch({ type: DELETE_ARCHIVED_TASK_BEGIN, queue, taskKey }); try { - await deleteDeadTask(queue, taskKey); - dispatch({ type: DELETE_DEAD_TASK_SUCCESS, queue, taskKey }); + await deleteArchivedTask(queue, taskKey); + dispatch({ type: DELETE_ARCHIVED_TASK_SUCCESS, queue, taskKey }); } catch (error) { - console.error("deleteDeadTaskAsync: ", error); + console.error("deleteArchivedTaskAsync: ", error); dispatch({ - type: DELETE_DEAD_TASK_ERROR, + type: DELETE_ARCHIVED_TASK_ERROR, error: `Could not delete task: ${taskKey}`, queue, taskKey, @@ -1387,20 +1399,23 @@ export function deleteDeadTaskAsync(queue: string, taskKey: string) { }; } -export function batchDeleteDeadTasksAsync(queue: string, taskKeys: string[]) { +export function batchDeleteArchivedTasksAsync( + queue: string, + taskKeys: string[] +) { return async (dispatch: Dispatch) => { - dispatch({ type: BATCH_DELETE_DEAD_TASKS_BEGIN, queue, taskKeys }); + dispatch({ type: BATCH_DELETE_ARCHIVED_TASKS_BEGIN, queue, taskKeys }); try { - const response = await batchDeleteDeadTasks(queue, taskKeys); + const response = await batchDeleteArchivedTasks(queue, taskKeys); dispatch({ - type: BATCH_DELETE_DEAD_TASKS_SUCCESS, + type: BATCH_DELETE_ARCHIVED_TASKS_SUCCESS, queue: queue, payload: response, }); } catch (error) { - console.error("batchDeleteDeadTasksAsync: ", error); + console.error("batchDeleteArchivedTasksAsync: ", error); dispatch({ - type: BATCH_DELETE_DEAD_TASKS_ERROR, + type: BATCH_DELETE_ARCHIVED_TASKS_ERROR, error: `Could not batch delete tasks: ${taskKeys}`, queue, taskKeys, @@ -1409,20 +1424,20 @@ export function batchDeleteDeadTasksAsync(queue: string, taskKeys: string[]) { }; } -export function batchRunDeadTasksAsync(queue: string, taskKeys: string[]) { +export function batchRunArchivedTasksAsync(queue: string, taskKeys: string[]) { return async (dispatch: Dispatch) => { - dispatch({ type: BATCH_RUN_DEAD_TASKS_BEGIN, queue, taskKeys }); + dispatch({ type: BATCH_RUN_ARCHIVED_TASKS_BEGIN, queue, taskKeys }); try { - const response = await batchRunDeadTasks(queue, taskKeys); + const response = await batchRunArchivedTasks(queue, taskKeys); dispatch({ - type: BATCH_RUN_DEAD_TASKS_SUCCESS, + type: BATCH_RUN_ARCHIVED_TASKS_SUCCESS, queue: queue, payload: response, }); } catch (error) { - console.error("batchRunDeadTasksAsync: ", error); + console.error("batchRunArchivedTasksAsync: ", error); dispatch({ - type: BATCH_RUN_DEAD_TASKS_ERROR, + type: BATCH_RUN_ARCHIVED_TASKS_ERROR, error: `Could not batch run tasks: ${taskKeys}`, queue, taskKeys, @@ -1431,34 +1446,34 @@ export function batchRunDeadTasksAsync(queue: string, taskKeys: string[]) { }; } -export function deleteAllDeadTasksAsync(queue: string) { +export function deleteAllArchivedTasksAsync(queue: string) { return async (dispatch: Dispatch) => { - dispatch({ type: DELETE_ALL_DEAD_TASKS_BEGIN, queue }); + dispatch({ type: DELETE_ALL_ARCHIVED_TASKS_BEGIN, queue }); try { - await deleteAllDeadTasks(queue); - dispatch({ type: DELETE_ALL_DEAD_TASKS_SUCCESS, queue }); + await deleteAllArchivedTasks(queue); + dispatch({ type: DELETE_ALL_ARCHIVED_TASKS_SUCCESS, queue }); } catch (error) { - console.error("deleteAllDeadTasksAsync: ", error); + console.error("deleteAllArchivedTasksAsync: ", error); dispatch({ - type: DELETE_ALL_DEAD_TASKS_ERROR, - error: `Could not delete all dead tasks`, + type: DELETE_ALL_ARCHIVED_TASKS_ERROR, + error: `Could not delete all archived tasks`, queue, }); } }; } -export function runAllDeadTasksAsync(queue: string) { +export function runAllArchivedTasksAsync(queue: string) { return async (dispatch: Dispatch) => { - dispatch({ type: RUN_ALL_DEAD_TASKS_BEGIN, queue }); + dispatch({ type: RUN_ALL_ARCHIVED_TASKS_BEGIN, queue }); try { - await runAllDeadTasks(queue); - dispatch({ type: RUN_ALL_DEAD_TASKS_SUCCESS, queue }); + await runAllArchivedTasks(queue); + dispatch({ type: RUN_ALL_ARCHIVED_TASKS_SUCCESS, queue }); } catch (error) { - console.error("runAllDeadTasksAsync: ", error); + console.error("runAllArchivedTasksAsync: ", error); dispatch({ - type: RUN_ALL_DEAD_TASKS_ERROR, - error: `Could not run all dead tasks`, + type: RUN_ALL_ARCHIVED_TASKS_ERROR, + error: `Could not run all archived tasks`, queue, }); } diff --git a/ui/src/api.ts b/ui/src/api.ts index 4d2f3f4..b6a7eb2 100644 --- a/ui/src/api.ts +++ b/ui/src/api.ts @@ -31,8 +31,8 @@ export interface ListRetryTasksResponse { stats: Queue; } -export interface ListDeadTasksResponse { - tasks: DeadTask[]; +export interface ListArchivedTasksResponse { + tasks: ArchivedTask[]; stats: Queue; } @@ -63,8 +63,8 @@ export interface BatchRunTasksResponse { error_keys: string[]; } -export interface BatchKillTasksResponse { - dead_keys: string[]; +export interface BatchArchiveTasksResponse { + archived_keys: string[]; error_keys: string[]; } @@ -221,7 +221,7 @@ export interface Queue { pending: number; scheduled: number; retry: number; - dead: number; + archived: number; processed: number; failed: number; timestamp: string; @@ -267,7 +267,7 @@ export interface RetryTask extends BaseTask { error_message: string; } -export interface DeadTask extends BaseTask { +export interface ArchivedTask extends BaseTask { id: string; key: string; queue: string; @@ -444,11 +444,11 @@ export async function listRetryTasks( return resp.data; } -export async function listDeadTasks( +export async function listArchivedTasks( qname: string, pageOpts?: PaginationOptions -): Promise { - let url = `${BASE_URL}/queues/${qname}/dead_tasks`; +): Promise { + let url = `${BASE_URL}/queues/${qname}/archived_tasks`; if (pageOpts) { url += `?${queryString.stringify(pageOpts)}`; } @@ -469,13 +469,13 @@ export async function runScheduledTask( }); } -export async function killScheduledTask( +export async function archiveScheduledTask( qname: string, taskKey: string ): Promise { await axios({ method: "post", - url: `${BASE_URL}/queues/${qname}/scheduled_tasks/${taskKey}:kill`, + url: `${BASE_URL}/queues/${qname}/scheduled_tasks/${taskKey}:archive`, }); } @@ -531,13 +531,13 @@ export async function runAllScheduledTasks(qname: string): Promise { }); } -export async function batchKillScheduledTasks( +export async function batchArchiveScheduledTasks( qname: string, taskKeys: string[] -): Promise { +): Promise { const resp = await axios({ method: "post", - url: `${BASE_URL}/queues/${qname}/scheduled_tasks:batch_kill`, + url: `${BASE_URL}/queues/${qname}/scheduled_tasks:batch_archive`, data: { task_keys: taskKeys, }, @@ -545,10 +545,10 @@ export async function batchKillScheduledTasks( return resp.data; } -export async function killAllScheduledTasks(qname: string): Promise { +export async function archiveAllScheduledTasks(qname: string): Promise { await axios({ method: "post", - url: `${BASE_URL}/queues/${qname}/scheduled_tasks:kill_all`, + url: `${BASE_URL}/queues/${qname}/scheduled_tasks:archive_all`, }); } @@ -562,13 +562,13 @@ export async function runRetryTask( }); } -export async function killRetryTask( +export async function archiveRetryTask( qname: string, taskKey: string ): Promise { await axios({ method: "post", - url: `${BASE_URL}/queues/${qname}/retry_tasks/${taskKey}:kill`, + url: `${BASE_URL}/queues/${qname}/retry_tasks/${taskKey}:archive`, }); } @@ -624,13 +624,13 @@ export async function runAllRetryTasks(qname: string): Promise { }); } -export async function batchKillRetryTasks( +export async function batchArchiveRetryTasks( qname: string, taskKeys: string[] -): Promise { +): Promise { const resp = await axios({ method: "post", - url: `${BASE_URL}/queues/${qname}/retry_tasks:batch_kill`, + url: `${BASE_URL}/queues/${qname}/retry_tasks:batch_archive`, data: { task_keys: taskKeys, }, @@ -638,40 +638,40 @@ export async function batchKillRetryTasks( return resp.data; } -export async function killAllRetryTasks(qname: string): Promise { +export async function archiveAllRetryTasks(qname: string): Promise { await axios({ method: "post", - url: `${BASE_URL}/queues/${qname}/retry_tasks:kill_all`, + url: `${BASE_URL}/queues/${qname}/retry_tasks:archive_all`, }); } -export async function runDeadTask( +export async function runArchivedTask( qname: string, taskKey: string ): Promise { await axios({ method: "post", - url: `${BASE_URL}/queues/${qname}/dead_tasks/${taskKey}:run`, + url: `${BASE_URL}/queues/${qname}/archived_tasks/${taskKey}:run`, }); } -export async function deleteDeadTask( +export async function deleteArchivedTask( qname: string, taskKey: string ): Promise { await axios({ method: "delete", - url: `${BASE_URL}/queues/${qname}/dead_tasks/${taskKey}`, + url: `${BASE_URL}/queues/${qname}/archived_tasks/${taskKey}`, }); } -export async function batchDeleteDeadTasks( +export async function batchDeleteArchivedTasks( qname: string, taskKeys: string[] ): Promise { const resp = await axios({ method: "post", - url: `${BASE_URL}/queues/${qname}/dead_tasks:batch_delete`, + url: `${BASE_URL}/queues/${qname}/archived_tasks:batch_delete`, data: { task_keys: taskKeys, }, @@ -679,20 +679,20 @@ export async function batchDeleteDeadTasks( return resp.data; } -export async function deleteAllDeadTasks(qname: string): Promise { +export async function deleteAllArchivedTasks(qname: string): Promise { await axios({ method: "delete", - url: `${BASE_URL}/queues/${qname}/dead_tasks:delete_all`, + url: `${BASE_URL}/queues/${qname}/archived_tasks:delete_all`, }); } -export async function batchRunDeadTasks( +export async function batchRunArchivedTasks( qname: string, taskKeys: string[] ): Promise { const resp = await axios({ method: "post", - url: `${BASE_URL}/queues/${qname}/dead_tasks:batch_run`, + url: `${BASE_URL}/queues/${qname}/archived_tasks:batch_run`, data: { task_keys: taskKeys, }, @@ -700,10 +700,10 @@ export async function batchRunDeadTasks( return resp.data; } -export async function runAllDeadTasks(qname: string): Promise { +export async function runAllArchivedTasks(qname: string): Promise { await axios({ method: "post", - url: `${BASE_URL}/queues/${qname}/dead_tasks:run_all`, + url: `${BASE_URL}/queues/${qname}/archived_tasks:run_all`, }); } diff --git a/ui/src/components/ArchivedTasksTable.tsx b/ui/src/components/ArchivedTasksTable.tsx new file mode 100644 index 0000000..02910b3 --- /dev/null +++ b/ui/src/components/ArchivedTasksTable.tsx @@ -0,0 +1,389 @@ +import React, { useCallback, useState } from "react"; +import clsx from "clsx"; +import { connect, ConnectedProps } from "react-redux"; +import { makeStyles } from "@material-ui/core/styles"; +import Table from "@material-ui/core/Table"; +import TableBody from "@material-ui/core/TableBody"; +import TableCell from "@material-ui/core/TableCell"; +import Checkbox from "@material-ui/core/Checkbox"; +import TableContainer from "@material-ui/core/TableContainer"; +import TableHead from "@material-ui/core/TableHead"; +import TableRow from "@material-ui/core/TableRow"; +import Tooltip from "@material-ui/core/Tooltip"; +import Paper from "@material-ui/core/Paper"; +import Box from "@material-ui/core/Box"; +import Collapse from "@material-ui/core/Collapse"; +import IconButton from "@material-ui/core/IconButton"; +import PlayArrowIcon from "@material-ui/icons/PlayArrow"; +import DeleteIcon from "@material-ui/icons/Delete"; +import MoreHorizIcon from "@material-ui/icons/MoreHoriz"; +import KeyboardArrowUpIcon from "@material-ui/icons/KeyboardArrowUp"; +import KeyboardArrowDownIcon from "@material-ui/icons/KeyboardArrowDown"; +import Typography from "@material-ui/core/Typography"; +import TableFooter from "@material-ui/core/TableFooter"; +import TablePagination from "@material-ui/core/TablePagination"; +import Alert from "@material-ui/lab/Alert"; +import AlertTitle from "@material-ui/lab/AlertTitle"; +import SyntaxHighlighter from "react-syntax-highlighter"; +import syntaxHighlightStyle from "react-syntax-highlighter/dist/esm/styles/hljs/github"; +import { AppState } from "../store"; +import { + batchDeleteArchivedTasksAsync, + batchRunArchivedTasksAsync, + deleteArchivedTaskAsync, + deleteAllArchivedTasksAsync, + listArchivedTasksAsync, + runArchivedTaskAsync, + runAllArchivedTasksAsync, +} from "../actions/tasksActions"; +import TablePaginationActions, { + defaultPageSize, + rowsPerPageOptions, +} from "./TablePaginationActions"; +import TableActions from "./TableActions"; +import { timeAgo, uuidPrefix } from "../utils"; +import { usePolling } from "../hooks"; +import { ArchivedTaskExtended } from "../reducers/tasksReducer"; +import { TableColumn } from "../types/table"; + +const useStyles = makeStyles({ + table: { + minWidth: 650, + }, +}); + +const useRowStyles = makeStyles({ + root: { + "& > *": { + borderBottom: "unset", + }, + }, + actionCell: { + width: "96px", + }, + activeActionCell: { + display: "flex", + justifyContent: "space-between", + }, +}); + +function mapStateToProps(state: AppState) { + return { + loading: state.tasks.archivedTasks.loading, + tasks: state.tasks.archivedTasks.data, + batchActionPending: state.tasks.archivedTasks.batchActionPending, + allActionPending: state.tasks.archivedTasks.allActionPending, + pollInterval: state.settings.pollInterval, + }; +} + +const mapDispatchToProps = { + listArchivedTasksAsync, + runArchivedTaskAsync, + runAllArchivedTasksAsync, + deleteArchivedTaskAsync, + deleteAllArchivedTasksAsync, + batchRunArchivedTasksAsync, + batchDeleteArchivedTasksAsync, +}; + +const connector = connect(mapStateToProps, mapDispatchToProps); + +type ReduxProps = ConnectedProps; + +interface Props { + queue: string; // name of the queue. + totalTaskCount: number; // totoal number of archived tasks. +} + +function ArchivedTasksTable(props: Props & ReduxProps) { + const { pollInterval, listArchivedTasksAsync, queue } = props; + const classes = useStyles(); + const [page, setPage] = useState(0); + const [pageSize, setPageSize] = useState(defaultPageSize); + const [selectedKeys, setSelectedKeys] = useState([]); + const [activeTaskId, setActiveTaskId] = useState(""); + + const handleChangePage = ( + event: React.MouseEvent | null, + newPage: number + ) => { + setPage(newPage); + }; + + const handleChangeRowsPerPage = ( + event: React.ChangeEvent + ) => { + setPageSize(parseInt(event.target.value, 10)); + setPage(0); + }; + + const handleSelectAllClick = (event: React.ChangeEvent) => { + if (event.target.checked) { + const newSelected = props.tasks.map((t) => t.key); + setSelectedKeys(newSelected); + } else { + setSelectedKeys([]); + } + }; + + const handleRunAllClick = () => { + props.runAllArchivedTasksAsync(queue); + }; + + const handleDeleteAllClick = () => { + props.deleteAllArchivedTasksAsync(queue); + }; + + const handleBatchRunClick = () => { + props + .batchRunArchivedTasksAsync(queue, selectedKeys) + .then(() => setSelectedKeys([])); + }; + + const handleBatchDeleteClick = () => { + props + .batchDeleteArchivedTasksAsync(queue, selectedKeys) + .then(() => setSelectedKeys([])); + }; + + const fetchData = useCallback(() => { + const pageOpts = { page: page + 1, size: pageSize }; + listArchivedTasksAsync(queue, pageOpts); + }, [page, pageSize, queue, listArchivedTasksAsync]); + + usePolling(fetchData, pollInterval); + + if (props.tasks.length === 0) { + return ( + + Info + No archived tasks at this time. + + ); + } + + const columns: TableColumn[] = [ + { key: "icon", label: "", align: "left" }, + { key: "id", label: "ID", align: "left" }, + { key: "type", label: "Type", align: "left" }, + { key: "last_failed", label: "Last Failed", align: "left" }, + { key: "last_error", label: "Last Error", align: "left" }, + { key: "actions", label: "Actions", align: "center" }, + ]; + + const rowCount = props.tasks.length; + const numSelected = selectedKeys.length; + return ( +
+ 0} + iconButtonActions={[ + { + tooltip: "Delete", + icon: , + onClick: handleBatchDeleteClick, + disabled: props.batchActionPending, + }, + { + tooltip: "Run", + icon: , + onClick: handleBatchRunClick, + disabled: props.batchActionPending, + }, + ]} + menuItemActions={[ + { + label: "Delete All", + onClick: handleDeleteAllClick, + disabled: props.allActionPending, + }, + { + label: "Run All", + onClick: handleRunAllClick, + disabled: props.allActionPending, + }, + ]} + /> + + + + + + 0 && numSelected < rowCount} + checked={rowCount > 0 && numSelected === rowCount} + onChange={handleSelectAllClick} + inputProps={{ + "aria-label": "select all tasks shown in the table", + }} + /> + + {columns.map((col) => ( + + {col.label} + + ))} + + + + {props.tasks.map((task) => ( + { + if (checked) { + setSelectedKeys(selectedKeys.concat(task.key)); + } else { + setSelectedKeys( + selectedKeys.filter((key) => key !== task.key) + ); + } + }} + onRunClick={() => { + props.runArchivedTaskAsync(queue, task.key); + }} + onDeleteClick={() => { + props.deleteArchivedTaskAsync(queue, task.key); + }} + allActionPending={props.allActionPending} + onActionCellEnter={() => setActiveTaskId(task.id)} + onActionCellLeave={() => setActiveTaskId("")} + showActions={activeTaskId === task.id} + /> + ))} + + + + + + +
+ +
+ ); +} + +interface RowProps { + task: ArchivedTaskExtended; + isSelected: boolean; + onSelectChange: (checked: boolean) => void; + onRunClick: () => void; + onDeleteClick: () => void; + allActionPending: boolean; + showActions: boolean; + onActionCellEnter: () => void; + onActionCellLeave: () => void; +} + +function Row(props: RowProps) { + const { task } = props; + const [open, setOpen] = useState(false); + const classes = useRowStyles(); + return ( + + + + ) => + props.onSelectChange(event.target.checked) + } + checked={props.isSelected} + /> + + + + setOpen(!open)} + > + {open ? : } + + + + + {uuidPrefix(task.id)} + + {task.type} + {timeAgo(task.last_failed_at)} + {task.error_message} + + {props.showActions ? ( + + + + + + + + + + + + + ) : ( + + + + )} + + + + + + + + Payload + + + {JSON.stringify(task.payload, null, 2)} + + + + + + + ); +} + +export default connector(ArchivedTasksTable); diff --git a/ui/src/components/DeadTasksTable.tsx b/ui/src/components/DeadTasksTable.tsx index ad773b1..02910b3 100644 --- a/ui/src/components/DeadTasksTable.tsx +++ b/ui/src/components/DeadTasksTable.tsx @@ -28,13 +28,13 @@ import SyntaxHighlighter from "react-syntax-highlighter"; import syntaxHighlightStyle from "react-syntax-highlighter/dist/esm/styles/hljs/github"; import { AppState } from "../store"; import { - batchDeleteDeadTasksAsync, - batchRunDeadTasksAsync, - deleteDeadTaskAsync, - deleteAllDeadTasksAsync, - listDeadTasksAsync, - runDeadTaskAsync, - runAllDeadTasksAsync, + batchDeleteArchivedTasksAsync, + batchRunArchivedTasksAsync, + deleteArchivedTaskAsync, + deleteAllArchivedTasksAsync, + listArchivedTasksAsync, + runArchivedTaskAsync, + runAllArchivedTasksAsync, } from "../actions/tasksActions"; import TablePaginationActions, { defaultPageSize, @@ -43,7 +43,7 @@ import TablePaginationActions, { import TableActions from "./TableActions"; import { timeAgo, uuidPrefix } from "../utils"; import { usePolling } from "../hooks"; -import { DeadTaskExtended } from "../reducers/tasksReducer"; +import { ArchivedTaskExtended } from "../reducers/tasksReducer"; import { TableColumn } from "../types/table"; const useStyles = makeStyles({ @@ -69,22 +69,22 @@ const useRowStyles = makeStyles({ function mapStateToProps(state: AppState) { return { - loading: state.tasks.deadTasks.loading, - tasks: state.tasks.deadTasks.data, - batchActionPending: state.tasks.deadTasks.batchActionPending, - allActionPending: state.tasks.deadTasks.allActionPending, + loading: state.tasks.archivedTasks.loading, + tasks: state.tasks.archivedTasks.data, + batchActionPending: state.tasks.archivedTasks.batchActionPending, + allActionPending: state.tasks.archivedTasks.allActionPending, pollInterval: state.settings.pollInterval, }; } const mapDispatchToProps = { - listDeadTasksAsync, - runDeadTaskAsync, - runAllDeadTasksAsync, - deleteDeadTaskAsync, - deleteAllDeadTasksAsync, - batchRunDeadTasksAsync, - batchDeleteDeadTasksAsync, + listArchivedTasksAsync, + runArchivedTaskAsync, + runAllArchivedTasksAsync, + deleteArchivedTaskAsync, + deleteAllArchivedTasksAsync, + batchRunArchivedTasksAsync, + batchDeleteArchivedTasksAsync, }; const connector = connect(mapStateToProps, mapDispatchToProps); @@ -93,11 +93,11 @@ type ReduxProps = ConnectedProps; interface Props { queue: string; // name of the queue. - totalTaskCount: number; // totoal number of dead tasks. + totalTaskCount: number; // totoal number of archived tasks. } -function DeadTasksTable(props: Props & ReduxProps) { - const { pollInterval, listDeadTasksAsync, queue } = props; +function ArchivedTasksTable(props: Props & ReduxProps) { + const { pollInterval, listArchivedTasksAsync, queue } = props; const classes = useStyles(); const [page, setPage] = useState(0); const [pageSize, setPageSize] = useState(defaultPageSize); @@ -128,29 +128,29 @@ function DeadTasksTable(props: Props & ReduxProps) { }; const handleRunAllClick = () => { - props.runAllDeadTasksAsync(queue); + props.runAllArchivedTasksAsync(queue); }; const handleDeleteAllClick = () => { - props.deleteAllDeadTasksAsync(queue); + props.deleteAllArchivedTasksAsync(queue); }; const handleBatchRunClick = () => { props - .batchRunDeadTasksAsync(queue, selectedKeys) + .batchRunArchivedTasksAsync(queue, selectedKeys) .then(() => setSelectedKeys([])); }; const handleBatchDeleteClick = () => { props - .batchDeleteDeadTasksAsync(queue, selectedKeys) + .batchDeleteArchivedTasksAsync(queue, selectedKeys) .then(() => setSelectedKeys([])); }; const fetchData = useCallback(() => { const pageOpts = { page: page + 1, size: pageSize }; - listDeadTasksAsync(queue, pageOpts); - }, [page, pageSize, queue, listDeadTasksAsync]); + listArchivedTasksAsync(queue, pageOpts); + }, [page, pageSize, queue, listArchivedTasksAsync]); usePolling(fetchData, pollInterval); @@ -158,7 +158,7 @@ function DeadTasksTable(props: Props & ReduxProps) { return ( Info - No dead tasks at this time. + No archived tasks at this time. ); } @@ -209,7 +209,7 @@ function DeadTasksTable(props: Props & ReduxProps) { @@ -247,10 +247,10 @@ function DeadTasksTable(props: Props & ReduxProps) { } }} onRunClick={() => { - props.runDeadTaskAsync(queue, task.key); + props.runArchivedTaskAsync(queue, task.key); }} onDeleteClick={() => { - props.deleteDeadTaskAsync(queue, task.key); + props.deleteArchivedTaskAsync(queue, task.key); }} allActionPending={props.allActionPending} onActionCellEnter={() => setActiveTaskId(task.id)} @@ -284,7 +284,7 @@ function DeadTasksTable(props: Props & ReduxProps) { } interface RowProps { - task: DeadTaskExtended; + task: ArchivedTaskExtended; isSelected: boolean; onSelectChange: (checked: boolean) => void; onRunClick: () => void; @@ -386,4 +386,4 @@ function Row(props: RowProps) { ); } -export default connector(DeadTasksTable); +export default connector(ArchivedTasksTable); diff --git a/ui/src/components/QueueSizeChart.tsx b/ui/src/components/QueueSizeChart.tsx index f3d0304..63ae21e 100644 --- a/ui/src/components/QueueSizeChart.tsx +++ b/ui/src/components/QueueSizeChart.tsx @@ -20,7 +20,7 @@ interface TaskBreakdown { pending: number; // number of pending tasks in the queue. scheduled: number; // number of scheduled tasks in the queue. retry: number; // number of retry tasks in the queue. - dead: number; // number of dead tasks in the queue. + archived: number; // number of archived tasks in the queue. } function QueueSizeChart(props: Props) { @@ -36,7 +36,7 @@ function QueueSizeChart(props: Props) { - + ); diff --git a/ui/src/components/QueuesOverviewTable.tsx b/ui/src/components/QueuesOverviewTable.tsx index 5bd91a7..df9a051 100644 --- a/ui/src/components/QueuesOverviewTable.tsx +++ b/ui/src/components/QueuesOverviewTable.tsx @@ -67,7 +67,7 @@ enum SortBy { Pending, Scheduled, Retry, - Dead, + Archived, None, // no sort support } @@ -84,7 +84,12 @@ const colConfigs: SortableTableColumn[] = [ align: "right", }, { label: "Retry", key: "retry", sortBy: SortBy.Retry, align: "right" }, - { label: "Dead", key: "dead", sortBy: SortBy.Dead, align: "right" }, + { + label: "Archived", + key: "archived", + sortBy: SortBy.Archived, + align: "right", + }, { label: "Actions", key: "actions", sortBy: SortBy.None, align: "center" }, ]; @@ -148,9 +153,9 @@ export default function QueuesOverviewTable(props: Props) { if (q1.retry === q2.retry) return 0; isQ1Smaller = q1.retry < q2.retry; break; - case SortBy.Dead: - if (q1.dead === q2.dead) return 0; - isQ1Smaller = q1.dead < q2.dead; + case SortBy.Archived: + if (q1.archived === q2.archived) return 0; + isQ1Smaller = q1.archived < q2.archived; break; default: // eslint-disable-next-line no-throw-literal @@ -248,10 +253,10 @@ export default function QueuesOverviewTable(props: Props) { - {q.dead} + {q.archived} @@ -318,7 +323,7 @@ export default function QueuesOverviewTable(props: Props) { {total.retry} - {total.dead} + {total.archived} @@ -338,7 +343,7 @@ interface AggregateCounts { pending: number; scheduled: number; retry: number; - dead: number; + archived: number; } function getAggregateCounts(queues: Queue[]): AggregateCounts { @@ -348,7 +353,7 @@ function getAggregateCounts(queues: Queue[]): AggregateCounts { pending: 0, scheduled: 0, retry: 0, - dead: 0, + archived: 0, }; queues.forEach((q) => { total.size += q.size; @@ -356,7 +361,7 @@ function getAggregateCounts(queues: Queue[]): AggregateCounts { total.pending += q.pending; total.scheduled += q.scheduled; total.retry += q.retry; - total.dead += q.dead; + total.archived += q.archived; }); return total; } diff --git a/ui/src/components/RetryTasksTable.tsx b/ui/src/components/RetryTasksTable.tsx index 32273df..02b7084 100644 --- a/ui/src/components/RetryTasksTable.tsx +++ b/ui/src/components/RetryTasksTable.tsx @@ -29,14 +29,14 @@ import syntaxHighlightStyle from "react-syntax-highlighter/dist/esm/styles/hljs/ import { batchDeleteRetryTasksAsync, batchRunRetryTasksAsync, - batchKillRetryTasksAsync, + batchArchiveRetryTasksAsync, deleteAllRetryTasksAsync, runAllRetryTasksAsync, - killAllRetryTasksAsync, + archiveAllRetryTasksAsync, listRetryTasksAsync, deleteRetryTaskAsync, runRetryTaskAsync, - killRetryTaskAsync, + archiveRetryTaskAsync, } from "../actions/tasksActions"; import { AppState } from "../store"; import TablePaginationActions, { @@ -69,14 +69,14 @@ function mapStateToProps(state: AppState) { const mapDispatchToProps = { batchDeleteRetryTasksAsync, batchRunRetryTasksAsync, - batchKillRetryTasksAsync, + batchArchiveRetryTasksAsync, deleteAllRetryTasksAsync, runAllRetryTasksAsync, - killAllRetryTasksAsync, + archiveAllRetryTasksAsync, listRetryTasksAsync, deleteRetryTaskAsync, runRetryTaskAsync, - killRetryTaskAsync, + archiveRetryTaskAsync, }; const connector = connect(mapStateToProps, mapDispatchToProps); @@ -127,8 +127,8 @@ function RetryTasksTable(props: Props & ReduxProps) { props.deleteAllRetryTasksAsync(queue); }; - const handleKillAllClick = () => { - props.killAllRetryTasksAsync(queue); + const handleArchiveAllClick = () => { + props.archiveAllRetryTasksAsync(queue); }; const handleBatchRunClick = () => { @@ -143,9 +143,9 @@ function RetryTasksTable(props: Props & ReduxProps) { .then(() => setSelectedKeys([])); }; - const handleBatchKillClick = () => { + const handleBatchArchiveClick = () => { props - .batchKillRetryTasksAsync(queue, selectedKeys) + .batchArchiveRetryTasksAsync(queue, selectedKeys) .then(() => setSelectedKeys([])); }; @@ -190,9 +190,9 @@ function RetryTasksTable(props: Props & ReduxProps) { disabled: props.batchActionPending, }, { - tooltip: "Kill", + tooltip: "Archive", icon: , - onClick: handleBatchKillClick, + onClick: handleBatchArchiveClick, disabled: props.batchActionPending, }, { @@ -209,8 +209,8 @@ function RetryTasksTable(props: Props & ReduxProps) { disabled: props.allActionPending, }, { - label: "Kill All", - onClick: handleKillAllClick, + label: "Archive All", + onClick: handleArchiveAllClick, disabled: props.allActionPending, }, { @@ -268,8 +268,8 @@ function RetryTasksTable(props: Props & ReduxProps) { onDeleteClick={() => { props.deleteRetryTaskAsync(task.queue, task.key); }} - onKillClick={() => { - props.killRetryTaskAsync(task.queue, task.key); + onArchiveClick={() => { + props.archiveRetryTaskAsync(task.queue, task.key); }} onActionCellEnter={() => setActiveTaskId(task.id)} onActionCellLeave={() => setActiveTaskId("")} @@ -322,7 +322,7 @@ interface RowProps { onSelectChange: (checked: boolean) => void; onDeleteClick: () => void; onRunClick: () => void; - onKillClick: () => void; + onArchiveClick: () => void; allActionPending: boolean; showActions: boolean; onActionCellEnter: () => void; @@ -387,9 +387,9 @@ function Row(props: RowProps) { - + diff --git a/ui/src/components/ScheduledTasksTable.tsx b/ui/src/components/ScheduledTasksTable.tsx index 87c33a6..d115eb4 100644 --- a/ui/src/components/ScheduledTasksTable.tsx +++ b/ui/src/components/ScheduledTasksTable.tsx @@ -30,14 +30,14 @@ import syntaxHighlightStyle from "react-syntax-highlighter/dist/esm/styles/hljs/ import { batchDeleteScheduledTasksAsync, batchRunScheduledTasksAsync, - batchKillScheduledTasksAsync, + batchArchiveScheduledTasksAsync, deleteAllScheduledTasksAsync, runAllScheduledTasksAsync, - killAllScheduledTasksAsync, + archiveAllScheduledTasksAsync, listScheduledTasksAsync, deleteScheduledTaskAsync, runScheduledTaskAsync, - killScheduledTaskAsync, + archiveScheduledTaskAsync, } from "../actions/tasksActions"; import { AppState } from "../store"; import TablePaginationActions, { @@ -70,13 +70,13 @@ const mapDispatchToProps = { listScheduledTasksAsync, batchDeleteScheduledTasksAsync, batchRunScheduledTasksAsync, - batchKillScheduledTasksAsync, + batchArchiveScheduledTasksAsync, deleteAllScheduledTasksAsync, runAllScheduledTasksAsync, - killAllScheduledTasksAsync, + archiveAllScheduledTasksAsync, deleteScheduledTaskAsync, runScheduledTaskAsync, - killScheduledTaskAsync, + archiveScheduledTaskAsync, }; const connector = connect(mapStateToProps, mapDispatchToProps); @@ -127,8 +127,8 @@ function ScheduledTasksTable(props: Props & ReduxProps) { props.deleteAllScheduledTasksAsync(queue); }; - const handleKillAllClick = () => { - props.killAllScheduledTasksAsync(queue); + const handleArchiveAllClick = () => { + props.archiveAllScheduledTasksAsync(queue); }; const handleBatchRunClick = () => { @@ -143,9 +143,9 @@ function ScheduledTasksTable(props: Props & ReduxProps) { .then(() => setSelectedKeys([])); }; - const handleBatchKillClick = () => { + const handleBatchArchiveClick = () => { props - .batchKillScheduledTasksAsync(queue, selectedKeys) + .batchArchiveScheduledTasksAsync(queue, selectedKeys) .then(() => setSelectedKeys([])); }; @@ -187,9 +187,9 @@ function ScheduledTasksTable(props: Props & ReduxProps) { disabled: props.batchActionPending, }, { - tooltip: "Kill", + tooltip: "Archive", icon: , - onClick: handleBatchKillClick, + onClick: handleBatchArchiveClick, disabled: props.batchActionPending, }, { @@ -206,8 +206,8 @@ function ScheduledTasksTable(props: Props & ReduxProps) { disabled: props.allActionPending, }, { - label: "Kill All", - onClick: handleKillAllClick, + label: "Archive All", + onClick: handleArchiveAllClick, disabled: props.allActionPending, }, { @@ -265,8 +265,8 @@ function ScheduledTasksTable(props: Props & ReduxProps) { onDeleteClick={() => { props.deleteScheduledTaskAsync(queue, task.key); }} - onKillClick={() => { - props.killScheduledTaskAsync(queue, task.key); + onArchiveClick={() => { + props.archiveScheduledTaskAsync(queue, task.key); }} onActionCellEnter={() => setActiveTaskId(task.id)} onActionCellLeave={() => setActiveTaskId("")} @@ -319,7 +319,7 @@ interface RowProps { onSelectChange: (checked: boolean) => void; onRunClick: () => void; onDeleteClick: () => void; - onKillClick: () => void; + onArchiveClick: () => void; allActionPending: boolean; showActions: boolean; onActionCellEnter: () => void; @@ -381,9 +381,9 @@ function Row(props: RowProps) { - + diff --git a/ui/src/components/TasksTable.tsx b/ui/src/components/TasksTable.tsx index 95d2784..31e7891 100644 --- a/ui/src/components/TasksTable.tsx +++ b/ui/src/components/TasksTable.tsx @@ -8,7 +8,7 @@ import ActiveTasksTable from "./ActiveTasksTable"; import PendingTasksTable from "./PendingTasksTable"; import ScheduledTasksTable from "./ScheduledTasksTable"; import RetryTasksTable from "./RetryTasksTable"; -import DeadTasksTable from "./DeadTasksTable"; +import ArchivedTasksTable from "./ArchivedTasksTable"; import { useHistory } from "react-router-dom"; import { queueDetailsPath } from "../paths"; import { Typography } from "@material-ui/core"; @@ -166,7 +166,7 @@ function mapStatetoProps(state: AppState, ownProps: Props) { pending: 0, scheduled: 0, retry: 0, - dead: 0, + archived: 0, processed: 0, failed: 0, timestamp: "n/a", @@ -246,15 +246,15 @@ function TasksTable(props: Props & ReduxProps) { {...a11yProps("retry")} /> {currentStats.dead}} + value="archived" + label="Archived" + icon={{currentStats.archived}} classes={{ root: classes.tabroot, wrapper: classes.tabwrapper, selected: classes.tabSelected, }} - {...a11yProps("dead")} + {...a11yProps("archived")} /> @@ -311,7 +311,7 @@ function TasksTable(props: Props & ReduxProps) { /> - + - diff --git a/ui/src/reducers/queuesReducer.ts b/ui/src/reducers/queuesReducer.ts index 0eb6fa4..bf29f27 100644 --- a/ui/src/reducers/queuesReducer.ts +++ b/ui/src/reducers/queuesReducer.ts @@ -14,33 +14,33 @@ import { LIST_QUEUES_ERROR, } from "../actions/queuesActions"; import { - BATCH_DELETE_DEAD_TASKS_SUCCESS, + BATCH_DELETE_ARCHIVED_TASKS_SUCCESS, BATCH_DELETE_RETRY_TASKS_SUCCESS, BATCH_DELETE_SCHEDULED_TASKS_SUCCESS, - BATCH_KILL_RETRY_TASKS_SUCCESS, - BATCH_KILL_SCHEDULED_TASKS_SUCCESS, - BATCH_RUN_DEAD_TASKS_SUCCESS, + BATCH_ARCHIVE_RETRY_TASKS_SUCCESS, + BATCH_ARCHIVE_SCHEDULED_TASKS_SUCCESS, + BATCH_RUN_ARCHIVED_TASKS_SUCCESS, BATCH_RUN_RETRY_TASKS_SUCCESS, BATCH_RUN_SCHEDULED_TASKS_SUCCESS, - DELETE_ALL_DEAD_TASKS_SUCCESS, + DELETE_ALL_ARCHIVED_TASKS_SUCCESS, DELETE_ALL_RETRY_TASKS_SUCCESS, DELETE_ALL_SCHEDULED_TASKS_SUCCESS, - DELETE_DEAD_TASK_SUCCESS, + DELETE_ARCHIVED_TASK_SUCCESS, DELETE_RETRY_TASK_SUCCESS, DELETE_SCHEDULED_TASK_SUCCESS, - KILL_ALL_RETRY_TASKS_SUCCESS, - KILL_ALL_SCHEDULED_TASKS_SUCCESS, - KILL_RETRY_TASK_SUCCESS, - KILL_SCHEDULED_TASK_SUCCESS, + ARCHIVE_ALL_RETRY_TASKS_SUCCESS, + ARCHIVE_ALL_SCHEDULED_TASKS_SUCCESS, + ARCHIVE_RETRY_TASK_SUCCESS, + ARCHIVE_SCHEDULED_TASK_SUCCESS, LIST_ACTIVE_TASKS_SUCCESS, - LIST_DEAD_TASKS_SUCCESS, + LIST_ARCHIVED_TASKS_SUCCESS, LIST_PENDING_TASKS_SUCCESS, LIST_RETRY_TASKS_SUCCESS, LIST_SCHEDULED_TASKS_SUCCESS, - RUN_ALL_DEAD_TASKS_SUCCESS, + RUN_ALL_ARCHIVED_TASKS_SUCCESS, RUN_ALL_RETRY_TASKS_SUCCESS, RUN_ALL_SCHEDULED_TASKS_SUCCESS, - RUN_DEAD_TASK_SUCCESS, + RUN_ARCHIVED_TASK_SUCCESS, RUN_RETRY_TASK_SUCCESS, RUN_SCHEDULED_TASK_SUCCESS, TasksActionTypes, @@ -155,7 +155,7 @@ function queuesReducer( case LIST_PENDING_TASKS_SUCCESS: case LIST_SCHEDULED_TASKS_SUCCESS: case LIST_RETRY_TASKS_SUCCESS: - case LIST_DEAD_TASKS_SUCCESS: { + case LIST_ARCHIVED_TASKS_SUCCESS: { const newData = state.data .filter((queueInfo) => queueInfo.name !== action.queue) .concat({ @@ -200,7 +200,7 @@ function queuesReducer( return { ...state, data: newData }; } - case RUN_DEAD_TASK_SUCCESS: { + case RUN_ARCHIVED_TASK_SUCCESS: { const newData = state.data.map((queueInfo) => { if (queueInfo.name !== action.queue) { return queueInfo; @@ -210,14 +210,14 @@ function queuesReducer( currentStats: { ...queueInfo.currentStats, pending: queueInfo.currentStats.pending + 1, - dead: queueInfo.currentStats.dead - 1, + archived: queueInfo.currentStats.archived - 1, }, }; }); return { ...state, data: newData }; } - case KILL_SCHEDULED_TASK_SUCCESS: { + case ARCHIVE_SCHEDULED_TASK_SUCCESS: { const newData = state.data.map((queueInfo) => { if (queueInfo.name !== action.queue) { return queueInfo; @@ -226,7 +226,7 @@ function queuesReducer( ...queueInfo, currentStats: { ...queueInfo.currentStats, - dead: queueInfo.currentStats.dead + 1, + archived: queueInfo.currentStats.archived + 1, scheduled: queueInfo.currentStats.scheduled - 1, }, }; @@ -234,7 +234,7 @@ function queuesReducer( return { ...state, data: newData }; } - case KILL_RETRY_TASK_SUCCESS: { + case ARCHIVE_RETRY_TASK_SUCCESS: { const newData = state.data.map((queueInfo) => { if (queueInfo.name !== action.queue) { return queueInfo; @@ -243,7 +243,7 @@ function queuesReducer( ...queueInfo, currentStats: { ...queueInfo.currentStats, - dead: queueInfo.currentStats.dead + 1, + archived: queueInfo.currentStats.archived + 1, retry: queueInfo.currentStats.retry - 1, }, }; @@ -288,7 +288,7 @@ function queuesReducer( return { ...state, data: newData }; } - case BATCH_KILL_SCHEDULED_TASKS_SUCCESS: { + case BATCH_ARCHIVE_SCHEDULED_TASKS_SUCCESS: { const newData = state.data.map((queueInfo) => { if (queueInfo.name !== action.queue) { return queueInfo; @@ -297,10 +297,12 @@ function queuesReducer( ...queueInfo, currentStats: { ...queueInfo.currentStats, - dead: queueInfo.currentStats.dead + action.payload.dead_keys.length, + archived: + queueInfo.currentStats.archived + + action.payload.archived_keys.length, scheduled: queueInfo.currentStats.scheduled - - action.payload.dead_keys.length, + action.payload.archived_keys.length, }, }; }); @@ -343,7 +345,7 @@ function queuesReducer( return { ...state, data: newData }; } - case KILL_ALL_SCHEDULED_TASKS_SUCCESS: { + case ARCHIVE_ALL_SCHEDULED_TASKS_SUCCESS: { const newData = state.data.map((queueInfo) => { if (queueInfo.name !== action.queue) { return queueInfo; @@ -352,8 +354,9 @@ function queuesReducer( ...queueInfo, currentStats: { ...queueInfo.currentStats, - dead: - queueInfo.currentStats.dead + queueInfo.currentStats.scheduled, + archived: + queueInfo.currentStats.archived + + queueInfo.currentStats.scheduled, scheduled: 0, }, }; @@ -413,7 +416,7 @@ function queuesReducer( return { ...state, data: newData }; } - case BATCH_KILL_RETRY_TASKS_SUCCESS: { + case BATCH_ARCHIVE_RETRY_TASKS_SUCCESS: { const newData = state.data.map((queueInfo) => { if (queueInfo.name !== action.queue) { return queueInfo; @@ -422,10 +425,12 @@ function queuesReducer( ...queueInfo, currentStats: { ...queueInfo.currentStats, - dead: - queueInfo.currentStats.pending + action.payload.dead_keys.length, + archived: + queueInfo.currentStats.pending + + action.payload.archived_keys.length, retry: - queueInfo.currentStats.retry - action.payload.dead_keys.length, + queueInfo.currentStats.retry - + action.payload.archived_keys.length, }, }; }); @@ -467,7 +472,7 @@ function queuesReducer( return { ...state, data: newData }; } - case KILL_ALL_RETRY_TASKS_SUCCESS: { + case ARCHIVE_ALL_RETRY_TASKS_SUCCESS: { const newData = state.data.map((queueInfo) => { if (queueInfo.name !== action.queue) { return queueInfo; @@ -476,7 +481,8 @@ function queuesReducer( ...queueInfo, currentStats: { ...queueInfo.currentStats, - dead: queueInfo.currentStats.dead + queueInfo.currentStats.retry, + archived: + queueInfo.currentStats.archived + queueInfo.currentStats.retry, retry: 0, }, }; @@ -500,7 +506,7 @@ function queuesReducer( return { ...state, data: newData }; } - case DELETE_DEAD_TASK_SUCCESS: { + case DELETE_ARCHIVED_TASK_SUCCESS: { const newData = state.data.map((queueInfo) => { if (queueInfo.name !== action.queue) { return queueInfo; @@ -509,14 +515,14 @@ function queuesReducer( ...queueInfo, currentStats: { ...queueInfo.currentStats, - dead: queueInfo.currentStats.dead - 1, + archived: queueInfo.currentStats.archived - 1, }, }; }); return { ...state, data: newData }; } - case BATCH_RUN_DEAD_TASKS_SUCCESS: { + case BATCH_RUN_ARCHIVED_TASKS_SUCCESS: { const newData = state.data.map((queueInfo) => { if (queueInfo.name !== action.queue) { return queueInfo; @@ -528,15 +534,16 @@ function queuesReducer( pending: queueInfo.currentStats.pending + action.payload.pending_keys.length, - dead: - queueInfo.currentStats.dead - action.payload.pending_keys.length, + archived: + queueInfo.currentStats.archived - + action.payload.pending_keys.length, }, }; }); return { ...state, data: newData }; } - case BATCH_DELETE_DEAD_TASKS_SUCCESS: { + case BATCH_DELETE_ARCHIVED_TASKS_SUCCESS: { const newData = state.data.map((queueInfo) => { if (queueInfo.name !== action.queue) { return queueInfo; @@ -545,15 +552,16 @@ function queuesReducer( ...queueInfo, currentStats: { ...queueInfo.currentStats, - dead: - queueInfo.currentStats.dead - action.payload.deleted_keys.length, + archived: + queueInfo.currentStats.archived - + action.payload.deleted_keys.length, }, }; }); return { ...state, data: newData }; } - case RUN_ALL_DEAD_TASKS_SUCCESS: { + case RUN_ALL_ARCHIVED_TASKS_SUCCESS: { const newData = state.data.map((queueInfo) => { if (queueInfo.name !== action.queue) { return queueInfo; @@ -563,15 +571,15 @@ function queuesReducer( currentStats: { ...queueInfo.currentStats, pending: - queueInfo.currentStats.pending + queueInfo.currentStats.dead, - dead: 0, + queueInfo.currentStats.pending + queueInfo.currentStats.archived, + archived: 0, }, }; }); return { ...state, data: newData }; } - case DELETE_ALL_DEAD_TASKS_SUCCESS: { + case DELETE_ALL_ARCHIVED_TASKS_SUCCESS: { const newData = state.data.map((queueInfo) => { if (queueInfo.name !== action.queue) { return queueInfo; @@ -580,7 +588,7 @@ function queuesReducer( ...queueInfo, currentStats: { ...queueInfo.currentStats, - dead: 0, + archived: 0, }, }; }); diff --git a/ui/src/reducers/snackbarReducer.ts b/ui/src/reducers/snackbarReducer.ts index cfe1c7c..e6cb8d8 100644 --- a/ui/src/reducers/snackbarReducer.ts +++ b/ui/src/reducers/snackbarReducer.ts @@ -4,29 +4,29 @@ import { } from "../actions/snackbarActions"; import { BATCH_CANCEL_ACTIVE_TASKS_SUCCESS, - BATCH_DELETE_DEAD_TASKS_SUCCESS, + BATCH_DELETE_ARCHIVED_TASKS_SUCCESS, BATCH_DELETE_RETRY_TASKS_SUCCESS, BATCH_DELETE_SCHEDULED_TASKS_SUCCESS, - BATCH_KILL_RETRY_TASKS_SUCCESS, - BATCH_KILL_SCHEDULED_TASKS_SUCCESS, - BATCH_RUN_DEAD_TASKS_SUCCESS, + BATCH_ARCHIVE_RETRY_TASKS_SUCCESS, + BATCH_ARCHIVE_SCHEDULED_TASKS_SUCCESS, + BATCH_RUN_ARCHIVED_TASKS_SUCCESS, BATCH_RUN_RETRY_TASKS_SUCCESS, BATCH_RUN_SCHEDULED_TASKS_SUCCESS, CANCEL_ALL_ACTIVE_TASKS_SUCCESS, - DELETE_ALL_DEAD_TASKS_SUCCESS, + DELETE_ALL_ARCHIVED_TASKS_SUCCESS, DELETE_ALL_RETRY_TASKS_SUCCESS, DELETE_ALL_SCHEDULED_TASKS_SUCCESS, - DELETE_DEAD_TASK_SUCCESS, + DELETE_ARCHIVED_TASK_SUCCESS, DELETE_RETRY_TASK_SUCCESS, DELETE_SCHEDULED_TASK_SUCCESS, - KILL_ALL_RETRY_TASKS_SUCCESS, - KILL_ALL_SCHEDULED_TASKS_SUCCESS, - KILL_RETRY_TASK_SUCCESS, - KILL_SCHEDULED_TASK_SUCCESS, - RUN_ALL_DEAD_TASKS_SUCCESS, + ARCHIVE_ALL_RETRY_TASKS_SUCCESS, + ARCHIVE_ALL_SCHEDULED_TASKS_SUCCESS, + ARCHIVE_RETRY_TASK_SUCCESS, + ARCHIVE_SCHEDULED_TASK_SUCCESS, + RUN_ALL_ARCHIVED_TASKS_SUCCESS, RUN_ALL_RETRY_TASKS_SUCCESS, RUN_ALL_SCHEDULED_TASKS_SUCCESS, - RUN_DEAD_TASK_SUCCESS, + RUN_ARCHIVED_TASK_SUCCESS, RUN_RETRY_TASK_SUCCESS, RUN_SCHEDULED_TASK_SUCCESS, TasksActionTypes, @@ -83,22 +83,22 @@ function snackbarReducer( message: `Retry task is now pending`, }; - case RUN_DEAD_TASK_SUCCESS: + case RUN_ARCHIVED_TASK_SUCCESS: return { isOpen: true, - message: `Dead task is now pending`, + message: `Archived task is now pending`, }; - case KILL_SCHEDULED_TASK_SUCCESS: + case ARCHIVE_SCHEDULED_TASK_SUCCESS: return { isOpen: true, - message: `Scheduled task is now dead`, + message: `Scheduled task is now archived`, }; - case KILL_RETRY_TASK_SUCCESS: + case ARCHIVE_RETRY_TASK_SUCCESS: return { isOpen: true, - message: `Retry task is now dead`, + message: `Retry task is now archived`, }; case DELETE_SCHEDULED_TASK_SUCCESS: @@ -117,11 +117,13 @@ function snackbarReducer( }; } - case BATCH_KILL_SCHEDULED_TASKS_SUCCESS: { - const n = action.payload.dead_keys.length; + case BATCH_ARCHIVE_SCHEDULED_TASKS_SUCCESS: { + const n = action.payload.archived_keys.length; return { isOpen: true, - message: `${n} scheduled ${n === 1 ? "task is" : "tasks are"} now dead`, + message: `${n} scheduled ${ + n === 1 ? "task is" : "tasks are" + } now archived`, }; } @@ -139,10 +141,10 @@ function snackbarReducer( message: "All scheduled tasks are now pending", }; - case KILL_ALL_SCHEDULED_TASKS_SUCCESS: + case ARCHIVE_ALL_SCHEDULED_TASKS_SUCCESS: return { isOpen: true, - message: "All scheduled tasks are now dead", + message: "All scheduled tasks are now archived", }; case DELETE_ALL_SCHEDULED_TASKS_SUCCESS: @@ -165,11 +167,11 @@ function snackbarReducer( }; } - case BATCH_KILL_RETRY_TASKS_SUCCESS: { - const n = action.payload.dead_keys.length; + case BATCH_ARCHIVE_RETRY_TASKS_SUCCESS: { + const n = action.payload.archived_keys.length; return { isOpen: true, - message: `${n} retry ${n === 1 ? "task is" : "tasks are"} now dead`, + message: `${n} retry ${n === 1 ? "task is" : "tasks are"} now archived`, }; } @@ -187,10 +189,10 @@ function snackbarReducer( message: "All retry tasks are now pending", }; - case KILL_ALL_RETRY_TASKS_SUCCESS: + case ARCHIVE_ALL_RETRY_TASKS_SUCCESS: return { isOpen: true, - message: "All retry tasks are now dead", + message: "All retry tasks are now archived", }; case DELETE_ALL_RETRY_TASKS_SUCCESS: @@ -199,38 +201,40 @@ function snackbarReducer( message: "All retry tasks deleted", }; - case DELETE_DEAD_TASK_SUCCESS: + case DELETE_ARCHIVED_TASK_SUCCESS: return { isOpen: true, - message: `Dead task deleted`, + message: `Archived task deleted`, }; - case BATCH_RUN_DEAD_TASKS_SUCCESS: { + case BATCH_RUN_ARCHIVED_TASKS_SUCCESS: { const n = action.payload.pending_keys.length; return { isOpen: true, - message: `${n} dead ${n === 1 ? "task is" : "tasks are"} now pending`, + message: `${n} archived ${ + n === 1 ? "task is" : "tasks are" + } now pending`, }; } - case BATCH_DELETE_DEAD_TASKS_SUCCESS: { + case BATCH_DELETE_ARCHIVED_TASKS_SUCCESS: { const n = action.payload.deleted_keys.length; return { isOpen: true, - message: `${n} dead ${n === 1 ? "task" : "tasks"} deleted`, + message: `${n} archived ${n === 1 ? "task" : "tasks"} deleted`, }; } - case RUN_ALL_DEAD_TASKS_SUCCESS: + case RUN_ALL_ARCHIVED_TASKS_SUCCESS: return { isOpen: true, - message: "All dead tasks are now pending", + message: "All archived tasks are now pending", }; - case DELETE_ALL_DEAD_TASKS_SUCCESS: + case DELETE_ALL_ARCHIVED_TASKS_SUCCESS: return { isOpen: true, - message: "All dead tasks deleted", + message: "All archived tasks deleted", }; default: diff --git a/ui/src/reducers/tasksReducer.ts b/ui/src/reducers/tasksReducer.ts index cd547d3..cf8e998 100644 --- a/ui/src/reducers/tasksReducer.ts +++ b/ui/src/reducers/tasksReducer.ts @@ -12,9 +12,9 @@ import { LIST_RETRY_TASKS_BEGIN, LIST_RETRY_TASKS_SUCCESS, LIST_RETRY_TASKS_ERROR, - LIST_DEAD_TASKS_BEGIN, - LIST_DEAD_TASKS_SUCCESS, - LIST_DEAD_TASKS_ERROR, + LIST_ARCHIVED_TASKS_BEGIN, + LIST_ARCHIVED_TASKS_SUCCESS, + LIST_ARCHIVED_TASKS_ERROR, CANCEL_ACTIVE_TASK_BEGIN, CANCEL_ACTIVE_TASK_SUCCESS, CANCEL_ACTIVE_TASK_ERROR, @@ -24,24 +24,24 @@ import { DELETE_SCHEDULED_TASK_BEGIN, DELETE_SCHEDULED_TASK_SUCCESS, DELETE_SCHEDULED_TASK_ERROR, - DELETE_DEAD_TASK_BEGIN, - DELETE_DEAD_TASK_SUCCESS, - DELETE_DEAD_TASK_ERROR, - BATCH_DELETE_DEAD_TASKS_BEGIN, - BATCH_DELETE_DEAD_TASKS_SUCCESS, - BATCH_DELETE_DEAD_TASKS_ERROR, - RUN_DEAD_TASK_BEGIN, - RUN_DEAD_TASK_SUCCESS, - RUN_DEAD_TASK_ERROR, - BATCH_RUN_DEAD_TASKS_BEGIN, - BATCH_RUN_DEAD_TASKS_ERROR, - BATCH_RUN_DEAD_TASKS_SUCCESS, - DELETE_ALL_DEAD_TASKS_BEGIN, - DELETE_ALL_DEAD_TASKS_SUCCESS, - DELETE_ALL_DEAD_TASKS_ERROR, - RUN_ALL_DEAD_TASKS_BEGIN, - RUN_ALL_DEAD_TASKS_ERROR, - RUN_ALL_DEAD_TASKS_SUCCESS, + DELETE_ARCHIVED_TASK_BEGIN, + DELETE_ARCHIVED_TASK_SUCCESS, + DELETE_ARCHIVED_TASK_ERROR, + BATCH_DELETE_ARCHIVED_TASKS_BEGIN, + BATCH_DELETE_ARCHIVED_TASKS_SUCCESS, + BATCH_DELETE_ARCHIVED_TASKS_ERROR, + RUN_ARCHIVED_TASK_BEGIN, + RUN_ARCHIVED_TASK_SUCCESS, + RUN_ARCHIVED_TASK_ERROR, + BATCH_RUN_ARCHIVED_TASKS_BEGIN, + BATCH_RUN_ARCHIVED_TASKS_ERROR, + BATCH_RUN_ARCHIVED_TASKS_SUCCESS, + DELETE_ALL_ARCHIVED_TASKS_BEGIN, + DELETE_ALL_ARCHIVED_TASKS_SUCCESS, + DELETE_ALL_ARCHIVED_TASKS_ERROR, + RUN_ALL_ARCHIVED_TASKS_BEGIN, + RUN_ALL_ARCHIVED_TASKS_ERROR, + RUN_ALL_ARCHIVED_TASKS_SUCCESS, BATCH_DELETE_RETRY_TASKS_ERROR, BATCH_RUN_RETRY_TASKS_ERROR, BATCH_DELETE_RETRY_TASKS_SUCCESS, @@ -72,24 +72,24 @@ import { RUN_SCHEDULED_TASK_BEGIN, RUN_SCHEDULED_TASK_SUCCESS, RUN_SCHEDULED_TASK_ERROR, - KILL_SCHEDULED_TASK_BEGIN, - KILL_SCHEDULED_TASK_SUCCESS, - KILL_SCHEDULED_TASK_ERROR, - KILL_ALL_SCHEDULED_TASKS_BEGIN, - KILL_ALL_SCHEDULED_TASKS_SUCCESS, - KILL_ALL_SCHEDULED_TASKS_ERROR, - BATCH_KILL_SCHEDULED_TASKS_BEGIN, - BATCH_KILL_SCHEDULED_TASKS_ERROR, - BATCH_KILL_SCHEDULED_TASKS_SUCCESS, - KILL_RETRY_TASK_BEGIN, - KILL_RETRY_TASK_SUCCESS, - KILL_RETRY_TASK_ERROR, - KILL_ALL_RETRY_TASKS_BEGIN, - KILL_ALL_RETRY_TASKS_SUCCESS, - KILL_ALL_RETRY_TASKS_ERROR, - BATCH_KILL_RETRY_TASKS_SUCCESS, - BATCH_KILL_RETRY_TASKS_BEGIN, - BATCH_KILL_RETRY_TASKS_ERROR, + ARCHIVE_SCHEDULED_TASK_BEGIN, + ARCHIVE_SCHEDULED_TASK_SUCCESS, + ARCHIVE_SCHEDULED_TASK_ERROR, + ARCHIVE_ALL_SCHEDULED_TASKS_BEGIN, + ARCHIVE_ALL_SCHEDULED_TASKS_SUCCESS, + ARCHIVE_ALL_SCHEDULED_TASKS_ERROR, + BATCH_ARCHIVE_SCHEDULED_TASKS_BEGIN, + BATCH_ARCHIVE_SCHEDULED_TASKS_ERROR, + BATCH_ARCHIVE_SCHEDULED_TASKS_SUCCESS, + ARCHIVE_RETRY_TASK_BEGIN, + ARCHIVE_RETRY_TASK_SUCCESS, + ARCHIVE_RETRY_TASK_ERROR, + ARCHIVE_ALL_RETRY_TASKS_BEGIN, + ARCHIVE_ALL_RETRY_TASKS_SUCCESS, + ARCHIVE_ALL_RETRY_TASKS_ERROR, + BATCH_ARCHIVE_RETRY_TASKS_SUCCESS, + BATCH_ARCHIVE_RETRY_TASKS_BEGIN, + BATCH_ARCHIVE_RETRY_TASKS_ERROR, BATCH_CANCEL_ACTIVE_TASKS_BEGIN, BATCH_CANCEL_ACTIVE_TASKS_SUCCESS, BATCH_CANCEL_ACTIVE_TASKS_ERROR, @@ -99,7 +99,7 @@ import { } from "../actions/tasksActions"; import { ActiveTask, - DeadTask, + ArchivedTask, PendingTask, RetryTask, ScheduledTask, @@ -127,7 +127,7 @@ export interface RetryTaskExtended extends RetryTask { requestPending: boolean; } -export interface DeadTaskExtended extends DeadTask { +export interface ArchivedTaskExtended extends ArchivedTask { // Indicates that a request has been sent for this // task and awaiting for a response. requestPending: boolean; @@ -160,12 +160,12 @@ interface TasksState { error: string; data: RetryTaskExtended[]; }; - deadTasks: { + archivedTasks: { loading: boolean; batchActionPending: boolean; allActionPending: boolean; error: string; - data: DeadTaskExtended[]; + data: ArchivedTaskExtended[]; }; } @@ -196,7 +196,7 @@ const initialState: TasksState = { error: "", data: [], }, - deadTasks: { + archivedTasks: { loading: false, batchActionPending: false, allActionPending: false, @@ -343,21 +343,21 @@ function tasksReducer( }, }; - case LIST_DEAD_TASKS_BEGIN: + case LIST_ARCHIVED_TASKS_BEGIN: return { ...state, - deadTasks: { - ...state.deadTasks, + archivedTasks: { + ...state.archivedTasks, error: "", loading: true, }, }; - case LIST_DEAD_TASKS_SUCCESS: + case LIST_ARCHIVED_TASKS_SUCCESS: return { ...state, - deadTasks: { - ...state.deadTasks, + archivedTasks: { + ...state.archivedTasks, loading: false, error: "", data: action.payload.tasks.map((task) => ({ @@ -367,11 +367,11 @@ function tasksReducer( }, }; - case LIST_DEAD_TASKS_ERROR: + case LIST_ARCHIVED_TASKS_ERROR: return { ...state, - deadTasks: { - ...state.deadTasks, + archivedTasks: { + ...state.archivedTasks, loading: false, error: action.error, }, @@ -522,7 +522,7 @@ function tasksReducer( } case RUN_SCHEDULED_TASK_BEGIN: - case KILL_SCHEDULED_TASK_BEGIN: + case ARCHIVE_SCHEDULED_TASK_BEGIN: case DELETE_SCHEDULED_TASK_BEGIN: return { ...state, @@ -538,7 +538,7 @@ function tasksReducer( }; case RUN_SCHEDULED_TASK_SUCCESS: - case KILL_SCHEDULED_TASK_SUCCESS: + case ARCHIVE_SCHEDULED_TASK_SUCCESS: case DELETE_SCHEDULED_TASK_SUCCESS: return { ...state, @@ -551,7 +551,7 @@ function tasksReducer( }; case RUN_SCHEDULED_TASK_ERROR: - case KILL_SCHEDULED_TASK_ERROR: + case ARCHIVE_SCHEDULED_TASK_ERROR: case DELETE_SCHEDULED_TASK_ERROR: return { ...state, @@ -567,7 +567,7 @@ function tasksReducer( }; case RUN_ALL_SCHEDULED_TASKS_BEGIN: - case KILL_ALL_SCHEDULED_TASKS_BEGIN: + case ARCHIVE_ALL_SCHEDULED_TASKS_BEGIN: case DELETE_ALL_SCHEDULED_TASKS_BEGIN: return { ...state, @@ -578,7 +578,7 @@ function tasksReducer( }; case RUN_ALL_SCHEDULED_TASKS_SUCCESS: - case KILL_ALL_SCHEDULED_TASKS_SUCCESS: + case ARCHIVE_ALL_SCHEDULED_TASKS_SUCCESS: case DELETE_ALL_SCHEDULED_TASKS_SUCCESS: return { ...state, @@ -590,7 +590,7 @@ function tasksReducer( }; case RUN_ALL_SCHEDULED_TASKS_ERROR: - case KILL_ALL_SCHEDULED_TASKS_ERROR: + case ARCHIVE_ALL_SCHEDULED_TASKS_ERROR: case DELETE_ALL_SCHEDULED_TASKS_ERROR: return { ...state, @@ -601,7 +601,7 @@ function tasksReducer( }; case BATCH_RUN_SCHEDULED_TASKS_BEGIN: - case BATCH_KILL_SCHEDULED_TASKS_BEGIN: + case BATCH_ARCHIVE_SCHEDULED_TASKS_BEGIN: case BATCH_DELETE_SCHEDULED_TASKS_BEGIN: return { ...state, @@ -634,9 +634,9 @@ function tasksReducer( }; } - case BATCH_KILL_SCHEDULED_TASKS_SUCCESS: { + case BATCH_ARCHIVE_SCHEDULED_TASKS_SUCCESS: { const newData = state.scheduledTasks.data.filter( - (task) => !action.payload.dead_keys.includes(task.key) + (task) => !action.payload.archived_keys.includes(task.key) ); return { ...state, @@ -663,7 +663,7 @@ function tasksReducer( } case BATCH_RUN_SCHEDULED_TASKS_ERROR: - case BATCH_KILL_SCHEDULED_TASKS_ERROR: + case BATCH_ARCHIVE_SCHEDULED_TASKS_ERROR: case BATCH_DELETE_SCHEDULED_TASKS_ERROR: return { ...state, @@ -683,7 +683,7 @@ function tasksReducer( }; case RUN_RETRY_TASK_BEGIN: - case KILL_RETRY_TASK_BEGIN: + case ARCHIVE_RETRY_TASK_BEGIN: case DELETE_RETRY_TASK_BEGIN: return { ...state, @@ -699,7 +699,7 @@ function tasksReducer( }; case RUN_RETRY_TASK_SUCCESS: - case KILL_RETRY_TASK_SUCCESS: + case ARCHIVE_RETRY_TASK_SUCCESS: case DELETE_RETRY_TASK_SUCCESS: return { ...state, @@ -712,7 +712,7 @@ function tasksReducer( }; case RUN_RETRY_TASK_ERROR: - case KILL_RETRY_TASK_ERROR: + case ARCHIVE_RETRY_TASK_ERROR: case DELETE_RETRY_TASK_ERROR: return { ...state, @@ -728,7 +728,7 @@ function tasksReducer( }; case RUN_ALL_RETRY_TASKS_BEGIN: - case KILL_ALL_RETRY_TASKS_BEGIN: + case ARCHIVE_ALL_RETRY_TASKS_BEGIN: case DELETE_ALL_RETRY_TASKS_BEGIN: return { ...state, @@ -739,7 +739,7 @@ function tasksReducer( }; case RUN_ALL_RETRY_TASKS_SUCCESS: - case KILL_ALL_RETRY_TASKS_SUCCESS: + case ARCHIVE_ALL_RETRY_TASKS_SUCCESS: case DELETE_ALL_RETRY_TASKS_SUCCESS: return { ...state, @@ -751,7 +751,7 @@ function tasksReducer( }; case RUN_ALL_RETRY_TASKS_ERROR: - case KILL_ALL_RETRY_TASKS_ERROR: + case ARCHIVE_ALL_RETRY_TASKS_ERROR: case DELETE_ALL_RETRY_TASKS_ERROR: return { ...state, @@ -762,7 +762,7 @@ function tasksReducer( }; case BATCH_RUN_RETRY_TASKS_BEGIN: - case BATCH_KILL_RETRY_TASKS_BEGIN: + case BATCH_ARCHIVE_RETRY_TASKS_BEGIN: case BATCH_DELETE_RETRY_TASKS_BEGIN: return { ...state, @@ -795,9 +795,9 @@ function tasksReducer( }; } - case BATCH_KILL_RETRY_TASKS_SUCCESS: { + case BATCH_ARCHIVE_RETRY_TASKS_SUCCESS: { const newData = state.retryTasks.data.filter( - (task) => !action.payload.dead_keys.includes(task.key) + (task) => !action.payload.archived_keys.includes(task.key) ); return { ...state, @@ -824,7 +824,7 @@ function tasksReducer( } case BATCH_RUN_RETRY_TASKS_ERROR: - case BATCH_KILL_RETRY_TASKS_ERROR: + case BATCH_ARCHIVE_RETRY_TASKS_ERROR: case BATCH_DELETE_RETRY_TASKS_ERROR: return { ...state, @@ -843,13 +843,13 @@ function tasksReducer( }, }; - case RUN_DEAD_TASK_BEGIN: - case DELETE_DEAD_TASK_BEGIN: + case RUN_ARCHIVED_TASK_BEGIN: + case DELETE_ARCHIVED_TASK_BEGIN: return { ...state, - deadTasks: { - ...state.deadTasks, - data: state.deadTasks.data.map((task) => { + archivedTasks: { + ...state.archivedTasks, + data: state.archivedTasks.data.map((task) => { if (task.key !== action.taskKey) { return task; } @@ -858,25 +858,25 @@ function tasksReducer( }, }; - case RUN_DEAD_TASK_SUCCESS: - case DELETE_DEAD_TASK_SUCCESS: + case RUN_ARCHIVED_TASK_SUCCESS: + case DELETE_ARCHIVED_TASK_SUCCESS: return { ...state, - deadTasks: { - ...state.deadTasks, - data: state.deadTasks.data.filter( + archivedTasks: { + ...state.archivedTasks, + data: state.archivedTasks.data.filter( (task) => task.key !== action.taskKey ), }, }; - case RUN_DEAD_TASK_ERROR: - case DELETE_DEAD_TASK_ERROR: + case RUN_ARCHIVED_TASK_ERROR: + case DELETE_ARCHIVED_TASK_ERROR: return { ...state, - deadTasks: { - ...state.deadTasks, - data: state.deadTasks.data.map((task) => { + archivedTasks: { + ...state.archivedTasks, + data: state.archivedTasks.data.map((task) => { if (task.key !== action.taskKey) { return task; } @@ -885,45 +885,45 @@ function tasksReducer( }, }; - case RUN_ALL_DEAD_TASKS_BEGIN: - case DELETE_ALL_DEAD_TASKS_BEGIN: + case RUN_ALL_ARCHIVED_TASKS_BEGIN: + case DELETE_ALL_ARCHIVED_TASKS_BEGIN: return { ...state, - deadTasks: { - ...state.deadTasks, + archivedTasks: { + ...state.archivedTasks, allActionPending: true, }, }; - case RUN_ALL_DEAD_TASKS_SUCCESS: - case DELETE_ALL_DEAD_TASKS_SUCCESS: + case RUN_ALL_ARCHIVED_TASKS_SUCCESS: + case DELETE_ALL_ARCHIVED_TASKS_SUCCESS: return { ...state, - deadTasks: { - ...state.deadTasks, + archivedTasks: { + ...state.archivedTasks, allActionPending: false, data: [], }, }; - case RUN_ALL_DEAD_TASKS_ERROR: - case DELETE_ALL_DEAD_TASKS_ERROR: + case RUN_ALL_ARCHIVED_TASKS_ERROR: + case DELETE_ALL_ARCHIVED_TASKS_ERROR: return { ...state, - deadTasks: { - ...state.deadTasks, + archivedTasks: { + ...state.archivedTasks, allActionPending: false, }, }; - case BATCH_RUN_DEAD_TASKS_BEGIN: - case BATCH_DELETE_DEAD_TASKS_BEGIN: + case BATCH_RUN_ARCHIVED_TASKS_BEGIN: + case BATCH_DELETE_ARCHIVED_TASKS_BEGIN: return { ...state, - deadTasks: { - ...state.deadTasks, + archivedTasks: { + ...state.archivedTasks, batchActionPending: true, - data: state.deadTasks.data.map((task) => { + data: state.archivedTasks.data.map((task) => { if (!action.taskKeys.includes(task.key)) { return task; } @@ -935,42 +935,42 @@ function tasksReducer( }, }; - case BATCH_RUN_DEAD_TASKS_SUCCESS: { - const newData = state.deadTasks.data.filter( + case BATCH_RUN_ARCHIVED_TASKS_SUCCESS: { + const newData = state.archivedTasks.data.filter( (task) => !action.payload.pending_keys.includes(task.key) ); return { ...state, - deadTasks: { - ...state.deadTasks, + archivedTasks: { + ...state.archivedTasks, batchActionPending: false, data: newData, }, }; } - case BATCH_DELETE_DEAD_TASKS_SUCCESS: { - const newData = state.deadTasks.data.filter( + case BATCH_DELETE_ARCHIVED_TASKS_SUCCESS: { + const newData = state.archivedTasks.data.filter( (task) => !action.payload.deleted_keys.includes(task.key) ); return { ...state, - deadTasks: { - ...state.deadTasks, + archivedTasks: { + ...state.archivedTasks, batchActionPending: false, data: newData, }, }; } - case BATCH_RUN_DEAD_TASKS_ERROR: - case BATCH_DELETE_DEAD_TASKS_ERROR: + case BATCH_RUN_ARCHIVED_TASKS_ERROR: + case BATCH_DELETE_ARCHIVED_TASKS_ERROR: return { ...state, - deadTasks: { - ...state.deadTasks, + archivedTasks: { + ...state.archivedTasks, batchActionPending: false, - data: state.deadTasks.data.map((task) => { + data: state.archivedTasks.data.map((task) => { if (!action.taskKeys.includes(task.key)) { return task; } diff --git a/ui/src/views/DashboardView.tsx b/ui/src/views/DashboardView.tsx index 939c134..05506cc 100644 --- a/ui/src/views/DashboardView.tsx +++ b/ui/src/views/DashboardView.tsx @@ -155,8 +155,8 @@ function DashboardView(props: Props) { retried in the future
- Dead: number of tasks exhausted their - retries + Archived: number of tasks exhausted + their retries
} diff --git a/ui/src/views/TasksView.tsx b/ui/src/views/TasksView.tsx index e99b324..a9ae167 100644 --- a/ui/src/views/TasksView.tsx +++ b/ui/src/views/TasksView.tsx @@ -29,7 +29,7 @@ interface RouteParams { qname: string; } -const validStatus = ["active", "pending", "scheduled", "retry", "dead"]; +const validStatus = ["active", "pending", "scheduled", "retry", "archived"]; const defaultStatus = "active"; function TasksView() { diff --git a/ui/yarn.lock b/ui/yarn.lock index f9f9f2a..f3e938d 100644 --- a/ui/yarn.lock +++ b/ui/yarn.lock @@ -1409,7 +1409,7 @@ "@material-ui/icons@4.9.1": version "4.9.1" - resolved "https://registry.yarnpkg.com/@material-ui/icons/-/icons-4.9.1.tgz#fdeadf8cb3d89208945b33dbc50c7c616d0bd665" + resolved "https://registry.yarnpkg.com/@material-ui/icons/-/icons-4.9.1.tgz#farchivedf8cb3d89208945b33dbc50c7c616d0bd665" integrity sha512-GBitL3oBWO0hzBhvA9KxqcowRUsA0qzwKkURyC8nppnC3fw54KPKZ+d4V1Eeg/UnDRSzDaI9nGCdel/eh9AQMg== dependencies: "@babel/runtime" "^7.4.4" @@ -7010,9 +7010,9 @@ jsx-ast-utils@^2.2.1, jsx-ast-utils@^2.2.3: array-includes "^3.0.3" object.assign "^4.1.0" -killable@^1.0.1: +archiveable@^1.0.1: version "1.0.1" - resolved "https://registry.yarnpkg.com/killable/-/killable-1.0.1.tgz#4c8ce441187a061c7474fb87ca08e2a638194892" + resolved "https://registry.yarnpkg.com/archiveable/-/archiveable-1.0.1.tgz#4c8ce441187a061c7474fb87ca08e2a638194892" integrity sha512-LzqtLKlUwirEUyl/nicirVmNiPvYs7l5n8wOPP7fyJVpUPkvCnW/vuiXGpylGUlnPDnB7311rARzAt3Mhswpjg== kind-of@^2.0.1: @@ -11459,7 +11459,7 @@ webpack-dev-server@3.11.0: internal-ip "^4.3.0" ip "^1.1.5" is-absolute-url "^3.0.3" - killable "^1.0.1" + archiveable "^1.0.1" loglevel "^1.6.8" opn "^5.5.0" p-retry "^3.0.1"