fix: use json to store task error message (#7351)

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

pkg/cloudcommon/db/taskman/interface.go

@@ -37,7 +37,7 @@ type ITask interface {
 	GetTaskRequestHeader() http.Header
 
 	SetStageComplete(ctx context.Context, data *jsonutils.JSONDict)
-	SetStageFailed(ctx context.Context, reason string)
+	SetStageFailed(ctx context.Context, reason jsonutils.JSONObject)
 
 	GetPendingUsage(quota quotas.IQuota, index int) error
 	ClearPendingUsage(index int) error

pkg/cloudcommon/db/taskman/tasks.go

@@ -398,18 +398,29 @@ func execITask(taskValue reflect.Value, task *STask, odata jsonutils.JSONObject,
 
 	taskFailed := false
 
-	data := odata
-	if data != nil {
-		taskStatus, _ := data.GetString("__status__")
-		if len(taskStatus) > 0 && taskStatus != "OK" {
-			taskFailed = true
-			if vdata, ok := data.(*jsonutils.JSONDict); ok {
-				reason, err := vdata.Get("__reason__") // only dict support Get
-				if err != nil {
-					reason = jsonutils.NewString(fmt.Sprintf("Task failed due to unknown remote errors! %s", odata))
-					vdata.Set("__reason__", reason)
+	var data jsonutils.JSONObject
+	if odata != nil {
+		switch dictdata := odata.(type) {
+		case *jsonutils.JSONDict:
+			taskStatus, _ := data.GetString("__status__")
+			if len(taskStatus) > 0 && taskStatus != "OK" {
+				taskFailed = true
+				dictdata.Set("__stage__", jsonutils.NewString(task.Stage))
+				if !dictdata.Contains("__reason__") {
+					reasonJson := dictdata.CopyExcludes("__status__", "__stage__")
+					dictdata.Set("__reason__", reasonJson)
 				}
+				/*if vdata, ok := data.(*jsonutils.JSONDict); ok {
+					reason, err := vdata.Get("__reason__") // only dict support Get
+					if err != nil {
+						reason = jsonutils.NewString(fmt.Sprintf("Task failed due to unknown remote errors! %s", odata))
+						vdata.Set("__reason__", reason)
+					}
+				}*/
 			}
+			data = dictdata
+		default:
+			data = odata
 		}
 	} else {
 		data = jsonutils.NewDict()
@@ -441,7 +452,7 @@ func execITask(taskValue reflect.Value, task *STask, odata jsonutils.JSONObject,
 			} else {
 				log.Errorf(msg)
 			}
-			task.SetStageFailed(ctx, msg)
+			task.SetStageFailed(ctx, jsonutils.NewString(msg))
 			task.SaveRequestContext(&ctxData)
 			return
 		}
@@ -451,16 +462,16 @@ func execITask(taskValue reflect.Value, task *STask, odata jsonutils.JSONObject,
 	if objManager == nil {
 		msg := fmt.Sprintf("model %s not found??? ...", task.ObjName)
 		log.Errorf(msg)
-		task.SetStageFailed(ctx, msg)
+		task.SetStageFailed(ctx, jsonutils.NewString(msg))
 		task.SaveRequestContext(&ctxData)
 		return
 	}
 	// log.Debugf("objManager: %s", objManager)
 	objResManager, ok := objManager.(db.IStandaloneModelManager)
 	if !ok {
-		msg := fmt.Sprintf("mode %s is not a resource??? ...", task.ObjName)
+		msg := fmt.Sprintf("model %s is not a resource??? ...", task.ObjName)
 		log.Errorf(msg)
-		task.SetStageFailed(ctx, msg)
+		task.SetStageFailed(ctx, jsonutils.NewString(msg))
 		task.SaveRequestContext(&ctxData)
 		return
 	}
@@ -476,7 +487,7 @@ func execITask(taskValue reflect.Value, task *STask, odata jsonutils.JSONObject,
 			if err != nil {
 				msg := fmt.Sprintf("fail to find %s object %s", task.ObjName, objId)
 				log.Errorf(msg)
-				task.SetStageFailed(ctx, msg)
+				task.SetStageFailed(ctx, jsonutils.NewString(msg))
 				task.SaveRequestContext(&ctxData)
 				return
 			}
@@ -493,7 +504,7 @@ func execITask(taskValue reflect.Value, task *STask, odata jsonutils.JSONObject,
 		if err != nil {
 			msg := fmt.Sprintf("fail to find %s object %s", task.ObjName, task.ObjId)
 			log.Errorf(msg)
-			task.SetStageFailed(ctx, msg)
+			task.SetStageFailed(ctx, jsonutils.NewString(msg))
 			task.SaveRequestContext(&ctxData)
 			return
 		}
@@ -637,18 +648,30 @@ func (self *STask) SetStageComplete(ctx context.Context, data *jsonutils.JSONDic
 	self.NotifyParentTaskComplete(ctx, data, false)
 }
 
-func (self *STask) SetStageFailed(ctx context.Context, reason string) {
+func (self *STask) SetStageFailed(ctx context.Context, reason jsonutils.JSONObject) {
 	if self.Stage == TASK_STAGE_FAILED {
 		log.Warningf("Task %s has been failed", self.TaskName)
 		return
 	}
 	log.Infof("XXX TASK %s failed: %s on stage %s", self.TaskName, reason, self.Stage)
-	prevFailed, _ := self.Params.GetString("__failed_reason")
-	if len(prevFailed) > 0 {
-		reason = prevFailed + ";" + reason
+	reasonDict := jsonutils.NewDict()
+	reasonDict.Add(jsonutils.NewString(self.Stage), "stage")
+	if reason != nil {
+		reasonDict.Add(reason, "reason")
+	}
+	reason = reasonDict
+	prevFailed, _ := self.Params.Get("__failed_reason")
+	if prevFailed != nil {
+		switch prevFailed.(type) {
+		case *jsonutils.JSONArray:
+			prevFailed.(*jsonutils.JSONArray).Add(reason)
+			reason = prevFailed
+		default:
+			reason = jsonutils.NewArray(prevFailed, reason)
+		}
 	}
 	data := jsonutils.NewDict()
-	data.Add(jsonutils.NewString(reason), "__failed_reason")
+	data.Add(reason, "__failed_reason")
 	self.SetStage(TASK_STAGE_FAILED, data)
 	self.NotifyParentTaskFailure(ctx, reason)
 }
@@ -700,10 +723,11 @@ func notifyRemoteTask(ctx context.Context, notifyUrl string, taskid string, body
 	log.Infof("Notify remote URL %s(%s) get acked: %s!", notifyUrl, taskid, body.String())
 }
 
-func (self *STask) NotifyParentTaskFailure(ctx context.Context, reason string) {
+func (self *STask) NotifyParentTaskFailure(ctx context.Context, reason jsonutils.JSONObject) {
 	body := jsonutils.NewDict()
 	body.Add(jsonutils.NewString("error"), "__status__")
-	body.Add(jsonutils.NewString(fmt.Sprintf("Subtask %s failed: %s", self.TaskName, reason)), "__reason__")
+	body.Add(jsonutils.NewString(self.TaskName), "__task_name__")
+	body.Add(reason, "__reason__")
 	self.NotifyParentTaskComplete(ctx, body, true)
 }
 

pkg/cloudevent/tasks/cloudevent_sync_task.go

@@ -38,9 +38,9 @@ func init() {
 	taskman.RegisterTask(CloudeventSyncTask{})
 }
 
-func (self *CloudeventSyncTask) taskFailed(ctx context.Context, cloudprovider *models.SCloudprovider, err error) {
+func (self *CloudeventSyncTask) taskFailed(ctx context.Context, cloudprovider *models.SCloudprovider, err jsonutils.JSONObject) {
 	cloudprovider.MarkEndSync(self.UserCred)
-	self.SetStageFailed(ctx, err.Error())
+	self.SetStageFailed(ctx, err)
 }
 
 func (self *CloudeventSyncTask) taskComplete(ctx context.Context, cloudprovider *models.SCloudprovider) {
@@ -53,19 +53,19 @@ func (self *CloudeventSyncTask) OnInit(ctx context.Context, obj db.IStandaloneMo
 
 	factory, err := provider.GetProviderFactory()
 	if err != nil {
-		self.taskFailed(ctx, provider, errors.Wrap(err, "cloudprovider.GetProviderFactory"))
+		self.taskFailed(ctx, provider, jsonutils.NewString(errors.Wrap(err, "cloudprovider.GetProviderFactory").Error()))
 		return
 	}
 
 	iProvider, err := provider.GetProvider()
 	if err != nil {
-		self.taskFailed(ctx, provider, errors.Wrap(err, "cloudprovider.GetProvider"))
+		self.taskFailed(ctx, provider, jsonutils.NewString(errors.Wrap(err, "cloudprovider.GetProvider").Error()))
 		return
 	}
 
 	start, end, err := provider.GetNextTimeRange()
 	if err != nil {
-		self.taskFailed(ctx, provider, errors.Wrap(err, "provider.GetNextTimeRange"))
+		self.taskFailed(ctx, provider, jsonutils.NewString(errors.Wrap(err, "provider.GetNextTimeRange").Error()))
 		return
 	}
 
@@ -87,7 +87,7 @@ func (self *CloudeventSyncTask) OnInit(ctx context.Context, obj db.IStandaloneMo
 					if err == cloudprovider.ErrNotSupported {
 						continue
 					}
-					self.taskFailed(ctx, provider, errors.Wrapf(err, "regions[%d].GetICloudEvents", i))
+					self.taskFailed(ctx, provider, jsonutils.NewString(errors.Wrapf(err, "regions[%d].GetICloudEvents", i).Error()))
 					return
 				}
 				events = append(events, _events...)

pkg/cloudid/tasks/cloudgroup_delete_task.go

@@ -36,10 +36,10 @@ func init() {
 	taskman.RegisterTask(CloudgroupDeleteTask{})
 }
 
-func (self *CloudgroupDeleteTask) taskFailed(ctx context.Context, group *models.SCloudgroup, err error) {
-	group.SetStatus(self.GetUserCred(), api.CLOUD_GROUP_STATUS_DELETE_FAILED, err.Error())
+func (self *CloudgroupDeleteTask) taskFailed(ctx context.Context, group *models.SCloudgroup, err jsonutils.JSONObject) {
+	group.SetStatus(self.GetUserCred(), api.CLOUD_GROUP_STATUS_DELETE_FAILED, err.String())
 	logclient.AddActionLogWithStartable(self, group, logclient.ACT_DELETE, err, self.UserCred, false)
-	self.SetStageFailed(ctx, err.Error())
+	self.SetStageFailed(ctx, err)
 }
 
 func (self *CloudgroupDeleteTask) OnInit(ctx context.Context, obj db.IStandaloneModel, body jsonutils.JSONObject) {
@@ -47,20 +47,20 @@ func (self *CloudgroupDeleteTask) OnInit(ctx context.Context, obj db.IStandalone
 
 	caches, err := group.GetCloudgroupcaches()
 	if err != nil {
-		self.taskFailed(ctx, group, errors.Wrap(err, "GetCloudgroupcaches"))
+		self.taskFailed(ctx, group, jsonutils.NewString(errors.Wrap(err, "GetCloudgroupcaches").Error()))
 		return
 	}
 
 	for i := range caches {
 		iGroup, err := caches[i].GetICloudgroup()
 		if err != nil && errors.Cause(err) != cloudprovider.ErrNotFound {
-			self.taskFailed(ctx, group, errors.Wrap(err, "caches[i].GetICloudgroup"))
+			self.taskFailed(ctx, group, jsonutils.NewString(errors.Wrap(err, "caches[i].GetICloudgroup").Error()))
 			return
 		}
 		if err == nil {
 			err = iGroup.Delete()
 			if err != nil {
-				self.taskFailed(ctx, group, errors.Wrap(err, "iGroup.Delete"))
+				self.taskFailed(ctx, group, jsonutils.NewString(errors.Wrap(err, "iGroup.Delete").Error()))
 				return
 			}
 		}
@@ -69,7 +69,7 @@ func (self *CloudgroupDeleteTask) OnInit(ctx context.Context, obj db.IStandalone
 
 	cnt, err := group.GetCloudgroupcacheCount()
 	if err != nil {
-		self.taskFailed(ctx, group, errors.Wrap(err, "GetCloudgroupcacheCount"))
+		self.taskFailed(ctx, group, jsonutils.NewString(errors.Wrap(err, "GetCloudgroupcacheCount").Error()))
 		return
 	}
 	if cnt == 0 {

pkg/cloudid/tasks/cloudgroup_sync_policies_task.go

@@ -36,10 +36,10 @@ func init() {
 	taskman.RegisterTask(CloudgroupSyncPoliciesTask{})
 }
 
-func (self *CloudgroupSyncPoliciesTask) taskFailed(ctx context.Context, group *models.SCloudgroup, err error) {
-	group.SetStatus(self.GetUserCred(), api.CLOUD_GROUP_STATUS_SYNC_POLICIES, err.Error())
+func (self *CloudgroupSyncPoliciesTask) taskFailed(ctx context.Context, group *models.SCloudgroup, err jsonutils.JSONObject) {
+	group.SetStatus(self.GetUserCred(), api.CLOUD_GROUP_STATUS_SYNC_POLICIES, err.String())
 	logclient.AddActionLogWithStartable(self, group, logclient.ACT_SYNC_POLICIES, err, self.UserCred, false)
-	self.SetStageFailed(ctx, err.Error())
+	self.SetStageFailed(ctx, err)
 }
 
 func (self *CloudgroupSyncPoliciesTask) OnInit(ctx context.Context, obj db.IStandaloneModel, body jsonutils.JSONObject) {
@@ -47,7 +47,7 @@ func (self *CloudgroupSyncPoliciesTask) OnInit(ctx context.Context, obj db.IStan
 
 	factory, err := group.GetProviderFactory()
 	if err != nil {
-		self.taskFailed(ctx, group, errors.Wrap(err, "group.GetProviderFactory"))
+		self.taskFailed(ctx, group, jsonutils.NewString(errors.Wrap(err, "group.GetProviderFactory").Error()))
 		return
 	}
 
@@ -55,7 +55,7 @@ func (self *CloudgroupSyncPoliciesTask) OnInit(ctx context.Context, obj db.IStan
 		if factory.IsSupportClouduserPolicy() {
 			users, err := group.GetCloudusers()
 			if err != nil {
-				self.taskFailed(ctx, group, errors.Wrap(err, "group.GetCloudusers"))
+				self.taskFailed(ctx, group, jsonutils.NewString(errors.Wrap(err, "group.GetCloudusers").Error()))
 				return
 			}
 			for i := range users {
@@ -67,7 +67,7 @@ func (self *CloudgroupSyncPoliciesTask) OnInit(ctx context.Context, obj db.IStan
 				log.Infof("Sync cloudpolicies for user %s(%s) result: %s", users[i].Name, users[i].Id, result.Result())
 
 				if result.AddErrCnt+result.DelErrCnt > 0 {
-					self.taskFailed(ctx, group, result.AllError())
+					self.taskFailed(ctx, group, jsonutils.NewString(result.AllError().Error()))
 					return
 				}
 			}
@@ -75,7 +75,7 @@ func (self *CloudgroupSyncPoliciesTask) OnInit(ctx context.Context, obj db.IStan
 	} else {
 		caches, err := group.GetCloudgroupcaches()
 		if err != nil {
-			self.taskFailed(ctx, group, errors.Wrap(err, "GetCloudgroupcaches"))
+			self.taskFailed(ctx, group, jsonutils.NewString(errors.Wrap(err, "GetCloudgroupcaches").Error()))
 			return
 		}
 
@@ -88,7 +88,7 @@ func (self *CloudgroupSyncPoliciesTask) OnInit(ctx context.Context, obj db.IStan
 			log.Infof("Sync cloudpolicies for group cache %s(%s) result: %s", caches[i].Name, caches[i].Id, result.Result())
 
 			if result.AddErrCnt+result.DelErrCnt > 0 {
-				self.taskFailed(ctx, group, result.AllError())
+				self.taskFailed(ctx, group, jsonutils.NewString(result.AllError().Error()))
 				return
 			}
 		}

pkg/cloudid/tasks/cloudgroup_sync_users_task.go

@@ -36,10 +36,10 @@ func init() {
 	taskman.RegisterTask(CloudgroupSyncUsersTask{})
 }
 
-func (self *CloudgroupSyncUsersTask) taskFailed(ctx context.Context, group *models.SCloudgroup, err error) {
-	group.SetStatus(self.GetUserCred(), api.CLOUD_GROUP_STATUS_SYNC_POLICIES, err.Error())
+func (self *CloudgroupSyncUsersTask) taskFailed(ctx context.Context, group *models.SCloudgroup, err jsonutils.JSONObject) {
+	group.SetStatus(self.GetUserCred(), api.CLOUD_GROUP_STATUS_SYNC_POLICIES, err.String())
 	logclient.AddActionLogWithStartable(self, group, logclient.ACT_SYNC_POLICIES, err, self.UserCred, false)
-	self.SetStageFailed(ctx, err.Error())
+	self.SetStageFailed(ctx, err)
 }
 
 func (self *CloudgroupSyncUsersTask) OnInit(ctx context.Context, obj db.IStandaloneModel, body jsonutils.JSONObject) {
@@ -47,13 +47,13 @@ func (self *CloudgroupSyncUsersTask) OnInit(ctx context.Context, obj db.IStandal
 
 	factory, err := group.GetProviderFactory()
 	if err != nil {
-		self.taskFailed(ctx, group, errors.Wrap(err, "GetProviderFactory"))
+		self.taskFailed(ctx, group, jsonutils.NewString(errors.Wrap(err, "GetProviderFactory").Error()))
 		return
 	}
 
 	users, err := group.GetCloudusers()
 	if err != nil {
-		self.taskFailed(ctx, group, errors.Wrap(err, "GetCloudusers"))
+		self.taskFailed(ctx, group, jsonutils.NewString(errors.Wrap(err, "GetCloudusers").Error()))
 		return
 	}
 
@@ -67,14 +67,14 @@ func (self *CloudgroupSyncUsersTask) OnInit(ctx context.Context, obj db.IStandal
 			log.Infof("Sync cloudpolicies for user %s(%s) result: %s", users[i].Name, users[i].Id, result.Result())
 
 			if result.AddErrCnt+result.DelErrCnt > 0 {
-				self.taskFailed(ctx, group, result.AllError())
+				self.taskFailed(ctx, group, jsonutils.NewString(result.AllError().Error()))
 				return
 			}
 		}
 	} else {
 		caches, err := group.GetCloudgroupcaches()
 		if err != nil {
-			self.taskFailed(ctx, group, errors.Wrap(err, "GetCloudgroupcaches"))
+			self.taskFailed(ctx, group, jsonutils.NewString(errors.Wrap(err, "GetCloudgroupcaches").Error()))
 			return
 		}
 
@@ -95,7 +95,7 @@ func (self *CloudgroupSyncUsersTask) OnInit(ctx context.Context, obj db.IStandal
 			log.Infof("Sync cloudpolicies for group cache %s(%s) result: %s", caches[i].Name, caches[i].Id, result.Result())
 
 			if result.AddErrCnt+result.DelErrCnt > 0 {
-				self.taskFailed(ctx, group, result.AllError())
+				self.taskFailed(ctx, group, jsonutils.NewString(result.AllError().Error()))
 				return
 			}
 		}
@@ -104,19 +104,19 @@ func (self *CloudgroupSyncUsersTask) OnInit(ctx context.Context, obj db.IStandal
 			if _, ok := accounts[user.CloudaccountId]; !ok {
 				account, err := user.GetCloudaccount()
 				if err != nil {
-					self.taskFailed(ctx, group, errors.Wrap(err, "GetCloudaccount"))
+					self.taskFailed(ctx, group, jsonutils.NewString(errors.Wrap(err, "GetCloudaccount").Error()))
 					return
 				}
 
 				cache, err := models.CloudgroupcacheManager.Register(group, account)
 				if err != nil {
-					self.taskFailed(ctx, group, errors.Wrap(err, "CloudgroupcacheManager.Register"))
+					self.taskFailed(ctx, group, jsonutils.NewString(errors.Wrap(err, "CloudgroupcacheManager.Register").Error()))
 					return
 				}
 
 				_, err = cache.GetOrCreateICloudgroup(ctx, self.GetUserCred())
 				if err != nil {
-					self.taskFailed(ctx, group, errors.Wrap(err, "GetOrCreateICloudgroup"))
+					self.taskFailed(ctx, group, jsonutils.NewString(errors.Wrap(err, "GetOrCreateICloudgroup").Error()))
 					return
 				}
 
@@ -128,7 +128,7 @@ func (self *CloudgroupSyncUsersTask) OnInit(ctx context.Context, obj db.IStandal
 				log.Infof("Sync cloudpolicies for group cache %s(%s) result: %s", cache.Name, cache.Id, result.Result())
 
 				if result.AddErrCnt+result.DelErrCnt > 0 {
-					self.taskFailed(ctx, group, result.AllError())
+					self.taskFailed(ctx, group, jsonutils.NewString(result.AllError().Error()))
 					return
 				}
 			}

pkg/cloudid/tasks/cloudgroupcache_delete_task.go

@@ -36,10 +36,10 @@ func init() {
 	taskman.RegisterTask(CloudgroupcacheDeleteTask{})
 }
 
-func (self *CloudgroupcacheDeleteTask) taskFailed(ctx context.Context, cache *models.SCloudgroupcache, err error) {
-	cache.SetStatus(self.GetUserCred(), api.CLOUD_GROUP_STATUS_DELETE_FAILED, err.Error())
+func (self *CloudgroupcacheDeleteTask) taskFailed(ctx context.Context, cache *models.SCloudgroupcache, err jsonutils.JSONObject) {
+	cache.SetStatus(self.GetUserCred(), api.CLOUD_GROUP_STATUS_DELETE_FAILED, err.String())
 	logclient.AddActionLogWithStartable(self, cache, logclient.ACT_DELETE, err, self.UserCred, false)
-	self.SetStageFailed(ctx, err.Error())
+	self.SetStageFailed(ctx, err)
 }
 
 func (self *CloudgroupcacheDeleteTask) taskComplete(ctx context.Context, cache *models.SCloudgroupcache) {
@@ -60,12 +60,12 @@ func (self *CloudgroupcacheDeleteTask) OnInit(ctx context.Context, obj db.IStand
 			self.taskComplete(ctx, cache)
 			return
 		}
-		self.taskFailed(ctx, cache, errors.Wrap(err, "GetICloudgroup"))
+		self.taskFailed(ctx, cache, jsonutils.NewString(errors.Wrap(err, "GetICloudgroup").Error()))
 		return
 	}
 	err = iGroup.Delete()
 	if err != nil {
-		self.taskFailed(ctx, cache, errors.Wrap(err, "iGroup.Delete"))
+		self.taskFailed(ctx, cache, jsonutils.NewString(errors.Wrap(err, "iGroup.Delete").Error()))
 		return
 	}
 	self.taskComplete(ctx, cache)

pkg/cloudid/tasks/cloudgroupcache_sync_status_task.go

@@ -35,17 +35,17 @@ func init() {
 	taskman.RegisterTask(CloudgroupcacheSyncstatusTask{})
 }
 
-func (self *CloudgroupcacheSyncstatusTask) taskFailed(ctx context.Context, cache *models.SCloudgroupcache, err error) {
-	cache.SetStatus(self.GetUserCred(), api.CLOUD_GROUP_CACHE_STATUS_UNKNOWN, err.Error())
+func (self *CloudgroupcacheSyncstatusTask) taskFailed(ctx context.Context, cache *models.SCloudgroupcache, err jsonutils.JSONObject) {
+	cache.SetStatus(self.GetUserCred(), api.CLOUD_GROUP_CACHE_STATUS_UNKNOWN, err.String())
 	logclient.AddActionLogWithStartable(self, cache, logclient.ACT_SYNC_STATUS, err, self.UserCred, false)
-	self.SetStageFailed(ctx, err.Error())
+	self.SetStageFailed(ctx, err)
 }
 
 func (self *CloudgroupcacheSyncstatusTask) OnInit(ctx context.Context, obj db.IStandaloneModel, body jsonutils.JSONObject) {
 	cache := obj.(*models.SCloudgroupcache)
 	_, err := cache.GetICloudgroup()
 	if err != nil {
-		self.taskFailed(ctx, cache, errors.Wrap(err, "GetICloudgroup"))
+		self.taskFailed(ctx, cache, jsonutils.NewString(errors.Wrap(err, "GetICloudgroup").Error()))
 		return
 	}
 	self.SetStageComplete(ctx, nil)

pkg/cloudid/tasks/clouduser_delete_task.go

@@ -36,10 +36,10 @@ func init() {
 	taskman.RegisterTask(ClouduserDeleteTask{})
 }
 
-func (self *ClouduserDeleteTask) taskFailed(ctx context.Context, clouduser *models.SClouduser, err error) {
-	clouduser.SetStatus(self.GetUserCred(), api.CLOUD_USER_STATUS_DELETE_FAILED, err.Error())
+func (self *ClouduserDeleteTask) taskFailed(ctx context.Context, clouduser *models.SClouduser, err jsonutils.JSONObject) {
+	clouduser.SetStatus(self.GetUserCred(), api.CLOUD_USER_STATUS_DELETE_FAILED, err.String())
 	logclient.AddActionLogWithStartable(self, clouduser, logclient.ACT_DELETE, err, self.UserCred, false)
-	self.SetStageFailed(ctx, err.Error())
+	self.SetStageFailed(ctx, err)
 }
 
 func (self *ClouduserDeleteTask) OnInit(ctx context.Context, obj db.IStandaloneModel, body jsonutils.JSONObject) {
@@ -58,13 +58,13 @@ func (self *ClouduserDeleteTask) OnInit(ctx context.Context, obj db.IStandaloneM
 			self.SetStageComplete(ctx, nil)
 			return
 		}
-		self.taskFailed(ctx, clouduser, errors.Wrap(err, "GetIClouduser"))
+		self.taskFailed(ctx, clouduser, jsonutils.NewString(errors.Wrap(err, "GetIClouduser").Error()))
 		return
 	}
 
 	err = iUser.Delete()
 	if err != nil {
-		self.taskFailed(ctx, clouduser, errors.Wrap(err, "user.Delete"))
+		self.taskFailed(ctx, clouduser, jsonutils.NewString(errors.Wrap(err, "user.Delete").Error()))
 		return
 	}
 	clouduser.RealDelete(ctx, self.GetUserCred())

pkg/cloudid/tasks/clouduser_reset_password_task.go

@@ -35,10 +35,10 @@ func init() {
 	taskman.RegisterTask(ClouduserResetPasswordTask{})
 }
 
-func (self *ClouduserResetPasswordTask) taskFailed(ctx context.Context, clouduser *models.SClouduser, err error) {
-	clouduser.SetStatus(self.GetUserCred(), api.CLOUD_USER_STATUS_RESET_PASSWORD_FAILED, err.Error())
+func (self *ClouduserResetPasswordTask) taskFailed(ctx context.Context, clouduser *models.SClouduser, err jsonutils.JSONObject) {
+	clouduser.SetStatus(self.GetUserCred(), api.CLOUD_USER_STATUS_RESET_PASSWORD_FAILED, err.String())
 	logclient.AddActionLogWithStartable(self, clouduser, logclient.ACT_RESET_PASSWORD, err, self.UserCred, false)
-	self.SetStageFailed(ctx, err.Error())
+	self.SetStageFailed(ctx, err)
 }
 
 func (self *ClouduserResetPasswordTask) OnInit(ctx context.Context, obj db.IStandaloneModel, body jsonutils.JSONObject) {
@@ -47,26 +47,26 @@ func (self *ClouduserResetPasswordTask) OnInit(ctx context.Context, obj db.IStan
 
 	account, err := clouduser.GetCloudaccount()
 	if err != nil {
-		self.taskFailed(ctx, clouduser, errors.Wrap(err, "GetCloudaccount"))
+		self.taskFailed(ctx, clouduser, jsonutils.NewString(errors.Wrap(err, "GetCloudaccount").Error()))
 		return
 	}
 
 	factory, err := account.GetProviderFactory()
 	if err != nil {
-		self.taskFailed(ctx, clouduser, errors.Wrap(err, "GetProviderFactory"))
+		self.taskFailed(ctx, clouduser, jsonutils.NewString(errors.Wrap(err, "GetProviderFactory").Error()))
 		return
 	}
 
 	iUser, err := clouduser.GetIClouduser()
 	if err != nil {
-		self.taskFailed(ctx, clouduser, errors.Wrap(err, "GetIClouduser"))
+		self.taskFailed(ctx, clouduser, jsonutils.NewString(errors.Wrap(err, "GetIClouduser").Error()))
 		return
 	}
 
 	if factory.IsSupportResetClouduserPassword() {
 		err = iUser.ResetPassword(password)
 		if err != nil {
-			self.taskFailed(ctx, clouduser, errors.Wrap(err, "ResetPassword"))
+			self.taskFailed(ctx, clouduser, jsonutils.NewString(errors.Wrap(err, "ResetPassword").Error()))
 			return
 		}
 		clouduser.SyncWithClouduser(ctx, self.GetUserCred(), iUser, clouduser.CloudproviderId)

pkg/cloudid/tasks/clouduser_sync_groups_task.go

@@ -35,9 +35,9 @@ func init() {
 	taskman.RegisterTask(ClouduserSyncGroupsTask{})
 }
 
-func (self *ClouduserSyncGroupsTask) taskFailed(ctx context.Context, clouduser *models.SClouduser, err error) {
-	clouduser.SetStatus(self.GetUserCred(), api.CLOUD_USER_STATUS_SYNC_GROUPS_FAILED, err.Error())
-	self.SetStageFailed(ctx, err.Error())
+func (self *ClouduserSyncGroupsTask) taskFailed(ctx context.Context, clouduser *models.SClouduser, err jsonutils.JSONObject) {
+	clouduser.SetStatus(self.GetUserCred(), api.CLOUD_USER_STATUS_SYNC_GROUPS_FAILED, err.String())
+	self.SetStageFailed(ctx, err)
 }
 
 func (self *ClouduserSyncGroupsTask) OnInit(ctx context.Context, obj db.IStandaloneModel, body jsonutils.JSONObject) {
@@ -45,54 +45,54 @@ func (self *ClouduserSyncGroupsTask) OnInit(ctx context.Context, obj db.IStandal
 
 	account, err := user.GetCloudaccount()
 	if err != nil {
-		self.taskFailed(ctx, user, errors.Wrap(err, "GetCloudaccount"))
+		self.taskFailed(ctx, user, jsonutils.NewString(errors.Wrap(err, "GetCloudaccount").Error()))
 		return
 	}
 
 	factory, err := account.GetProviderFactory()
 	if err != nil {
-		self.taskFailed(ctx, user, errors.Wrap(err, "GetCloudaccount"))
+		self.taskFailed(ctx, user, jsonutils.NewString(errors.Wrap(err, "GetCloudaccount").Error()))
 		return
 	}
 
 	if factory.IsSupportCreateCloudgroup() {
 		groups, err := user.GetCloudgroups()
 		if err != nil {
-			self.taskFailed(ctx, user, errors.Wrap(err, "GetCloudgroups"))
+			self.taskFailed(ctx, user, jsonutils.NewString(errors.Wrap(err, "GetCloudgroups").Error()))
 			return
 		}
 
 		for i := range groups {
 			cache, err := models.CloudgroupcacheManager.Register(&groups[i], account)
 			if err != nil {
-				self.taskFailed(ctx, user, errors.Wrap(err, "CloudgroupcacheManager.Register"))
+				self.taskFailed(ctx, user, jsonutils.NewString(errors.Wrap(err, "CloudgroupcacheManager.Register").Error()))
 				return
 			}
 			_, err = cache.GetOrCreateICloudgroup(ctx, self.GetUserCred())
 			if err != nil {
-				self.taskFailed(ctx, user, errors.Wrap(err, "GetOrCreateICloudgroup"))
+				self.taskFailed(ctx, user, jsonutils.NewString(errors.Wrap(err, "GetOrCreateICloudgroup").Error()))
 				return
 			}
 			result, err := cache.SyncCloudusersForCloud(ctx)
 			if err != nil {
-				self.taskFailed(ctx, user, errors.Wrap(err, "SyncCloudusersForCloud"))
+				self.taskFailed(ctx, user, jsonutils.NewString(errors.Wrap(err, "SyncCloudusersForCloud").Error()))
 				return
 			}
 			log.Infof("sync cloudusers for cache %s(%s) result: %s", cache.Name, cache.Id, result.Result())
 
 			if result.AddErrCnt+result.DelErrCnt > 0 {
-				self.taskFailed(ctx, user, result.AllError())
+				self.taskFailed(ctx, user, jsonutils.NewString(result.AllError().Error()))
 				return
 			}
 
 			result, err = cache.SyncCloudpoliciesForCloud(ctx)
 			if err != nil {
-				self.taskFailed(ctx, user, errors.Wrap(err, "SyncCloudpoliciesForCloud"))
+				self.taskFailed(ctx, user, jsonutils.NewString(errors.Wrap(err, "SyncCloudpoliciesForCloud").Error()))
 				return
 			}
 
 			if result.AddErrCnt+result.DelErrCnt > 0 {
-				self.taskFailed(ctx, user, result.AllError())
+				self.taskFailed(ctx, user, jsonutils.NewString(result.AllError().Error()))
 				return
 			}
 			log.Infof("sync cloudpolicies for cache %s(%s) result: %s", cache.Name, cache.Id, result.Result())
@@ -100,13 +100,13 @@ func (self *ClouduserSyncGroupsTask) OnInit(ctx context.Context, obj db.IStandal
 	} else if factory.IsSupportClouduserPolicy() {
 		result, err := user.SyncCloudpoliciesForCloud(ctx)
 		if err != nil {
-			self.taskFailed(ctx, user, errors.Wrap(err, "SyncCloudpoliciesForCloud"))
+			self.taskFailed(ctx, user, jsonutils.NewString(errors.Wrap(err, "SyncCloudpoliciesForCloud").Error()))
 			return
 		}
 		log.Infof("sync cloudpolicies for user %s(%s) result: %s", user.Name, user.Id, result.Result())
 
 		if result.AddErrCnt+result.DelErrCnt > 0 {
-			self.taskFailed(ctx, user, result.AllError())
+			self.taskFailed(ctx, user, jsonutils.NewString(result.AllError().Error()))
 			return
 		}
 	}

pkg/cloudid/tasks/clouduser_sync_policies_task.go

@@ -35,9 +35,9 @@ func init() {
 	taskman.RegisterTask(ClouduserSyncPoliciesTask{})
 }
 
-func (self *ClouduserSyncPoliciesTask) taskFailed(ctx context.Context, clouduser *models.SClouduser, err error) {
-	clouduser.SetStatus(self.GetUserCred(), api.CLOUD_USER_STATUS_SYNC_POLICIES_FAILED, err.Error())
-	self.SetStageFailed(ctx, err.Error())
+func (self *ClouduserSyncPoliciesTask) taskFailed(ctx context.Context, clouduser *models.SClouduser, err jsonutils.JSONObject) {
+	clouduser.SetStatus(self.GetUserCred(), api.CLOUD_USER_STATUS_SYNC_POLICIES_FAILED, err.String())
+	self.SetStageFailed(ctx, err)
 }
 
 func (self *ClouduserSyncPoliciesTask) OnInit(ctx context.Context, obj db.IStandaloneModel, body jsonutils.JSONObject) {
@@ -45,26 +45,26 @@ func (self *ClouduserSyncPoliciesTask) OnInit(ctx context.Context, obj db.IStand
 
 	account, err := user.GetCloudaccount()
 	if err != nil {
-		self.taskFailed(ctx, user, errors.Wrap(err, "GetCloudaccount"))
+		self.taskFailed(ctx, user, jsonutils.NewString(errors.Wrap(err, "GetCloudaccount").Error()))
 		return
 	}
 
 	factory, err := account.GetProviderFactory()
 	if err != nil {
-		self.taskFailed(ctx, user, errors.Wrap(err, "account.GetProviderFactory"))
+		self.taskFailed(ctx, user, jsonutils.NewString(errors.Wrap(err, "account.GetProviderFactory").Error()))
 		return
 	}
 
 	if factory.IsSupportClouduserPolicy() {
 		result, err := user.SyncCloudpoliciesForCloud(ctx)
 		if err != nil {
-			self.taskFailed(ctx, user, errors.Wrap(err, "SyncCloudpoliciesForCloud"))
+			self.taskFailed(ctx, user, jsonutils.NewString(errors.Wrap(err, "SyncCloudpoliciesForCloud").Error()))
 			return
 		}
 		log.Infof("sync cloudpolicies for user %s(%s) result: %s", user.Name, user.Id, result.Result())
 
 		if result.AddErrCnt+result.DelErrCnt > 0 {
-			self.taskFailed(ctx, user, result.AllError())
+			self.taskFailed(ctx, user, jsonutils.NewString(result.AllError().Error()))
 			return
 		}
 	}

pkg/cloudid/tasks/clouduser_sync_task.go

@@ -34,9 +34,9 @@ func init() {
 	taskman.RegisterTask(ClouduserSyncTask{})
 }
 
-func (self *ClouduserSyncTask) taskFailed(ctx context.Context, clouduser *models.SClouduser, err error) {
-	clouduser.SetStatus(self.GetUserCred(), api.CLOUD_USER_STATUS_SYNC_FAILED, err.Error())
-	self.SetStageFailed(ctx, err.Error())
+func (self *ClouduserSyncTask) taskFailed(ctx context.Context, clouduser *models.SClouduser, err jsonutils.JSONObject) {
+	clouduser.SetStatus(self.GetUserCred(), api.CLOUD_USER_STATUS_SYNC_FAILED, err.String())
+	self.SetStageFailed(ctx, err)
 }
 
 func (self *ClouduserSyncTask) OnInit(ctx context.Context, obj db.IStandaloneModel, body jsonutils.JSONObject) {
@@ -49,12 +49,12 @@ func (self *ClouduserSyncTask) OnInit(ctx context.Context, obj db.IStandaloneMod
 func (self *ClouduserSyncTask) OnSyncCloudpoliciesComplete(ctx context.Context, user *models.SClouduser, body jsonutils.JSONObject) {
 	account, err := user.GetCloudaccount()
 	if err != nil {
-		self.taskFailed(ctx, user, errors.Wrap(err, "user.GetCloudaccount"))
+		self.taskFailed(ctx, user, jsonutils.NewString(errors.Wrap(err, "user.GetCloudaccount").Error()))
 		return
 	}
 	factory, err := account.GetProviderFactory()
 	if err != nil {
-		self.taskFailed(ctx, user, errors.Wrap(err, "GetProviderFactory"))
+		self.taskFailed(ctx, user, jsonutils.NewString(errors.Wrap(err, "GetProviderFactory").Error()))
 		return
 	}
 
@@ -69,7 +69,7 @@ func (self *ClouduserSyncTask) OnSyncCloudpoliciesComplete(ctx context.Context,
 }
 
 func (self *ClouduserSyncTask) OnSyncCloudpoliciesCompleteFailed(ctx context.Context, user *models.SClouduser, data jsonutils.JSONObject) {
-	self.taskFailed(ctx, user, errors.Error(data.String()))
+	self.taskFailed(ctx, user, data)
 }
 
 func (self *ClouduserSyncTask) OnSyncCloudgroupsComplete(ctx context.Context, user *models.SClouduser, body jsonutils.JSONObject) {
@@ -78,5 +78,5 @@ func (self *ClouduserSyncTask) OnSyncCloudgroupsComplete(ctx context.Context, us
 }
 
 func (self *ClouduserSyncTask) OnSyncCloudgroupsCompleteFailed(ctx context.Context, user *models.SClouduser, data jsonutils.JSONObject) {
-	self.taskFailed(ctx, user, errors.Error(data.String()))
+	self.taskFailed(ctx, user, data)
 }

pkg/cloudid/tasks/clouduser_syncstatus_task.go

@@ -34,9 +34,9 @@ func init() {
 	taskman.RegisterTask(ClouduserSyncstatusTask{})
 }
 
-func (self *ClouduserSyncstatusTask) taskFailed(ctx context.Context, clouduser *models.SClouduser, err error) {
-	clouduser.SetStatus(self.GetUserCred(), api.CLOUD_USER_STATUS_UNKNOWN, err.Error())
-	self.SetStageFailed(ctx, err.Error())
+func (self *ClouduserSyncstatusTask) taskFailed(ctx context.Context, clouduser *models.SClouduser, err jsonutils.JSONObject) {
+	clouduser.SetStatus(self.GetUserCred(), api.CLOUD_USER_STATUS_UNKNOWN, err.String())
+	self.SetStageFailed(ctx, err)
 }
 
 func (self *ClouduserSyncstatusTask) OnInit(ctx context.Context, obj db.IStandaloneModel, body jsonutils.JSONObject) {
@@ -44,7 +44,7 @@ func (self *ClouduserSyncstatusTask) OnInit(ctx context.Context, obj db.IStandal
 
 	_, err := clouduser.GetIClouduser()
 	if err != nil {
-		self.taskFailed(ctx, clouduser, errors.Wrap(err, "GetIClouduser"))
+		self.taskFailed(ctx, clouduser, jsonutils.NewString(errors.Wrap(err, "GetIClouduser").Error()))
 		return
 	}
 

pkg/cloudid/tasks/sync_cloudpolicies_task.go

@@ -34,8 +34,8 @@ func init() {
 	taskman.RegisterTask(SyncCloudIdResourcesTask{})
 }
 
-func (self *SyncCloudIdResourcesTask) taskFailed(ctx context.Context, cloudaccount *models.SCloudaccount, err error) {
-	self.SetStageFailed(ctx, err.Error())
+func (self *SyncCloudIdResourcesTask) taskFailed(ctx context.Context, cloudaccount *models.SCloudaccount, err jsonutils.JSONObject) {
+	self.SetStageFailed(ctx, err)
 }
 
 func (self *SyncCloudIdResourcesTask) OnInit(ctx context.Context, obj db.IStandaloneModel, body jsonutils.JSONObject) {
@@ -43,7 +43,7 @@ func (self *SyncCloudIdResourcesTask) OnInit(ctx context.Context, obj db.IStanda
 
 	provider, err := account.GetProvider()
 	if err != nil {
-		self.taskFailed(ctx, account, errors.Wrap(err, "GetProvider"))
+		self.taskFailed(ctx, account, jsonutils.NewString(errors.Wrap(err, "GetProvider").Error()))
 		return
 	}
 
@@ -73,5 +73,5 @@ func (self *SyncCloudIdResourcesTask) OnSyncCloudusersComplete(ctx context.Conte
 }
 
 func (self *SyncCloudIdResourcesTask) OnClouduserSyncCompleteFailed(ctx context.Context, obj db.IStandaloneModel, data jsonutils.JSONObject) {
-	self.SetStageFailed(ctx, data.String())
+	self.SetStageFailed(ctx, data)
 }

pkg/cloudid/tasks/sync_cloudusers_task.go

@@ -121,5 +121,5 @@ func (self *SyncCloudusersTask) OnClouduserSyncComplete(ctx context.Context, obj
 }
 
 func (self *SyncCloudusersTask) OnClouduserSyncCompleteFailed(ctx context.Context, obj db.IStandaloneModel, data jsonutils.JSONObject) {
-	self.SetStageFailed(ctx, data.String())
+	self.SetStageFailed(ctx, data)
 }

pkg/compute/tasks/baremetal_cdrom_task.go

@@ -47,16 +47,16 @@ func (self *BaremetalCdromTask) OnInit(ctx context.Context, obj db.IStandaloneMo
 	self.SetStage("OnSyncConfigComplete", nil)
 	_, err := baremetal.BaremetalSyncRequest(ctx, "POST", url, headers, self.Params)
 	if err != nil {
-		self.OnFailure(ctx, baremetal, err.Error())
+		self.OnFailure(ctx, baremetal, jsonutils.Marshal(err))
 	}
 }
 
-func (self *BaremetalCdromTask) OnFailure(ctx context.Context, baremetal *models.SHost, reason string) {
+func (self *BaremetalCdromTask) OnFailure(ctx context.Context, baremetal *models.SHost, reason jsonutils.JSONObject) {
 	action, _ := self.Params.GetString("action")
 	if action == api.BAREMETAL_CDROM_ACTION_INSERT {
-		baremetal.SetStatus(self.UserCred, api.BAREMETAL_INSERT_FAIL, reason)
+		baremetal.SetStatus(self.UserCred, api.BAREMETAL_INSERT_FAIL, reason.String())
 	} else {
-		baremetal.SetStatus(self.UserCred, api.BAREMETAL_EJECT_FAIL, reason)
+		baremetal.SetStatus(self.UserCred, api.BAREMETAL_EJECT_FAIL, reason.String())
 	}
 	self.SetStageFailed(ctx, reason)
 }
@@ -66,6 +66,5 @@ func (self *BaremetalCdromTask) OnSyncConfigComplete(ctx context.Context, bareme
 }
 
 func (self *BaremetalCdromTask) OnSyncConfigCompleteFailed(ctx context.Context, baremetal *models.SHost, body jsonutils.JSONObject) {
-	reason, _ := body.GetString("__reason__")
-	self.OnFailure(ctx, baremetal, reason)
+	self.OnFailure(ctx, baremetal, body)
 }

pkg/compute/tasks/baremetal_convert_hypervisor_task.go

@@ -60,7 +60,7 @@ func (self *BaremetalConvertHypervisorTask) OnInit(ctx context.Context, obj db.I
 	paramsDict := params.(*jsonutils.JSONDict)
 	input, err := cmdline.FetchServerCreateInputByJSON(paramsDict)
 	if err != nil {
-		self.SetStageFailed(ctx, err.Error())
+		self.SetStageFailed(ctx, jsonutils.Marshal(err))
 		return
 	}
 	input.ParentTaskId = self.GetTaskId()
@@ -74,7 +74,7 @@ func (self *BaremetalConvertHypervisorTask) OnGuestDeployComplete(ctx context.Co
 	hypervisor := self.getHypervisor()
 	driver := models.GetHostDriver(hypervisor)
 	if driver == nil {
-		self.SetStageFailed(ctx, fmt.Sprintf("Get Host Driver error %s", hypervisor))
+		self.SetStageFailed(ctx, jsonutils.NewString(fmt.Sprintf("Get Host Driver error %s", hypervisor)))
 	}
 	err := driver.FinishConvert(self.UserCred, baremetal, guest, driver.GetHostType())
 	if err != nil {
@@ -105,5 +105,5 @@ func (self *BaremetalConvertHypervisorTask) OnGuestDeleteComplete(ctx context.Co
 }
 
 func (self *BaremetalConvertHypervisorTask) OnFailedSyncstatusComplete(ctx context.Context, baremetal *models.SHost, body jsonutils.JSONObject) {
-	self.SetStageFailed(ctx, "convert failed")
+	self.SetStageFailed(ctx, body)
 }

pkg/compute/tasks/baremetal_delete_task.go

@@ -67,6 +67,6 @@ func (self *BaremetalDeleteTask) OnDeleteBaremetalCompleteFailed(ctx context.Con
 }
 
 func (self *BaremetalDeleteTask) OnFailure(ctx context.Context, baremetal *models.SHost, body jsonutils.JSONObject) {
-	baremetal.SetStatus(self.UserCred, api.BAREMETAL_DELETE_FAIL, "")
-	self.SetStageFailed(ctx, "")
+	baremetal.SetStatus(self.UserCred, api.BAREMETAL_DELETE_FAIL, body.String())
+	self.SetStageFailed(ctx, body)
 }

pkg/compute/tasks/baremetal_ipmi_probe_task.go

@@ -43,13 +43,13 @@ func (self *BaremetalIpmiProbeTask) OnInit(ctx context.Context, obj db.IStandalo
 	self.SetStage("OnSyncConfigComplete", nil)
 	_, err := baremetal.BaremetalSyncRequest(ctx, "POST", url, headers, self.Params)
 	if err != nil {
-		self.OnFailure(ctx, baremetal, err.Error())
+		self.OnFailure(ctx, baremetal, jsonutils.Marshal(err))
 	}
 }
 
-func (self *BaremetalIpmiProbeTask) OnFailure(ctx context.Context, baremetal *models.SHost, reason string) {
+func (self *BaremetalIpmiProbeTask) OnFailure(ctx context.Context, baremetal *models.SHost, reason jsonutils.JSONObject) {
 	logclient.AddActionLogWithStartable(self, baremetal, logclient.ACT_PROBE, reason, self.UserCred, false)
-	baremetal.SetStatus(self.UserCred, api.BAREMETAL_PROBE_FAIL, reason)
+	baremetal.SetStatus(self.UserCred, api.BAREMETAL_PROBE_FAIL, reason.String())
 	self.SetStageFailed(ctx, reason)
 }
 
@@ -59,6 +59,5 @@ func (self *BaremetalIpmiProbeTask) OnSyncConfigComplete(ctx context.Context, ba
 }
 
 func (self *BaremetalIpmiProbeTask) OnSyncConfigCompleteFailed(ctx context.Context, baremetal *models.SHost, body jsonutils.JSONObject) {
-	reason, _ := body.GetString("__reason__")
-	self.OnFailure(ctx, baremetal, reason)
+	self.OnFailure(ctx, baremetal, body)
 }

pkg/compute/tasks/baremetal_maintenance_task.go

@@ -73,7 +73,7 @@ func (self *BaremetalMaintenanceTask) OnEnterMaintenantModeSucc(ctx context.Cont
 }
 
 func (self *BaremetalMaintenanceTask) OnEnterMaintenantModeSuccFailed(ctx context.Context, baremetal *models.SHost, body jsonutils.JSONObject) {
-	self.SetStageFailed(ctx, body.String())
+	self.SetStageFailed(ctx, body)
 	baremetal.StartSyncstatus(ctx, self.UserCred, "")
 	guest := baremetal.GetBaremetalServer()
 	if guest != nil {
@@ -81,6 +81,6 @@ func (self *BaremetalMaintenanceTask) OnEnterMaintenantModeSuccFailed(ctx contex
 	}
 	action := self.Action()
 	if len(action) > 0 {
-		logclient.AddActionLogWithStartable(self, baremetal, action, body.String(), self.UserCred, false)
+		logclient.AddActionLogWithStartable(self, baremetal, action, body, self.UserCred, false)
 	}
 }

pkg/compute/tasks/baremetal_prepare_task.go

@@ -41,12 +41,12 @@ func (self *BaremetalPrepareTask) OnInit(ctx context.Context, obj db.IStandalone
 	self.SetStage("OnSyncConfigComplete", nil)
 	_, err := baremetal.BaremetalSyncRequest(ctx, "POST", url, headers, self.Params)
 	if err != nil {
-		self.OnFailure(ctx, baremetal, err.Error())
+		self.OnFailure(ctx, baremetal, jsonutils.Marshal(err))
 	}
 }
 
-func (self *BaremetalPrepareTask) OnFailure(ctx context.Context, baremetal *models.SHost, reason string) {
-	baremetal.SetStatus(self.UserCred, api.BAREMETAL_PREPARE_FAIL, reason)
+func (self *BaremetalPrepareTask) OnFailure(ctx context.Context, baremetal *models.SHost, reason jsonutils.JSONObject) {
+	baremetal.SetStatus(self.UserCred, api.BAREMETAL_PREPARE_FAIL, reason.String())
 	self.SetStageFailed(ctx, reason)
 }
 
@@ -56,6 +56,5 @@ func (self *BaremetalPrepareTask) OnSyncConfigComplete(ctx context.Context, bare
 }
 
 func (self *BaremetalPrepareTask) OnSyncConfigCompleteFailed(ctx context.Context, baremetal *models.SHost, body jsonutils.JSONObject) {
-	reason, _ := body.GetString("__reason__")
-	self.OnFailure(ctx, baremetal, reason)
+	self.OnFailure(ctx, baremetal, body)
 }

pkg/compute/tasks/baremetal_server_reset_task.go

@@ -33,7 +33,7 @@ func (self *BaremetalServerResetTask) OnInit(ctx context.Context, obj db.IStanda
 	guest := obj.(*models.SGuest)
 	baremetal := guest.GetHost()
 	if baremetal == nil {
-		self.SetStageFailed(ctx, "Baremetal is None")
+		self.SetStageFailed(ctx, jsonutils.NewString("Baremetal is not found"))
 		return
 	}
 	url := fmt.Sprintf("/baremetals/%s/servers/%s/reset", baremetal.Id, guest.Id)
@@ -41,7 +41,7 @@ func (self *BaremetalServerResetTask) OnInit(ctx context.Context, obj db.IStanda
 	_, err := baremetal.BaremetalSyncRequest(ctx, "POST", url, headers, nil)
 	if err != nil {
 		log.Errorln(err)
-		self.SetStageFailed(ctx, err.Error())
+		self.SetStageFailed(ctx, jsonutils.Marshal(err))
 	} else {
 		self.SetStageComplete(ctx, nil)
 	}

pkg/compute/tasks/baremetal_server_start_task.go

@@ -65,10 +65,9 @@ func (self *BaremetalServerStartTask) OnStartComplete(ctx context.Context, guest
 }
 
 func (self *BaremetalServerStartTask) OnStartCompleteFailed(ctx context.Context, guest *models.SGuest, body jsonutils.JSONObject) {
-	reason := body.String()
-	guest.SetStatus(self.UserCred, api.VM_START_FAILED, reason)
-	db.OpsLog.LogEvent(guest, db.ACT_START_FAIL, reason, self.UserCred)
+	guest.SetStatus(self.UserCred, api.VM_START_FAILED, body.String())
+	db.OpsLog.LogEvent(guest, db.ACT_START_FAIL, body, self.UserCred)
 	baremetal := guest.GetHost()
-	baremetal.SetStatus(self.UserCred, api.BAREMETAL_START_FAIL, reason)
-	self.SetStageFailed(ctx, reason)
+	baremetal.SetStatus(self.UserCred, api.BAREMETAL_START_FAIL, body.String())
+	self.SetStageFailed(ctx, body)
 }

pkg/compute/tasks/baremetal_server_stop_task.go

@@ -80,10 +80,10 @@ func (self *BaremetalServerStopTask) OnGuestStopTaskComplete(ctx context.Context
 
 func (self *BaremetalServerStopTask) OnGuestStopTaskCompleteFailed(ctx context.Context, guest *models.SGuest, data jsonutils.JSONObject) {
 	guest.SetStatus(self.UserCred, db.ACT_STOP_FAIL, data.String())
-	db.OpsLog.LogEvent(guest, db.ACT_STOP_FAIL, data.String(), self.UserCred)
+	db.OpsLog.LogEvent(guest, db.ACT_STOP_FAIL, data, self.UserCred)
 	baremetal := guest.GetHost()
-	baremetal.SetStatus(self.UserCred, api.BAREMETAL_READY, "")
-	self.SetStageFailed(ctx, data.String())
+	baremetal.SetStatus(self.UserCred, api.BAREMETAL_READY, data.String())
+	self.SetStageFailed(ctx, data)
 }
 
 func (self *BaremetalServerStopTask) OnStopGuestFail(ctx context.Context, guest *models.SGuest, reason string) {

pkg/compute/tasks/baremetal_sync_config_task.go

@@ -49,7 +49,7 @@ func (self *BaremetalSyncConfigTask) DoSyncConfig(ctx context.Context, baremetal
 	headers := self.GetTaskRequestHeader()
 	_, err := baremetal.BaremetalSyncRequest(ctx, "POST", url, headers, nil)
 	if err != nil {
-		self.SetStageFailed(ctx, err.Error())
+		self.SetStageFailed(ctx, jsonutils.Marshal(err))
 	}
 }
 

pkg/compute/tasks/baremetal_sync_status_task.go

@@ -47,7 +47,7 @@ func (self *BaremetalSyncStatusTask) DoSyncStatus(ctx context.Context, baremetal
 	headers := self.GetTaskRequestHeader()
 	_, err := baremetal.BaremetalSyncRequest(ctx, "POST", url, headers, nil)
 	if err != nil {
-		self.SetStageFailed(ctx, err.Error())
+		self.SetStageFailed(ctx, jsonutils.Marshal(err))
 	}
 }
 

pkg/compute/tasks/baremetal_unconvert_hypervisor_task.go

@@ -40,7 +40,7 @@ func (self *BaremetalUnconvertHypervisorTask) OnInit(ctx context.Context, obj db
 	baremetal.SetStatus(self.UserCred, api.BAREMETAL_CONVERTING, "")
 	guests := baremetal.GetGuests()
 	if len(guests) > 1 {
-		self.SetStageFailed(ctx, "Host guest conut > 1")
+		self.SetStageFailed(ctx, jsonutils.NewString("Host guest conut > 1"))
 	}
 	if len(guests) == 1 {
 		guest := guests[0]
@@ -68,7 +68,7 @@ func (self *BaremetalUnconvertHypervisorTask) OnGuestDeleteCompleteFailed(ctx co
 	db.OpsLog.LogEvent(baremetal, db.ACT_UNCONVERT_FAIL, body, self.UserCred)
 	self.SetStage("OnFailSyncstatusComplete", nil)
 	baremetal.StartSyncstatus(ctx, self.UserCred, self.GetTaskId())
-	logclient.AddActionLogWithStartable(self, baremetal, logclient.ACT_BM_UNCONVERT_HYPER, nil, self.UserCred, false)
+	logclient.AddActionLogWithStartable(self, baremetal, logclient.ACT_BM_UNCONVERT_HYPER, body, self.UserCred, false)
 }
 
 func (self *BaremetalUnconvertHypervisorTask) OnPrepareComplete(ctx context.Context, baremetal *models.SHost, body jsonutils.JSONObject) {
@@ -76,5 +76,5 @@ func (self *BaremetalUnconvertHypervisorTask) OnPrepareComplete(ctx context.Cont
 }
 
 func (self *BaremetalUnconvertHypervisorTask) OnFailSyncstatusComplete(ctx context.Context, baremetal *models.SHost, body jsonutils.JSONObject) {
-	self.SetStageFailed(ctx, "Delete server failed")
+	self.SetStageFailed(ctx, jsonutils.NewString("Delete server failed"))
 }

pkg/compute/tasks/baremetal_unmaintenance_task.go

@@ -43,10 +43,9 @@ func (self *BaremetalUnmaintenanceTask) OnInit(ctx context.Context, obj db.IStan
 	_, err := baremetal.BaremetalSyncRequest(ctx, "POST", url, headers, self.Params)
 	if err != nil {
 		if len(action) > 0 {
-			msg := fmt.Sprintf("unmaintenance error %s", err.Error())
-			logclient.AddActionLogWithStartable(self, baremetal, action, msg, self.UserCred, false)
+			logclient.AddActionLogWithStartable(self, baremetal, action, err, self.UserCred, false)
 		}
-		self.SetStageFailed(ctx, err.Error())
+		self.SetStageFailed(ctx, jsonutils.Marshal(err))
 	} else {
 		if len(action) > 0 {
 			logclient.AddActionLogWithStartable(self, baremetal, action, "", self.UserCred, true)

pkg/compute/tasks/bucket_create_task.go

@@ -36,9 +36,9 @@ func init() {
 
 func (task *BucketCreateTask) taskFailed(ctx context.Context, bucket *models.SBucket, err error) {
 	bucket.SetStatus(task.UserCred, api.BUCKET_STATUS_CREATE_FAIL, err.Error())
-	db.OpsLog.LogEvent(bucket, db.ACT_ALLOCATE_FAIL, err.Error(), task.UserCred)
-	logclient.AddActionLogWithStartable(task, bucket, logclient.ACT_ALLOCATE, err.Error(), task.UserCred, false)
-	task.SetStageFailed(ctx, err.Error())
+	db.OpsLog.LogEvent(bucket, db.ACT_ALLOCATE_FAIL, err, task.UserCred)
+	logclient.AddActionLogWithStartable(task, bucket, logclient.ACT_ALLOCATE, err, task.UserCred, false)
+	task.SetStageFailed(ctx, jsonutils.Marshal(err))
 }
 
 func (task *BucketCreateTask) OnInit(ctx context.Context, obj db.IStandaloneModel, body jsonutils.JSONObject) {

pkg/compute/tasks/bucket_delete_task.go

@@ -38,7 +38,7 @@ func (task *BucketDeleteTask) taskFailed(ctx context.Context, bucket *models.SBu
 	bucket.SetStatus(task.UserCred, api.VPC_STATUS_DELETE_FAILED, err.Error())
 	db.OpsLog.LogEvent(bucket, db.ACT_DELOCATE_FAIL, err.Error(), task.UserCred)
 	logclient.AddActionLogWithStartable(task, bucket, logclient.ACT_DELETE, err.Error(), task.UserCred, false)
-	task.SetStageFailed(ctx, err.Error())
+	task.SetStageFailed(ctx, jsonutils.Marshal(err))
 }
 
 func (task *BucketDeleteTask) OnInit(ctx context.Context, obj db.IStandaloneModel, body jsonutils.JSONObject) {

pkg/compute/tasks/bucket_syncstatus_task.go

@@ -38,7 +38,7 @@ func init() {
 
 func (self *BucketSyncstatusTask) taskFailed(ctx context.Context, bucket *models.SBucket, err error) {
 	bucket.SetStatus(self.GetUserCred(), api.BUCKET_STATUS_UNKNOWN, err.Error())
-	self.SetStageFailed(ctx, err.Error())
+	self.SetStageFailed(ctx, jsonutils.Marshal(err))
 	db.OpsLog.LogEvent(bucket, db.ACT_SYNC_STATUS, bucket.GetShortDesc(ctx), self.GetUserCred())
 	logclient.AddActionLogWithContext(ctx, bucket, logclient.ACT_SYNC_STATUS, err, self.UserCred, false)
 }

pkg/compute/tasks/cloud_account_delete_task.go

@@ -53,7 +53,7 @@ func (self *CloudAccountDeleteTask) OnInit(ctx context.Context, obj db.IStandalo
 		if err != nil {
 			// very unlikely
 			account.SetStatus(self.UserCred, api.CLOUD_PROVIDER_DELETE_FAILED, err.Error())
-			self.SetStageFailed(ctx, err.Error())
+			self.SetStageFailed(ctx, jsonutils.Marshal(err))
 			return
 		}
 	}
@@ -73,7 +73,7 @@ func (self *CloudAccountDeleteTask) OnAllCloudProviderDeleteCompleteFailed(ctx c
 	account := obj.(*models.SCloudaccount)
 
 	account.SetStatus(self.UserCred, api.CLOUD_PROVIDER_DELETE_FAILED, body.String())
-	self.SetStageFailed(ctx, body.String())
+	self.SetStageFailed(ctx, body)
 
 	logclient.AddActionLogWithStartable(self, account, logclient.ACT_DELETE, body, self.UserCred, false)
 }

pkg/compute/tasks/cloud_account_sync_skus_task.go

@@ -41,8 +41,8 @@ func init() {
 func (self *CloudAccountSyncSkusTask) taskFailed(ctx context.Context, account *models.SCloudaccount, err error) {
 	account.SetStatus(self.UserCred, api.CLOUD_PROVIDER_SYNC_STATUS_ERROR, err.Error())
 	db.OpsLog.LogEvent(account, db.ACT_SYNC_CLOUD_SKUS, err.Error(), self.GetUserCred())
-	logclient.AddActionLogWithStartable(self, account, logclient.ACT_CLOUD_SYNC, err.Error(), self.UserCred, false)
-	self.SetStageFailed(ctx, err.Error())
+	logclient.AddActionLogWithStartable(self, account, logclient.ACT_CLOUD_SYNC, err, self.UserCred, false)
+	self.SetStageFailed(ctx, jsonutils.Marshal(err))
 }
 
 func (self *CloudAccountSyncSkusTask) OnInit(ctx context.Context, obj db.IStandaloneModel, body jsonutils.JSONObject) {

pkg/compute/tasks/cloud_account_sync_task.go

@@ -64,7 +64,7 @@ func (self *CloudAccountSyncInfoTask) OnInit(ctx context.Context, obj db.IStanda
 func (self *CloudAccountSyncInfoTask) OnCloudaccountSyncReadyFailed(ctx context.Context, obj db.IStandaloneModel, err jsonutils.JSONObject) {
 	cloudaccount := obj.(*models.SCloudaccount)
 	db.OpsLog.LogEvent(cloudaccount, db.ACT_SYNC_HOST_FAILED, err, self.UserCred)
-	self.SetStageFailed(ctx, err.String())
+	self.SetStageFailed(ctx, jsonutils.Marshal(err))
 	logclient.AddActionLogWithStartable(self, cloudaccount, logclient.ACT_CLOUD_SYNC, err, self.UserCred, false)
 }
 
@@ -75,7 +75,7 @@ func (self *CloudAccountSyncInfoTask) OnCloudaccountSyncReady(ctx context.Contex
 	if err != nil {
 		cloudaccount.MarkEndSyncWithLock(ctx, self.UserCred)
 		db.OpsLog.LogEvent(cloudaccount, db.ACT_SYNC_HOST_FAILED, err, self.UserCred)
-		self.SetStageFailed(ctx, err.Error())
+		self.SetStageFailed(ctx, jsonutils.Marshal(err))
 		logclient.AddActionLogWithStartable(self, cloudaccount, logclient.ACT_CLOUD_SYNC, err, self.UserCred, false)
 		return
 	}
@@ -129,6 +129,6 @@ func (self *CloudAccountSyncInfoTask) OnCloudaccountSyncCompleteFailed(ctx conte
 	cloudaccount := obj.(*models.SCloudaccount)
 	cloudaccount.MarkEndSyncWithLock(ctx, self.UserCred)
 	db.OpsLog.LogEvent(cloudaccount, db.ACT_SYNC_HOST_FAILED, err, self.UserCred)
-	self.SetStageFailed(ctx, err.String())
+	self.SetStageFailed(ctx, err)
 	logclient.AddActionLogWithStartable(self, cloudaccount, logclient.ACT_CLOUD_SYNC, err, self.UserCred, false)
 }

pkg/compute/tasks/cloud_provider_delete_task.go

@@ -42,8 +42,8 @@ func (self *CloudProviderDeleteTask) OnInit(ctx context.Context, obj db.IStandal
 	err := provider.RealDelete(ctx, self.UserCred)
 	if err != nil {
 		provider.SetStatus(self.UserCred, api.CLOUD_PROVIDER_DELETE_FAILED, "StartDiskCloudproviderTask")
-		self.SetStageFailed(ctx, err.Error())
-		logclient.AddActionLogWithStartable(self, provider, logclient.ACT_DELETE, err.Error(), self.UserCred, false)
+		self.SetStageFailed(ctx, jsonutils.Marshal(err))
+		logclient.AddActionLogWithStartable(self, provider, logclient.ACT_DELETE, err, self.UserCred, false)
 		return
 	}
 

pkg/compute/tasks/cloud_provider_sync_info_task.go

@@ -58,11 +58,6 @@ func getAction(params *jsonutils.JSONDict) string {
 	return action
 }
 
-func taskFail(ctx context.Context, task *CloudProviderSyncInfoTask, provider *models.SCloudprovider, reason string) {
-	logclient.AddActionLogWithStartable(task, provider, getAction(task.Params), reason, task.UserCred, false)
-	task.SetStageFailed(ctx, reason)
-}
-
 func (self *CloudProviderSyncInfoTask) GetSyncRange() models.SSyncRange {
 	syncRange := models.SSyncRange{}
 	syncRangeJson, _ := self.Params.Get("sync_range")

pkg/compute/tasks/dbinstance_account_create_task.go

@@ -40,8 +40,8 @@ func init() {
 func (self *DBInstanceAccountCreateTask) taskFailed(ctx context.Context, account *models.SDBInstanceAccount, err error) {
 	account.SetStatus(self.UserCred, api.DBINSTANCE_USER_CREATE_FAILED, err.Error())
 	db.OpsLog.LogEvent(account, db.ACT_CREATE, err.Error(), self.GetUserCred())
-	logclient.AddActionLogWithStartable(self, account, logclient.ACT_CREATE, err.Error(), self.UserCred, false)
-	self.SetStageFailed(ctx, err.Error())
+	logclient.AddActionLogWithStartable(self, account, logclient.ACT_CREATE, err, self.UserCred, false)
+	self.SetStageFailed(ctx, jsonutils.Marshal(err))
 }
 
 func (self *DBInstanceAccountCreateTask) OnInit(ctx context.Context, obj db.IStandaloneModel, data jsonutils.JSONObject) {

pkg/compute/tasks/dbinstance_account_delete_task.go

@@ -38,8 +38,8 @@ func init() {
 func (self *DBInstanceAccountDeleteTask) taskFailed(ctx context.Context, account *models.SDBInstanceAccount, err error) {
 	account.SetStatus(self.UserCred, api.DBINSTANCE_USER_DELETE_FAILED, err.Error())
 	db.OpsLog.LogEvent(account, db.ACT_DELETE, err.Error(), self.GetUserCred())
-	logclient.AddActionLogWithStartable(self, account, logclient.ACT_DELETE, err.Error(), self.UserCred, false)
-	self.SetStageFailed(ctx, err.Error())
+	logclient.AddActionLogWithStartable(self, account, logclient.ACT_DELETE, err, self.UserCred, false)
+	self.SetStageFailed(ctx, jsonutils.Marshal(err))
 }
 
 func (self *DBInstanceAccountDeleteTask) OnInit(ctx context.Context, obj db.IStandaloneModel, data jsonutils.JSONObject) {

pkg/compute/tasks/dbinstance_account_grant_privilege_task.go

@@ -40,8 +40,8 @@ func init() {
 func (self *DBInstanceAccountGrantPrivilegeTask) taskFailed(ctx context.Context, account *models.SDBInstanceAccount, err error) {
 	account.SetStatus(self.UserCred, api.DBINSTANCE_USER_AVAILABLE, err.Error())
 	db.OpsLog.LogEvent(account, db.ACT_GRANT_PRIVILEGE, err.Error(), self.GetUserCred())
-	logclient.AddActionLogWithStartable(self, account, logclient.ACT_GRANT_PRIVILEGE, err.Error(), self.UserCred, false)
-	self.SetStageFailed(ctx, err.Error())
+	logclient.AddActionLogWithStartable(self, account, logclient.ACT_GRANT_PRIVILEGE, err, self.UserCred, false)
+	self.SetStageFailed(ctx, jsonutils.Marshal(err))
 }
 
 func (self *DBInstanceAccountGrantPrivilegeTask) OnInit(ctx context.Context, obj db.IStandaloneModel, data jsonutils.JSONObject) {

pkg/compute/tasks/dbinstance_account_reset_password_task.go

@@ -37,9 +37,9 @@ func init() {
 
 func (self *DBInstanceAccountResetPasswordTask) taskFailed(ctx context.Context, account *models.SDBInstanceAccount, err error) {
 	account.SetStatus(self.UserCred, api.DBINSTANCE_USER_RESET_PASSWD_FAILED, err.Error())
-	db.OpsLog.LogEvent(account, db.ACT_RESET_PASSWORD, err.Error(), self.GetUserCred())
-	logclient.AddActionLogWithStartable(self, account, logclient.ACT_RESET_PASSWORD, err.Error(), self.UserCred, false)
-	self.SetStageFailed(ctx, err.Error())
+	db.OpsLog.LogEvent(account, db.ACT_RESET_PASSWORD, err, self.GetUserCred())
+	logclient.AddActionLogWithStartable(self, account, logclient.ACT_RESET_PASSWORD, err, self.UserCred, false)
+	self.SetStageFailed(ctx, jsonutils.Marshal(err))
 }
 
 func (self *DBInstanceAccountResetPasswordTask) OnInit(ctx context.Context, obj db.IStandaloneModel, data jsonutils.JSONObject) {

pkg/compute/tasks/dbinstance_account_revoke_privilege_task.go

@@ -39,9 +39,9 @@ func init() {
 
 func (self *DBInstanceAccountRevokePrivilegeTask) taskFailed(ctx context.Context, account *models.SDBInstanceAccount, err error) {
 	account.SetStatus(self.UserCred, api.DBINSTANCE_USER_AVAILABLE, err.Error())
-	db.OpsLog.LogEvent(account, db.ACT_REVOKE_PRIVILEGE, err.Error(), self.GetUserCred())
-	logclient.AddActionLogWithStartable(self, account, logclient.ACT_REVOKE_PRIVILEGE, err.Error(), self.UserCred, false)
-	self.SetStageFailed(ctx, err.Error())
+	db.OpsLog.LogEvent(account, db.ACT_REVOKE_PRIVILEGE, err, self.GetUserCred())
+	logclient.AddActionLogWithStartable(self, account, logclient.ACT_REVOKE_PRIVILEGE, err, self.UserCred, false)
+	self.SetStageFailed(ctx, jsonutils.Marshal(err))
 }
 
 func (self *DBInstanceAccountRevokePrivilegeTask) OnInit(ctx context.Context, obj db.IStandaloneModel, data jsonutils.JSONObject) {

pkg/compute/tasks/dbinstance_account_set_privileges_task.go

@@ -40,9 +40,9 @@ func init() {
 
 func (self *DBInstanceAccountSetPrivilegesTask) taskFailed(ctx context.Context, account *models.SDBInstanceAccount, err error) {
 	account.SetStatus(self.UserCred, api.DBINSTANCE_USER_AVAILABLE, err.Error())
-	db.OpsLog.LogEvent(account, db.ACT_SET_PRIVILEGES, err.Error(), self.GetUserCred())
-	logclient.AddActionLogWithStartable(self, account, logclient.ACT_SET_PRIVILEGES, err.Error(), self.UserCred, false)
-	self.SetStageFailed(ctx, err.Error())
+	db.OpsLog.LogEvent(account, db.ACT_SET_PRIVILEGES, err, self.GetUserCred())
+	logclient.AddActionLogWithStartable(self, account, logclient.ACT_SET_PRIVILEGES, err, self.UserCred, false)
+	self.SetStageFailed(ctx, jsonutils.Marshal(err))
 }
 
 func (self *DBInstanceAccountSetPrivilegesTask) OnInit(ctx context.Context, obj db.IStandaloneModel, data jsonutils.JSONObject) {

pkg/compute/tasks/dbinstance_backup_create_task.go

@@ -38,13 +38,13 @@ func init() {
 
 func (self *DBInstanceBackupCreateTask) taskFailed(ctx context.Context, backup *models.SDBInstanceBackup, err error) {
 	backup.SetStatus(self.UserCred, api.DBINSTANCE_BACKUP_CREATE_FAILED, err.Error())
-	db.OpsLog.LogEvent(backup, db.ACT_CREATE, err.Error(), self.GetUserCred())
-	logclient.AddActionLogWithStartable(self, backup, logclient.ACT_CREATE, err.Error(), self.UserCred, false)
+	db.OpsLog.LogEvent(backup, db.ACT_CREATE, err, self.GetUserCred())
+	logclient.AddActionLogWithStartable(self, backup, logclient.ACT_CREATE, err, self.UserCred, false)
 	instance, _ := backup.GetDBInstance()
 	if instance != nil {
 		instance.SetStatus(self.UserCred, api.DBINSTANCE_BACKING_UP_FAILED, err.Error())
 	}
-	self.SetStageFailed(ctx, err.Error())
+	self.SetStageFailed(ctx, jsonutils.Marshal(err))
 }
 
 func (self *DBInstanceBackupCreateTask) OnInit(ctx context.Context, obj db.IStandaloneModel, data jsonutils.JSONObject) {

pkg/compute/tasks/dbinstance_backup_delete.go

@@ -38,9 +38,9 @@ func init() {
 
 func (self *DBInstanceBackupDeleteTask) taskFailed(ctx context.Context, backup *models.SDBInstanceBackup, err error) {
 	backup.SetStatus(self.UserCred, api.DBINSTANCE_BACKUP_DELETE_FAILED, err.Error())
-	db.OpsLog.LogEvent(backup, db.ACT_DELETE, err.Error(), self.GetUserCred())
-	logclient.AddActionLogWithStartable(self, backup, logclient.ACT_DELETE, err.Error(), self.UserCred, false)
-	self.SetStageFailed(ctx, err.Error())
+	db.OpsLog.LogEvent(backup, db.ACT_DELETE, err, self.GetUserCred())
+	logclient.AddActionLogWithStartable(self, backup, logclient.ACT_DELETE, err, self.UserCred, false)
+	self.SetStageFailed(ctx, jsonutils.Marshal(err))
 }
 
 func (self *DBInstanceBackupDeleteTask) OnInit(ctx context.Context, obj db.IStandaloneModel, data jsonutils.JSONObject) {

pkg/compute/tasks/dbinstance_backup_syncstatus_task.go

@@ -38,7 +38,7 @@ func init() {
 
 func (self *DBInstanceBackupSyncstatusTask) taskFailed(ctx context.Context, backup *models.SDBInstanceBackup, err error) {
 	backup.SetStatus(self.GetUserCred(), api.DBINSTANCE_BACKUP_UNKNOWN, err.Error())
-	self.SetStageFailed(ctx, err.Error())
+	self.SetStageFailed(ctx, jsonutils.Marshal(err))
 	db.OpsLog.LogEvent(backup, db.ACT_SYNC_STATUS, backup.GetShortDesc(ctx), self.GetUserCred())
 	logclient.AddActionLogWithContext(ctx, backup, logclient.ACT_SYNC_STATUS, err, self.UserCred, false)
 }

pkg/compute/tasks/dbinstance_change_config.go

@@ -37,9 +37,9 @@ func init() {
 
 func (self *DBInstanceChangeConfigTask) taskFailed(ctx context.Context, dbinstance *models.SDBInstance, err error) {
 	dbinstance.SetStatus(self.UserCred, api.DBINSTANCE_CHANGE_CONFIG_FAILED, err.Error())
-	db.OpsLog.LogEvent(dbinstance, db.ACT_CHANGE_CONFIG, err.Error(), self.GetUserCred())
-	logclient.AddActionLogWithStartable(self, dbinstance, logclient.ACT_CHANGE_CONFIG, err.Error(), self.UserCred, false)
-	self.SetStageFailed(ctx, err.Error())
+	db.OpsLog.LogEvent(dbinstance, db.ACT_CHANGE_CONFIG, err, self.GetUserCred())
+	logclient.AddActionLogWithStartable(self, dbinstance, logclient.ACT_CHANGE_CONFIG, err, self.UserCred, false)
+	self.SetStageFailed(ctx, jsonutils.Marshal(err))
 }
 
 func (self *DBInstanceChangeConfigTask) OnInit(ctx context.Context, obj db.IStandaloneModel, data jsonutils.JSONObject) {
@@ -70,5 +70,5 @@ func (self *DBInstanceChangeConfigTask) OnSyncDBInstanceStatusComplete(ctx conte
 }
 
 func (self *DBInstanceChangeConfigTask) OnSyncDBInstanceStatusCompleteFailed(ctx context.Context, obj db.IStandaloneModel, data jsonutils.JSONObject) {
-	self.SetStageFailed(ctx, data.String())
+	self.SetStageFailed(ctx, data)
 }

pkg/compute/tasks/dbinstance_create_task.go

@@ -38,9 +38,9 @@ func init() {
 
 func (self *DBInstanceCreateTask) taskFailed(ctx context.Context, dbinstance *models.SDBInstance, err error) {
 	dbinstance.SetStatus(self.UserCred, api.DBINSTANCE_CREATE_FAILED, err.Error())
-	db.OpsLog.LogEvent(dbinstance, db.ACT_CREATE, err.Error(), self.GetUserCred())
-	logclient.AddActionLogWithStartable(self, dbinstance, logclient.ACT_CREATE, err.Error(), self.UserCred, false)
-	self.SetStageFailed(ctx, err.Error())
+	db.OpsLog.LogEvent(dbinstance, db.ACT_CREATE, err, self.GetUserCred())
+	logclient.AddActionLogWithStartable(self, dbinstance, logclient.ACT_CREATE, err, self.UserCred, false)
+	self.SetStageFailed(ctx, jsonutils.Marshal(err))
 }
 
 func (self *DBInstanceCreateTask) OnInit(ctx context.Context, obj db.IStandaloneModel, data jsonutils.JSONObject) {
@@ -105,5 +105,5 @@ func (self *DBInstanceCreateTask) OnSyncDBInstanceStatusComplete(ctx context.Con
 }
 
 func (self *DBInstanceCreateTask) OnSyncDBInstanceStatusCompleteFailed(ctx context.Context, obj db.IStandaloneModel, data jsonutils.JSONObject) {
-	self.SetStageFailed(ctx, data.String())
+	self.SetStageFailed(ctx, data)
 }

pkg/compute/tasks/dbinstance_database_create_task.go

@@ -39,9 +39,9 @@ func init() {
 
 func (self *DBInstanceDatabaseCreateTask) taskFailed(ctx context.Context, database *models.SDBInstanceDatabase, err error) {
 	database.SetStatus(self.UserCred, api.DBINSTANCE_DATABASE_CREATE_FAILE, err.Error())
-	db.OpsLog.LogEvent(database, db.ACT_CREATE, err.Error(), self.GetUserCred())
-	logclient.AddActionLogWithStartable(self, database, logclient.ACT_CREATE, err.Error(), self.UserCred, false)
-	self.SetStageFailed(ctx, err.Error())
+	db.OpsLog.LogEvent(database, db.ACT_CREATE, err, self.GetUserCred())
+	logclient.AddActionLogWithStartable(self, database, logclient.ACT_CREATE, err, self.UserCred, false)
+	self.SetStageFailed(ctx, jsonutils.Marshal(err))
 }
 
 func (self *DBInstanceDatabaseCreateTask) OnInit(ctx context.Context, obj db.IStandaloneModel, data jsonutils.JSONObject) {

pkg/compute/tasks/dbinstance_database_delete_task.go

@@ -37,9 +37,9 @@ func init() {
 
 func (self *DBInstanceDatabaseDeleteTask) taskFailed(ctx context.Context, database *models.SDBInstanceDatabase, err error) {
 	database.SetStatus(self.UserCred, api.DBINSTANCE_DATABASE_DELETE_FAILED, err.Error())
-	db.OpsLog.LogEvent(database, db.ACT_DELETE, err.Error(), self.GetUserCred())
-	logclient.AddActionLogWithStartable(self, database, logclient.ACT_DELETE, err.Error(), self.UserCred, false)
-	self.SetStageFailed(ctx, err.Error())
+	db.OpsLog.LogEvent(database, db.ACT_DELETE, err, self.GetUserCred())
+	logclient.AddActionLogWithStartable(self, database, logclient.ACT_DELETE, err, self.UserCred, false)
+	self.SetStageFailed(ctx, jsonutils.Marshal(err))
 }
 
 func (self *DBInstanceDatabaseDeleteTask) OnInit(ctx context.Context, obj db.IStandaloneModel, data jsonutils.JSONObject) {

pkg/compute/tasks/dbinstance_delete_task.go

@@ -38,9 +38,9 @@ func init() {
 
 func (self *DBInstanceDeleteTask) taskFailed(ctx context.Context, dbinstance *models.SDBInstance, err error) {
 	dbinstance.SetStatus(self.UserCred, api.DBINSTANCE_DELETE_FAILED, err.Error())
-	db.OpsLog.LogEvent(dbinstance, db.ACT_DELETE, err.Error(), self.GetUserCred())
-	logclient.AddActionLogWithStartable(self, dbinstance, logclient.ACT_DELETE, err.Error(), self.UserCred, false)
-	self.SetStageFailed(ctx, err.Error())
+	db.OpsLog.LogEvent(dbinstance, db.ACT_DELETE, err, self.GetUserCred())
+	logclient.AddActionLogWithStartable(self, dbinstance, logclient.ACT_DELETE, err, self.UserCred, false)
+	self.SetStageFailed(ctx, jsonutils.Marshal(err))
 }
 
 func (self *DBInstanceDeleteTask) OnInit(ctx context.Context, obj db.IStandaloneModel, data jsonutils.JSONObject) {

pkg/compute/tasks/dbinstance_public_connection_task.go

@@ -47,8 +47,8 @@ func (self *DBInstancePublicConnectionTask) getAction() string {
 
 func (self *DBInstancePublicConnectionTask) taskFailed(ctx context.Context, dbinstance *models.SDBInstance, err error) {
 	dbinstance.SetStatus(self.UserCred, api.DBINSTANCE_FAILE, err.Error())
-	logclient.AddActionLogWithStartable(self, dbinstance, self.getAction(), err.Error(), self.UserCred, false)
-	self.SetStageFailed(ctx, err.Error())
+	logclient.AddActionLogWithStartable(self, dbinstance, self.getAction(), err, self.UserCred, false)
+	self.SetStageFailed(ctx, jsonutils.Marshal(err))
 }
 
 func (self *DBInstancePublicConnectionTask) OnInit(ctx context.Context, obj db.IStandaloneModel, data jsonutils.JSONObject) {

pkg/compute/tasks/dbinstance_reboot_task.go

@@ -39,9 +39,9 @@ func init() {
 
 func (self *DBInstanceRebootTask) taskFailed(ctx context.Context, dbinstance *models.SDBInstance, err error) {
 	dbinstance.SetStatus(self.UserCred, api.DBINSTANCE_REBOOT_FAILED, err.Error())
-	db.OpsLog.LogEvent(dbinstance, db.ACT_REBOOT, err.Error(), self.GetUserCred())
-	logclient.AddActionLogWithStartable(self, dbinstance, logclient.ACT_REBOOT, err.Error(), self.UserCred, false)
-	self.SetStageFailed(ctx, err.Error())
+	db.OpsLog.LogEvent(dbinstance, db.ACT_REBOOT, err, self.GetUserCred())
+	logclient.AddActionLogWithStartable(self, dbinstance, logclient.ACT_REBOOT, err, self.UserCred, false)
+	self.SetStageFailed(ctx, jsonutils.Marshal(err))
 }
 
 func (self *DBInstanceRebootTask) OnInit(ctx context.Context, obj db.IStandaloneModel, data jsonutils.JSONObject) {

pkg/compute/tasks/dbinstance_recovery_task.go

@@ -40,9 +40,9 @@ func init() {
 
 func (self *DBInstanceRecoveryTask) taskFailed(ctx context.Context, instance *models.SDBInstance, err error) {
 	instance.SetStatus(self.UserCred, api.DBINSTANCE_RESTORE_FAILED, err.Error())
-	db.OpsLog.LogEvent(instance, db.ACT_RESTORE, err.Error(), self.GetUserCred())
-	logclient.AddActionLogWithStartable(self, instance, logclient.ACT_RESTORE, err.Error(), self.UserCred, false)
-	self.SetStageFailed(ctx, err.Error())
+	db.OpsLog.LogEvent(instance, db.ACT_RESTORE, err, self.GetUserCred())
+	logclient.AddActionLogWithStartable(self, instance, logclient.ACT_RESTORE, err, self.UserCred, false)
+	self.SetStageFailed(ctx, jsonutils.Marshal(err))
 }
 
 func (self *DBInstanceRecoveryTask) OnInit(ctx context.Context, obj db.IStandaloneModel, data jsonutils.JSONObject) {

pkg/compute/tasks/dbinstance_renew_task.go

@@ -45,12 +45,12 @@ func (self *DBInstanceRenewTask) OnInit(ctx context.Context, obj db.IStandaloneM
 
 	exp, err := instance.GetRegion().GetDriver().RequestRenewDBInstance(instance, bc)
 	if err != nil {
-		msg := fmt.Sprintf("RequestRenewDBInstance failed %s", err)
-		log.Errorf(msg)
-		db.OpsLog.LogEvent(instance, db.ACT_REW_FAIL, msg, self.UserCred)
-		logclient.AddActionLogWithStartable(self, instance, logclient.ACT_RENEW, msg, self.UserCred, false)
-		instance.SetStatus(self.GetUserCred(), api.DBINSTANCE_RENEW_FAILED, msg)
-		self.SetStageFailed(ctx, msg)
+		// msg := fmt.Sprintf("RequestRenewDBInstance failed %s", err)
+		// log.Errorf(msg)
+		db.OpsLog.LogEvent(instance, db.ACT_REW_FAIL, err, self.UserCred)
+		logclient.AddActionLogWithStartable(self, instance, logclient.ACT_RENEW, err, self.UserCred, false)
+		instance.SetStatus(self.GetUserCred(), api.DBINSTANCE_RENEW_FAILED, err.Error())
+		self.SetStageFailed(ctx, jsonutils.Marshal(err))
 		return
 	}
 
@@ -58,7 +58,7 @@ func (self *DBInstanceRenewTask) OnInit(ctx context.Context, obj db.IStandaloneM
 	if err != nil {
 		msg := fmt.Sprintf("SaveRenewInfo fail %s", err)
 		log.Errorf(msg)
-		self.SetStageFailed(ctx, msg)
+		self.SetStageFailed(ctx, jsonutils.NewString(msg))
 		return
 	}
 

pkg/compute/tasks/dbinstance_sync_status_task.go

@@ -37,9 +37,9 @@ func init() {
 
 func (self *DBInstanceSyncStatusTask) taskFailed(ctx context.Context, dbinstance *models.SDBInstance, err error) {
 	dbinstance.SetStatus(self.UserCred, api.DBINSTANCE_UNKNOWN, err.Error())
-	db.OpsLog.LogEvent(dbinstance, db.ACT_SYNC_STATUS, err.Error(), self.GetUserCred())
-	logclient.AddActionLogWithStartable(self, dbinstance, logclient.ACT_SYNC_STATUS, err.Error(), self.UserCred, false)
-	self.SetStageFailed(ctx, err.Error())
+	db.OpsLog.LogEvent(dbinstance, db.ACT_SYNC_STATUS, err, self.GetUserCred())
+	logclient.AddActionLogWithStartable(self, dbinstance, logclient.ACT_SYNC_STATUS, err, self.UserCred, false)
+	self.SetStageFailed(ctx, jsonutils.Marshal(err))
 }
 
 func (self *DBInstanceSyncStatusTask) OnInit(ctx context.Context, obj db.IStandaloneModel, data jsonutils.JSONObject) {

pkg/compute/tasks/dbinstance_sync_task.go

@@ -37,9 +37,9 @@ func init() {
 
 func (self *DBInstanceSyncTask) taskFailed(ctx context.Context, dbinstance *models.SDBInstance, err error) {
 	dbinstance.SetStatus(self.UserCred, api.DBINSTANCE_UNKNOWN, err.Error())
-	db.OpsLog.LogEvent(dbinstance, db.ACT_SYNC_CONF, err.Error(), self.GetUserCred())
-	logclient.AddActionLogWithStartable(self, dbinstance, logclient.ACT_SYNC_CONF, err.Error(), self.UserCred, false)
-	self.SetStageFailed(ctx, err.Error())
+	db.OpsLog.LogEvent(dbinstance, db.ACT_SYNC_CONF, err, self.GetUserCred())
+	logclient.AddActionLogWithStartable(self, dbinstance, logclient.ACT_SYNC_CONF, err, self.UserCred, false)
+	self.SetStageFailed(ctx, jsonutils.Marshal(err))
 }
 
 func (self *DBInstanceSyncTask) OnInit(ctx context.Context, obj db.IStandaloneModel, data jsonutils.JSONObject) {

pkg/compute/tasks/disk_base_task.go

@@ -17,6 +17,8 @@ package tasks
 import (
 	"context"
 
+	"yunion.io/x/jsonutils"
+
 	"yunion.io/x/onecloud/pkg/cloudcommon/db/quotas"
 	"yunion.io/x/onecloud/pkg/cloudcommon/db/taskman"
 	"yunion.io/x/onecloud/pkg/compute/models"
@@ -31,7 +33,7 @@ func (self *SDiskBaseTask) getDisk() *models.SDisk {
 	return obj.(*models.SDisk)
 }
 
-func (self *SDiskBaseTask) SetStageFailed(ctx context.Context, reason string) {
+func (self *SDiskBaseTask) SetStageFailed(ctx context.Context, reason jsonutils.JSONObject) {
 	self.finalReleasePendingUsage(ctx)
 	self.STask.SetStageFailed(ctx, reason)
 }

pkg/compute/tasks/disk_batch_create_task.go

@@ -103,7 +103,7 @@ func (self *DiskBatchCreateTask) GetFirstDisk() (*api.DiskConfig, error) {
 	return disks[0], nil
 }
 
-func (self *DiskBatchCreateTask) OnScheduleFailCallback(ctx context.Context, obj IScheduleModel, reason string) {
+func (self *DiskBatchCreateTask) OnScheduleFailCallback(ctx context.Context, obj IScheduleModel, reason jsonutils.JSONObject) {
 	self.SSchedTask.OnScheduleFailCallback(ctx, obj, reason)
 	disk := obj.(*models.SDisk)
 	log.Errorf("Schedule disk %s failed", disk.Name)
@@ -127,7 +127,7 @@ func (self *DiskBatchCreateTask) SaveScheduleResult(ctx context.Context, obj ISc
 	onError := func(err error) {
 		self.clearPendingUsage(ctx, disk)
 		disk.SetStatus(self.UserCred, api.DISK_ALLOC_FAILED, err.Error())
-		self.SetStageFailed(ctx, err.Error())
+		self.SetStageFailed(ctx, jsonutils.Marshal(err))
 		db.OpsLog.LogEvent(disk, db.ACT_ALLOCATE_FAIL, err, self.UserCred)
 		notifyclient.NotifySystemError(disk.Id, disk.Name, api.DISK_ALLOC_FAILED, err.Error())
 	}

pkg/compute/tasks/disk_clean_overdued_snapshots.go

@@ -43,13 +43,13 @@ func (self *DiskCleanOverduedSnapshots) OnInit(ctx context.Context, obj db.IStan
 	spId, _ := self.Params.GetString("snapshotpolicy_id")
 	sp, _ := models.SnapshotPolicyManager.FetchSnapshotPolicyById(spId)
 	if sp == nil {
-		self.SetStageFailed(ctx, "missing snapshot policy ???")
+		self.SetStageFailed(ctx, jsonutils.NewString("missing snapshot policy ???"))
 		return
 	}
 
 	now, err := self.Params.GetTime("start_time")
 	if err != nil {
-		self.SetStageFailed(ctx, "failed to get start time")
+		self.SetStageFailed(ctx, jsonutils.NewString("failed to get start time"))
 		return
 	}
 
@@ -71,7 +71,7 @@ func (self *DiskCleanOverduedSnapshots) OnInit(ctx context.Context, obj db.IStan
 		snapCount, err = models.SnapshotManager.Query().Equals("fake_deleted", false).Equals("disk_id", disk.Id).
 			Equals("created_by", compute.SNAPSHOT_AUTO).LT("created_at", t).CountWithError()
 		if err != nil {
-			self.SetStageFailed(ctx, err.Error())
+			self.SetStageFailed(ctx, jsonutils.NewString(err.Error()))
 			return
 		}
 		cleanOverdueSnapshots = snapCount > 0
@@ -86,13 +86,13 @@ func (self *DiskCleanOverduedSnapshots) OnInit(ctx context.Context, obj db.IStan
 	err = models.SnapshotManager.Query().Equals("disk_id", disk.Id).
 		Equals("created_by", compute.SNAPSHOT_AUTO).Equals("fake_deleted", false).Asc("created_at").First(snapshot)
 	if err != nil {
-		self.SetStageFailed(ctx, err.Error())
+		self.SetStageFailed(ctx, jsonutils.NewString(err.Error()))
 		return
 	}
 	snapshot.SetModelManager(models.SnapshotManager, snapshot)
 	err = snapshot.StartSnapshotDeleteTask(ctx, self.UserCred, false, self.Id)
 	if err != nil {
-		self.SetStageFailed(ctx, err.Error())
+		self.SetStageFailed(ctx, jsonutils.NewString(err.Error()))
 		return
 	}
 }
@@ -104,7 +104,7 @@ type SnapshotCleanupTask struct {
 func (self *SnapshotCleanupTask) OnInit(ctx context.Context, obj db.IStandaloneModel, data jsonutils.JSONObject) {
 	now, err := self.Params.GetTime("tick")
 	if err != nil {
-		self.SetStageFailed(ctx, "failed get tick")
+		self.SetStageFailed(ctx, jsonutils.NewString("failed get tick"))
 		return
 	}
 	var snapshots = make([]models.SSnapshot, 0)
@@ -116,7 +116,7 @@ func (self *SnapshotCleanupTask) OnInit(ctx context.Context, obj db.IStandaloneM
 		self.SetStageComplete(ctx, nil)
 		return
 	} else if err != nil {
-		self.SetStageFailed(ctx, fmt.Sprintf("failed get snapshot %s", err))
+		self.SetStageFailed(ctx, jsonutils.NewString(fmt.Sprintf("failed get snapshot %s", err)))
 		return
 	}
 	self.StartSnapshotsDelete(ctx, snapshots)
@@ -145,7 +145,7 @@ func (self *SnapshotCleanupTask) OnDeleteSnapshot(ctx context.Context, obj db.IS
 	var snapshots = make([]models.SSnapshot, 0)
 	err := self.Params.Unmarshal(&snapshots, "snapshots")
 	if err != nil {
-		self.SetStageFailed(ctx, err.Error())
+		self.SetStageFailed(ctx, jsonutils.NewString(err.Error()))
 		return
 	}
 	if len(snapshots) > 0 {

pkg/compute/tasks/disk_create_task.go

@@ -71,7 +71,7 @@ func (self *DiskCreateTask) OnStorageCacheImageComplete(ctx context.Context, dis
 func (self *DiskCreateTask) OnStartAllocateFailed(ctx context.Context, disk *models.SDisk, data jsonutils.JSONObject) {
 	disk.SetStatus(self.UserCred, api.DISK_ALLOC_FAILED, data.String())
 	logclient.AddActionLogWithStartable(self, disk, logclient.ACT_ALLOCATE, data, self.UserCred, false)
-	self.SetStageFailed(ctx, data.String())
+	self.SetStageFailed(ctx, data)
 }
 
 func (self *DiskCreateTask) OnDiskReady(ctx context.Context, disk *models.SDisk, data jsonutils.JSONObject) {
@@ -106,7 +106,7 @@ func (self *DiskCreateTask) OnDiskReady(ctx context.Context, disk *models.SDisk,
 func (self *DiskCreateTask) OnDiskReadyFailed(ctx context.Context, disk *models.SDisk, data jsonutils.JSONObject) {
 	disk.SetStatus(self.UserCred, api.DISK_ALLOC_FAILED, data.String())
 	logclient.AddActionLogWithStartable(self, disk, logclient.ACT_ALLOCATE, data, self.UserCred, false)
-	self.SetStageFailed(ctx, data.String())
+	self.SetStageFailed(ctx, data)
 }
 
 func init() {

pkg/compute/tasks/disk_delete_task.go

@@ -44,13 +44,13 @@ func (self *DiskDeleteTask) OnInit(ctx context.Context, obj db.IStandaloneModel,
 	cnt, err := disk.GetGuestDiskCount()
 	if err != nil {
 		reason := "Disk GetGuestDiskCount fail: " + err.Error()
-		self.SetStageFailed(ctx, reason)
+		self.SetStageFailed(ctx, jsonutils.NewString(reason))
 		db.OpsLog.LogEvent(disk, db.ACT_DELOCATE_FAIL, reason, self.UserCred)
 		return
 	}
 	if cnt > 0 {
 		reason := "Disk has been attached to server"
-		self.SetStageFailed(ctx, reason)
+		self.SetStageFailed(ctx, jsonutils.NewString(reason))
 		db.OpsLog.LogEvent(disk, db.ACT_DELOCATE_FAIL, reason, self.UserCred)
 		return
 	}
@@ -179,7 +179,7 @@ func (self *DiskDeleteTask) OnGuestDiskDeleteComplete(ctx context.Context, obj d
 
 func (self *DiskDeleteTask) OnGuestDiskDeleteCompleteFailed(ctx context.Context, disk *models.SDisk, reason jsonutils.JSONObject) {
 	disk.SetStatus(self.GetUserCred(), api.DISK_DEALLOC_FAILED, reason.String())
-	self.SetStageFailed(ctx, reason.String())
+	self.SetStageFailed(ctx, reason)
 	db.OpsLog.LogEvent(disk, db.ACT_DELOCATE_FAIL, disk.GetShortDesc(ctx), self.GetUserCred())
 	logclient.AddActionLogWithContext(ctx, disk, logclient.ACT_DELOCATE, reason, self.UserCred, false)
 }

pkg/compute/tasks/disk_reset_task.go

@@ -57,7 +57,7 @@ func (self *DiskResetTask) TaskFailed(ctx context.Context, disk *models.SDisk, r
 	if snapshot != nil {
 		logclient.AddActionLogWithStartable(self, snapshot, logclient.ACT_RESET_DISK, reason, self.UserCred, false)
 	}
-	self.SetStageFailed(ctx, reason.Error())
+	self.SetStageFailed(ctx, jsonutils.Marshal(reason))
 	guests := disk.GetGuests()
 	if len(guests) == 1 {
 		guests[0].SetStatus(self.UserCred, api.VM_DISK_RESET_FAIL, reason.Error())
@@ -168,13 +168,13 @@ func (self *DiskCleanUpSnapshotsTask) StartCleanUpSnapshots(ctx context.Context,
 	if len(guests) == 1 {
 		host = guests[0].GetHost()
 	} else {
-		self.SetStageFailed(ctx, "Disk can't get guest")
+		self.SetStageFailed(ctx, jsonutils.NewString("Disk can't get guest"))
 		return
 	}
 	self.SetStage("OnCleanUpSnapshots", nil)
 	err := host.GetHostDriver().RequestCleanUpDiskSnapshots(ctx, host, disk, self.Params, self)
 	if err != nil {
-		self.SetStageFailed(ctx, err.Error())
+		self.SetStageFailed(ctx, jsonutils.Marshal(err))
 	}
 }
 
@@ -208,6 +208,6 @@ func (self *DiskCleanUpSnapshotsTask) OnCleanUpSnapshots(ctx context.Context, di
 }
 
 func (self *DiskCleanUpSnapshotsTask) OnCleanUpSnapshotsFailed(ctx context.Context, disk *models.SDisk, data jsonutils.JSONObject) {
-	db.OpsLog.LogEvent(disk, db.ACT_DISK_CLEAN_UP_SNAPSHOTS_FAIL, data.String(), self.UserCred)
-	self.SetStageFailed(ctx, data.String())
+	db.OpsLog.LogEvent(disk, db.ACT_DISK_CLEAN_UP_SNAPSHOTS_FAIL, data, self.UserCred)
+	self.SetStageFailed(ctx, data)
 }

pkg/compute/tasks/disk_resize_task.go

@@ -60,7 +60,7 @@ func (self *DiskResizeTask) OnInit(ctx context.Context, obj db.IStandaloneModel,
 	reason := "Cannot find host for disk"
 	if host == nil || host.HostStatus != api.HOST_ONLINE {
 		self.SetDiskReady(ctx, disk, self.GetUserCred(), reason)
-		self.SetStageFailed(ctx, reason)
+		self.SetStageFailed(ctx, jsonutils.NewString(reason))
 		db.OpsLog.LogEvent(disk, db.ACT_RESIZE_FAIL, reason, self.GetUserCred())
 		logclient.AddActionLogWithStartable(self, disk, logclient.ACT_RESIZE, reason, self.UserCred, false)
 		return
@@ -88,9 +88,9 @@ func (self *DiskResizeTask) OnStartResizeDiskSucc(ctx context.Context, disk *mod
 
 func (self *DiskResizeTask) OnStartResizeDiskFailed(ctx context.Context, disk *models.SDisk, reason error) {
 	self.SetDiskReady(ctx, disk, self.GetUserCred(), reason.Error())
-	self.SetStageFailed(ctx, reason.Error())
-	db.OpsLog.LogEvent(disk, db.ACT_RESIZE_FAIL, reason.Error(), self.GetUserCred())
-	logclient.AddActionLogWithStartable(self, disk, logclient.ACT_RESIZE, reason.Error(), self.UserCred, false)
+	self.SetStageFailed(ctx, jsonutils.Marshal(reason))
+	db.OpsLog.LogEvent(disk, db.ACT_RESIZE_FAIL, reason, self.GetUserCred())
+	logclient.AddActionLogWithStartable(self, disk, logclient.ACT_RESIZE, reason, self.UserCred, false)
 }
 
 func (self *DiskResizeTask) OnDiskResizeComplete(ctx context.Context, disk *models.SDisk, data jsonutils.JSONObject) {
@@ -150,6 +150,6 @@ func (self *DiskResizeTask) OnDiskResized(ctx context.Context, disk *models.SDis
 func (self *DiskResizeTask) OnDiskResizeCompleteFailed(ctx context.Context, disk *models.SDisk, data jsonutils.JSONObject) {
 	self.SetDiskReady(ctx, disk, self.GetUserCred(), data.String())
 	db.OpsLog.LogEvent(disk, db.ACT_RESIZE_FAIL, disk.GetShortDesc(ctx), self.UserCred)
-	logclient.AddActionLogWithStartable(self, disk, logclient.ACT_RESIZE, data.String(), self.UserCred, false)
-	self.SetStageFailed(ctx, data.String())
+	logclient.AddActionLogWithStartable(self, disk, logclient.ACT_RESIZE, data, self.UserCred, false)
+	self.SetStageFailed(ctx, data)
 }

pkg/compute/tasks/disk_save_task.go

@@ -55,7 +55,7 @@ func (self *DiskSaveTask) OnInit(ctx context.Context, obj db.IStandaloneModel, d
 	if host := self.GetMasterHost(disk); host == nil {
 		reason := "Cannot find host for disk"
 		disk.SetDiskReady(ctx, self.GetUserCred(), reason)
-		self.TaskFailed(ctx, reason)
+		self.TaskFailed(ctx, jsonutils.NewString(reason))
 		db.OpsLog.LogEvent(disk, db.ACT_SAVE_FAIL, reason, self.GetUserCred())
 	} else {
 		disk.SetStatus(self.GetUserCred(), api.DISK_START_SAVE, "")
@@ -73,15 +73,15 @@ func (self *DiskSaveTask) StartBackupDisk(ctx context.Context, disk *models.SDis
 	if err := host.GetHostDriver().RequestPrepareSaveDiskOnHost(ctx, host, disk, imageId, self); err != nil {
 		log.Errorf("Backup failed: %v", err)
 		disk.SetDiskReady(ctx, self.GetUserCred(), err.Error())
-		self.TaskFailed(ctx, err.Error())
+		self.TaskFailed(ctx, jsonutils.Marshal(err))
 		db.OpsLog.LogEvent(disk, db.ACT_SAVE_FAIL, err.Error(), self.GetUserCred())
 	}
 }
 
 func (self *DiskSaveTask) OnDiskBackupCompleteFailed(ctx context.Context, disk *models.SDisk, data jsonutils.JSONObject) {
 	disk.SetDiskReady(ctx, self.GetUserCred(), data.String())
-	db.OpsLog.LogEvent(disk, db.ACT_SAVE_FAIL, data.String(), self.GetUserCred())
-	self.SetStageFailed(ctx, data.String())
+	db.OpsLog.LogEvent(disk, db.ACT_SAVE_FAIL, data, self.GetUserCred())
+	self.SetStageFailed(ctx, data)
 }
 
 func (self *DiskSaveTask) OnDiskBackupComplete(ctx context.Context, disk *models.SDisk, data *jsonutils.JSONDict) {
@@ -91,7 +91,7 @@ func (self *DiskSaveTask) OnDiskBackupComplete(ctx context.Context, disk *models
 	imageId, _ := self.GetParams().GetString("image_id")
 	if host := self.GetMasterHost(disk); host == nil {
 		log.Errorf("Saved disk Host mast not be nil")
-		self.TaskFailed(ctx, "Saved disk Host mast not be nil")
+		self.TaskFailed(ctx, jsonutils.NewString("Saved disk Host mast not be nil"))
 	} else {
 		if self.Params.Contains("format") {
 			format, _ := self.Params.Get("format")
@@ -99,7 +99,7 @@ func (self *DiskSaveTask) OnDiskBackupComplete(ctx context.Context, disk *models
 		}
 		if err := self.UploadDisk(ctx, host, disk, imageId, data); err != nil {
 			log.Errorf("UploadDisk failed: %v", err)
-			self.TaskFailed(ctx, err.Error())
+			self.TaskFailed(ctx, jsonutils.Marshal(err))
 		}
 		self.RefreshImageCache(ctx, imageId)
 	}
@@ -113,7 +113,7 @@ func (self *DiskSaveTask) UploadDisk(ctx context.Context, host *models.SHost, di
 	return host.GetHostDriver().RequestSaveUploadImageOnHost(ctx, host, disk, imageId, self, jsonutils.Marshal(data))
 }
 
-func (self *DiskSaveTask) TaskFailed(ctx context.Context, reason string) {
+func (self *DiskSaveTask) TaskFailed(ctx context.Context, reason jsonutils.JSONObject) {
 	self.SetStageFailed(ctx, reason)
 	if imageId, err := self.GetParams().GetString("image_id"); err != nil && len(imageId) > 0 {
 		log.Errorf("save disk task failed, set image %s killed", imageId)

pkg/compute/tasks/disk_syncstatus_task.go

@@ -38,7 +38,7 @@ func init() {
 
 func (self *DiskSyncstatusTask) taskFailed(ctx context.Context, disk *models.SDisk, err error) {
 	disk.SetStatus(self.GetUserCred(), api.DISK_UNKNOWN, err.Error())
-	self.SetStageFailed(ctx, err.Error())
+	self.SetStageFailed(ctx, jsonutils.Marshal(err))
 	db.OpsLog.LogEvent(disk, db.ACT_SYNC_STATUS, disk.GetShortDesc(ctx), self.GetUserCred())
 	logclient.AddActionLogWithContext(ctx, disk, logclient.ACT_SYNC_STATUS, err, self.UserCred, false)
 }

pkg/compute/tasks/eip_allocate_task.go

@@ -38,12 +38,12 @@ func init() {
 	taskman.RegisterTask(EipAllocateTask{})
 }
 
-func (self *EipAllocateTask) onFailed(ctx context.Context, eip *models.SElasticip, reason string) {
+func (self *EipAllocateTask) onFailed(ctx context.Context, eip *models.SElasticip, reason jsonutils.JSONObject) {
 	self.setGuestAllocateEipFailed(eip, reason)
 	self.SetStageFailed(ctx, reason)
 }
 
-func (self *EipAllocateTask) setGuestAllocateEipFailed(eip *models.SElasticip, reason string) {
+func (self *EipAllocateTask) setGuestAllocateEipFailed(eip *models.SElasticip, reason jsonutils.JSONObject) {
 	if eip != nil {
 		db.OpsLog.LogEvent(eip, db.ACT_ALLOCATE_FAIL, reason, self.GetUserCred())
 		logclient.AddActionLogWithStartable(self, eip, logclient.ACT_ALLOCATE, reason, self.UserCred, false)
@@ -56,7 +56,7 @@ func (self *EipAllocateTask) setGuestAllocateEipFailed(eip *models.SElasticip, r
 			return
 		}
 		guest := instance.(*models.SGuest)
-		guest.SetStatus(self.UserCred, api.VM_ASSOCIATE_EIP_FAILED, reason)
+		guest.SetStatus(self.UserCred, api.VM_ASSOCIATE_EIP_FAILED, reason.String())
 	}
 }
 
@@ -78,7 +78,7 @@ func (self *EipAllocateTask) OnInit(ctx context.Context, obj db.IStandaloneModel
 		_network, err := models.NetworkManager.FetchById(eip.NetworkId)
 		if err != nil {
 			msg := fmt.Sprintf("failed to found network %s error: %v", eip.NetworkId, err)
-			self.onFailed(ctx, eip, msg)
+			self.onFailed(ctx, eip, jsonutils.NewString(msg))
 			return
 		}
 		network := _network.(*models.SNetwork)
@@ -89,12 +89,12 @@ func (self *EipAllocateTask) OnInit(ctx context.Context, obj db.IStandaloneModel
 
 			ipAddr, err := network.GetFreeIP(ctx, self.UserCred, nil, nil, reqIp, api.IPAllocationNone, false)
 			if err != nil {
-				self.onFailed(ctx, eip, err.Error())
+				self.onFailed(ctx, eip, jsonutils.NewString(err.Error()))
 				return
 			}
 			if reqIp != "" && ipAddr != reqIp {
 				msg := fmt.Sprintf("requested ip %s is occupied!", reqIp)
-				self.onFailed(ctx, eip, msg)
+				self.onFailed(ctx, eip, jsonutils.NewString(msg))
 				return
 			}
 			_, err = db.Update(eip, func() error {
@@ -102,7 +102,7 @@ func (self *EipAllocateTask) OnInit(ctx context.Context, obj db.IStandaloneModel
 				return nil
 			})
 			if err != nil {
-				self.onFailed(ctx, eip, err.Error())
+				self.onFailed(ctx, eip, jsonutils.NewString(err.Error()))
 				return
 			}
 			if !eipIsManaged {
@@ -125,7 +125,7 @@ func (self *EipAllocateTask) OnInit(ctx context.Context, obj db.IStandaloneModel
 		if err != nil {
 			msg := fmt.Sprintf("fail to find iregion for eip %s", err)
 			eip.SetStatus(self.UserCred, api.EIP_STATUS_ALLOCATE_FAIL, msg)
-			self.onFailed(ctx, eip, msg)
+			self.onFailed(ctx, eip, jsonutils.NewString(msg))
 			return
 		}
 
@@ -133,14 +133,14 @@ func (self *EipAllocateTask) OnInit(ctx context.Context, obj db.IStandaloneModel
 		if err != nil {
 			msg := fmt.Sprintf("create eip fail %s", err)
 			eip.SetStatus(self.UserCred, api.EIP_STATUS_ALLOCATE_FAIL, msg)
-			self.onFailed(ctx, eip, msg)
+			self.onFailed(ctx, eip, jsonutils.NewString(msg))
 			return
 		}
 
 		if err := eip.SyncWithCloudEip(ctx, self.UserCred, eip.GetCloudprovider(), extEip, nil); err != nil {
 			msg := fmt.Sprintf("sync eip fail %s", err)
 			eip.SetStatus(self.UserCred, api.EIP_STATUS_ALLOCATE_FAIL, msg)
-			self.onFailed(ctx, eip, msg)
+			self.onFailed(ctx, eip, jsonutils.NewString(msg))
 			return
 		}
 	}
@@ -149,7 +149,7 @@ func (self *EipAllocateTask) OnInit(ctx context.Context, obj db.IStandaloneModel
 		self.SetStage("on_eip_associate_complete", nil)
 		if err := eip.StartEipAssociateTask(ctx, self.UserCred, self.Params, self.GetId()); err != nil {
 			msg := fmt.Sprintf("start associate task fail %s", err)
-			self.SetStageFailed(ctx, msg)
+			self.SetStageFailed(ctx, jsonutils.NewString(msg))
 		}
 	} else {
 		logclient.AddActionLogWithStartable(self, eip, logclient.ACT_ALLOCATE, nil, self.UserCred, true)
@@ -165,6 +165,6 @@ func (self *EipAllocateTask) OnEipAssociateComplete(ctx context.Context, obj db.
 
 func (self *EipAllocateTask) OnEipAssociateCompleteFailed(ctx context.Context, obj db.IStandaloneModel, data jsonutils.JSONObject) {
 	eip := obj.(*models.SElasticip)
-	self.setGuestAllocateEipFailed(eip, data.String())
-	self.SetStageFailed(ctx, data.String())
+	self.setGuestAllocateEipFailed(eip, data)
+	self.SetStageFailed(ctx, data)
 }

pkg/compute/tasks/eip_associate_task.go

@@ -35,11 +35,11 @@ func init() {
 	taskman.RegisterTask(EipAssociateTask{})
 }
 
-func (self *EipAssociateTask) TaskFail(ctx context.Context, eip *models.SElasticip, msg string, vm *models.SGuest) {
-	eip.SetStatus(self.UserCred, api.EIP_STATUS_READY, msg)
+func (self *EipAssociateTask) TaskFail(ctx context.Context, eip *models.SElasticip, msg jsonutils.JSONObject, vm *models.SGuest) {
+	eip.SetStatus(self.UserCred, api.EIP_STATUS_READY, msg.String())
 	self.SetStageFailed(ctx, msg)
 	if vm != nil {
-		vm.SetStatus(self.UserCred, api.VM_ASSOCIATE_EIP_FAILED, msg)
+		vm.SetStatus(self.UserCred, api.VM_ASSOCIATE_EIP_FAILED, msg.String())
 		db.OpsLog.LogEvent(vm, db.ACT_EIP_ATTACH, msg, self.GetUserCred())
 		logclient.AddActionLogWithStartable(self, vm, logclient.ACT_EIP_ASSOCIATE, msg, self.UserCred, false)
 	}
@@ -54,20 +54,20 @@ func (self *EipAssociateTask) OnInit(ctx context.Context, obj db.IStandaloneMode
 
 	if server == nil {
 		msg := fmt.Sprintf("fail to find server for instanceId %s", instanceId)
-		self.TaskFail(ctx, eip, msg, nil)
+		self.TaskFail(ctx, eip, jsonutils.NewString(msg), nil)
 		return
 	}
 
 	driver := server.GetDriver()
 	if driver == nil {
 		msg := fmt.Sprintf("fail to find guest driver for instanceId %s", instanceId)
-		self.TaskFail(ctx, eip, msg, nil)
+		self.TaskFail(ctx, eip, jsonutils.NewString(msg), nil)
 		return
 	}
 
 	self.SetStage("OnAssociateEipComplete", nil)
 	if err := driver.RequestAssociateEip(ctx, self.UserCred, server, eip, self); err != nil {
-		self.TaskFail(ctx, eip, err.Error(), server)
+		self.TaskFail(ctx, eip, jsonutils.Marshal(err), server)
 		return
 	}
 }
@@ -87,6 +87,6 @@ func (self *EipAssociateTask) OnAssociateEipCompleteFailed(ctx context.Context,
 	eip := obj.(*models.SElasticip)
 	instanceId, _ := self.Params.GetString("instance_id")
 	server := models.GuestManager.FetchGuestById(instanceId)
-	self.TaskFail(ctx, eip, data.String(), server)
+	self.TaskFail(ctx, eip, data, server)
 	return
 }

pkg/compute/tasks/eip_change_bandwidth_task.go

@@ -35,8 +35,8 @@ func init() {
 	taskman.RegisterTask(EipChangeBandwidthTask{})
 }
 
-func (self *EipChangeBandwidthTask) TaskFail(ctx context.Context, eip *models.SElasticip, msg string) {
-	eip.SetStatus(self.UserCred, api.EIP_STATUS_READY, msg)
+func (self *EipChangeBandwidthTask) TaskFail(ctx context.Context, eip *models.SElasticip, msg jsonutils.JSONObject) {
+	eip.SetStatus(self.UserCred, api.EIP_STATUS_READY, msg.String())
 	db.OpsLog.LogEvent(eip, db.ACT_CHANGE_BANDWIDTH, msg, self.GetUserCred())
 	logclient.AddActionLogWithStartable(self, eip, logclient.ACT_CHANGE_BANDWIDTH, msg, self.UserCred, false)
 	self.SetStageFailed(ctx, msg)
@@ -47,7 +47,7 @@ func (self *EipChangeBandwidthTask) OnInit(ctx context.Context, obj db.IStandalo
 	bandwidth, _ := self.Params.Int("bandwidth")
 	if bandwidth <= 0 {
 		msg := fmt.Sprintf("invalid bandwidth %d", bandwidth)
-		self.TaskFail(ctx, eip, msg)
+		self.TaskFail(ctx, eip, jsonutils.NewString(msg))
 		return
 	}
 
@@ -55,7 +55,7 @@ func (self *EipChangeBandwidthTask) OnInit(ctx context.Context, obj db.IStandalo
 		extEip, err := eip.GetIEip()
 		if err != nil {
 			msg := fmt.Sprintf("fail to find iEip %s", err)
-			self.TaskFail(ctx, eip, msg)
+			self.TaskFail(ctx, eip, jsonutils.NewString(msg))
 			return
 		}
 
@@ -63,7 +63,7 @@ func (self *EipChangeBandwidthTask) OnInit(ctx context.Context, obj db.IStandalo
 
 		if err != nil {
 			msg := fmt.Sprintf("fail to find iEip %s", err)
-			self.TaskFail(ctx, eip, msg)
+			self.TaskFail(ctx, eip, jsonutils.NewString(msg))
 			return
 		}
 
@@ -71,7 +71,7 @@ func (self *EipChangeBandwidthTask) OnInit(ctx context.Context, obj db.IStandalo
 
 	if err := eip.DoChangeBandwidth(self.UserCred, int(bandwidth)); err != nil {
 		msg := fmt.Sprintf("fail to synchronize iEip bandwidth %s", err)
-		self.TaskFail(ctx, eip, msg)
+		self.TaskFail(ctx, eip, jsonutils.NewString(msg))
 		return
 	}
 	logclient.AddActionLogWithStartable(self, eip, logclient.ACT_CHANGE_BANDWIDTH, nil, self.UserCred, true)

pkg/compute/tasks/eip_deallocate_task.go

@@ -37,8 +37,8 @@ func init() {
 	taskman.RegisterTask(EipDeallocateTask{})
 }
 
-func (self *EipDeallocateTask) taskFail(ctx context.Context, eip *models.SElasticip, msg string) {
-	eip.SetStatus(self.UserCred, api.EIP_STATUS_DEALLOCATE_FAIL, msg)
+func (self *EipDeallocateTask) taskFail(ctx context.Context, eip *models.SElasticip, msg jsonutils.JSONObject) {
+	eip.SetStatus(self.UserCred, api.EIP_STATUS_DEALLOCATE_FAIL, msg.String())
 	db.OpsLog.LogEvent(eip, db.ACT_DELOCATE, msg, self.GetUserCred())
 	logclient.AddActionLogWithStartable(self, eip, logclient.ACT_DELETE, msg, self.UserCred, false)
 	self.SetStageFailed(ctx, msg)
@@ -53,14 +53,14 @@ func (self *EipDeallocateTask) OnInit(ctx context.Context, obj db.IStandaloneMod
 		if err != nil {
 			if errors.Cause(err) != cloudprovider.ErrNotFound && errors.Cause(err) != cloudprovider.ErrInvalidProvider {
 				msg := fmt.Sprintf("fail to find iEIP for eip %s", err)
-				self.taskFail(ctx, eip, msg)
+				self.taskFail(ctx, eip, jsonutils.NewString(msg))
 				return
 			}
 		} else {
 			err = expEip.Delete()
 			if err != nil {
 				msg := fmt.Sprintf("fail to delete iEIP %s", err)
-				self.taskFail(ctx, eip, msg)
+				self.taskFail(ctx, eip, jsonutils.NewString(msg))
 				return
 			}
 		}
@@ -73,7 +73,7 @@ func (self *EipDeallocateTask) OnInit(ctx context.Context, obj db.IStandaloneMod
 	err := eip.RealDelete(ctx, self.UserCred)
 	if err != nil {
 		msg := fmt.Sprintf("fail to delete EIP %s", err)
-		self.taskFail(ctx, eip, msg)
+		self.taskFail(ctx, eip, jsonutils.NewString(msg))
 		return
 	}
 

pkg/compute/tasks/eip_dissociate_task.go

@@ -38,20 +38,20 @@ func init() {
 	taskman.RegisterTask(EipDissociateTask{})
 }
 
-func (self *EipDissociateTask) TaskFail(ctx context.Context, eip *models.SElasticip, msg string, model db.IModel) {
-	eip.SetStatus(self.UserCred, api.EIP_STATUS_READY, msg)
+func (self *EipDissociateTask) TaskFail(ctx context.Context, eip *models.SElasticip, msg jsonutils.JSONObject, model db.IModel) {
+	eip.SetStatus(self.UserCred, api.EIP_STATUS_READY, msg.String())
 	self.SetStageFailed(ctx, msg)
 	var logOp string
 	if model != nil {
 		switch srv := model.(type) {
 		case *models.SGuest:
-			srv.SetStatus(self.UserCred, api.VM_DISSOCIATE_EIP_FAILED, msg)
+			srv.SetStatus(self.UserCred, api.VM_DISSOCIATE_EIP_FAILED, msg.String())
 			logOp = logclient.ACT_VM_DISSOCIATE
 		case *models.SNatGateway:
-			srv.SetStatus(self.UserCred, api.VM_DISSOCIATE_EIP_FAILED, msg)
+			srv.SetStatus(self.UserCred, api.VM_DISSOCIATE_EIP_FAILED, msg.String())
 			logOp = logclient.ACT_NATGATEWAY_DISSOCIATE
 		case *models.SLoadbalancer:
-			srv.SetStatus(self.UserCred, api.VM_DISSOCIATE_EIP_FAILED, msg)
+			srv.SetStatus(self.UserCred, api.VM_DISSOCIATE_EIP_FAILED, msg.String())
 			logOp = logclient.ACT_LOADBALANCER_DISSOCIATE
 		}
 		db.OpsLog.LogEvent(model, db.ACT_EIP_DETACH, msg, self.GetUserCred())
@@ -82,7 +82,7 @@ func (self *EipDissociateTask) OnInit(ctx context.Context, obj db.IStandaloneMod
 			model = nat
 			logOp = logclient.ACT_NATGATEWAY_DISSOCIATE
 		} else {
-			self.TaskFail(ctx, eip, "unsupported associate type", nil)
+			self.TaskFail(ctx, eip, jsonutils.NewString("unsupported associate type"), nil)
 			return
 		}
 		lockman.LockObject(ctx, model)
@@ -92,14 +92,14 @@ func (self *EipDissociateTask) OnInit(ctx context.Context, obj db.IStandaloneMod
 			extEip, err := eip.GetIEip()
 			if err != nil && errors.Cause(err) != cloudprovider.ErrNotFound {
 				msg := fmt.Sprintf("fail to find iEIP for eip %s", err)
-				self.TaskFail(ctx, eip, msg, model)
+				self.TaskFail(ctx, eip, jsonutils.NewString(msg), model)
 				return
 			}
 			if err == nil && len(extEip.GetAssociationExternalId()) > 0 {
 				err = extEip.Dissociate()
 				if err != nil {
 					msg := fmt.Sprintf("fail to remote dissociate eip %s", err)
-					self.TaskFail(ctx, eip, msg, model)
+					self.TaskFail(ctx, eip, jsonutils.NewString(msg), model)
 					return
 				}
 			}
@@ -110,7 +110,7 @@ func (self *EipDissociateTask) OnInit(ctx context.Context, obj db.IStandaloneMod
 				Equals("eip_id", eip.Id)
 			if err := db.FetchModelObjects(models.GuestnetworkManager, q, &guestnics); err != nil {
 				msg := errors.Wrapf(err, "fetch guest nic associated with eip %s(%s)", eip.Name, eip.Id).Error()
-				self.TaskFail(ctx, eip, msg, model)
+				self.TaskFail(ctx, eip, jsonutils.NewString(msg), model)
 				return
 			}
 			var errs []error
@@ -126,13 +126,13 @@ func (self *EipDissociateTask) OnInit(ctx context.Context, obj db.IStandaloneMod
 			if len(errs) > 0 {
 				err := errors.NewAggregate(errs)
 				msg := errors.Wrapf(err, "disassociate eip %s(%s)", eip.Name, eip.Id).Error()
-				self.TaskFail(ctx, eip, msg, model)
+				self.TaskFail(ctx, eip, jsonutils.NewString(msg), model)
 			}
 		}
 
 		if err := eip.Dissociate(ctx, self.UserCred); err != nil {
 			msg := fmt.Sprintf("fail to local dissociate eip %s", err)
-			self.TaskFail(ctx, eip, msg, model)
+			self.TaskFail(ctx, eip, jsonutils.NewString(msg), model)
 			return
 		}
 

pkg/compute/tasks/eip_syncstatus_task.go

@@ -35,8 +35,8 @@ func init() {
 	taskman.RegisterTask(EipSyncstatusTask{})
 }
 
-func (self *EipSyncstatusTask) taskFail(ctx context.Context, eip *models.SElasticip, msg string) {
-	eip.SetStatus(self.UserCred, api.EIP_STATUS_UNKNOWN, msg)
+func (self *EipSyncstatusTask) taskFail(ctx context.Context, eip *models.SElasticip, msg jsonutils.JSONObject) {
+	eip.SetStatus(self.UserCred, api.EIP_STATUS_UNKNOWN, msg.String())
 	db.OpsLog.LogEvent(eip, db.ACT_SYNC_STATUS, msg, self.GetUserCred())
 	logclient.AddActionLogWithStartable(self, eip, logclient.ACT_SYNC_STATUS, msg, self.UserCred, false)
 	self.SetStageFailed(ctx, msg)
@@ -48,28 +48,28 @@ func (self *EipSyncstatusTask) OnInit(ctx context.Context, obj db.IStandaloneMod
 	extEip, err := eip.GetIEip()
 	if err != nil {
 		msg := fmt.Sprintf("fail to find ieip for eip %s", err)
-		self.taskFail(ctx, eip, msg)
+		self.taskFail(ctx, eip, jsonutils.NewString(msg))
 		return
 	}
 
 	err = extEip.Refresh()
 	if err != nil {
 		msg := fmt.Sprintf("fail to refresh eip status %s", err)
-		self.taskFail(ctx, eip, msg)
+		self.taskFail(ctx, eip, jsonutils.NewString(msg))
 		return
 	}
 
 	err = eip.SyncWithCloudEip(ctx, self.UserCred, eip.GetCloudprovider(), extEip, nil)
 	if err != nil {
 		msg := fmt.Sprintf("fail to sync eip status %s", err)
-		self.taskFail(ctx, eip, msg)
+		self.taskFail(ctx, eip, jsonutils.NewString(msg))
 		return
 	}
 
 	err = eip.SyncInstanceWithCloudEip(ctx, self.UserCred, extEip)
 	if err != nil {
 		msg := fmt.Sprintf("fail to sync eip status %s", err)
-		self.taskFail(ctx, eip, msg)
+		self.taskFail(ctx, eip, jsonutils.NewString(msg))
 		return
 	}
 

pkg/compute/tasks/elasticcache_account_create_task.go

@@ -36,11 +36,11 @@ func init() {
 	taskman.RegisterTask(ElasticcacheAccountCreateTask{})
 }
 
-func (self *ElasticcacheAccountCreateTask) taskFail(ctx context.Context, elasticcache *models.SElasticcacheAccount, reason string) {
-	elasticcache.SetStatus(self.GetUserCred(), api.ELASTIC_CACHE_ACCOUNT_STATUS_CREATE_FAILED, reason)
+func (self *ElasticcacheAccountCreateTask) taskFail(ctx context.Context, elasticcache *models.SElasticcacheAccount, reason jsonutils.JSONObject) {
+	elasticcache.SetStatus(self.GetUserCred(), api.ELASTIC_CACHE_ACCOUNT_STATUS_CREATE_FAILED, reason.String())
 	db.OpsLog.LogEvent(elasticcache, db.ACT_ALLOCATE_FAIL, reason, self.UserCred)
 	logclient.AddActionLogWithStartable(self, elasticcache, logclient.ACT_CREATE, reason, self.UserCred, false)
-	notifyclient.NotifySystemError(elasticcache.Id, elasticcache.Name, api.ELASTIC_CACHE_ACCOUNT_STATUS_CREATE_FAILED, reason)
+	notifyclient.NotifySystemError(elasticcache.Id, elasticcache.Name, api.ELASTIC_CACHE_ACCOUNT_STATUS_CREATE_FAILED, reason.String())
 	self.SetStageFailed(ctx, reason)
 }
 
@@ -48,13 +48,13 @@ func (self *ElasticcacheAccountCreateTask) OnInit(ctx context.Context, obj db.IS
 	ea := obj.(*models.SElasticcacheAccount)
 	region := ea.GetRegion()
 	if region == nil {
-		self.taskFail(ctx, ea, fmt.Sprintf("failed to find region for elastic cache account %s", ea.GetName()))
+		self.taskFail(ctx, ea, jsonutils.NewString(fmt.Sprintf("failed to find region for elastic cache account %s", ea.GetName())))
 		return
 	}
 
 	self.SetStage("OnElasticcacheAccountCreateComplete", nil)
 	if err := region.GetDriver().RequestCreateElasticcacheAccount(ctx, self.GetUserCred(), ea, self); err != nil {
-		self.taskFail(ctx, ea, err.Error())
+		self.taskFail(ctx, ea, jsonutils.Marshal(err))
 		return
 	}
 }
@@ -65,5 +65,5 @@ func (self *ElasticcacheAccountCreateTask) OnElasticcacheAccountCreateComplete(c
 }
 
 func (self *ElasticcacheAccountCreateTask) OnElasticcacheAccountCreateCompleteFailed(ctx context.Context, ea *models.SElasticcacheAccount, data jsonutils.JSONObject) {
-	self.taskFail(ctx, ea, data.String())
+	self.taskFail(ctx, ea, data)
 }

pkg/compute/tasks/elasticcache_account_delete_task.go

@@ -36,11 +36,11 @@ func init() {
 	taskman.RegisterTask(ElasticcacheAccountDeleteTask{})
 }
 
-func (self *ElasticcacheAccountDeleteTask) taskFail(ctx context.Context, ea *models.SElasticcacheAccount, reason string) {
-	ea.SetStatus(self.GetUserCred(), api.ELASTIC_CACHE_ACCOUNT_STATUS_DELETE_FAILED, reason)
+func (self *ElasticcacheAccountDeleteTask) taskFail(ctx context.Context, ea *models.SElasticcacheAccount, reason jsonutils.JSONObject) {
+	ea.SetStatus(self.GetUserCred(), api.ELASTIC_CACHE_ACCOUNT_STATUS_DELETE_FAILED, reason.String())
 	db.OpsLog.LogEvent(ea, db.ACT_DELETE_FAIL, reason, self.UserCred)
 	logclient.AddActionLogWithStartable(self, ea, logclient.ACT_DELETE, reason, self.UserCred, false)
-	notifyclient.NotifySystemError(ea.Id, ea.Name, api.ELASTIC_CACHE_ACCOUNT_STATUS_DELETE_FAILED, reason)
+	notifyclient.NotifySystemError(ea.Id, ea.Name, api.ELASTIC_CACHE_ACCOUNT_STATUS_DELETE_FAILED, reason.String())
 	self.SetStageFailed(ctx, reason)
 }
 
@@ -48,18 +48,18 @@ func (self *ElasticcacheAccountDeleteTask) OnInit(ctx context.Context, obj db.IS
 	ea := obj.(*models.SElasticcacheAccount)
 	region := ea.GetRegion()
 	if region == nil {
-		self.taskFail(ctx, ea, fmt.Sprintf("failed to find region for elastic cache account %s", ea.GetName()))
+		self.taskFail(ctx, ea, jsonutils.NewString(fmt.Sprintf("failed to find region for elastic cache account %s", ea.GetName())))
 		return
 	}
 
 	self.SetStage("OnElasticcacheAccountDeleteComplete", nil)
 	if err := region.GetDriver().RequestDeleteElasticcacheAccount(ctx, self.GetUserCred(), ea, self); err != nil {
-		self.taskFail(ctx, ea, err.Error())
+		self.taskFail(ctx, ea, jsonutils.Marshal(err))
 		return
 	} else {
 		err = db.DeleteModel(ctx, self.GetUserCred(), ea)
 		if err != nil {
-			self.taskFail(ctx, ea, err.Error())
+			self.taskFail(ctx, ea, jsonutils.NewString(err.Error()))
 			return
 		}
 

pkg/compute/tasks/elasticcache_account_reset_password_task.go

@@ -36,15 +36,15 @@ func init() {
 	taskman.RegisterTask(ElasticcacheAccountResetPasswordTask{})
 }
 
-func (self *ElasticcacheAccountResetPasswordTask) taskFail(ctx context.Context, ea *models.SElasticcacheAccount, reason string) {
-	ea.SetStatus(self.GetUserCred(), api.ELASTIC_CACHE_STATUS_CHANGE_FAILED, reason)
+func (self *ElasticcacheAccountResetPasswordTask) taskFail(ctx context.Context, ea *models.SElasticcacheAccount, reason jsonutils.JSONObject) {
+	ea.SetStatus(self.GetUserCred(), api.ELASTIC_CACHE_STATUS_CHANGE_FAILED, reason.String())
 	ec, err := db.FetchById(models.ElasticcacheManager, ea.ElasticcacheId)
 	if err == nil {
-		ec.(*models.SElasticcache).SetStatus(self.GetUserCred(), api.ELASTIC_CACHE_STATUS_CHANGE_FAILED, reason)
+		ec.(*models.SElasticcache).SetStatus(self.GetUserCred(), api.ELASTIC_CACHE_STATUS_CHANGE_FAILED, reason.String())
 	}
 	db.OpsLog.LogEvent(ea, db.ACT_RESET_PASSWORD, reason, self.UserCred)
 	logclient.AddActionLogWithStartable(self, ea, logclient.ACT_RESET_PASSWORD, reason, self.UserCred, false)
-	notifyclient.NotifySystemError(ea.Id, ea.Name, api.ELASTIC_CACHE_STATUS_CREATE_FAILED, reason)
+	notifyclient.NotifySystemError(ea.Id, ea.Name, api.ELASTIC_CACHE_STATUS_CREATE_FAILED, reason.String())
 	self.SetStageFailed(ctx, reason)
 }
 
@@ -52,13 +52,13 @@ func (self *ElasticcacheAccountResetPasswordTask) OnInit(ctx context.Context, ob
 	ea := obj.(*models.SElasticcacheAccount)
 	region := ea.GetRegion()
 	if region == nil {
-		self.taskFail(ctx, ea, fmt.Sprintf("failed to find region for elastic cache account %s", ea.GetName()))
+		self.taskFail(ctx, ea, jsonutils.NewString(fmt.Sprintf("failed to find region for elastic cache account %s", ea.GetName())))
 		return
 	}
 
 	self.SetStage("OnElasticcacheAccountResetPasswordComplete", nil)
 	if err := region.GetDriver().RequestElasticcacheAccountResetPassword(ctx, self.GetUserCred(), ea, self); err != nil {
-		self.taskFail(ctx, ea, err.Error())
+		self.taskFail(ctx, ea, jsonutils.Marshal(err))
 		return
 	} else {
 		logclient.AddActionLogWithStartable(self, ea, logclient.ACT_RESET_PASSWORD, nil, self.UserCred, true)

pkg/compute/tasks/elasticcache_acl_create_task.go

@@ -36,11 +36,11 @@ func init() {
 	taskman.RegisterTask(ElasticcacheAclCreateTask{})
 }
 
-func (self *ElasticcacheAclCreateTask) taskFail(ctx context.Context, ea *models.SElasticcacheAcl, reason string) {
-	ea.SetStatus(self.GetUserCred(), api.ELASTIC_CACHE_ACL_STATUS_CREATE_FAILED, reason)
+func (self *ElasticcacheAclCreateTask) taskFail(ctx context.Context, ea *models.SElasticcacheAcl, reason jsonutils.JSONObject) {
+	ea.SetStatus(self.GetUserCred(), api.ELASTIC_CACHE_ACL_STATUS_CREATE_FAILED, reason.String())
 	db.OpsLog.LogEvent(ea, db.ACT_ALLOCATE_FAIL, reason, self.UserCred)
 	logclient.AddActionLogWithStartable(self, ea, logclient.ACT_CREATE, reason, self.UserCred, false)
-	notifyclient.NotifySystemError(ea.Id, ea.Name, api.ELASTIC_CACHE_ACL_STATUS_CREATE_FAILED, reason)
+	notifyclient.NotifySystemError(ea.Id, ea.Name, api.ELASTIC_CACHE_ACL_STATUS_CREATE_FAILED, reason.String())
 	self.SetStageFailed(ctx, reason)
 }
 
@@ -48,13 +48,13 @@ func (self *ElasticcacheAclCreateTask) OnInit(ctx context.Context, obj db.IStand
 	ea := obj.(*models.SElasticcacheAcl)
 	region := ea.GetRegion()
 	if region == nil {
-		self.taskFail(ctx, ea, fmt.Sprintf("failed to find region for elastic cache backup %s", ea.GetName()))
+		self.taskFail(ctx, ea, jsonutils.NewString(fmt.Sprintf("failed to find region for elastic cache backup %s", ea.GetName())))
 		return
 	}
 
 	self.SetStage("OnElasticcacheAclCreateComplete", nil)
 	if err := region.GetDriver().RequestCreateElasticcacheAcl(ctx, self.GetUserCred(), ea, self); err != nil {
-		self.taskFail(ctx, ea, err.Error())
+		self.taskFail(ctx, ea, jsonutils.Marshal(err))
 		return
 	}
 }
@@ -65,5 +65,5 @@ func (self *ElasticcacheAclCreateTask) OnElasticcacheAclCreateComplete(ctx conte
 }
 
 func (self *ElasticcacheAclCreateTask) OnElasticcacheAclCreateCompleteFailed(ctx context.Context, ea *models.SElasticcacheAcl, data jsonutils.JSONObject) {
-	self.taskFail(ctx, ea, data.String())
+	self.taskFail(ctx, ea, data)
 }

pkg/compute/tasks/elasticcache_acl_delete_task.go

@@ -36,11 +36,11 @@ func init() {
 	taskman.RegisterTask(ElasticcacheAclDeleteTask{})
 }
 
-func (self *ElasticcacheAclDeleteTask) taskFail(ctx context.Context, ea *models.SElasticcacheAcl, reason string) {
-	ea.SetStatus(self.GetUserCred(), api.ELASTIC_CACHE_ACL_STATUS_DELETE_FAILED, reason)
+func (self *ElasticcacheAclDeleteTask) taskFail(ctx context.Context, ea *models.SElasticcacheAcl, reason jsonutils.JSONObject) {
+	ea.SetStatus(self.GetUserCred(), api.ELASTIC_CACHE_ACL_STATUS_DELETE_FAILED, reason.String())
 	db.OpsLog.LogEvent(ea, db.ACT_DELOCATE_FAIL, reason, self.UserCred)
 	logclient.AddActionLogWithStartable(self, ea, logclient.ACT_DELETE, reason, self.UserCred, false)
-	notifyclient.NotifySystemError(ea.Id, ea.Name, api.ELASTIC_CACHE_ACL_STATUS_DELETE_FAILED, reason)
+	notifyclient.NotifySystemError(ea.Id, ea.Name, api.ELASTIC_CACHE_ACL_STATUS_DELETE_FAILED, reason.String())
 	self.SetStageFailed(ctx, reason)
 }
 
@@ -48,18 +48,18 @@ func (self *ElasticcacheAclDeleteTask) OnInit(ctx context.Context, obj db.IStand
 	ea := obj.(*models.SElasticcacheAcl)
 	region := ea.GetRegion()
 	if region == nil {
-		self.taskFail(ctx, ea, fmt.Sprintf("failed to find region for elastic cache account %s", ea.GetName()))
+		self.taskFail(ctx, ea, jsonutils.NewString(fmt.Sprintf("failed to find region for elastic cache account %s", ea.GetName())))
 		return
 	}
 
 	self.SetStage("OnElasticcacheAclDeleteComplete", nil)
 	if err := region.GetDriver().RequestDeleteElasticcacheAcl(ctx, self.GetUserCred(), ea, self); err != nil {
-		self.taskFail(ctx, ea, err.Error())
+		self.taskFail(ctx, ea, jsonutils.Marshal(err))
 		return
 	} else {
 		err = db.DeleteModel(ctx, self.GetUserCred(), ea)
 		if err != nil {
-			self.taskFail(ctx, ea, err.Error())
+			self.taskFail(ctx, ea, jsonutils.NewString(err.Error()))
 			return
 		}
 		logclient.AddActionLogWithStartable(self, ea, logclient.ACT_DELETE, nil, self.UserCred, true)

pkg/compute/tasks/elasticcache_acl_update_task.go

@@ -36,11 +36,11 @@ func init() {
 	taskman.RegisterTask(ElasticcacheAclUpdateTask{})
 }
 
-func (self *ElasticcacheAclUpdateTask) taskFail(ctx context.Context, ea *models.SElasticcacheAcl, reason string) {
-	ea.SetStatus(self.GetUserCred(), api.ELASTIC_CACHE_ACL_STATUS_UPDATE_FAILED, reason)
+func (self *ElasticcacheAclUpdateTask) taskFail(ctx context.Context, ea *models.SElasticcacheAcl, reason jsonutils.JSONObject) {
+	ea.SetStatus(self.GetUserCred(), api.ELASTIC_CACHE_ACL_STATUS_UPDATE_FAILED, reason.String())
 	db.OpsLog.LogEvent(ea, db.ACT_UPDATE, reason, self.UserCred)
 	logclient.AddActionLogWithStartable(self, ea, logclient.ACT_UPDATE, reason, self.UserCred, false)
-	notifyclient.NotifySystemError(ea.Id, ea.Name, api.ELASTIC_CACHE_ACL_STATUS_UPDATE_FAILED, reason)
+	notifyclient.NotifySystemError(ea.Id, ea.Name, api.ELASTIC_CACHE_ACL_STATUS_UPDATE_FAILED, reason.String())
 	self.SetStageFailed(ctx, reason)
 }
 
@@ -48,13 +48,13 @@ func (self *ElasticcacheAclUpdateTask) OnInit(ctx context.Context, obj db.IStand
 	ea := obj.(*models.SElasticcacheAcl)
 	region := ea.GetRegion()
 	if region == nil {
-		self.taskFail(ctx, ea, fmt.Sprintf("failed to find region for elastic cache backup %s", ea.GetName()))
+		self.taskFail(ctx, ea, jsonutils.NewString(fmt.Sprintf("failed to find region for elastic cache backup %s", ea.GetName())))
 		return
 	}
 
 	self.SetStage("OnElasticcacheAclUpdateComplete", nil)
 	if err := region.GetDriver().RequestElasticcacheAclUpdate(ctx, self.GetUserCred(), ea, self); err != nil {
-		self.taskFail(ctx, ea, err.Error())
+		self.taskFail(ctx, ea, jsonutils.Marshal(err))
 		return
 	}
 }
@@ -65,5 +65,5 @@ func (self *ElasticcacheAclUpdateTask) OnElasticcacheAclUpdateComplete(ctx conte
 }
 
 func (self *ElasticcacheAclUpdateTask) OnElasticcacheAclUpdateCompleteFailed(ctx context.Context, ea *models.SElasticcacheAcl, data jsonutils.JSONObject) {
-	self.taskFail(ctx, ea, data.String())
+	self.taskFail(ctx, ea, data)
 }

pkg/compute/tasks/elasticcache_allocate_public_connection_task.go

@@ -36,11 +36,11 @@ func init() {
 	taskman.RegisterTask(ElasticcacheAllocatePublicConnectionTask{})
 }
 
-func (self *ElasticcacheAllocatePublicConnectionTask) taskFail(ctx context.Context, elasticcache *models.SElasticcache, reason string) {
-	elasticcache.SetStatus(self.GetUserCred(), api.ELASTIC_CACHE_STATUS_CHANGING, reason)
+func (self *ElasticcacheAllocatePublicConnectionTask) taskFail(ctx context.Context, elasticcache *models.SElasticcache, reason jsonutils.JSONObject) {
+	elasticcache.SetStatus(self.GetUserCred(), api.ELASTIC_CACHE_STATUS_CHANGING, reason.String())
 	db.OpsLog.LogEvent(elasticcache, db.ACT_ALLOCATE_FAIL, reason, self.UserCred)
 	logclient.AddActionLogWithStartable(self, elasticcache, logclient.ACT_ALLOCATE, reason, self.UserCred, false)
-	notifyclient.NotifySystemError(elasticcache.Id, elasticcache.Name, api.ELASTIC_CACHE_STATUS_CHANGE_FAILED, reason)
+	notifyclient.NotifySystemError(elasticcache.Id, elasticcache.Name, api.ELASTIC_CACHE_STATUS_CHANGE_FAILED, reason.String())
 	self.SetStageFailed(ctx, reason)
 }
 
@@ -48,13 +48,13 @@ func (self *ElasticcacheAllocatePublicConnectionTask) OnInit(ctx context.Context
 	elasticcache := obj.(*models.SElasticcache)
 	region := elasticcache.GetRegion()
 	if region == nil {
-		self.taskFail(ctx, elasticcache, fmt.Sprintf("failed to find region for elastic cache %s", elasticcache.GetName()))
+		self.taskFail(ctx, elasticcache, jsonutils.NewString(fmt.Sprintf("failed to find region for elastic cache %s", elasticcache.GetName())))
 		return
 	}
 
 	self.SetStage("OnElasticcacheAllocatePublicConnectionComplete", nil)
 	if err := region.GetDriver().RequestElasticcacheAllocatePublicConnection(ctx, self.GetUserCred(), elasticcache, self); err != nil {
-		self.OnElasticcacheAllocatePublicConnectionCompleteFailed(ctx, elasticcache, err.Error())
+		self.OnElasticcacheAllocatePublicConnectionCompleteFailed(ctx, elasticcache, jsonutils.Marshal(err))
 		return
 	}
 
@@ -68,6 +68,6 @@ func (self *ElasticcacheAllocatePublicConnectionTask) OnElasticcacheAllocatePubl
 	self.SetStageComplete(ctx, nil)
 }
 
-func (self *ElasticcacheAllocatePublicConnectionTask) OnElasticcacheAllocatePublicConnectionCompleteFailed(ctx context.Context, elasticcache *models.SElasticcache, reason string) {
+func (self *ElasticcacheAllocatePublicConnectionTask) OnElasticcacheAllocatePublicConnectionCompleteFailed(ctx context.Context, elasticcache *models.SElasticcache, reason jsonutils.JSONObject) {
 	self.taskFail(ctx, elasticcache, reason)
 }

pkg/compute/tasks/elasticcache_backup_create_task.go

@@ -36,11 +36,11 @@ func init() {
 	taskman.RegisterTask(ElasticcacheBackupCreateTask{})
 }
 
-func (self *ElasticcacheBackupCreateTask) taskFail(ctx context.Context, elasticcache *models.SElasticcacheBackup, reason string) {
-	elasticcache.SetStatus(self.GetUserCred(), api.ELASTIC_CACHE_STATUS_CREATE_FAILED, reason)
+func (self *ElasticcacheBackupCreateTask) taskFail(ctx context.Context, elasticcache *models.SElasticcacheBackup, reason jsonutils.JSONObject) {
+	elasticcache.SetStatus(self.GetUserCred(), api.ELASTIC_CACHE_STATUS_CREATE_FAILED, reason.String())
 	db.OpsLog.LogEvent(elasticcache, db.ACT_ALLOCATE_FAIL, reason, self.UserCred)
 	logclient.AddActionLogWithStartable(self, elasticcache, logclient.ACT_CREATE, reason, self.UserCred, false)
-	notifyclient.NotifySystemError(elasticcache.Id, elasticcache.Name, api.ELASTIC_CACHE_STATUS_CREATE_FAILED, reason)
+	notifyclient.NotifySystemError(elasticcache.Id, elasticcache.Name, api.ELASTIC_CACHE_STATUS_CREATE_FAILED, reason.String())
 	self.SetStageFailed(ctx, reason)
 }
 
@@ -48,13 +48,13 @@ func (self *ElasticcacheBackupCreateTask) OnInit(ctx context.Context, obj db.ISt
 	eb := obj.(*models.SElasticcacheBackup)
 	region := eb.GetRegion()
 	if region == nil {
-		self.taskFail(ctx, eb, fmt.Sprintf("failed to find region for elastic cache backup %s", eb.GetName()))
+		self.taskFail(ctx, eb, jsonutils.NewString(fmt.Sprintf("failed to find region for elastic cache backup %s", eb.GetName())))
 		return
 	}
 
 	self.SetStage("OnElasticcacheBackupCreateComplete", nil)
 	if err := region.GetDriver().RequestCreateElasticcacheBackup(ctx, self.GetUserCred(), eb, self); err != nil {
-		self.taskFail(ctx, eb, err.Error())
+		self.taskFail(ctx, eb, jsonutils.Marshal(err))
 		return
 	}
 }
@@ -65,5 +65,5 @@ func (self *ElasticcacheBackupCreateTask) OnElasticcacheBackupCreateComplete(ctx
 }
 
 func (self *ElasticcacheBackupCreateTask) OnElasticcacheBackupCreateCompleteFailed(ctx context.Context, eb *models.SElasticcacheBackup, data jsonutils.JSONObject) {
-	self.taskFail(ctx, eb, data.String())
+	self.taskFail(ctx, eb, data)
 }

pkg/compute/tasks/elasticcache_backup_restore_instance_task.go

@@ -36,11 +36,11 @@ func init() {
 	taskman.RegisterTask(ElasticcacheBackupRestoreInstanceTask{})
 }
 
-func (self *ElasticcacheBackupRestoreInstanceTask) taskFail(ctx context.Context, eb *models.SElasticcacheBackup, reason string) {
-	eb.SetStatus(self.GetUserCred(), api.ELASTIC_CACHE_STATUS_CREATE_FAILED, reason)
+func (self *ElasticcacheBackupRestoreInstanceTask) taskFail(ctx context.Context, eb *models.SElasticcacheBackup, reason jsonutils.JSONObject) {
+	eb.SetStatus(self.GetUserCred(), api.ELASTIC_CACHE_STATUS_CREATE_FAILED, reason.String())
 	db.OpsLog.LogEvent(eb, db.ACT_CONVERT_FAIL, reason, self.UserCred)
 	logclient.AddActionLogWithStartable(self, eb, logclient.ACT_RESTORE, reason, self.UserCred, false)
-	notifyclient.NotifySystemError(eb.Id, eb.Name, api.ELASTIC_CACHE_STATUS_CREATE_FAILED, reason)
+	notifyclient.NotifySystemError(eb.Id, eb.Name, api.ELASTIC_CACHE_STATUS_CREATE_FAILED, reason.String())
 	self.SetStageFailed(ctx, reason)
 }
 
@@ -48,13 +48,13 @@ func (self *ElasticcacheBackupRestoreInstanceTask) OnInit(ctx context.Context, o
 	eb := obj.(*models.SElasticcacheBackup)
 	region := eb.GetRegion()
 	if region == nil {
-		self.taskFail(ctx, eb, fmt.Sprintf("failed to find region for elastic cache backup %s", eb.GetName()))
+		self.taskFail(ctx, eb, jsonutils.NewString(fmt.Sprintf("failed to find region for elastic cache backup %s", eb.GetName())))
 		return
 	}
 
 	self.SetStage("OnElasticcacheBackupRestoreInstanceComplete", nil)
 	if err := region.GetDriver().RequestElasticcacheBackupRestoreInstance(ctx, self.GetUserCred(), eb, self); err != nil {
-		self.OnElasticcacheBackupRestoreInstanceCompleteFailed(ctx, eb, err.Error())
+		self.OnElasticcacheBackupRestoreInstanceCompleteFailed(ctx, eb, jsonutils.Marshal(err))
 		return
 	}
 
@@ -68,6 +68,6 @@ func (self *ElasticcacheBackupRestoreInstanceTask) OnElasticcacheBackupRestoreIn
 	self.SetStageComplete(ctx, nil)
 }
 
-func (self *ElasticcacheBackupRestoreInstanceTask) OnElasticcacheBackupRestoreInstanceCompleteFailed(ctx context.Context, eb *models.SElasticcacheBackup, reason string) {
+func (self *ElasticcacheBackupRestoreInstanceTask) OnElasticcacheBackupRestoreInstanceCompleteFailed(ctx context.Context, eb *models.SElasticcacheBackup, reason jsonutils.JSONObject) {
 	self.taskFail(ctx, eb, reason)
 }

pkg/compute/tasks/elasticcache_change_spec_task.go

@@ -36,11 +36,11 @@ func init() {
 	taskman.RegisterTask(ElasticcacheChangeSpecTask{})
 }
 
-func (self *ElasticcacheChangeSpecTask) taskFail(ctx context.Context, ec *models.SElasticcache, reason string) {
-	ec.SetStatus(self.GetUserCred(), api.ELASTIC_CACHE_STATUS_CHANGE_FAILED, reason)
+func (self *ElasticcacheChangeSpecTask) taskFail(ctx context.Context, ec *models.SElasticcache, reason jsonutils.JSONObject) {
+	ec.SetStatus(self.GetUserCred(), api.ELASTIC_CACHE_STATUS_CHANGE_FAILED, reason.String())
 	db.OpsLog.LogEvent(ec, db.ACT_CHANGE_FLAVOR, reason, self.UserCred)
 	logclient.AddActionLogWithStartable(self, ec, logclient.ACT_VM_CHANGE_FLAVOR, reason, self.UserCred, false)
-	notifyclient.NotifySystemError(ec.Id, ec.Name, api.ELASTIC_CACHE_STATUS_CHANGE_FAILED, reason)
+	notifyclient.NotifySystemError(ec.Id, ec.Name, api.ELASTIC_CACHE_STATUS_CHANGE_FAILED, reason.String())
 	self.SetStageFailed(ctx, reason)
 }
 
@@ -48,13 +48,13 @@ func (self *ElasticcacheChangeSpecTask) OnInit(ctx context.Context, obj db.IStan
 	elasticcache := obj.(*models.SElasticcache)
 	region := elasticcache.GetRegion()
 	if region == nil {
-		self.taskFail(ctx, elasticcache, fmt.Sprintf("failed to find region for elastic cache %s", elasticcache.GetName()))
+		self.taskFail(ctx, elasticcache, jsonutils.NewString(fmt.Sprintf("failed to find region for elastic cache %s", elasticcache.GetName())))
 		return
 	}
 
 	self.SetStage("OnElasticcacheChangeSpecComplete", nil)
 	if err := region.GetDriver().RequestElasticcacheChangeSpec(ctx, self.GetUserCred(), elasticcache, self); err != nil {
-		self.OnElasticcacheChangeSpecCompleteFailed(ctx, elasticcache, err.Error())
+		self.OnElasticcacheChangeSpecCompleteFailed(ctx, elasticcache, jsonutils.Marshal(err))
 		return
 	}
 
@@ -68,6 +68,6 @@ func (self *ElasticcacheChangeSpecTask) OnElasticcacheChangeSpecComplete(ctx con
 	self.SetStageComplete(ctx, nil)
 }
 
-func (self *ElasticcacheChangeSpecTask) OnElasticcacheChangeSpecCompleteFailed(ctx context.Context, elasticcache *models.SElasticcache, reason string) {
+func (self *ElasticcacheChangeSpecTask) OnElasticcacheChangeSpecCompleteFailed(ctx context.Context, elasticcache *models.SElasticcache, reason jsonutils.JSONObject) {
 	self.taskFail(ctx, elasticcache, reason)
 }

pkg/compute/tasks/elasticcache_create_task.go

@@ -36,11 +36,11 @@ func init() {
 	taskman.RegisterTask(ElasticcacheCreateTask{})
 }
 
-func (self *ElasticcacheCreateTask) taskFail(ctx context.Context, elasticcache *models.SElasticcache, reason string) {
-	elasticcache.SetStatus(self.GetUserCred(), api.ELASTIC_CACHE_STATUS_CREATE_FAILED, reason)
+func (self *ElasticcacheCreateTask) taskFail(ctx context.Context, elasticcache *models.SElasticcache, reason jsonutils.JSONObject) {
+	elasticcache.SetStatus(self.GetUserCred(), api.ELASTIC_CACHE_STATUS_CREATE_FAILED, reason.String())
 	db.OpsLog.LogEvent(elasticcache, db.ACT_ALLOCATE_FAIL, reason, self.UserCred)
 	logclient.AddActionLogWithStartable(self, elasticcache, logclient.ACT_CREATE, reason, self.UserCred, false)
-	notifyclient.NotifySystemError(elasticcache.Id, elasticcache.Name, api.ELASTIC_CACHE_STATUS_CREATE_FAILED, reason)
+	notifyclient.NotifySystemError(elasticcache.Id, elasticcache.Name, api.ELASTIC_CACHE_STATUS_CREATE_FAILED, reason.String())
 	self.SetStageFailed(ctx, reason)
 }
 
@@ -48,7 +48,7 @@ func (self *ElasticcacheCreateTask) OnInit(ctx context.Context, obj db.IStandalo
 	elasticcache := obj.(*models.SElasticcache)
 	region := elasticcache.GetRegion()
 	if region == nil {
-		self.taskFail(ctx, elasticcache, fmt.Sprintf("failed to find region for elastic cache %s", elasticcache.GetName()))
+		self.taskFail(ctx, elasticcache, jsonutils.NewString(fmt.Sprintf("failed to find region for elastic cache %s", elasticcache.GetName())))
 		return
 	}
 
@@ -61,7 +61,7 @@ func (self *ElasticcacheCreateTask) OnSyncSecurityGroupComplete(ctx context.Cont
 	region := elasticcache.GetRegion()
 	self.SetStage("OnElasticcacheCreateComplete", nil)
 	if err := region.GetDriver().RequestCreateElasticcache(ctx, self.GetUserCred(), elasticcache, self); err != nil {
-		self.taskFail(ctx, elasticcache, err.Error())
+		self.taskFail(ctx, elasticcache, jsonutils.Marshal(err))
 		return
 	}
 }
@@ -73,5 +73,5 @@ func (self *ElasticcacheCreateTask) OnElasticcacheCreateComplete(ctx context.Con
 }
 
 func (self *ElasticcacheCreateTask) OnElasticcacheCreateCompleteFailed(ctx context.Context, elasticcache *models.SElasticcache, reason jsonutils.JSONObject) {
-	self.taskFail(ctx, elasticcache, reason.String())
+	self.taskFail(ctx, elasticcache, reason)
 }

pkg/compute/tasks/elasticcache_delete_task.go

@@ -36,11 +36,11 @@ func init() {
 	taskman.RegisterTask(ElasticcacheDeleteTask{})
 }
 
-func (self *ElasticcacheDeleteTask) taskFail(ctx context.Context, elasticcache *models.SElasticcache, reason string) {
-	elasticcache.SetStatus(self.GetUserCred(), api.ELASTIC_CACHE_STATUS_RELEASE_FAILED, reason)
+func (self *ElasticcacheDeleteTask) taskFail(ctx context.Context, elasticcache *models.SElasticcache, reason jsonutils.JSONObject) {
+	elasticcache.SetStatus(self.GetUserCred(), api.ELASTIC_CACHE_STATUS_RELEASE_FAILED, reason.String())
 	db.OpsLog.LogEvent(elasticcache, db.ACT_DELOCATE_FAIL, reason, self.UserCred)
 	logclient.AddActionLogWithStartable(self, elasticcache, logclient.ACT_DELETE, reason, self.UserCred, false)
-	notifyclient.NotifySystemError(elasticcache.Id, elasticcache.Name, api.ELASTIC_CACHE_STATUS_RELEASE_FAILED, reason)
+	notifyclient.NotifySystemError(elasticcache.Id, elasticcache.Name, api.ELASTIC_CACHE_STATUS_RELEASE_FAILED, reason.String())
 	self.SetStageFailed(ctx, reason)
 }
 
@@ -48,13 +48,13 @@ func (self *ElasticcacheDeleteTask) OnInit(ctx context.Context, obj db.IStandalo
 	ec := obj.(*models.SElasticcache)
 	region := ec.GetRegion()
 	if region == nil {
-		self.taskFail(ctx, ec, fmt.Sprintf("failed to find region for elastic cache %s", ec.GetName()))
+		self.taskFail(ctx, ec, jsonutils.NewString(fmt.Sprintf("failed to find region for elastic cache %s", ec.GetName())))
 		return
 	}
 
 	self.SetStage("OnElasticcacheDeleteComplete", nil)
 	if err := region.GetDriver().RequestDeleteElasticcache(ctx, self.GetUserCred(), ec, self); err != nil {
-		self.taskFail(ctx, ec, err.Error())
+		self.taskFail(ctx, ec, jsonutils.Marshal(err))
 		return
 	} else {
 		ec.SetStatus(self.GetUserCred(), api.ELASTIC_CACHE_STATUS_RELEASED, "")

pkg/compute/tasks/elasticcache_flush_instance.go

@@ -36,11 +36,11 @@ func init() {
 	taskman.RegisterTask(ElasticcacheFlushInstanceTask{})
 }
 
-func (self *ElasticcacheFlushInstanceTask) taskFail(ctx context.Context, elasticcache *models.SElasticcache, reason string) {
-	elasticcache.SetStatus(self.GetUserCred(), api.ELASTIC_CACHE_STATUS_FLUSHING_FAILED, reason)
+func (self *ElasticcacheFlushInstanceTask) taskFail(ctx context.Context, elasticcache *models.SElasticcache, reason jsonutils.JSONObject) {
+	elasticcache.SetStatus(self.GetUserCred(), api.ELASTIC_CACHE_STATUS_FLUSHING_FAILED, reason.String())
 	db.OpsLog.LogEvent(elasticcache, db.ACT_FLUSH_INSTANCE_FAIL, reason, self.UserCred)
 	logclient.AddActionLogWithStartable(self, elasticcache, logclient.ACT_FLUSH_INSTANCE, reason, self.UserCred, false)
-	notifyclient.NotifySystemError(elasticcache.Id, elasticcache.Name, api.ELASTIC_CACHE_STATUS_FLUSHING_FAILED, reason)
+	notifyclient.NotifySystemError(elasticcache.Id, elasticcache.Name, api.ELASTIC_CACHE_STATUS_FLUSHING_FAILED, reason.String())
 	self.SetStageFailed(ctx, reason)
 }
 
@@ -48,13 +48,13 @@ func (self *ElasticcacheFlushInstanceTask) OnInit(ctx context.Context, obj db.IS
 	elasticcache := obj.(*models.SElasticcache)
 	region := elasticcache.GetRegion()
 	if region == nil {
-		self.taskFail(ctx, elasticcache, fmt.Sprintf("failed to find region for elastic cache %s", elasticcache.GetName()))
+		self.taskFail(ctx, elasticcache, jsonutils.NewString(fmt.Sprintf("failed to find region for elastic cache %s", elasticcache.GetName())))
 		return
 	}
 
 	self.SetStage("OnElasticcacheFlushInstanceComplete", nil)
 	if err := region.GetDriver().RequestElasticcacheFlushInstance(ctx, self.GetUserCred(), elasticcache, self); err != nil {
-		self.OnElasticcacheFlushInstanceCompleteFailed(ctx, elasticcache, err.Error())
+		self.OnElasticcacheFlushInstanceCompleteFailed(ctx, elasticcache, jsonutils.Marshal(err))
 		return
 	}
 
@@ -68,6 +68,6 @@ func (self *ElasticcacheFlushInstanceTask) OnElasticcacheFlushInstanceComplete(c
 	self.SetStageComplete(ctx, nil)
 }
 
-func (self *ElasticcacheFlushInstanceTask) OnElasticcacheFlushInstanceCompleteFailed(ctx context.Context, elasticcache *models.SElasticcache, reason string) {
+func (self *ElasticcacheFlushInstanceTask) OnElasticcacheFlushInstanceCompleteFailed(ctx context.Context, elasticcache *models.SElasticcache, reason jsonutils.JSONObject) {
 	self.taskFail(ctx, elasticcache, reason)
 }

pkg/compute/tasks/elasticcache_parameter_update_task.go

@@ -36,11 +36,11 @@ func init() {
 	taskman.RegisterTask(ElasticcacheParameterUpdateTask{})
 }
 
-func (self *ElasticcacheParameterUpdateTask) taskFail(ctx context.Context, ep *models.SElasticcacheParameter, reason string) {
-	ep.SetStatus(self.GetUserCred(), api.ELASTIC_CACHE_PARAMETER_STATUS_UPDATE_FAILED, reason)
+func (self *ElasticcacheParameterUpdateTask) taskFail(ctx context.Context, ep *models.SElasticcacheParameter, reason jsonutils.JSONObject) {
+	ep.SetStatus(self.GetUserCred(), api.ELASTIC_CACHE_PARAMETER_STATUS_UPDATE_FAILED, reason.String())
 	db.OpsLog.LogEvent(ep, db.ACT_UPDATE, reason, self.UserCred)
 	logclient.AddActionLogWithStartable(self, ep, logclient.ACT_UPDATE, reason, self.UserCred, false)
-	notifyclient.NotifySystemError(ep.Id, ep.Name, api.ELASTIC_CACHE_PARAMETER_STATUS_UPDATE_FAILED, reason)
+	notifyclient.NotifySystemError(ep.Id, ep.Name, api.ELASTIC_CACHE_PARAMETER_STATUS_UPDATE_FAILED, reason.String())
 	self.SetStageFailed(ctx, reason)
 }
 
@@ -48,19 +48,19 @@ func (self *ElasticcacheParameterUpdateTask) OnInit(ctx context.Context, obj db.
 	ep := obj.(*models.SElasticcacheParameter)
 	region := ep.GetRegion()
 	if region == nil {
-		self.taskFail(ctx, ep, fmt.Sprintf("failed to find region for elastic cache parameter %s", ep.GetName()))
+		self.taskFail(ctx, ep, jsonutils.NewString(fmt.Sprintf("failed to find region for elastic cache parameter %s", ep.GetName())))
 		return
 	}
 
 	iec, err := db.FetchById(models.ElasticcacheManager, ep.ElasticcacheId)
 	if err != nil {
-		self.taskFail(ctx, ep, fmt.Sprintf("failed to find elastic instance for  parameter %s", ep.GetName()))
+		self.taskFail(ctx, ep, jsonutils.NewString(fmt.Sprintf("failed to find elastic instance for  parameter %s", ep.GetName())))
 		return
 	}
 
 	self.SetStage("OnElasticcacheParameterUpdateComplete", nil)
 	if err := region.GetDriver().RequestElasticcacheUpdateInstanceParameters(ctx, self.GetUserCred(), iec.(*models.SElasticcache), self); err != nil {
-		self.OnElasticcacheParameterUpdateCompleteFailed(ctx, ep, err.Error())
+		self.OnElasticcacheParameterUpdateCompleteFailed(ctx, ep, jsonutils.Marshal(err))
 		return
 	}
 
@@ -72,6 +72,6 @@ func (self *ElasticcacheParameterUpdateTask) OnElasticcacheParameterUpdateComple
 	self.SetStageComplete(ctx, nil)
 }
 
-func (self *ElasticcacheParameterUpdateTask) OnElasticcacheParameterUpdateCompleteFailed(ctx context.Context, ep *models.SElasticcacheParameter, reason string) {
+func (self *ElasticcacheParameterUpdateTask) OnElasticcacheParameterUpdateCompleteFailed(ctx context.Context, ep *models.SElasticcacheParameter, reason jsonutils.JSONObject) {
 	self.taskFail(ctx, ep, reason)
 }

pkg/compute/tasks/elasticcache_release_public_connection_task.go

@@ -36,11 +36,11 @@ func init() {
 	taskman.RegisterTask(ElasticcacheReleasePublicConnectionTask{})
 }
 
-func (self *ElasticcacheReleasePublicConnectionTask) taskFail(ctx context.Context, elasticcache *models.SElasticcache, reason string) {
-	elasticcache.SetStatus(self.GetUserCred(), api.ELASTIC_CACHE_STATUS_CHANGING, reason)
+func (self *ElasticcacheReleasePublicConnectionTask) taskFail(ctx context.Context, elasticcache *models.SElasticcache, reason jsonutils.JSONObject) {
+	elasticcache.SetStatus(self.GetUserCred(), api.ELASTIC_CACHE_STATUS_CHANGING, reason.String())
 	db.OpsLog.LogEvent(elasticcache, db.ACT_DELOCATE_FAIL, reason, self.UserCred)
 	logclient.AddActionLogWithStartable(self, elasticcache, logclient.ACT_DELOCATE, reason, self.UserCred, false)
-	notifyclient.NotifySystemError(elasticcache.Id, elasticcache.Name, api.ELASTIC_CACHE_STATUS_CHANGE_FAILED, reason)
+	notifyclient.NotifySystemError(elasticcache.Id, elasticcache.Name, api.ELASTIC_CACHE_STATUS_CHANGE_FAILED, reason.String())
 	self.SetStageFailed(ctx, reason)
 }
 
@@ -48,13 +48,13 @@ func (self *ElasticcacheReleasePublicConnectionTask) OnInit(ctx context.Context,
 	elasticcache := obj.(*models.SElasticcache)
 	region := elasticcache.GetRegion()
 	if region == nil {
-		self.taskFail(ctx, elasticcache, fmt.Sprintf("failed to find region for elastic cache %s", elasticcache.GetName()))
+		self.taskFail(ctx, elasticcache, jsonutils.NewString(fmt.Sprintf("failed to find region for elastic cache %s", elasticcache.GetName())))
 		return
 	}
 
 	self.SetStage("OnElasticcacheReleasePublicConnectionComplete", nil)
 	if err := region.GetDriver().RequestElasticcacheReleasePublicConnection(ctx, self.GetUserCred(), elasticcache, self); err != nil {
-		self.OnElasticcacheReleasePublicConnectionCompleteFailed(ctx, elasticcache, err.Error())
+		self.OnElasticcacheReleasePublicConnectionCompleteFailed(ctx, elasticcache, jsonutils.Marshal(err))
 		return
 	}
 
@@ -68,6 +68,6 @@ func (self *ElasticcacheReleasePublicConnectionTask) OnElasticcacheReleasePublic
 	self.SetStageComplete(ctx, nil)
 }
 
-func (self *ElasticcacheReleasePublicConnectionTask) OnElasticcacheReleasePublicConnectionCompleteFailed(ctx context.Context, elasticcache *models.SElasticcache, reason string) {
+func (self *ElasticcacheReleasePublicConnectionTask) OnElasticcacheReleasePublicConnectionCompleteFailed(ctx context.Context, elasticcache *models.SElasticcache, reason jsonutils.JSONObject) {
 	self.taskFail(ctx, elasticcache, reason)
 }

pkg/compute/tasks/elasticcache_restart_task.go

@@ -36,11 +36,11 @@ func init() {
 	taskman.RegisterTask(ElasticcacheRestartTask{})
 }
 
-func (self *ElasticcacheRestartTask) taskFail(ctx context.Context, elasticcache *models.SElasticcache, reason string) {
-	elasticcache.SetStatus(self.GetUserCred(), api.ELASTIC_CACHE_STATUS_RESTART_FAILED, reason)
+func (self *ElasticcacheRestartTask) taskFail(ctx context.Context, elasticcache *models.SElasticcache, reason jsonutils.JSONObject) {
+	elasticcache.SetStatus(self.GetUserCred(), api.ELASTIC_CACHE_STATUS_RESTART_FAILED, reason.String())
 	db.OpsLog.LogEvent(elasticcache, db.ACT_RESTART_FAIL, reason, self.UserCred)
 	logclient.AddActionLogWithStartable(self, elasticcache, logclient.ACT_VM_RESTART, reason, self.UserCred, false)
-	notifyclient.NotifySystemError(elasticcache.Id, elasticcache.Name, api.ELASTIC_CACHE_STATUS_RESTART_FAILED, reason)
+	notifyclient.NotifySystemError(elasticcache.Id, elasticcache.Name, api.ELASTIC_CACHE_STATUS_RESTART_FAILED, reason.String())
 	self.SetStageFailed(ctx, reason)
 }
 
@@ -48,13 +48,13 @@ func (self *ElasticcacheRestartTask) OnInit(ctx context.Context, obj db.IStandal
 	ec := obj.(*models.SElasticcache)
 	region := ec.GetRegion()
 	if region == nil {
-		self.taskFail(ctx, ec, fmt.Sprintf("failed to find region for elastic cache %s", ec.GetName()))
+		self.taskFail(ctx, ec, jsonutils.NewString(fmt.Sprintf("failed to find region for elastic cache %s", ec.GetName())))
 		return
 	}
 
 	self.SetStage("OnElasticcacheRestartComplete", nil)
 	if err := region.GetDriver().RequestRestartElasticcache(ctx, self.GetUserCred(), ec, self); err != nil {
-		self.taskFail(ctx, ec, err.Error())
+		self.taskFail(ctx, ec, jsonutils.Marshal(err))
 		return
 	} else {
 		logclient.AddActionLogWithStartable(self, ec, logclient.ACT_VM_RESTART, nil, self.UserCred, true)

pkg/compute/tasks/elasticcache_set_maintain_time_task.go

@@ -36,11 +36,11 @@ func init() {
 	taskman.RegisterTask(ElasticcacheSetMaintainTimeTask{})
 }
 
-func (self *ElasticcacheSetMaintainTimeTask) taskFail(ctx context.Context, elasticcache *models.SElasticcache, reason string) {
-	elasticcache.SetStatus(self.GetUserCred(), api.ELASTIC_CACHE_STATUS_CHANGE_FAILED, reason)
+func (self *ElasticcacheSetMaintainTimeTask) taskFail(ctx context.Context, elasticcache *models.SElasticcache, reason jsonutils.JSONObject) {
+	elasticcache.SetStatus(self.GetUserCred(), api.ELASTIC_CACHE_STATUS_CHANGE_FAILED, reason.String())
 	db.OpsLog.LogEvent(elasticcache, db.ACT_UPDATE, reason, self.UserCred)
 	logclient.AddActionLogWithStartable(self, elasticcache, logclient.ACT_UPDATE, reason, self.UserCred, false)
-	notifyclient.NotifySystemError(elasticcache.Id, elasticcache.Name, api.ELASTIC_CACHE_STATUS_CHANGE_FAILED, reason)
+	notifyclient.NotifySystemError(elasticcache.Id, elasticcache.Name, api.ELASTIC_CACHE_STATUS_CHANGE_FAILED, reason.String())
 	self.SetStageFailed(ctx, reason)
 }
 
@@ -48,13 +48,13 @@ func (self *ElasticcacheSetMaintainTimeTask) OnInit(ctx context.Context, obj db.
 	elasticcache := obj.(*models.SElasticcache)
 	region := elasticcache.GetRegion()
 	if region == nil {
-		self.taskFail(ctx, elasticcache, fmt.Sprintf("failed to find region for elastic cache %s", elasticcache.GetName()))
+		self.taskFail(ctx, elasticcache, jsonutils.NewString(fmt.Sprintf("failed to find region for elastic cache %s", elasticcache.GetName())))
 		return
 	}
 
 	self.SetStage("OnElasticcacheSetMaintainTimeComplete", nil)
 	if err := region.GetDriver().RequestElasticcacheSetMaintainTime(ctx, self.GetUserCred(), elasticcache, self); err != nil {
-		self.OnElasticcacheSetMaintainTimeCompleteFailed(ctx, elasticcache, err.Error())
+		self.OnElasticcacheSetMaintainTimeCompleteFailed(ctx, elasticcache, jsonutils.Marshal(err))
 		return
 	}
 
@@ -68,6 +68,6 @@ func (self *ElasticcacheSetMaintainTimeTask) OnElasticcacheSetMaintainTimeComple
 	self.SetStageComplete(ctx, nil)
 }
 
-func (self *ElasticcacheSetMaintainTimeTask) OnElasticcacheSetMaintainTimeCompleteFailed(ctx context.Context, elasticcache *models.SElasticcache, reason string) {
+func (self *ElasticcacheSetMaintainTimeTask) OnElasticcacheSetMaintainTimeCompleteFailed(ctx context.Context, elasticcache *models.SElasticcache, reason jsonutils.JSONObject) {
 	self.taskFail(ctx, elasticcache, reason)
 }

pkg/compute/tasks/elasticcache_sync_task.go

@@ -36,11 +36,11 @@ func init() {
 	taskman.RegisterTask(ElasticcacheSyncTask{})
 }
 
-func (self *ElasticcacheSyncTask) taskFail(ctx context.Context, elasticcache *models.SElasticcache, reason string) {
-	elasticcache.SetStatus(self.GetUserCred(), api.ELASTIC_CACHE_STATUS_SYNC_FAILED, reason)
+func (self *ElasticcacheSyncTask) taskFail(ctx context.Context, elasticcache *models.SElasticcache, reason jsonutils.JSONObject) {
+	elasticcache.SetStatus(self.GetUserCred(), api.ELASTIC_CACHE_STATUS_SYNC_FAILED, reason.String())
 	db.OpsLog.LogEvent(elasticcache, db.ACT_SYNC_CONF, reason, self.UserCred)
 	logclient.AddActionLogWithStartable(self, elasticcache, logclient.ACT_SYNC_CONF, reason, self.UserCred, false)
-	notifyclient.NotifySystemError(elasticcache.Id, elasticcache.Name, api.ELASTIC_CACHE_STATUS_SYNC_FAILED, reason)
+	notifyclient.NotifySystemError(elasticcache.Id, elasticcache.Name, api.ELASTIC_CACHE_STATUS_SYNC_FAILED, reason.String())
 	self.SetStageFailed(ctx, reason)
 }
 
@@ -48,13 +48,13 @@ func (self *ElasticcacheSyncTask) OnInit(ctx context.Context, obj db.IStandalone
 	ec := obj.(*models.SElasticcache)
 	region := ec.GetRegion()
 	if region == nil {
-		self.taskFail(ctx, ec, fmt.Sprintf("failed to find region for elastic cache %s", ec.GetName()))
+		self.taskFail(ctx, ec, jsonutils.NewString(fmt.Sprintf("failed to find region for elastic cache %s", ec.GetName())))
 		return
 	}
 
 	self.SetStage("OnElasticcacheSyncComplete", nil)
 	if err := region.GetDriver().RequestSyncElasticcache(ctx, self.GetUserCred(), ec, self); err != nil {
-		self.taskFail(ctx, ec, err.Error())
+		self.taskFail(ctx, ec, jsonutils.Marshal(err))
 		return
 	} else {
 		logclient.AddActionLogWithStartable(self, ec, logclient.ACT_SYNC_CONF, "", self.UserCred, true)

pkg/compute/tasks/elasticcache_syncstatus_task.go

@@ -19,7 +19,6 @@ import (
 	"fmt"
 
 	"yunion.io/x/jsonutils"
-	"yunion.io/x/pkg/errors"
 
 	api "yunion.io/x/onecloud/pkg/apis/compute"
 	"yunion.io/x/onecloud/pkg/cloudcommon/db"
@@ -36,9 +35,9 @@ func init() {
 	taskman.RegisterTask(ElasticcacheSyncstatusTask{})
 }
 
-func (self *ElasticcacheSyncstatusTask) taskFailed(ctx context.Context, cache *models.SElasticcache, err error) {
-	cache.SetStatus(self.GetUserCred(), api.ELASTIC_CACHE_STATUS_UNKNOWN, err.Error())
-	self.SetStageFailed(ctx, err.Error())
+func (self *ElasticcacheSyncstatusTask) taskFailed(ctx context.Context, cache *models.SElasticcache, err jsonutils.JSONObject) {
+	cache.SetStatus(self.GetUserCred(), api.ELASTIC_CACHE_STATUS_UNKNOWN, err.String())
+	self.SetStageFailed(ctx, err)
 	db.OpsLog.LogEvent(cache, db.ACT_SYNC_STATUS, cache.GetShortDesc(ctx), self.GetUserCred())
 	logclient.AddActionLogWithContext(ctx, cache, logclient.ACT_SYNC_STATUS, err, self.UserCred, false)
 }
@@ -48,14 +47,14 @@ func (self *ElasticcacheSyncstatusTask) OnInit(ctx context.Context, obj db.IStan
 
 	region := cache.GetRegion()
 	if region == nil {
-		self.taskFailed(ctx, cache, fmt.Errorf("failed to found cloudregion for elasticcache %s(%s)", cache.Name, cache.Id))
+		self.taskFailed(ctx, cache, jsonutils.NewString(fmt.Sprintf("failed to found cloudregion for elasticcache %s(%s)", cache.Name, cache.Id)))
 		return
 	}
 
 	self.SetStage("OnElasticcacheSyncStatusComplete", nil)
 	err := region.GetDriver().RequestSyncElasticcacheStatus(ctx, self.GetUserCred(), cache, self)
 	if err != nil {
-		self.taskFailed(ctx, cache, errors.Wrap(err, "RequestSyncElasticcacheStatus"))
+		self.taskFailed(ctx, cache, jsonutils.Marshal(err))
 		return
 	}
 }
@@ -65,5 +64,5 @@ func (self *ElasticcacheSyncstatusTask) OnElasticcacheSyncStatusComplete(ctx con
 }
 
 func (self *ElasticcacheSyncstatusTask) OnElasticcacheSyncStatusCompleteFailed(ctx context.Context, cache *models.SElasticcache, data jsonutils.JSONObject) {
-	self.taskFailed(ctx, cache, fmt.Errorf(data.String()))
+	self.taskFailed(ctx, cache, data)
 }

pkg/compute/tasks/elasticcache_update_auth_mode_task.go

@@ -36,11 +36,11 @@ func init() {
 	taskman.RegisterTask(ElasticcacheUpdateAuthModeTask{})
 }
 
-func (self *ElasticcacheUpdateAuthModeTask) taskFail(ctx context.Context, elasticcache *models.SElasticcache, reason string) {
-	elasticcache.SetStatus(self.GetUserCred(), api.ELASTIC_CACHE_STATUS_CHANGE_FAILED, reason)
+func (self *ElasticcacheUpdateAuthModeTask) taskFail(ctx context.Context, elasticcache *models.SElasticcache, reason jsonutils.JSONObject) {
+	elasticcache.SetStatus(self.GetUserCred(), api.ELASTIC_CACHE_STATUS_CHANGE_FAILED, reason.String())
 	db.OpsLog.LogEvent(elasticcache, db.ACT_UPDATE, reason, self.UserCred)
 	logclient.AddActionLogWithStartable(self, elasticcache, logclient.ACT_UPDATE, reason, self.UserCred, false)
-	notifyclient.NotifySystemError(elasticcache.Id, elasticcache.Name, api.ELASTIC_CACHE_STATUS_CHANGE_FAILED, reason)
+	notifyclient.NotifySystemError(elasticcache.Id, elasticcache.Name, api.ELASTIC_CACHE_STATUS_CHANGE_FAILED, reason.String())
 	self.SetStageFailed(ctx, reason)
 }
 
@@ -48,13 +48,13 @@ func (self *ElasticcacheUpdateAuthModeTask) OnInit(ctx context.Context, obj db.I
 	elasticcache := obj.(*models.SElasticcache)
 	region := elasticcache.GetRegion()
 	if region == nil {
-		self.taskFail(ctx, elasticcache, fmt.Sprintf("failed to find region for elastic cache %s", elasticcache.GetName()))
+		self.taskFail(ctx, elasticcache, jsonutils.Marshal(fmt.Sprintf("failed to find region for elastic cache %s", elasticcache.GetName())))
 		return
 	}
 
 	self.SetStage("OnElasticcacheUpdateAuthModeComplete", nil)
 	if err := region.GetDriver().RequestUpdateElasticcacheAuthMode(ctx, self.GetUserCred(), elasticcache, self); err != nil {
-		self.OnElasticcacheUpdateAuthModeCompleteFailed(ctx, elasticcache, err.Error())
+		self.OnElasticcacheUpdateAuthModeCompleteFailed(ctx, elasticcache, jsonutils.Marshal(err))
 		return
 	}
 
@@ -68,6 +68,6 @@ func (self *ElasticcacheUpdateAuthModeTask) OnElasticcacheUpdateAuthModeComplete
 	self.SetStageComplete(ctx, nil)
 }
 
-func (self *ElasticcacheUpdateAuthModeTask) OnElasticcacheUpdateAuthModeCompleteFailed(ctx context.Context, elasticcache *models.SElasticcache, reason string) {
+func (self *ElasticcacheUpdateAuthModeTask) OnElasticcacheUpdateAuthModeCompleteFailed(ctx context.Context, elasticcache *models.SElasticcache, reason jsonutils.JSONObject) {
 	self.taskFail(ctx, elasticcache, reason)
 }

pkg/compute/tasks/elasticcache_update_backup_policy_task.go

@@ -36,11 +36,11 @@ func init() {
 	taskman.RegisterTask(ElasticcacheUpdateBackupPolicyTask{})
 }
 
-func (self *ElasticcacheUpdateBackupPolicyTask) taskFail(ctx context.Context, elasticcache *models.SElasticcache, reason string) {
-	elasticcache.SetStatus(self.GetUserCred(), api.ELASTIC_CACHE_STATUS_CHANGE_FAILED, reason)
+func (self *ElasticcacheUpdateBackupPolicyTask) taskFail(ctx context.Context, elasticcache *models.SElasticcache, reason jsonutils.JSONObject) {
+	elasticcache.SetStatus(self.GetUserCred(), api.ELASTIC_CACHE_STATUS_CHANGE_FAILED, reason.String())
 	db.OpsLog.LogEvent(elasticcache, db.ACT_UPDATE, reason, self.UserCred)
 	logclient.AddActionLogWithStartable(self, elasticcache, logclient.ACT_UPDATE, reason, self.UserCred, false)
-	notifyclient.NotifySystemError(elasticcache.Id, elasticcache.Name, api.ELASTIC_CACHE_STATUS_CHANGE_FAILED, reason)
+	notifyclient.NotifySystemError(elasticcache.Id, elasticcache.Name, api.ELASTIC_CACHE_STATUS_CHANGE_FAILED, reason.String())
 	self.SetStageFailed(ctx, reason)
 }
 
@@ -48,13 +48,13 @@ func (self *ElasticcacheUpdateBackupPolicyTask) OnInit(ctx context.Context, obj
 	elasticcache := obj.(*models.SElasticcache)
 	region := elasticcache.GetRegion()
 	if region == nil {
-		self.taskFail(ctx, elasticcache, fmt.Sprintf("failed to find region for elastic cache %s", elasticcache.GetName()))
+		self.taskFail(ctx, elasticcache, jsonutils.Marshal(fmt.Sprintf("failed to find region for elastic cache %s", elasticcache.GetName())))
 		return
 	}
 
 	self.SetStage("OnElasticcacheUpdateBackupPolicyComplete", nil)
 	if err := region.GetDriver().RequestElasticcacheUpdateBackupPolicy(ctx, self.GetUserCred(), elasticcache, self); err != nil {
-		self.OnElasticcacheUpdateBackupPolicyCompleteFailed(ctx, elasticcache, err.Error())
+		self.OnElasticcacheUpdateBackupPolicyCompleteFailed(ctx, elasticcache, jsonutils.Marshal(err))
 		return
 	}
 
@@ -68,6 +68,6 @@ func (self *ElasticcacheUpdateBackupPolicyTask) OnElasticcacheUpdateBackupPolicy
 	self.SetStageComplete(ctx, nil)
 }
 
-func (self *ElasticcacheUpdateBackupPolicyTask) OnElasticcacheUpdateBackupPolicyCompleteFailed(ctx context.Context, elasticcache *models.SElasticcache, reason string) {
+func (self *ElasticcacheUpdateBackupPolicyTask) OnElasticcacheUpdateBackupPolicyCompleteFailed(ctx context.Context, elasticcache *models.SElasticcache, reason jsonutils.JSONObject) {
 	self.taskFail(ctx, elasticcache, reason)
 }

pkg/compute/tasks/guest_attach_disk_task.go

@@ -41,12 +41,12 @@ func (self *GuestAttachDiskTask) OnInit(ctx context.Context, obj db.IStandaloneM
 	diskId, _ := self.Params.GetString("disk_id")
 	objDisk, err := models.DiskManager.FetchById(diskId)
 	if err != nil {
-		self.OnTaskFail(ctx, guest, nil, err)
+		self.OnTaskFail(ctx, guest, nil, jsonutils.NewString(err.Error()))
 		return
 	}
 	disk := objDisk.(*models.SDisk)
 	if disk == nil {
-		self.OnTaskFail(ctx, guest, nil, fmt.Errorf("Connot find disk %s", diskId))
+		self.OnTaskFail(ctx, guest, nil, jsonutils.NewString(fmt.Sprintf("Connot find disk %s", diskId)))
 		return
 	}
 
@@ -56,7 +56,7 @@ func (self *GuestAttachDiskTask) OnInit(ctx context.Context, obj db.IStandaloneM
 
 	err = guest.AttachDisk(ctx, disk, self.UserCred, driver, cache, mountpoint)
 	if err != nil {
-		self.OnTaskFail(ctx, guest, nil, err)
+		self.OnTaskFail(ctx, guest, nil, jsonutils.NewString(err.Error()))
 		return
 	}
 	disk.SetStatus(self.UserCred, api.DISK_ATTACHING, "Disk attach")
@@ -68,12 +68,12 @@ func (self *GuestAttachDiskTask) OnSyncConfigComplete(ctx context.Context, guest
 	diskId, _ := self.Params.GetString("disk_id")
 	objDisk, err := models.DiskManager.FetchById(diskId)
 	if err != nil {
-		self.OnTaskFail(ctx, guest, nil, err)
+		self.OnTaskFail(ctx, guest, nil, jsonutils.NewString(err.Error()))
 		return
 	}
 	disk := objDisk.(*models.SDisk)
 	if disk == nil {
-		self.OnTaskFail(ctx, guest, nil, fmt.Errorf("Connot find disk %s", diskId))
+		self.OnTaskFail(ctx, guest, nil, jsonutils.NewString(fmt.Sprintf("Connot find disk %s", diskId)))
 		return
 	}
 	disk.SetDiskReady(ctx, self.UserCred, "")
@@ -86,22 +86,22 @@ func (self *GuestAttachDiskTask) OnSyncConfigCompleteFailed(ctx context.Context,
 	diskId, _ := self.Params.GetString("disk_id")
 	objDisk, err := models.DiskManager.FetchById(diskId)
 	if err != nil {
-		self.OnTaskFail(ctx, guest, nil, err)
+		self.OnTaskFail(ctx, guest, nil, jsonutils.NewString(err.Error()))
 		return
 	}
 	disk := objDisk.(*models.SDisk)
 	db.OpsLog.LogEvent(disk, db.ACT_ATTACH, reason.String(), self.UserCred)
 	disk.SetStatus(self.UserCred, api.DISK_READY, "")
 	guest.DetachDisk(ctx, disk, self.UserCred)
-	self.OnTaskFail(ctx, guest, disk, fmt.Errorf(reason.String()))
+	self.OnTaskFail(ctx, guest, disk, reason)
 }
 
-func (self *GuestAttachDiskTask) OnTaskFail(ctx context.Context, guest *models.SGuest, disk *models.SDisk, err error) {
+func (self *GuestAttachDiskTask) OnTaskFail(ctx context.Context, guest *models.SGuest, disk *models.SDisk, err jsonutils.JSONObject) {
 	if disk != nil {
 		disk.SetStatus(self.UserCred, api.DISK_READY, "")
 	}
-	guest.SetStatus(self.UserCred, api.VM_ATTACH_DISK_FAILED, err.Error())
-	self.SetStageFailed(ctx, err.Error())
-	log.Errorf("Guest %s GuestAttachDiskTask failed %s", guest.Name, err.Error())
-	logclient.AddActionLogWithStartable(self, guest, logclient.ACT_VM_ATTACH_DISK, err.Error(), self.UserCred, false)
+	guest.SetStatus(self.UserCred, api.VM_ATTACH_DISK_FAILED, err.String())
+	self.SetStageFailed(ctx, err)
+	log.Errorf("Guest %s GuestAttachDiskTask failed %s", guest.Name, err.String())
+	logclient.AddActionLogWithStartable(self, guest, logclient.ACT_VM_ATTACH_DISK, err, self.UserCred, false)
 }

pkg/compute/tasks/guest_backup_tasks.go

@@ -59,7 +59,7 @@ func (self *GuestSwitchToBackupTask) OnEnsureMasterGuestStoped(ctx context.Conte
 	self.SetStage("OnBackupGuestStoped", nil)
 	err := guest.GetDriver().RequestStopOnHost(ctx, guest, backupHost, self)
 	if err != nil {
-		self.OnFail(ctx, guest, fmt.Sprintf("Stop backup guest error: %s", err))
+		self.OnFail(ctx, guest, jsonutils.Marshal(err))
 	}
 }
 
@@ -75,13 +75,13 @@ func (self *GuestSwitchToBackupTask) OnBackupGuestStoped(ctx context.Context, gu
 					disk.SwitchToBackup(self.UserCred)
 				}
 			}
-			self.OnFail(ctx, guest, fmt.Sprintf("Switch to backup disk error: %s", err))
+			self.OnFail(ctx, guest, jsonutils.NewString(fmt.Sprintf("Switch to backup disk error: %s", err)))
 			return
 		}
 	}
 	err := guest.SwitchToBackup(self.UserCred)
 	if err != nil {
-		self.OnFail(ctx, guest, fmt.Sprintf("Switch to backup guest error: %s", err))
+		self.OnFail(ctx, guest, jsonutils.NewString(fmt.Sprintf("Switch to backup guest error: %s", err)))
 		return
 	}
 	db.OpsLog.LogEvent(guest, db.ACT_SWITCHED, "Switch to backup", self.UserCred)
@@ -102,8 +102,8 @@ func (self *GuestSwitchToBackupTask) OnNewMasterStarted(ctx context.Context, gue
 	self.OnComplete(ctx, guest, nil)
 }
 
-func (self *GuestSwitchToBackupTask) OnFail(ctx context.Context, guest *models.SGuest, reason string) {
-	guest.SetStatus(self.UserCred, api.VM_SWITCH_TO_BACKUP_FAILED, reason)
+func (self *GuestSwitchToBackupTask) OnFail(ctx context.Context, guest *models.SGuest, reason jsonutils.JSONObject) {
+	guest.SetStatus(self.UserCred, api.VM_SWITCH_TO_BACKUP_FAILED, reason.String())
 	db.OpsLog.LogEvent(guest, db.ACT_SWITCH_FAILED, reason, self.UserCred)
 	logclient.AddActionLogWithContext(ctx, guest, logclient.ACT_SWITCH_TO_BACKUP, reason, self.UserCred, false)
 	self.SetSwitchFiledGuestMetadata(ctx, guest)
@@ -191,7 +191,7 @@ func (self *GuestSwitchToBackupTask) OnCreatedBackupFailed(ctx context.Context,
 }
 
 func (self *GuestSwitchToBackupTask) OnSwitchedFailed(ctx context.Context, guest *models.SGuest, data jsonutils.JSONObject) {
-	self.OnFail(ctx, guest, data.String())
+	self.OnFail(ctx, guest, data)
 }
 
 /********************* GuestStartAndSyncToBackupTask *********************/
@@ -212,7 +212,7 @@ func (self *GuestStartAndSyncToBackupTask) checkTemplete(ctx context.Context, gu
 		err := guest.GetDriver().CheckDiskTemplateOnStorage(ctx, self.UserCred, diskCat.Root.GetTemplateId(), diskCat.Root.DiskFormat,
 			diskCat.Root.BackupStorageId, self)
 		if err != nil {
-			self.SetStageFailed(ctx, err.Error())
+			self.SetStageFailed(ctx, jsonutils.Marshal(err))
 		}
 	} else {
 		self.OnCheckTemplete(ctx, guest, nil)
@@ -223,14 +223,14 @@ func (self *GuestStartAndSyncToBackupTask) OnCheckTemplete(ctx context.Context,
 	self.SetStage("OnStartBackupGuest", nil)
 	host := models.HostManager.FetchHostById(guest.BackupHostId)
 	if _, err := guest.GetDriver().RequestStartOnHost(ctx, guest, host, self.UserCred, self); err != nil {
-		self.SetStageFailed(ctx, err.Error())
+		self.SetStageFailed(ctx, jsonutils.Marshal(err))
 	}
 }
 
 func (self *GuestStartAndSyncToBackupTask) OnStartBackupGuest(ctx context.Context, guest *models.SGuest, data jsonutils.JSONObject) {
 	nbdServerPort, err := data.Int("nbd_server_port")
 	if err != nil {
-		self.SetStageFailed(ctx, "Start Backup Guest Missing Nbd Port")
+		self.SetStageFailed(ctx, jsonutils.NewString("Start Backup Guest Missing Nbd Port"))
 		return
 	}
 	backupHost := models.HostManager.FetchHostById(guest.BackupHostId)
@@ -248,7 +248,7 @@ func (self *GuestStartAndSyncToBackupTask) OnStartBackupGuest(ctx context.Contex
 		self.SetStage("OnRequestSyncToBackup", nil)
 		err = guest.GetDriver().RequestSyncToBackup(ctx, guest, self)
 		if err != nil {
-			self.SetStageFailed(ctx, fmt.Sprintf("Guest Request Sync to backup failed %s", err))
+			self.SetStageFailed(ctx, jsonutils.Marshal(err))
 		}
 	} else {
 		self.SetStageComplete(ctx, nil)
@@ -258,7 +258,7 @@ func (self *GuestStartAndSyncToBackupTask) OnStartBackupGuest(ctx context.Contex
 func (self *GuestStartAndSyncToBackupTask) OnStartBackupGuestFailed(ctx context.Context, guest *models.SGuest, data jsonutils.JSONObject) {
 	guest.SetMetadata(ctx, "__mirror_job_status", "failed", self.UserCred)
 	db.OpsLog.LogEvent(guest, db.ACT_BACKUP_START_FAILED, data.String(), self.UserCred)
-	self.SetStageFailed(ctx, data.String())
+	self.SetStageFailed(ctx, data)
 }
 
 func (self *GuestStartAndSyncToBackupTask) OnRequestSyncToBackup(ctx context.Context, guest *models.SGuest, data jsonutils.JSONObject) {
@@ -269,7 +269,7 @@ func (self *GuestStartAndSyncToBackupTask) OnRequestSyncToBackup(ctx context.Con
 
 func (self *GuestStartAndSyncToBackupTask) OnRequestSyncToBackupFailed(ctx context.Context, guest *models.SGuest, data jsonutils.JSONObject) {
 	guest.SetStatus(self.UserCred, api.VM_BLOCK_STREAM_FAIL, "OnSyncToBackup")
-	self.SetStageFailed(ctx, data.String())
+	self.SetStageFailed(ctx, data)
 }
 
 type GuestCreateBackupTask struct {
@@ -297,11 +297,11 @@ func (self *GuestCreateBackupTask) GetSchedParams() (*schedapi.ScheduleInput, er
 	return schedDesc, nil
 }
 
-func (self *GuestCreateBackupTask) OnScheduleFailCallback(ctx context.Context, obj IScheduleModel, reason string) {
+func (self *GuestCreateBackupTask) OnScheduleFailCallback(ctx context.Context, obj IScheduleModel, reason jsonutils.JSONObject) {
 	// do nothing
 }
 
-func (self *GuestCreateBackupTask) OnScheduleFailed(ctx context.Context, reason string) {
+func (self *GuestCreateBackupTask) OnScheduleFailed(ctx context.Context, reason jsonutils.JSONObject) {
 	obj := self.GetObject()
 	guest := obj.(*models.SGuest)
 	self.TaskFailed(ctx, guest, reason)
@@ -312,7 +312,7 @@ func (self *GuestCreateBackupTask) SaveScheduleResult(ctx context.Context, obj I
 	targetHostId := candidate.HostId
 	targetHost := models.HostManager.FetchHostById(candidate.HostId)
 	if targetHost == nil {
-		self.TaskFailed(ctx, guest, "target host not found?")
+		self.TaskFailed(ctx, guest, jsonutils.NewString("target host not found?"))
 		return
 	}
 	guest.SetHostIdWithBackup(self.UserCred, guest.HostId, targetHostId)
@@ -330,7 +330,7 @@ func (self *GuestCreateBackupTask) StartCreateBackupDisks(ctx context.Context, g
 		}
 		storage := guest.ChooseHostStorage(host, api.STORAGE_LOCAL, candidateDisk)
 		if storage == nil {
-			self.TaskFailed(ctx, guest, "Get backup storage error")
+			self.TaskFailed(ctx, guest, jsonutils.NewString("Get backup storage error"))
 			return
 		}
 		disk := guestDisks[i].GetDisk()
@@ -342,7 +342,7 @@ func (self *GuestCreateBackupTask) StartCreateBackupDisks(ctx context.Context, g
 	self.SetStage("OnCreateBackupDisks", nil)
 	err := guest.CreateBackupDisks(ctx, self.UserCred, self.GetTaskId())
 	if err != nil {
-		self.TaskFailed(ctx, guest, err.Error())
+		self.TaskFailed(ctx, guest, jsonutils.NewString(err.Error()))
 	}
 }
 
@@ -357,7 +357,7 @@ func (self *GuestCreateBackupTask) OnInsertIso(ctx context.Context, guest *model
 }
 
 func (self *GuestCreateBackupTask) OnInsertIsoFailed(ctx context.Context, guest *models.SGuest, data jsonutils.JSONObject) {
-	self.TaskFailed(ctx, guest, fmt.Sprintf("Backup guest insert ISO failed %s", data.String()))
+	self.TaskFailed(ctx, guest, jsonutils.NewString(fmt.Sprintf("Backup guest insert ISO failed %s", data.String())))
 }
 
 func (self *GuestCreateBackupTask) OnCreateBackupDisks(ctx context.Context, guest *models.SGuest, data jsonutils.JSONObject) {
@@ -370,11 +370,11 @@ func (self *GuestCreateBackupTask) OnCreateBackupDisks(ctx context.Context, gues
 }
 
 func (self *GuestCreateBackupTask) OnCreateBackupDisksFailed(ctx context.Context, guest *models.SGuest, data jsonutils.JSONObject) {
-	self.TaskFailed(ctx, guest, fmt.Sprintf("Create Backup Disks failed %s", data.String()))
+	self.TaskFailed(ctx, guest, data)
 }
 
 func (self *GuestCreateBackupTask) OnCreateBackupFailed(ctx context.Context, guest *models.SGuest, data jsonutils.JSONObject) {
-	self.TaskFailed(ctx, guest, fmt.Sprintf("Deploy Backup failed %s", data.String()))
+	self.TaskFailed(ctx, guest, data)
 }
 
 func (self *GuestCreateBackupTask) OnCreateBackup(ctx context.Context, guest *models.SGuest, data jsonutils.JSONObject) {
@@ -390,7 +390,7 @@ func (self *GuestCreateBackupTask) OnGuestStart(ctx context.Context, guest *mode
 	self.SetStage("OnSyncToBackup", nil)
 	err := guest.GuestStartAndSyncToBackup(ctx, self.UserCred, self.GetTaskId(), guestStatus)
 	if err != nil {
-		self.TaskFailed(ctx, guest, fmt.Sprintf("Guest sycn to backup error %s", err.Error()))
+		self.TaskFailed(ctx, guest, jsonutils.NewString(fmt.Sprintf("Guest sycn to backup error %s", err.Error())))
 	}
 }
 
@@ -399,7 +399,7 @@ func (self *GuestCreateBackupTask) OnSyncToBackup(ctx context.Context, guest *mo
 }
 
 func (self *GuestCreateBackupTask) OnSyncToBackupFailed(ctx context.Context, guest *models.SGuest, data jsonutils.JSONObject) {
-	self.TaskFailed(ctx, guest, data.String())
+	self.TaskFailed(ctx, guest, data)
 }
 
 func (self *GuestCreateBackupTask) TaskCompleted(ctx context.Context, guest *models.SGuest, reason string) {
@@ -415,8 +415,8 @@ func (self *GuestCreateBackupTask) TaskCompleted(ctx context.Context, guest *mod
 	guest.StartSyncstatus(ctx, self.UserCred, "")
 }
 
-func (self *GuestCreateBackupTask) TaskFailed(ctx context.Context, guest *models.SGuest, reason string) {
-	guest.SetStatus(self.UserCred, api.VM_BACKUP_CREATE_FAILED, reason)
+func (self *GuestCreateBackupTask) TaskFailed(ctx context.Context, guest *models.SGuest, reason jsonutils.JSONObject) {
+	guest.SetStatus(self.UserCred, api.VM_BACKUP_CREATE_FAILED, reason.String())
 	if jsonutils.QueryBoolean(self.Params, "reconcile_backup", false) {
 		if res := guest.GetMetadata("create_backup", self.UserCred); len(res) == 0 {
 			guest.SetMetadata(

pkg/compute/tasks/guest_base_task.go

@@ -17,6 +17,8 @@ package tasks
 import (
 	"context"
 
+	"yunion.io/x/jsonutils"
+
 	"yunion.io/x/onecloud/pkg/cloudcommon/db/quotas"
 	"yunion.io/x/onecloud/pkg/cloudcommon/db/taskman"
 	"yunion.io/x/onecloud/pkg/compute/models"
@@ -31,7 +33,7 @@ func (self *SGuestBaseTask) getGuest() *models.SGuest {
 	return obj.(*models.SGuest)
 }
 
-func (self *SGuestBaseTask) SetStageFailed(ctx context.Context, reason string) {
+func (self *SGuestBaseTask) SetStageFailed(ctx context.Context, reason jsonutils.JSONObject) {
 	self.finalReleasePendingUsage(ctx)
 	self.STask.SetStageFailed(ctx, reason)
 }

pkg/compute/tasks/guest_batch_create_task.go

@@ -84,7 +84,7 @@ func (self *GuestBatchCreateTask) OnInit(ctx context.Context, objs []db.IStandal
 	StartScheduleObjects(ctx, self, objs)
 }
 
-func (self *GuestBatchCreateTask) OnScheduleFailCallback(ctx context.Context, obj IScheduleModel, reason string) {
+func (self *GuestBatchCreateTask) OnScheduleFailCallback(ctx context.Context, obj IScheduleModel, reason jsonutils.JSONObject) {
 	guest := obj.(*models.SGuest)
 	if guest.DisableDelete.IsTrue() {
 		guest.SetDisableDelete(self.UserCred, false)
@@ -276,9 +276,9 @@ func (self *GuestBatchCreateTask) SaveScheduleResult(ctx context.Context, obj IS
 	if err != nil {
 		self.clearPendingUsage(ctx, guest)
 		db.OpsLog.LogEvent(guest, db.ACT_ALLOCATE_FAIL, err, self.UserCred)
-		logclient.AddActionLogWithStartable(self, obj, logclient.ACT_ALLOCATE, err.Error(), self.GetUserCred(), false)
+		logclient.AddActionLogWithStartable(self, obj, logclient.ACT_ALLOCATE, err, self.GetUserCred(), false)
 		notifyclient.NotifySystemError(guest.Id, guest.Name, api.VM_CREATE_FAILED, err.Error())
-		self.SetStageFailed(ctx, err.Error())
+		self.SetStageFailed(ctx, jsonutils.Marshal(err))
 	}
 }
 

pkg/compute/tasks/guest_block_io_throttle_task.go

@@ -86,8 +86,8 @@ func (self *GuestBlockIoThrottleTask) OnGuestSyncFailed(ctx context.Context, gue
 }
 
 func (self *GuestBlockIoThrottleTask) OnIoThrottleFailed(ctx context.Context, guest *models.SGuest, data jsonutils.JSONObject) {
-	db.OpsLog.LogEvent(guest, db.ACT_VM_IO_THROTTLE_FAIL, data.String(), self.UserCred)
-	logclient.AddActionLogWithContext(ctx, guest, logclient.ACT_VM_IO_THROTTLE, data.String(), self.UserCred, false)
+	db.OpsLog.LogEvent(guest, db.ACT_VM_IO_THROTTLE_FAIL, data, self.UserCred)
+	logclient.AddActionLogWithContext(ctx, guest, logclient.ACT_VM_IO_THROTTLE, data, self.UserCred, false)
 	guest.SetStatus(self.UserCred, api.VM_IO_THROTTLE_FAIL, data.String())
-	self.SetStageFailed(ctx, data.String())
+	self.SetStageFailed(ctx, data)
 }

pkg/compute/tasks/guest_change_config_task.go

@@ -54,40 +54,40 @@ func (self *GuestChangeConfigTask) OnDisksResizeComplete(ctx context.Context, ob
 
 	iResizeDisks, err := self.Params.Get("resize")
 	if iResizeDisks == nil || err != nil {
-		self.markStageFailed(ctx, guest, err.Error())
+		self.markStageFailed(ctx, guest, jsonutils.NewString(err.Error()))
 		return
 	}
 	resizeDisks := iResizeDisks.(*jsonutils.JSONArray)
 	for i := 0; i < resizeDisks.Length(); i++ {
 		iResizeSet, err := resizeDisks.GetAt(i)
 		if err != nil {
-			self.markStageFailed(ctx, guest, fmt.Sprintf("resizeDisks.GetAt fail %s", err))
+			self.markStageFailed(ctx, guest, jsonutils.NewString(fmt.Sprintf("resizeDisks.GetAt fail %s", err)))
 			return
 		}
 		resizeSet := iResizeSet.(*jsonutils.JSONArray)
 		diskId, err := resizeSet.GetAt(0)
 		if err != nil {
-			self.markStageFailed(ctx, guest, fmt.Sprintf("resizeSet.GetAt(0) fail %s", err))
+			self.markStageFailed(ctx, guest, jsonutils.NewString(fmt.Sprintf("resizeSet.GetAt(0) fail %s", err)))
 			return
 		}
 		idStr, err := diskId.GetString()
 		if err != nil {
-			self.markStageFailed(ctx, guest, fmt.Sprintf("diskId.GetString fail %s", err))
+			self.markStageFailed(ctx, guest, jsonutils.NewString(fmt.Sprintf("diskId.GetString fail %s", err)))
 			return
 		}
 		jSize, err := resizeSet.GetAt(1)
 		if err != nil {
-			self.markStageFailed(ctx, guest, fmt.Sprintf("resizeSet.GetAt(1) fail %s", err))
+			self.markStageFailed(ctx, guest, jsonutils.NewString(fmt.Sprintf("resizeSet.GetAt(1) fail %s", err)))
 			return
 		}
 		size, err := jSize.Int()
 		if err != nil {
-			self.markStageFailed(ctx, guest, fmt.Sprintf("jSize.Int fail %s", err))
+			self.markStageFailed(ctx, guest, jsonutils.NewString(fmt.Sprintf("jSize.Int fail %s", err)))
 			return
 		}
 		iDisk, err := models.DiskManager.FetchById(idStr)
 		if err != nil {
-			self.markStageFailed(ctx, guest, fmt.Sprintf("models.DiskManager.FetchById(idStr) fail %s", err))
+			self.markStageFailed(ctx, guest, jsonutils.NewString(fmt.Sprintf("models.DiskManager.FetchById(idStr) fail %s", err)))
 			return
 		}
 		disk := iDisk.(*models.SDisk)
@@ -95,12 +95,12 @@ func (self *GuestChangeConfigTask) OnDisksResizeComplete(ctx context.Context, ob
 			var pendingUsage models.SQuota
 			err = self.GetPendingUsage(&pendingUsage, 0)
 			if err != nil {
-				self.markStageFailed(ctx, guest, fmt.Sprintf("self.GetPendingUsage(&pendingUsage) fail %s", err))
+				self.markStageFailed(ctx, guest, jsonutils.NewString(fmt.Sprintf("self.GetPendingUsage(&pendingUsage) fail %s", err)))
 				return
 			}
 			err = guest.StartGuestDiskResizeTask(ctx, self.UserCred, disk.Id, size, self.GetTaskId(), &pendingUsage)
 			if err != nil {
-				self.markStageFailed(ctx, guest, fmt.Sprintf("guest.StartGuestDiskResizeTask fail %s", err))
+				self.markStageFailed(ctx, guest, jsonutils.NewString(fmt.Sprintf("guest.StartGuestDiskResizeTask fail %s", err)))
 				return
 			}
 			return
@@ -123,7 +123,7 @@ func (self *GuestChangeConfigTask) DoCreateDisksTask(ctx context.Context, guest
 
 func (self *GuestChangeConfigTask) OnCreateDisksCompleteFailed(ctx context.Context, obj db.IStandaloneModel, err jsonutils.JSONObject) {
 	guest := obj.(*models.SGuest)
-	self.markStageFailed(ctx, guest, fmt.Sprintf("OnCreateDisksCompleteFailed %s", err))
+	self.markStageFailed(ctx, guest, err)
 }
 
 func (self *GuestChangeConfigTask) OnCreateDisksComplete(ctx context.Context, obj db.IStandaloneModel, data jsonutils.JSONObject) {
@@ -138,7 +138,7 @@ func (self *GuestChangeConfigTask) OnCreateDisksComplete(ctx context.Context, ob
 			provider := guest.GetDriver().GetProvider()
 			sku, err := models.ServerSkuManager.FetchSkuByNameAndProvider(instanceType, provider, false)
 			if err != nil {
-				self.markStageFailed(ctx, guest, fmt.Sprintf("models.ServerSkuManager.FetchSkuByNameAndProvider error %s", err))
+				self.markStageFailed(ctx, guest, jsonutils.NewString(fmt.Sprintf("models.ServerSkuManager.FetchSkuByNameAndProvider error %s", err)))
 				return
 			}
 			vcpuCount = int64(sku.CpuCoreCount)
@@ -160,7 +160,7 @@ func (self *GuestChangeConfigTask) OnCreateDisksComplete(ctx context.Context, ob
 func (self *GuestChangeConfigTask) startGuestChangeCpuMemSpec(ctx context.Context, guest *models.SGuest, instanceType string, vcpuCount int64, vmemSize int64) {
 	err := guest.GetDriver().RequestChangeVmConfig(ctx, guest, self, instanceType, vcpuCount, vmemSize)
 	if err != nil {
-		self.markStageFailed(ctx, guest, fmt.Sprintf("guest.GetDriver().RequestChangeVmConfig fail %s", err))
+		self.markStageFailed(ctx, guest, jsonutils.Marshal(err))
 		return
 	}
 }
@@ -195,7 +195,7 @@ func (self *GuestChangeConfigTask) OnGuestChangeCpuMemSpecComplete(ctx context.C
 		return nil
 	})
 	if err != nil {
-		self.markStageFailed(ctx, guest, fmt.Sprintf("Update fail %s", err))
+		self.markStageFailed(ctx, guest, jsonutils.NewString(fmt.Sprintf("Update fail %s", err)))
 		return
 	}
 	changeConfigSpec := jsonutils.NewDict()
@@ -214,7 +214,7 @@ func (self *GuestChangeConfigTask) OnGuestChangeCpuMemSpecComplete(ctx context.C
 	var pendingUsage models.SQuota
 	err = self.GetPendingUsage(&pendingUsage, 0)
 	if err != nil {
-		self.markStageFailed(ctx, guest, fmt.Sprintf("GetPendingUsage %s", err))
+		self.markStageFailed(ctx, guest, jsonutils.NewString(fmt.Sprintf("GetPendingUsage %s", err)))
 		return
 	}
 	var cancelUsage models.SQuota
@@ -232,7 +232,7 @@ func (self *GuestChangeConfigTask) OnGuestChangeCpuMemSpecComplete(ctx context.C
 
 	keys, err := guest.GetQuotaKeys()
 	if err != nil {
-		self.markStageFailed(ctx, guest, fmt.Sprintf("guest.GetQuotaKeys %s", err))
+		self.markStageFailed(ctx, guest, jsonutils.NewString(fmt.Sprintf("guest.GetQuotaKeys %s", err)))
 		return
 	}
 	cancelUsage.SetKeys(keys)
@@ -244,12 +244,12 @@ func (self *GuestChangeConfigTask) OnGuestChangeCpuMemSpecComplete(ctx context.C
 	if !cancelUsage.IsEmpty() {
 		err = quotas.CancelPendingUsage(ctx, self.UserCred, &pendingUsage, &cancelUsage, true) // success
 		if err != nil {
-			self.markStageFailed(ctx, guest, fmt.Sprintf("CancelPendingUsage fail %s", err))
+			self.markStageFailed(ctx, guest, jsonutils.NewString(fmt.Sprintf("CancelPendingUsage fail %s", err)))
 			return
 		}
 		err = self.SetPendingUsage(&pendingUsage, 0)
 		if err != nil {
-			self.markStageFailed(ctx, guest, fmt.Sprintf("SetPendingUsage fail %s", err))
+			self.markStageFailed(ctx, guest, jsonutils.NewString(fmt.Sprintf("SetPendingUsage fail %s", err)))
 			return
 		}
 	}
@@ -265,7 +265,7 @@ func (self *GuestChangeConfigTask) OnGuestChangeCpuMemSpecCompleteFailed(ctx con
 	if err := guest.GetDriver().OnGuestChangeCpuMemFailed(ctx, guest, data.(*jsonutils.JSONDict), self); err != nil {
 		log.Errorln(err)
 	}
-	self.markStageFailed(ctx, guest, fmt.Sprintf("guest.GetDriver().RequestChangeVmConfig fail %s", data))
+	self.markStageFailed(ctx, guest, data)
 }
 
 func (self *GuestChangeConfigTask) OnGuestChangeCpuMemSpecFinish(ctx context.Context, guest *models.SGuest) {
@@ -273,7 +273,7 @@ func (self *GuestChangeConfigTask) OnGuestChangeCpuMemSpecFinish(ctx context.Con
 	self.SetStage("OnSyncConfigComplete", nil)
 	err := guest.StartSyncTaskWithoutSyncstatus(ctx, self.UserCred, false, self.GetTaskId())
 	if err != nil {
-		self.markStageFailed(ctx, guest, fmt.Sprintf("StartSyncstatus fail %s", err))
+		self.markStageFailed(ctx, guest, jsonutils.NewString(fmt.Sprintf("StartSyncstatus fail %s", err)))
 		return
 	}
 }
@@ -284,7 +284,7 @@ func (self *GuestChangeConfigTask) OnSyncConfigComplete(ctx context.Context, obj
 	self.SetStage("on_sync_status_complete", nil)
 	err := guest.StartSyncstatus(ctx, self.UserCred, self.GetTaskId())
 	if err != nil {
-		self.markStageFailed(ctx, guest, fmt.Sprintf("StartSyncstatus fail %s", err))
+		self.markStageFailed(ctx, guest, jsonutils.NewString(fmt.Sprintf("StartSyncstatus fail %s", err)))
 		return
 	}
 }
@@ -310,11 +310,11 @@ func (self *GuestChangeConfigTask) OnGuestStartComplete(ctx context.Context, obj
 }
 
 func (self *GuestChangeConfigTask) OnGuestStartCompleteFailed(ctx context.Context, obj db.IStandaloneModel, data jsonutils.JSONObject) {
-	self.SetStageFailed(ctx, data.String())
+	self.SetStageFailed(ctx, data)
 }
 
-func (self *GuestChangeConfigTask) markStageFailed(ctx context.Context, guest *models.SGuest, reason string) {
-	guest.SetStatus(self.UserCred, api.VM_CHANGE_FLAVOR_FAIL, reason)
+func (self *GuestChangeConfigTask) markStageFailed(ctx context.Context, guest *models.SGuest, reason jsonutils.JSONObject) {
+	guest.SetStatus(self.UserCred, api.VM_CHANGE_FLAVOR_FAIL, reason.String())
 	db.OpsLog.LogEvent(guest, db.ACT_CHANGE_FLAVOR_FAIL, reason, self.UserCred)
 	logclient.AddActionLogWithStartable(self, guest, logclient.ACT_VM_CHANGE_FLAVOR, reason, self.UserCred, false)
 	self.SetStageFailed(ctx, reason)

pkg/compute/tasks/guest_convert_esxi_to_kvm_task.go

@@ -61,15 +61,15 @@ func (self *GuestConvertEsxiToKvmTask) OnStartSchedule(obj IScheduleModel) {
 	db.OpsLog.LogEvent(guest, db.ACT_VM_CONVERTING, "", self.UserCred)
 }
 
-func (self *GuestConvertEsxiToKvmTask) OnScheduleFailed(ctx context.Context, reason string) {
+func (self *GuestConvertEsxiToKvmTask) OnScheduleFailed(ctx context.Context, reason jsonutils.JSONObject) {
 	guest := self.GetObject().(*models.SGuest)
 	self.taskFailed(ctx, guest, reason)
 }
 
-func (self *GuestConvertEsxiToKvmTask) taskFailed(ctx context.Context, guest *models.SGuest, reason string) {
-	guest.SetStatus(self.UserCred, api.VM_CONVERT_FAILED, reason)
+func (self *GuestConvertEsxiToKvmTask) taskFailed(ctx context.Context, guest *models.SGuest, reason jsonutils.JSONObject) {
+	guest.SetStatus(self.UserCred, api.VM_CONVERT_FAILED, reason.String())
 	targetGuest := self.getTargetGuest()
-	targetGuest.SetStatus(self.UserCred, api.VM_CONVERT_FAILED, reason)
+	targetGuest.SetStatus(self.UserCred, api.VM_CONVERT_FAILED, reason.String())
 	db.OpsLog.LogEvent(guest, db.ACT_VM_CONVERT_FAIL, reason, self.UserCred)
 	logclient.AddSimpleActionLog(guest, logclient.ACT_VM_CONVERT, reason, self.UserCred, false)
 	logclient.AddSimpleActionLog(targetGuest, logclient.ACT_VM_CONVERT, reason, self.UserCred, false)
@@ -100,17 +100,17 @@ func (self *GuestConvertEsxiToKvmTask) SaveScheduleResult(ctx context.Context, o
 	targetGuest := self.getTargetGuest()
 	esxiAccessInfo, err := self.GenerateEsxiAcceessInfo(guest)
 	if err != nil {
-		self.taskFailed(ctx, guest, fmt.Sprintf("generate esxi access info %s", err))
+		self.taskFailed(ctx, guest, jsonutils.NewString(fmt.Sprintf("generate esxi access info %s", err)))
 		return
 	}
 	err = targetGuest.SetHostId(self.UserCred, target.HostId)
 	if err != nil {
-		self.taskFailed(ctx, guest, fmt.Sprintf("update guest %s", err))
+		self.taskFailed(ctx, guest, jsonutils.NewString(fmt.Sprintf("update guest %s", err)))
 		return
 	}
 	err = targetGuest.SetMetadata(ctx, api.SERVER_META_CONVERT_FROM_ESXI, guest.Id, self.UserCred)
 	if err != nil {
-		self.taskFailed(ctx, guest, fmt.Sprintf("guest set metadata %s", err))
+		self.taskFailed(ctx, guest, jsonutils.NewString(fmt.Sprintf("guest set metadata %s", err)))
 		return
 	}
 	host := targetGuest.GetHost()
@@ -121,13 +121,13 @@ func (self *GuestConvertEsxiToKvmTask) SaveScheduleResult(ctx context.Context, o
 	err = targetGuest.CreateDisksOnHost(ctx, self.UserCred, host, input.Disks, nil,
 		true, true, target.Disks, nil, true)
 	if err != nil {
-		self.taskFailed(ctx, guest, fmt.Sprintf("guest create disks %s", err))
+		self.taskFailed(ctx, guest, jsonutils.NewString(fmt.Sprintf("guest create disks %s", err)))
 		return
 	}
 
 	self.SetStage("OnHostCreateGuest", nil)
 	if err = self.RequestHostCreateGuestFromEsxi(ctx, targetGuest, esxiAccessInfo); err != nil {
-		self.taskFailed(ctx, guest, err.Error())
+		self.taskFailed(ctx, guest, jsonutils.Marshal(err))
 		return
 	}
 	host.ClearSchedDescCache()
@@ -167,13 +167,13 @@ func (self *GuestConvertEsxiToKvmTask) OnHostCreateGuest(
 		err = disk.SetMetadata(ctx, api.DISK_META_ESXI_FLAT_FILE_PATH, esxiFlatFilePath, self.UserCred)
 		if err != nil {
 			log.Errorf("disk set metadata failed %s", err)
-			self.taskFailed(ctx, guest, err.Error())
+			self.taskFailed(ctx, guest, jsonutils.NewString(err.Error()))
 			return
 		}
 		db.OpsLog.LogEvent(disk, db.ACT_ALLOCATE, disk.GetShortDesc(ctx), self.UserCred)
 	}
 	if err := guest.ConvertNetworks(targetGuest); err != nil {
-		self.taskFailed(ctx, guest, err.Error())
+		self.taskFailed(ctx, guest, jsonutils.NewString(err.Error()))
 		return
 	}
 	self.TaskComplete(ctx, guest, targetGuest)
@@ -182,7 +182,7 @@ func (self *GuestConvertEsxiToKvmTask) OnHostCreateGuest(
 func (self *GuestConvertEsxiToKvmTask) OnHostCreateGuestFailed(
 	ctx context.Context, guest *models.SGuest, data jsonutils.JSONObject,
 ) {
-	self.taskFailed(ctx, guest, data.String())
+	self.taskFailed(ctx, guest, data)
 }
 
 func (self *GuestConvertEsxiToKvmTask) TaskComplete(ctx context.Context, guest, targetGuest *models.SGuest) {