feature: archived task show (#22309)

Co-authored-by: Qiu Jian <qiujian@yunionyun.com>

cmd/climc/shell/misc/tasks.go

@@ -18,6 +18,7 @@ import (
 	"fmt"
 
 	"yunion.io/x/jsonutils"
+	"yunion.io/x/pkg/errors"
 
 	"yunion.io/x/onecloud/pkg/apis"
 	"yunion.io/x/onecloud/pkg/mcclient"
@@ -34,38 +35,47 @@ func init() {
 	cmds := []struct {
 		service string
 		manager modulebase.Manager
+
+		archivedManager modulebase.Manager
 	}{
 		{
-			service: "region",
-			manager: &compute.ComputeTasks,
+			service:         "region",
+			manager:         &compute.ComputeTasks,
+			archivedManager: &compute.ArchivedComputeTasks,
 		},
 		{
-			service: "devtool",
-			manager: &devtool.DevtoolTasks,
+			service:         "devtool",
+			manager:         &devtool.DevtoolTasks,
+			archivedManager: &devtool.ArchivedDevtoolTasks,
 		},
 		{
-			service: "image",
-			manager: &image.Tasks,
+			service:         "image",
+			manager:         &image.Tasks,
+			archivedManager: &image.ArchivedTasks,
 		},
 		{
-			service: "identity",
-			manager: &identity.Tasks,
+			service:         "identity",
+			manager:         &identity.Tasks,
+			archivedManager: &identity.ArchivedTasks,
 		},
 		{
-			service: "k8s",
-			manager: k8s.KubeTasks,
+			service:         "k8s",
+			manager:         k8s.KubeTasks,
+			archivedManager: k8s.ArchivedKubeTasks,
 		},
 		{
-			service: "notify",
-			manager: &notify.Tasks,
+			service:         "notify",
+			manager:         &notify.Tasks,
+			archivedManager: &notify.ArchivedTasks,
 		},
 	}
 	for i := range cmds {
 		c := cmds[i]
+
 		type TaskListOptions struct {
 			apis.TaskListInput
 		}
-		R(&TaskListOptions{}, fmt.Sprintf("%s-task-list", c.service), "List tasks on region server", func(s *mcclient.ClientSession, args *TaskListOptions) error {
+		R(&TaskListOptions{}, fmt.Sprintf("%s-task-list", c.service), fmt.Sprintf("List tasks on %s server", c.service), func(s *mcclient.ClientSession, args *TaskListOptions) error {
 			params := jsonutils.Marshal(args)
 			result, err := c.manager.List(s, params)
 			if err != nil {
@@ -78,7 +88,7 @@ func init() {
 		type TaskShowOptions struct {
 			ID string `help:"ID or name of the task"`
 		}
-		R(&TaskShowOptions{}, "region-task-show", "Show details of a region task", func(s *mcclient.ClientSession, args *TaskShowOptions) error {
+		R(&TaskShowOptions{}, fmt.Sprintf("%s-task-show", c.service), fmt.Sprintf("Show details of a %s task", c.service), func(s *mcclient.ClientSession, args *TaskShowOptions) error {
 			result, err := c.manager.GetById(s, args.ID, nil)
 			if err != nil {
 				return err
@@ -86,39 +96,43 @@ func init() {
 			printObject(result)
 			return nil
 		})
-	}
 
-	/*type TaskListOptions struct {
-		ObjName     string `help:"object name"`
-		ObjId       string `help:"object id"`
-		TaskName    string `help:"task name"`
-		ServiceType string `choices:"image|cloudid|cloudevent|devtool|ansible|identity|notify|log|compute|compute_v2"`
-	}
-	R(&TaskListOptions{}, "task-list", "List tasks", func(s *mcclient.ClientSession, args *TaskListOptions) error {
-		params := jsonutils.Marshal(args)
-		man := compute.TasksManager{}
-		result, err := man.List(s, params)
-		if err != nil {
-			return err
-		}
-		printList(result, man.GetColumns(s))
-		return nil
-	})
+		R(&TaskShowOptions{}, fmt.Sprintf("%s-task-cancel", c.service), fmt.Sprintf("Cancel a %s task", c.service), func(s *mcclient.ClientSession, args *TaskShowOptions) error {
+			result, err := c.manager.PerformAction(s, args.ID, "cancel", nil)
+			if err != nil {
+				return err
+			}
+			printObject(result)
+			return nil
+		})
 
-	type TaskShowOptions struct {
-		ID          string `help:"ID or name of the task"`
-		ServiceType string `choices:"image|cloudid|cloudevent|devtool|ansible|identity|notify|log|compute|compute_v2"`
-	}
+		R(&TaskListOptions{}, fmt.Sprintf("%s-archived-task-list", c.service), fmt.Sprintf("List archived tasks on %s server", c.service), func(s *mcclient.ClientSession, args *TaskListOptions) error {
+			params := jsonutils.Marshal(args)
+			result, err := c.archivedManager.List(s, params)
+			if err != nil {
+				return err
+			}
+			printList(result, c.archivedManager.GetColumns(s))
+			return nil
+		})
 
-	R(&TaskShowOptions{}, "task-show", "Show details of a task", func(s *mcclient.ClientSession, args *TaskShowOptions) error {
-		man := compute.TasksManager{}
-		params := jsonutils.Marshal(args)
-		result, err := man.Get(s, args.ID, params)
-		if err != nil {
-			return err
-		}
-		printObject(result)
-		return nil
-	})*/
+		R(&TaskShowOptions{}, fmt.Sprintf("%s-archived-task-show", c.service), fmt.Sprintf("Show details of an archived %s task", c.service), func(s *mcclient.ClientSession, args *TaskShowOptions) error {
+			params := jsonutils.NewDict()
+			params.Set("task_id", jsonutils.NewString(args.ID))
+			result, err := c.archivedManager.List(s, params)
+			if err != nil {
+				return err
+			}
+			if result.Total == 1 {
+				printObject(result.Data[0])
+				return nil
+			} else if result.Total == 0 {
+				return errors.Wrapf(errors.ErrNotFound, "not found %s", args.ID)
+			} else {
+				printList(result, c.archivedManager.GetColumns(s))
+				return errors.Wrapf(errors.ErrDuplicateId, "found %d record for %s", result.Total, args.ID)
+			}
+		})
+	}
 
 }

pkg/apis/list.go

@@ -391,3 +391,9 @@ type IdNameDetails struct {
 type TotalCountBase struct {
 	Count int `json:"count"`
 }
+
+type LogBaseListInput struct {
+	ModelBaseListInput
+
+	Id []string `json:"id"`
+}

pkg/apis/notify/emailqueue.go

@@ -85,9 +85,9 @@ type EmailQueueCreateInput struct {
 }
 
 type EmailQueueListInput struct {
-	apis.ModelBaseListInput
+	apis.LogBaseListInput
 
-	Id        []int    `json:"id"`
+	// Id        []int    `json:"id"`
 	To        []string `json:"to"`
 	Subject   string   `json:"subject"`
 	SessionId []string `json:"session_id"`

pkg/apis/tasks.go

@@ -20,12 +20,10 @@ import (
 	"yunion.io/x/jsonutils"
 )
 
-type TaskListInput struct {
-	ModelBaseListInput
+type TaskBaseListInput struct {
 	ProjectizedResourceListInput
 	StatusResourceBaseListInput
 
-	Id         []string `json:"id" help:"id filter"`
 	ObjId      []string `json:"obj_id" help:"object id filter"`
 	ObjType    []string `json:"obj_type" help:"object type (in singular form) filter"`
 	ObjName    []string `json:"obj_name" help:"object name filter"`
@@ -38,9 +36,27 @@ type TaskListInput struct {
 	ParentId   []string `json:"parent_id" help:"filter tasks by parent_task_id"`
 	IsRoot     *bool    `json:"is_root" help:"filter root tasks"`
 
+	ParentTaskId string `json:"parent_task_id" help:"filter by parent_task_id"`
+
 	SubTask *bool `json:"sub_task" help:"show sub task states"`
 }
 
+type TaskListInput struct {
+	ModelBaseListInput
+
+	TaskBaseListInput
+
+	Id []string `json:"id" help:"id filter"`
+}
+
+type ArchivedTaskListInput struct {
+	LogBaseListInput
+
+	TaskBaseListInput
+
+	TaskId []string `json:"task_id" help:"filter by task_id"`
+}
+
 type TaskDetails struct {
 	ModelBaseDetails
 	ProjectizedResourceInfo
@@ -67,3 +83,6 @@ type TaskDetails struct {
 	Stage        string
 	ParentTaskId string
 }
+
+type TaskCancelInput struct {
+}

pkg/cloudcommon/db/baselog.go

@@ -26,6 +26,7 @@ import (
 	"yunion.io/x/sqlchemy"
 	"yunion.io/x/sqlchemy/backends/clickhouse"
 
+	"yunion.io/x/onecloud/pkg/apis"
 	"yunion.io/x/onecloud/pkg/cloudcommon/consts"
 	"yunion.io/x/onecloud/pkg/httperrors"
 	"yunion.io/x/onecloud/pkg/mcclient"
@@ -145,3 +146,18 @@ func (l *SLogBase) ValidateUpdateData(
 ) (jsonutils.JSONObject, error) {
 	return nil, errors.Wrap(httperrors.ErrForbidden, "not allow")
 }
+
+// 操作日志列表
+func (manager *SLogBaseManager) ListItemFilter(
+	ctx context.Context,
+	q *sqlchemy.SQuery,
+	userCred mcclient.TokenCredential,
+	input apis.LogBaseListInput,
+) (*sqlchemy.SQuery, error) {
+	var err error
+	q, err = manager.SModelBaseManager.ListItemFilter(ctx, q, userCred, input.ModelBaseListInput)
+	if err != nil {
+		return nil, errors.Wrap(err, "SModelBaseManager.ListItemFilter")
+	}
+	return q, nil
+}

pkg/cloudcommon/db/taskman/handler.go

@@ -23,4 +23,10 @@ import (
 func AddTaskHandler(prefix string, app *appsrv.Application) {
 	handler := db.NewModelHandler(TaskManager)
 	dispatcher.AddModelDispatcher(prefix, app, handler)
+
+	{
+		initArchivedTaskManager()
+		archiveHandler := db.NewModelHandler(ArchivedTaskManager)
+		dispatcher.AddModelDispatcher(prefix, app, archiveHandler)
+	}
 }

pkg/cloudcommon/db/taskman/taskarchive.go

@@ -22,9 +22,12 @@ import (
 	"yunion.io/x/pkg/util/rbacscope"
 	"yunion.io/x/sqlchemy"
 
+	"yunion.io/x/onecloud/pkg/apis"
 	"yunion.io/x/onecloud/pkg/cloudcommon/consts"
 	"yunion.io/x/onecloud/pkg/cloudcommon/db"
+	"yunion.io/x/onecloud/pkg/httperrors"
 	"yunion.io/x/onecloud/pkg/mcclient"
+	"yunion.io/x/onecloud/pkg/util/stringutils2"
 )
 
 type SArchivedTaskManager struct {
@@ -34,13 +37,13 @@ type SArchivedTaskManager struct {
 
 var ArchivedTaskManager *SArchivedTaskManager
 
-func InitArchivedTaskManager() {
+func initArchivedTaskManager() {
 	ArchivedTaskManager = &SArchivedTaskManager{
 		SLogBaseManager: db.NewLogBaseManager(
 			SArchivedTask{},
 			"archived_tasks_tbl",
-			"achivedtask",
-			"achivedtasks",
+			"archivedtask",
+			"archivedtasks",
 			"start_at",
 			consts.OpsLogWithClickhouse,
 		),
@@ -100,3 +103,140 @@ func (manager *SArchivedTaskManager) FilterByOwner(ctx context.Context, q *sqlch
 func (manager *SArchivedTaskManager) FetchOwnerId(ctx context.Context, data jsonutils.JSONObject) (mcclient.IIdentityProvider, error) {
 	return nil, nil
 }
+
+// 操作日志列表
+func (manager *SArchivedTaskManager) ListItemFilter(
+	ctx context.Context,
+	q *sqlchemy.SQuery,
+	userCred mcclient.TokenCredential,
+	input apis.ArchivedTaskListInput,
+) (*sqlchemy.SQuery, error) {
+	var err error
+
+	q, err = manager.SLogBaseManager.ListItemFilter(ctx, q, userCred, input.LogBaseListInput)
+	if err != nil {
+		return q, errors.Wrap(err, "SLogBaseManager.ListItemFilter")
+	}
+	q, err = manager.SStatusResourceBaseManager.ListItemFilter(ctx, q, userCred, input.StatusResourceBaseListInput)
+	if err != nil {
+		return q, errors.Wrap(err, "SStatusResourceBaseManager.ListItemFilter")
+	}
+
+	if len(input.TaskId) > 0 {
+		q = q.In("task_id", input.TaskId)
+	}
+
+	if len(input.ObjId) > 0 {
+		if len(input.ObjId) == 1 {
+			q = q.Contains("obj_ids", input.ObjId[0])
+		} else {
+			filters := make([]sqlchemy.ICondition, 0)
+			for i := range input.ObjId {
+				filters = append(filters, sqlchemy.Contains(q.Field("obj_ids"), input.ObjId[i]))
+			}
+			q = q.Filter(sqlchemy.OR(filters...))
+		}
+	}
+
+	if len(input.ObjName) > 0 {
+		if len(input.ObjName) == 1 {
+			q = q.Contains("obj_names", input.ObjName[0])
+		} else {
+			filters := make([]sqlchemy.ICondition, 0)
+			for i := range input.ObjName {
+				filters = append(filters, sqlchemy.Contains(q.Field("obj_names"), input.ObjName[i]))
+			}
+			q = q.Filter(sqlchemy.OR(filters...))
+		}
+	}
+
+	if len(input.ObjType) > 0 {
+		q = q.In("obj_type", input.ObjType)
+	}
+
+	if len(input.TaskName) > 0 {
+		q = q.In("task_name", input.TaskName)
+	}
+
+	if len(input.Stage) > 0 {
+		q = q.In("stage", input.Stage)
+	}
+
+	if len(input.NotStage) > 0 {
+		q = q.NotIn("stage", input.NotStage)
+	}
+
+	if len(input.ParentId) > 0 {
+		q = q.In("parent_task_id", input.ParentId)
+	}
+
+	if input.IsRoot != nil {
+		if *input.IsRoot {
+			q = q.IsNullOrEmpty("parent_task_id")
+		} else {
+			q = q.IsNotEmpty("parent_task_id")
+		}
+	}
+
+	if len(input.ParentTaskId) > 0 {
+		q = q.Equals("parent_task_id", input.ParentTaskId)
+	}
+
+	return q, nil
+}
+
+func (manager *SArchivedTaskManager) ListItemExportKeys(ctx context.Context, q *sqlchemy.SQuery, userCred mcclient.TokenCredential, keys stringutils2.SSortedStrings) (*sqlchemy.SQuery, error) {
+	var err error
+	q, err = manager.SModelBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+	if err != nil {
+		return nil, errors.Wrap(err, "SModelBaseManager.ListItemExportKeys")
+	}
+	// q, err = manager.SProjectizedResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+	// if err != nil {
+	//	return nil, errors.Wrap(err, "SProjectizedResourceBaseManager.ListItemExportKeys")
+	// }
+	return q, nil
+}
+
+func (manager *SArchivedTaskManager) QueryDistinctExtraField(q *sqlchemy.SQuery, field string) (*sqlchemy.SQuery, error) {
+	var err error
+	q, err = manager.SModelBaseManager.QueryDistinctExtraField(q, field)
+	if err == nil {
+		return q, nil
+	}
+	// q, err = manager.SProjectizedResourceBaseManager.QueryDistinctExtraField(q, field)
+	// if err == nil {
+	//	return q, nil
+	// }
+	return q, httperrors.ErrNotFound
+}
+
+func (manager *SArchivedTaskManager) ResourceScope() rbacscope.TRbacScope {
+	return rbacscope.ScopeProject
+}
+
+/*func (manager *SArchivedTaskManager) FetchCustomizeColumns(
+	ctx context.Context,
+	userCred mcclient.TokenCredential,
+	query jsonutils.JSONObject,
+	objs []interface{},
+	fields stringutils2.SSortedStrings,
+	isList bool,
+) []apis.TaskDetails {
+	rows := make([]apis.TaskDetails, len(objs))
+	return rows
+}*/
+
+func (manager *SArchivedTaskManager) OrderByExtraFields(
+	ctx context.Context,
+	q *sqlchemy.SQuery,
+	userCred mcclient.TokenCredential,
+	query apis.ArchivedTaskListInput,
+) (*sqlchemy.SQuery, error) {
+	var err error
+	q, err = manager.SModelBaseManager.OrderByExtraFields(ctx, q, userCred, query.ModelBaseListInput)
+	if err != nil {
+		return q, errors.Wrap(err, "SModelBaseManager.OrderByExtraField")
+	}
+	return q, nil
+}

pkg/cloudcommon/db/taskman/tasks.go

@@ -1115,6 +1115,10 @@ func (manager *STaskManager) ListItemFilter(
 		}
 	}
 
+	if len(input.ParentTaskId) > 0 {
+		q = q.Equals("parent_task_id", input.ParentTaskId)
+	}
+
 	if input.SubTask != nil && *input.SubTask {
 		subSQFunc := func(status string, cntField string) *sqlchemy.SSubQuery {
 			subQ := SubTaskManager.Query()
@@ -1275,9 +1279,7 @@ func (manager *STaskManager) InitializeData() error {
 }
 
 func (manager *STaskManager) failTimeoutTasks() error {
-	// failed unfinished tasks 24 hours ago
 	q := manager.Query().NotIn("stage", []string{TASK_STAGE_FAILED, TASK_STAGE_COMPLETE})
-	// q = q.LT("created_at", time.Now().Add(-24*time.Hour))
 
 	tasks := make([]STask, 0)
 	err := db.FetchModelObjects(manager, q, &tasks)
@@ -1470,3 +1472,49 @@ func (manager *STaskManager) TaskCleanupJob(ctx context.Context, userCred mcclie
 	}
 	log.Infof("TaskCleanupJob migrate %d tasks, takes %f seconds, batch limit=%d threshold hours=%d", count, time.Since(taskStart).Seconds(), consts.TaskArchiveBatchLimit(), consts.TaskArchiveThresholdHours())
 }
+
+func (task *STask) PerformCancel(
+	ctx context.Context,
+	userCred mcclient.TokenCredential,
+	query jsonutils.JSONObject,
+	input apis.TaskCancelInput,
+) (jsonutils.JSONObject, error) {
+	if utils.IsInArray(task.Stage, []string{TASK_STAGE_FAILED, TASK_STAGE_COMPLETE}) {
+		return nil, errors.Wrapf(errors.ErrInvalidStatus, "cannot cancel stage in %s", task.Stage)
+	}
+	err := task.cancel(ctx)
+	if err != nil {
+		return nil, errors.Wrap(err, "cancel")
+	}
+	return nil, nil
+}
+
+func (task *STask) fetchSubTasks() ([]STask, error) {
+	q := task.GetModelManager().Query().Equals("parent_task_id", task.Id)
+
+	tasks := make([]STask, 0)
+	err := db.FetchModelObjects(task.GetModelManager(), q, &tasks)
+	if err != nil {
+		return nil, errors.Wrap(err, "db.FetchModelObjects")
+	}
+	return tasks, nil
+}
+
+func (task *STask) cancel(ctx context.Context) error {
+	if utils.IsInArray(task.Stage, []string{TASK_STAGE_FAILED, TASK_STAGE_COMPLETE}) {
+		return nil
+	}
+	subtasks, err := task.fetchSubTasks()
+	if err != nil {
+		return errors.Wrap(err, "fetchSubTasks")
+	}
+	for i := range subtasks {
+		err := subtasks[i].cancel(ctx)
+		if err != nil {
+			return errors.Wrap(err, "cancelTask")
+		}
+	}
+	reason := jsonutils.NewString("cancel")
+	task.SetStageFailed(ctx, reason)
+	return nil
+}

pkg/cloudevent/service/handlers.go

@@ -42,7 +42,6 @@ func InitHandlers(app *appsrv.Application) {
 
 	models.InitCloudevent()
 
-	taskman.InitArchivedTaskManager()
 	taskman.AddTaskHandler("v1", app)
 
 	for _, manager := range []db.IModelManager{

pkg/cloudid/service/handlers.go

@@ -40,7 +40,6 @@ import (
 func InitHandlers(app *appsrv.Application) {
 	db.InitAllManagers()
 
-	taskman.InitArchivedTaskManager()
 	taskman.AddTaskHandler("v1", app)
 
 	db.AddScopeResourceCountHandler("", app)

pkg/compute/service/handlers.go

@@ -53,7 +53,6 @@ func InitHandlers(app *appsrv.Application) {
 	specs.AddSpecHandler("", app)
 	sshkeys.AddSshKeysHandler("", app)
 
-	taskman.InitArchivedTaskManager()
 	taskman.AddTaskHandler("", app)
 
 	misc.AddMiscHandler("", app)

pkg/devtool/service/handler.go

@@ -25,7 +25,6 @@ import (
 func InitHandlers(app *appsrv.Application) {
 	db.InitAllManagers()
 
-	taskman.InitArchivedTaskManager()
 	taskman.AddTaskHandler("", app)
 
 	for _, manager := range []db.IModelManager{

pkg/image/service/handlers.go

@@ -43,7 +43,6 @@ func InitHandlers(app *appsrv.Application) {
 	quotas.AddQuotaHandler(&models.QuotaManager.SQuotaBaseManager, API_VERSION, app)
 	usages.AddUsageHandler(API_VERSION, app)
 
-	taskman.InitArchivedTaskManager()
 	taskman.AddTaskHandler(API_VERSION, app)
 
 	app_common.ExportOptionsHandler(app, &options.Options)

pkg/keystone/service/handlers.go

@@ -43,7 +43,6 @@ func InitHandlers(app *appsrv.Application) {
 
 	usages.AddUsageHandler(API_VERSION, app)
 
-	taskman.InitArchivedTaskManager()
 	taskman.AddTaskHandler(API_VERSION, app)
 
 	app_common.ExportOptionsHandlerWithPrefix(app, API_VERSION, &options.Options)

pkg/mcclient/modules/compute/mod_tasks.go

@@ -20,12 +20,8 @@ import (
 )
 
 var ComputeTasks tasks.TasksManager
+var ArchivedComputeTasks tasks.TasksManager
 
 func init() {
-	ComputeTasks = tasks.TasksManager{
-		ResourceManager: modules.NewComputeManager("task", "tasks",
-			[]string{},
-			[]string{"Id", "Obj_name", "Obj_Id", "Task_name", "Stage", "Created_at"}),
-	}
-	modules.RegisterCompute(&ComputeTasks)
+	ComputeTasks, ArchivedComputeTasks = tasks.NewTaskManagers(modules.NewComputeManager)
 }

pkg/mcclient/modules/devtool/mod_tasks.go

@@ -20,13 +20,8 @@ import (
 )
 
 var DevtoolTasks tasks.TasksManager
+var ArchivedDevtoolTasks tasks.TasksManager
 
 func init() {
-	DevtoolTasks = tasks.TasksManager{
-		ResourceManager: modules.NewDevtoolManager("task", "tasks",
-			[]string{},
-			[]string{"Id", "Obj_name", "Obj_Id", "Task_name", "Stage", "Created_at"},
-		),
-	}
-	modules.Register(&DevtoolTasks)
+	DevtoolTasks, ArchivedDevtoolTasks = tasks.NewTaskManagers(modules.NewDevtoolManager)
 }

pkg/mcclient/modules/identity/mod_tasks.go

@@ -20,13 +20,8 @@ import (
 )
 
 var Tasks tasks.TasksManager
+var ArchivedTasks tasks.TasksManager
 
 func init() {
-	Tasks = tasks.TasksManager{
-		ResourceManager: modules.NewIdentityV3Manager("task", "tasks",
-			[]string{},
-			[]string{"Id", "Obj_name", "Obj_Id", "Task_name", "Stage", "Created_at"},
-		),
-	}
-	modules.Register(&Tasks)
+	Tasks, ArchivedTasks = tasks.NewTaskManagers(modules.NewIdentityV3Manager)
 }

pkg/mcclient/modules/image/mod_tasks.go

@@ -20,13 +20,8 @@ import (
 )
 
 var Tasks tasks.TasksManager
+var ArchivedTasks tasks.TasksManager
 
 func init() {
-	Tasks = tasks.TasksManager{
-		ResourceManager: modules.NewImageManager("task", "tasks",
-			[]string{},
-			[]string{"Id", "Obj_name", "Obj_Id", "Task_name", "Stage", "Created_at"},
-		),
-	}
-	modules.Register(&Tasks)
+	Tasks, ArchivedTasks = tasks.NewTaskManagers(modules.NewImageManager)
 }

pkg/mcclient/modules/k8s/tasks.go

@@ -19,7 +19,8 @@ import (
 )
 
 var (
-	KubeTasks *tasks.TasksManager
+	KubeTasks         *tasks.TasksManager
+	ArchivedKubeTasks *tasks.TasksManager
 )
 
 type KubeTasksManager struct {
@@ -27,9 +28,13 @@ type KubeTasksManager struct {
 }
 
 func init() {
-	k8sResMan := NewResourceManager("task", "tasks", NewColumns(), NewColumns("Id", "Obj_name", "Obj_Id", "Task_name", "Stage", "Created_at"))
+	k8sTasksMan := NewResourceManager("task", "tasks", NewColumns(), NewColumns("Id", "Obj_name", "Obj_Id", "Task_name", "Stage", "Created_at"))
+	k8sArchivedTasksMan := NewResourceManager("archivedtask", "archivedtasks", NewColumns(), NewColumns("Id", "Obj_name", "Obj_Id", "Task_name", "Stage", "Created_at"))
 
 	KubeTasks = &tasks.TasksManager{
-		ResourceManager: k8sResMan.GetBaseManager(),
+		ResourceManager: k8sTasksMan.GetBaseManager(),
+	}
+	ArchivedKubeTasks = &tasks.TasksManager{
+		ResourceManager: k8sArchivedTasksMan.GetBaseManager(),
 	}
 }

pkg/mcclient/modules/notify/mod_tasks.go

@@ -20,13 +20,8 @@ import (
 )
 
 var Tasks tasks.TasksManager
+var ArchivedTasks tasks.TasksManager
 
 func init() {
-	Tasks = tasks.TasksManager{
-		ResourceManager: modules.NewNotifyv2Manager("task", "tasks",
-			[]string{},
-			[]string{"Id", "Obj_name", "Obj_Id", "Task_name", "Stage", "Created_at"},
-		),
-	}
-	modules.Register(&Tasks)
+	Tasks, ArchivedTasks = tasks.NewTaskManagers(modules.NewNotifyv2Manager)
 }

pkg/mcclient/modules/tasks/mod_tasks.go

@@ -22,32 +22,28 @@ import (
 
 	"yunion.io/x/onecloud/pkg/mcclient"
 	"yunion.io/x/onecloud/pkg/mcclient/modulebase"
+	"yunion.io/x/onecloud/pkg/mcclient/modules"
 )
 
-/*var (
-	ComputeTasks TasksManager
-	DevtoolTasks TasksManager
-)*/
-
 type TasksManager struct {
 	modulebase.ResourceManager
 }
 
-/*func init() {
-	ComputeTasks = TasksManager{
-		ResourceManager: modules.NewComputeManager("task", "tasks",
+func NewTaskManagers(taskManager func(string, string, []string, []string) modulebase.ResourceManager) (TasksManager, TasksManager) {
+	task := TasksManager{
+		ResourceManager: taskManager("task", "tasks",
 			[]string{},
 			[]string{"Id", "Obj_name", "Obj_Id", "Task_name", "Stage", "Created_at"}),
 	}
-	modules.RegisterCompute(&ComputeTasks)
-
-	DevtoolTasks = TasksManager{
-		ResourceManager: modules.NewDevtoolManager("task", "tasks",
+	modules.Register(&task)
+	archivedTask := TasksManager{
+		ResourceManager: taskManager("archivedtask", "archivedtasks",
 			[]string{},
-			[]string{"Id", "Obj_name", "Obj_Id", "Task_name", "Stage", "Created_at"},
-		),
+			[]string{"Id", "task_id", "Obj_name", "Obj_Id", "Task_name", "Stage", "Start_at"}),
 	}
-}*/
+	modules.Register(&archivedTask)
+	return task, archivedTask
+}
 
 func (man *TasksManager) TaskComplete(session *mcclient.ClientSession, taskId string, params jsonutils.JSONObject) {
 	for i := 0; i < 3; i++ {

pkg/monitor/service/handlers.go

@@ -41,7 +41,6 @@ func InitHandlers(app *appsrv.Application) {
 	db.RegisterModelManager(db.RoleCacheManager)
 	db.RegistUserCredCacheUpdater()
 
-	taskman.InitArchivedTaskManager()
 	taskman.AddTaskHandler("", app)
 
 	for _, manager := range []db.IModelManager{

pkg/notify/models/emailqueue.go

@@ -225,14 +225,11 @@ func (manager *SEmailQueueManager) ListItemFilter(
 	query api.EmailQueueListInput,
 ) (*sqlchemy.SQuery, error) {
 	var err error
-	q, err = manager.SLogBaseManager.ListItemFilter(ctx, q, userCred, query.ModelBaseListInput)
+	q, err = manager.SLogBaseManager.ListItemFilter(ctx, q, userCred, query.LogBaseListInput)
 	if err != nil {
 		return q, errors.Wrap(err, "SLogBaseManager.ListItemFilter")
 	}
 
-	if len(query.Id) > 0 {
-		q = q.In("id", query.Id)
-	}
 	if len(query.To) > 0 {
 		cond := make([]sqlchemy.ICondition, 0)
 		for _, to := range query.To {

pkg/notify/service/handlers.go

@@ -34,7 +34,8 @@ func InitHandlers(app *appsrv.Application) {
 	models.InitEmailQueue()
 
 	db.RegistUserCredCacheUpdater()
-	taskman.InitArchivedTaskManager()
+
+	taskman.AddTaskHandler(API_VERSION, app)
 
 	db.AddScopeResourceCountHandler(API_VERSION, app)