fix: unhandled errors (#25383)

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

cmd/climc/shell/cloudnet/meshnetworks.go

@@ -56,6 +56,9 @@ func init() {
 	})
 	R(&options.MeshNetworkUpdateOptions{}, "meshnetwork-update", "Update mesh network", func(s *mcclient.ClientSession, opts *options.MeshNetworkUpdateOptions) error {
 		params, err := base_options.StructToParams(opts)
+		if err != nil {
+			return err
+		}
 		mn, err := modules.MeshNetworks.Update(s, opts.ID, params)
 		if err != nil {
 			return err

cmd/climc/shell/cloudnet/routers.go

@@ -56,6 +56,9 @@ func init() {
 	})
 	R(&options.RouterUpdateOptions{}, "router-update", "Update router", func(s *mcclient.ClientSession, opts *options.RouterUpdateOptions) error {
 		params, err := base_options.StructToParams(opts)
+		if err != nil {
+			return err
+		}
 		router, err := modules.Routers.Update(s, opts.ID, params)
 		if err != nil {
 			return err

cmd/climc/shell/cloudnet/routes.go

@@ -56,6 +56,9 @@ func init() {
 	})
 	R(&options.RouteUpdateOptions{}, "router-route-update", "Update router route", func(s *mcclient.ClientSession, opts *options.RouteUpdateOptions) error {
 		params, err := base_options.StructToParams(opts)
+		if err != nil {
+			return err
+		}
 		router, err := modules.Routes.Update(s, opts.ID, params)
 		if err != nil {
 			return err

cmd/climc/shell/cloudnet/rules.go

@@ -56,6 +56,9 @@ func init() {
 	})
 	R(&options.RuleUpdateOptions{}, "router-rule-update", "Update router rule", func(s *mcclient.ClientSession, opts *options.RuleUpdateOptions) error {
 		params, err := base_options.StructToParams(opts)
+		if err != nil {
+			return err
+		}
 		router, err := modules.Rules.Update(s, opts.ID, params)
 		if err != nil {
 			return err

cmd/climc/shell/compute/cloudregions.go

@@ -235,6 +235,9 @@ func init() {
 	}
 	R(&CloudregionCapabiltyOptions{}, "cloud-region-capability", "Show region's capacibilities", func(s *mcclient.ClientSession, args *CloudregionCapabiltyOptions) error {
 		query, err := options.StructToParams(args)
+		if err != nil {
+			return err
+		}
 		result, err := modules.Cloudregions.GetSpecific(s, args.ID, "capability", query)
 		if err != nil {
 			return err

cmd/climc/shell/compute/loadbalanceragents.go

@@ -97,6 +97,9 @@ func init() {
 	})
 	R(&options.LoadbalancerAgentUpdateOptions{}, "lbagent-update", "Update lbagent", func(s *mcclient.ClientSession, opts *options.LoadbalancerAgentUpdateOptions) error {
 		params, err := opts.Params()
+		if err != nil {
+			return err
+		}
 		lbagent, err := modules.LoadbalancerAgents.Update(s, opts.ID, params)
 		if err != nil {
 			return err

cmd/climc/shell/compute/loadbalancerbackends.go

@@ -55,6 +55,9 @@ func init() {
 	})
 	R(&options.LoadbalancerBackendUpdateOptions{}, "lbbackend-update", "Update lbbackend", func(s *mcclient.ClientSession, opts *options.LoadbalancerBackendUpdateOptions) error {
 		params, err := opts.Params()
+		if err != nil {
+			return err
+		}
 		lbbackend, err := modules.LoadbalancerBackends.Update(s, opts.ID, params)
 		if err != nil {
 			return err

cmd/climc/shell/compute/loadbalancerlistenerrules.go

@@ -54,6 +54,9 @@ func init() {
 	})
 	R(&options.LoadbalancerListenerRuleUpdateOptions{}, "lblistenerrule-update", "Update lblistenerrule", func(s *mcclient.ClientSession, opts *options.LoadbalancerListenerRuleUpdateOptions) error {
 		params, err := opts.Params()
+		if err != nil {
+			return err
+		}
 		lblistenerrule, err := modules.LoadbalancerListenerRules.Update(s, opts.ID, params)
 		if err != nil {
 			return err

cmd/climc/shell/compute/loadbalancerlisteners.go

@@ -87,6 +87,9 @@ func init() {
 	})
 	R(&options.LoadbalancerListenerUpdateOptions{}, "lblistener-update", "Update lblistener", func(s *mcclient.ClientSession, opts *options.LoadbalancerListenerUpdateOptions) error {
 		params, err := opts.Params()
+		if err != nil {
+			return err
+		}
 		lblistener, err := modules.LoadbalancerListeners.Update(s, opts.ID, params)
 		if err != nil {
 			return err

cmd/climc/shell/compute/proxysettings.go

@@ -57,6 +57,9 @@ func init() {
 	})
 	R(&options.ProxySettingUpdateOptions{}, "proxysetting-update", "Update proxysetting", func(s *mcclient.ClientSession, opts *options.ProxySettingUpdateOptions) error {
 		params, err := options.StructToParams(opts)
+		if err != nil {
+			return err
+		}
 		proxysetting, err := modules.ProxySettings.Update(s, opts.ID, params)
 		if err != nil {
 			return err

cmd/climc/shell/compute/scaling_policy.go

@@ -49,6 +49,9 @@ func init() {
 	R(&ScalingPolicyListOptions{}, "scaling-policy-list", "List Scaling Policy", func(s *mcclient.ClientSession,
 		args *ScalingPolicyListOptions) error {
 		params, err := options.ListStructToParams(args)
+		if err != nil {
+			return err
+		}
 		policies, err := modules.ScalingPolicy.List(s, params)
 		if err != nil {
 			return err

cmd/climc/shell/devtool/devtoolcronjob.go

@@ -57,6 +57,9 @@ func init() {
 		}
 		var result *printutils.ListResult
 		result, err = modules.DevToolCronjobs.List(s, params)
+		if err != nil {
+			return err
+		}
 		printList(result, modules.DevToolCronjobs.GetColumns(s))
 		return nil
 	})

cmd/climc/shell/devtool/devtooltemplate.go

@@ -50,6 +50,9 @@ func init() {
 		}
 		var result *printutils.ListResult
 		result, err = modules.DevToolTemplates.List(s, params)
+		if err != nil {
+			return err
+		}
 		printList(result, modules.DevToolTemplates.GetColumns(s))
 		return nil
 	})

cmd/climc/shell/k8s/clusters.go

@@ -312,6 +312,9 @@ func initKubeCluster() {
 
 		// 2. edit yaml
 		yaml, err := shellutils.Edit(setting.YAMLString())
+		if err != nil {
+			return errors.Wrap(err, "edit component setting")
+		}
 		if len(yaml) == 0 {
 			if !args.Force {
 				log.Infof("Nothing to update")

cmd/climc/shell/k8s/container_registry.go

@@ -101,6 +101,9 @@ func initContainerRegistry() {
 				Username: args.Username,
 				Password: args.Password,
 			})
+			if err != nil {
+				return errors.Wrap(err, "download image by manager")
+			}
 		}
 		output := args.Output
 		if output == "" && fileName != "" {

cmd/climc/shell/scheduledtask/scheduledtask.go

@@ -45,6 +45,9 @@ func init() {
 	}
 	R(&ScheduledTaskListOptions{}, "scheduledtask-list", "list Scheduled Task", func(s *mcclient.ClientSession, args *ScheduledTaskListOptions) error {
 		params, err := options.ListStructToParams(args)
+		if err != nil {
+			return err
+		}
 		tasks, err := modules.ScheduledTask.List(s, params)
 		if err != nil {
 			return err

cmd/fetcherfs/fs.go

@@ -232,8 +232,11 @@ func (fs *FetcherFs) doFetchData(idx int64) error {
 	}
 
 	buf, err := ioutil.ReadAll(lz4Reader)
+	if err != nil {
+		return errors.Wrap(err, "read lz4 data")
+	}
 	if len(buf) != int(end-start+1) {
-		return errors.Wrap(err, "written local file")
+		return errors.Errorf("written local file: size mismatch got %d want %d", len(buf), int(end-start+1))
 	}
 
 	written, err := fs.localFile.WriteAt(buf, start)

pkg/apigateway/handler/auth.go

@@ -978,7 +978,7 @@ func getUserInfo2(s *mcclient.ClientSession, uid string, pid string, loginIp str
 		data.Add(jsonutils.NewString(projDomainName), "projectDomain")
 		data.Add(jsonutils.NewString(projDomainId), "projectDomainId")
 
-		pmeta, err := projInfo.Get("metadata")
+		pmeta, _ := projInfo.Get("metadata")
 		if pmeta != nil {
 			data.Add(pmeta, "project_meta")
 		}

pkg/apigateway/handler/auth_totp.go

@@ -317,8 +317,12 @@ func listTotpRecoveryQuestions(ctx context.Context, w http.ResponseWriter, req *
 	s := auth.GetAdminSession(ctx, FetchRegion(req))
 	// 做缓存？
 	ss, err := modules.Credentials.GetRecoverySecrets(s, t.GetUserId())
+	if err != nil {
+		log.Errorf("ListTotpRecoveryQuestions %s", err)
+		httperrors.GeneralServerError(ctx, w, err)
+		return
+	}
 	if len(ss) == 0 {
-		log.Errorf("ListTotpRecoveryQuestions %s", err.Error())
 		httperrors.NotFoundError(ctx, w, "no revocery questions.")
 		return
 	}

pkg/apigateway/handler/imageutils.go

@@ -258,9 +258,8 @@ func imageDownloadHandler(ctx context.Context, w http.ResponseWriter, r *http.Re
 func imageDownloadByUrlHandler(ctx context.Context, w http.ResponseWriter, r *http.Request) {
 	_, query, _ := appsrv.FetchEnv(ctx, w, r)
 	// input params
-	token, err := query.GetString("signature")
+	token, _ := query.GetString("signature")
 	if len(token) == 0 {
-		log.Debugf("get signature %s", err)
 		httperrors.MissingParameterError(ctx, w, "signature")
 		return
 	}

pkg/baremetal/pxe/dhcp.go

@@ -151,7 +151,11 @@ func (h *DHCPHandler) newRequest(pkt dhcp.Packet, man IBaremetalManager) (*dhcpR
 			default:
 				err = errors.Error("malformed client GUID (option 97), wrong size")
 			}
-			cliGuid, err = req.Options.String(optCode)
+			cliGuidStr, guidErr := req.Options.String(optCode)
+			if err == nil {
+				err = guidErr
+			}
+			cliGuid = cliGuidStr
 		}
 		if err != nil {
 			log.Errorf("[DHCP] parse vendor option %d error: %v", optCode, err)

pkg/baremetal/utils/raid/drivers/drivers.go

@@ -30,6 +30,7 @@ import (
 	_ "yunion.io/x/onecloud/pkg/baremetal/utils/raid/mvcli"
 	_ "yunion.io/x/onecloud/pkg/baremetal/utils/raid/sas2iru"
 	"yunion.io/x/onecloud/pkg/compute/baremetal"
+	"yunion.io/x/onecloud/pkg/httperrors"
 )
 
 func GetDriver(name string, term raid.IExecTerm) raid.IRaidDriver {
@@ -122,8 +123,11 @@ func buildRaid(driver raid.IRaidDriver, adapter raid.IRaidAdapter, confs []*api.
 
 	for _, conf := range confs {
 		selected, left, err = baremetal.RetrieveStorages(conf, left)
+		if err != nil {
+			return errors.Wrap(err, "baremetal.RetrieveStorages")
+		}
 		if len(selected) == 0 {
-			return errors.Wrapf(err, "no enough disks for config %#v", conf)
+			return errors.Wrapf(httperrors.ErrInputParameter, "no enough disks for config %#v", conf)
 		}
 		var err error
 		switch conf.Conf {

pkg/cloudcommon/cmdline/helper.go

@@ -476,6 +476,9 @@ func FetchDiskCreateInputByJSON(data jsonutils.JSONObject) (*compute.DiskCreateI
 	}
 	if data.Contains("disk") {
 		desc, err := data.GetString("disk")
+		if err != nil {
+			return nil, err
+		}
 		config, err = ParseDiskConfig(desc, -1)
 		if err != nil {
 			return nil, err

pkg/cloudcommon/db/modelbase.go

@@ -414,6 +414,9 @@ func (manager *SModelBaseManager) GetPropertyDistinctField(ctx context.Context,
 		im = manager
 	}
 	fn, err := query.GetArray("field")
+	if err != nil {
+		return nil, httperrors.NewInputParameterError("missing field")
+	}
 	efs, _ := query.GetArray("extra_field")
 	fields := make([]string, len(fn))
 

pkg/cloudcommon/db/quotas/handler.go

@@ -580,6 +580,9 @@ func (manager *SQuotaBaseManager) listQuotas(ctx context.Context, userCred mccli
 		keyList = append(keyList, quota.GetKeys())
 	}
 	idNameMap, err := manager.keyList2IdNameMap(ctx, keyList)
+	if err != nil {
+		return nil, errors.Wrap(err, "keyList2IdNameMap")
+	}
 	var fields []string
 	for i := range quotaList {
 		keys := quotaList[i].GetKeys()

pkg/cloudcommon/db/rolecache.go

@@ -172,6 +172,9 @@ func (manager *SRoleCacheManager) Save(ctx context.Context, idStr string, name s
 		}
 	} else {
 		objm, err := NewModelObject(manager)
+		if err != nil {
+			return nil, err
+		}
 		obj := objm.(*SRole)
 		obj.Id = idStr
 		obj.Name = name

pkg/cloudcommon/db/tenantcache.go

@@ -391,6 +391,9 @@ func (manager *STenantCacheManager) Save(ctx context.Context, item SCachedTenant
 		}
 	} else {
 		objm, err := NewModelObject(manager)
+		if err != nil {
+			return nil, err
+		}
 		obj := objm.(*STenant)
 		obj.Id = item.Id
 		obj.Name = item.Name

pkg/cloudcommon/db/usercache.go

@@ -177,6 +177,9 @@ func (manager *SUserCacheManager) Save(ctx context.Context, idStr string, name s
 		}
 	} else {
 		objm, err := NewModelObject(manager)
+		if err != nil {
+			return nil, err
+		}
 		obj := objm.(*SUser)
 		obj.Id = idStr
 		obj.Name = name

pkg/cloudmon/misc/usageservice.go

@@ -83,6 +83,9 @@ func UsegReport(ctx context.Context, userCred mcclient.TokenCredential, isStart
 		}
 		//查询host-type==""的情况，对应onecloud-控制面板-全部 要展示的内容
 		dataList, err = packMetricList(s, dataList, imageUsageFieldsDict, "host-type", "", nowTime)
+		if err != nil {
+			return err
+		}
 		//获取域/项目 虚拟机usage
 		data, err := getDomainAndProjectServerUsage(s, nowTime)
 		if err != nil {

pkg/cloudproxy/models/forwards.go

@@ -250,6 +250,9 @@ func (man *SForwardManager) PerformCreateFromServer(ctx context.Context, userCre
 	} else {
 		data, err = man.validatePortReq(ctx, typ, -1, agentId, epId, data)
 	}
+	if err != nil {
+		return nil, err
+	}
 
 	forwardObj, err := db.NewModelObject(man)
 	if err != nil {

pkg/compute/guestdrivers/cloudpods-esxi.go

@@ -319,8 +319,11 @@ func (self *SCloudpodsESXiGuestDriver) GetJsonDescAtHost(ctx context.Context, us
 			return nil, fmt.Errorf("unable to fetch disk %s", diskId)
 		}
 		storage, err := disk.GetStorage()
+		if err != nil {
+			return nil, errors.Wrap(err, "disk.GetStorage")
+		}
 		if storage == nil {
-			return nil, errors.Wrapf(err, "unable to fetch storage of disk %s", diskId)
+			return nil, errors.Wrapf(httperrors.ErrInvalidStatus, "unable to fetch storage of disk %s", diskId)
 		}
 		desc.Disks[i].StorageId = storage.GetExternalId()
 		desc.Disks[i].Preallocation = disk.Preallocation

pkg/compute/guestdrivers/esxi.go

@@ -341,8 +341,11 @@ func (self *SESXiGuestDriver) GetJsonDescAtHost(ctx context.Context, userCred mc
 			return nil, fmt.Errorf("unable to fetch disk %s", diskId)
 		}
 		storage, err := disk.GetStorage()
+		if err != nil {
+			return nil, errors.Wrap(err, "disk.GetStorage")
+		}
 		if storage == nil {
-			return nil, errors.Wrapf(err, "unable to fetch storage of disk %s", diskId)
+			return nil, errors.Wrapf(httperrors.ErrInvalidStatus, "unable to fetch storage of disk %s", diskId)
 		}
 		desc.Disks[i].StorageId = storage.GetExternalId()
 		desc.Disks[i].Preallocation = disk.Preallocation

pkg/compute/guestdrivers/kvm.go

@@ -210,9 +210,9 @@ func (self *SKVMGuestDriver) GetGuestVncInfo(ctx context.Context, userCred mccli
 	if err != nil {
 		return nil, errors.Wrapf(err, "Fail to request VNC info")
 	}
-	results, err := ret.GetString("results")
+	results, _ := ret.GetString("results")
 	if len(results) == 0 {
-		return nil, errors.Wrapf(err, "Can't get vnc information from host.")
+		return nil, errors.Wrapf(httperrors.ErrInvalidStatus, "Can't get vnc information from host.")
 	}
 	// info_vnc = result['results'].split('\n')
 	// port = int(info_vnc[1].split(':')[-1].split()[0])
@@ -268,7 +268,7 @@ func (self *SKVMGuestDriver) RequestStopOnHost(ctx context.Context, guest *model
 			timeout = int64(options.Options.LinuxGuestStopTimeout)
 		}
 	}
-	isForce, err := params.Bool("is_force")
+	isForce, _ := params.Bool("is_force")
 	if isForce {
 		body.Set("is_force", jsonutils.JSONTrue)
 	}

pkg/compute/misc/handler.go

@@ -57,7 +57,9 @@ func getBmAgentUrl(ctx context.Context, w http.ResponseWriter, r *http.Request)
 	log.Infof("getBmAgentUrl request ipaddr %s", ipAddr)
 	n, err := models.NetworkManager.GetOnPremiseNetworkOfIP(ipAddr, "", tristate.None)
 	if n == nil {
-		log.Errorf("failed get network of ip %s: %s", ipAddr, err)
+		if err != nil {
+			log.Errorf("failed get network of ip %s: %s", ipAddr, err)
+		}
 		httperrors.NotFoundError(ctx, w, "Network not found")
 		return
 	}

pkg/compute/models/cloudaccounts.go

@@ -2523,10 +2523,11 @@ func (account *SCloudaccount) SubmitSyncAccountTask(ctx context.Context, userCre
 		}()
 		log.Debugf("syncAccountStatus %s %s", account.Id, account.Name)
 		err := account.syncAccountStatus(ctx, userCred, true)
+		if err != nil {
+			log.Errorf("syncAccountStatus %s %s fail: %s", account.Id, account.Name, err)
+			err = errors.Wrap(err, "account.syncAccountStatus")
+		}
 		if waitChan != nil {
-			if err != nil {
-				err = errors.Wrap(err, "account.syncAccountStatus")
-			}
 			waitChan <- err
 		}
 	})

pkg/compute/models/cloudregions.go

@@ -910,6 +910,9 @@ func (manager *SCloudregionManager) ListItemFilter(
 	}
 
 	domainId, err := db.FetchQueryDomain(ctx, userCred, jsonutils.Marshal(query))
+	if err != nil {
+		return nil, err
+	}
 	if len(domainId) > 0 {
 		q = q.In("id", getCloudRegionIdByDomainId(domainId))
 	}

pkg/compute/models/elasticips.go

@@ -1118,7 +1118,7 @@ func (manager *SElasticipManager) ValidateCreateData(ctx context.Context, userCr
 
 func (eip *SElasticip) GetQuotaKeys() (quotas.IQuotaKeys, error) {
 	region, err := eip.GetRegion()
-	if region == nil {
+	if err != nil {
 		return nil, errors.Wrapf(err, "eip.GetRegion")
 	}
 	return fetchRegionalQuotaKeys(

pkg/compute/models/guest_actions.go

@@ -6078,6 +6078,9 @@ func (self *SGuest) PerformSnapshotAndClone(
 	input.ServerCreateSnapshotParams = params
 	// set guest pending usage
 	pendingUsage, pendingRegionUsage, err := self.getGuestUsage(count)
+	if err != nil {
+		return nil, errors.Wrap(err, "getGuestUsage")
+	}
 	keys, err := self.GetQuotaKeys()
 	if err != nil {
 		quotas.CancelPendingUsage(ctx, userCred, snapshotUsage, snapshotUsage, false)

pkg/compute/models/guest_convert.go

@@ -171,6 +171,9 @@ func (self *SGuest) StartConvertToKvmTask(
 func (self *SGuest) createConvertedServer(ctx context.Context, userCred mcclient.TokenCredential, data *api.ConvertToKvmInput) (*SGuest, *api.ServerCreateInput, error) {
 	// set guest pending usage
 	pendingUsage, pendingRegionUsage, err := self.getGuestUsage(1)
+	if err != nil {
+		return nil, nil, errors.Wrap(err, "getGuestUsage")
+	}
 	keys, err := self.GetQuotaKeys()
 	if err != nil {
 		return nil, nil, errors.Wrap(err, "GetQuotaKeys")

pkg/compute/models/guests.go

@@ -1695,6 +1695,9 @@ func parseInstanceSnapshot(ctx context.Context, input *api.ServerCreateInput) (*
 		return nil, httperrors.NewBadRequestError("Instance snapshot not ready")
 	}
 	input, err = isp.ToInstanceCreateInput(input)
+	if err != nil {
+		return nil, errors.Wrap(err, "ToInstanceCreateInput")
+	}
 	if len(input.Disks) == 0 {
 		return nil, httperrors.NewInputParameterError("there are no disks in this instance snapshot, try another one")
 	}
@@ -1714,6 +1717,9 @@ func parseInstanceBackup(ctx context.Context, input *api.ServerCreateInput) (*ap
 		return nil, httperrors.NewBadRequestError("Instance backup not ready")
 	}
 	input, err = isp.ToInstanceCreateInput(input)
+	if err != nil {
+		return nil, errors.Wrap(err, "ToInstanceCreateInput")
+	}
 	if len(input.Disks) == 0 {
 		return nil, httperrors.NewInputParameterError("there are no disks in this instance backup, try another one")
 	}
@@ -5263,6 +5269,9 @@ func (self *SGuest) createDiskOnHost(
 	}
 	if autoAttach {
 		err = self.attach2Disk(ctx, disk, userCred, diskConfig.Driver, diskConfig.Cache, diskConfig.Mountpoint, diskConfig.BootIndex)
+		if err != nil {
+			return nil, err
+		}
 	}
 	err = self.InheritTo(ctx, userCred, disk)
 	if err != nil {

pkg/compute/models/hosts.go

@@ -7690,7 +7690,10 @@ func (hh *SHost) GetDetailsJnlp(ctx context.Context, userCred mcclient.TokenCred
 
 func (hh *SHost) PerformInsertIso(ctx context.Context, userCred mcclient.TokenCredential, query jsonutils.JSONObject, data jsonutils.JSONObject) (jsonutils.JSONObject, error) {
 	if utils.IsInStringArray(hh.Status, []string{api.BAREMETAL_READY, api.BAREMETAL_RUNNING}) {
-		imageStr, err := data.GetString("image")
+		imageStr, _ := data.GetString("image")
+		if len(imageStr) == 0 {
+			return nil, httperrors.NewInputParameterError("missing image")
+		}
 		image, err := CachedimageManager.getImageInfo(ctx, userCred, imageStr, false)
 		if err != nil {
 			if err == sql.ErrNoRows {

pkg/compute/models/isolated_devices.go

@@ -656,8 +656,12 @@ func (manager *SIsolatedDeviceManager) attachHostDeviceToGuestByDesc(
 
 func (manager *SIsolatedDeviceManager) attachSpecificDeviceToGuest(ctx context.Context, guest *SGuest, devConfig *api.IsolatedDeviceConfig, userCred mcclient.TokenCredential) error {
 	devObj, err := manager.FetchById(devConfig.Id)
-	if devObj == nil {
-		return fmt.Errorf("Device %s not found: %s", devConfig.Id, err)
+	if err != nil {
+		if errors.Cause(err) == sql.ErrNoRows {
+			return httperrors.NewResourceNotFoundError2(manager.Keyword(), devConfig.Id)
+		} else {
+			return errors.Wrap(err, "SIsolatedDeviceManager.FetchById")
+		}
 	}
 	dev := devObj.(*SIsolatedDevice)
 	if len(devConfig.DevType) > 0 && devConfig.DevType != dev.DevType {

pkg/compute/models/scaling_group.go

@@ -112,6 +112,9 @@ func (sgm *SScalingGroupManager) ValidateCreateData(ctx context.Context, userCre
 	var err error
 	input.VirtualResourceCreateInput, err = sgm.SVirtualResourceBaseManager.ValidateCreateData(ctx, userCred,
 		ownerId, query, input.VirtualResourceCreateInput)
+	if err != nil {
+		return input, err
+	}
 	// check InstanceNumber
 	if input.MinInstanceNumber < 0 {
 		return input, httperrors.NewInputParameterError("min_instance_number should not be smaller than 0")
@@ -532,6 +535,9 @@ func (sg *SScalingGroup) Scale(ctx context.Context, triggerDesc IScalingTriggerD
 		err = scalingActivity.SetReject("",
 			fmt.Sprintf("The Cooling Time limit the execution time of the policy to at least: %s",
 				sg.AllowScaleTime.In(CoolingTimeLocation).Format("2006-01-02 15:04:05 -0700")))
+		if err != nil {
+			return errors.Wrap(err, "SetReject")
+		}
 		return nil
 	}
 

pkg/compute/models/snapshots.go

@@ -862,6 +862,9 @@ func (self *SSnapshotManager) GetConvertSnapshot(deleteSnapshot *SSnapshot) (*SS
 // +onecloud:swagger-gen-ignore
 func (self *SSnapshotManager) PerformDeleteDiskSnapshots(ctx context.Context, userCred mcclient.TokenCredential, query jsonutils.JSONObject, input api.SnapshotDeleteDiskSnapshotsInput) (jsonutils.JSONObject, error) {
 	disk, err := DiskManager.FetchById(input.DiskId)
+	if err != nil && errors.Cause(err) != sql.ErrNoRows {
+		return nil, err
+	}
 	if disk != nil {
 		return nil, httperrors.NewBadRequestError("Cannot delete disk %s snapshots, disk still exists", input.DiskId)
 	}

pkg/compute/models/storagecachedimages.go

@@ -361,6 +361,9 @@ func (manager *SStoragecachedimageManager) RecoverStoragecachedImage(
 		}
 		return nil
 	})
+	if err != nil {
+		return nil, err
+	}
 
 	db.OpsLog.LogEvent(&storagecachedImage, db.ACT_UPDATE, diff, userCred)
 	return &storagecachedImage, nil

pkg/compute/models/vpcs.go

@@ -1065,9 +1065,9 @@ func (svpc *SVpc) GetIVpc(ctx context.Context) (cloudprovider.ICloudVpc, error)
 	if provider.GetFactory().IsOnPremise() {
 		iregion, err = provider.GetOnPremiseIRegion()
 	} else {
-		region, err := svpc.GetRegion()
-		if err != nil {
-			return nil, err
+		region, rerr := svpc.GetRegion()
+		if rerr != nil {
+			return nil, rerr
 		}
 		iregion, err = provider.GetIRegionById(region.ExternalId)
 	}

pkg/compute/models/zones.go

@@ -803,6 +803,9 @@ func (manager *SZoneManager) ListItemFilter(
 
 	data := jsonutils.Marshal(query.DomainizedResourceListInput)
 	domainId, err := db.FetchQueryDomain(ctx, userCred, data)
+	if err != nil {
+		return nil, err
+	}
 	if len(domainId) > 0 {
 		q = q.In("cloudregion_id", getCloudRegionIdByDomainId(domainId))
 	}
@@ -869,6 +872,9 @@ func (manager *SZoneManager) ListItemFilter(
 	}
 
 	q, err = managedResourceFilterByRegion(ctx, q, query.RegionalFilterListInput, "", nil)
+	if err != nil {
+		return nil, err
+	}
 
 	if len(query.Location) > 0 {
 		q = q.In("location", query.Location)

pkg/compute/regiondrivers/managedvirtual.go

@@ -1650,6 +1650,9 @@ func (self *SManagedVirtualizationRegionDriver) RequestCreateElasticcache(ctx co
 		params.Tags, _ = ec.GetAllUserMetadata()
 
 		zone, err := ec.GetZone()
+		if err != nil {
+			return nil, errors.Wrapf(err, "GetZone")
+		}
 		if zone != nil {
 			izone, err := iRegion.GetIZoneById(zone.ExternalId)
 			if err != nil {

pkg/compute/regiondrivers/qcloud.go

@@ -500,6 +500,9 @@ func (self *SQcloudRegionDriver) RequestElasticcacheAccountResetPassword(ctx con
 		}
 
 		err = iec.UpdateAuthMode(noAuth, pwd)
+		if err != nil {
+			return errors.Wrap(err, "qcloudRegionDriver.RequestElasticcacheAccountResetPassword.UpdateAuthMode")
+		}
 	} else {
 		err = iea.UpdateAccount(input)
 		if err != nil {

pkg/compute/tasks/guest/guest_batch_create_task.go

@@ -169,6 +169,9 @@ func (task *GuestBatchCreateTask) allocateGuestOnHost(ctx context.Context, guest
 	}
 	quotaCpuMem.SetKeys(keys)
 	err = quotas.CancelPendingUsage(ctx, task.UserCred, &pendingUsage, &quotaCpuMem, true) // success
+	if err != nil {
+		log.Errorf("CancelPendingUsage fail %s", err)
+	}
 	task.SetPendingUsage(&pendingUsage, 0)
 
 	input, err := task.GetCreateInput(data)

pkg/compute/tasks/guest/guest_convert_cloudpods_to_kvm_task.go

@@ -256,6 +256,11 @@ func (task *GuestConvertCloudpodsToKvmTask) OnHostCreateGuest(
 			disk.Status = api.DISK_READY
 			return nil
 		})
+		if err != nil {
+			log.Errorf("update disk failed %s", err)
+			task.taskFailed(ctx, guest, jsonutils.NewString(err.Error()))
+			return
+		}
 		diskUrl, _ := data.GetString(disk.Id, "origin_disk_url")
 		err = disk.SetMetadata(ctx, api.DISK_META_REMOTE_ACCESS_PATH, diskUrl, task.UserCred)
 		if err != nil {

pkg/compute/tasks/guest/guest_convert_esxi_to_kvm_task.go

@@ -211,6 +211,11 @@ func (task *GuestConvertEsxiToKvmTask) OnHostCreateGuest(
 			disk.Status = api.DISK_READY
 			return nil
 		})
+		if err != nil {
+			log.Errorf("update disk failed %s", err)
+			task.taskFailed(ctx, guest, jsonutils.NewString(err.Error()))
+			return
+		}
 		// TODO: update flat file path on guest start
 		err = disk.SetMetadata(ctx, api.DISK_META_REMOTE_ACCESS_PATH, esxiFlatFilePath, task.UserCred)
 		if err != nil {

pkg/compute/tasks/guest/guest_sync_task.go

@@ -80,10 +80,10 @@ func (self *GuestSyncConfTask) StartRestartNetworkTask(ctx context.Context, gues
 		log.Errorf("unable to get prev_mac when restart_network is true when sync guest")
 		return
 	}
-	ipMask, err := self.Params.GetString("ip_mask")
-	gateway, err := self.Params.GetString("gateway")
-	ip6Mask, err := self.Params.GetString("ip6_mask")
-	gateway6, err := self.Params.GetString("gateway6")
+	ipMask, _ := self.Params.GetString("ip_mask")
+	gateway, _ := self.Params.GetString("gateway")
+	ip6Mask, _ := self.Params.GetString("ip6_mask")
+	gateway6, _ := self.Params.GetString("gateway6")
 	if ipMask == "" && ip6Mask == "" {
 		log.Errorf("unable to get ip_mask when restart_network is true when sync guest")
 		return

pkg/controller/autoscaling/controller.go

@@ -663,7 +663,7 @@ func (asc *SASController) actionAfterCreate(
 		}
 		// cancel delete project
 		_, e := modules.Servers.Update(session, ret.Id, updateParams)
-		if err != nil {
+		if e != nil {
 			sggs[0].SetGuestStatus(compute.SG_GUEST_STATUS_READY)
 			log.Errorf("cancel delete project of instance '%s' failed: %s", ret.Id, e.Error())
 			return

pkg/devtool/models/actions.go

@@ -117,6 +117,9 @@ func (obj *SDevtoolTemplate) Binding(ctx context.Context, userCred mcclient.Toke
 	template := obj
 	s := auth.GetSession(ctx, userCred, "")
 	ServerID, err := data.GetString("server_id")
+	if err != nil {
+		return nil, errors.Wrap(err, "get server_id")
+	}
 
 	attrs, err := getServerAttrs(ServerID, s)
 	if err != nil {
@@ -190,6 +193,9 @@ func (obj *SDevtoolTemplate) Unbinding(ctx context.Context, userCred mcclient.To
 	template := obj
 	s := auth.GetSession(ctx, userCred, "")
 	ServerID, err := data.GetString("server_id")
+	if err != nil {
+		return nil, errors.Wrap(err, "get server_id")
+	}
 
 	newPlaybookName := template.Name + "-" + template.Id[0:8] + "-" + ServerID[0:8]
 	if len(newPlaybookName) > 32 {

pkg/devtool/utils/ssh.go

@@ -281,6 +281,7 @@ func CheckSSHable(session *mcclient.ClientSession, serverId string) (sshable SSH
 		sshport, err = getServerSshport(session, serverDetail.Id, false)
 		if err != nil {
 			err = errors.Wrapf(err, "unable to get sshport of server %s", serverDetail.Id)
+			return
 		}
 		// create local forward
 		createP := jsonutils.NewDict()

pkg/hostman/diskutils/qemu_kvm/driver.go

@@ -628,7 +628,7 @@ func (d *QemuBaseDriver) CleanGuest() {
 	}
 
 	if d.hugepagePath != "" {
-		err, out := procutils.NewCommand("umount", d.hugepagePath).Output()
+		out, err := procutils.NewCommand("umount", d.hugepagePath).Output()
 		if err != nil {
 			log.Errorf("failed umount %s %s : %s", d.hugepagePath, err, out)
 		} else {

pkg/hostman/guestfs/guestfishpart/guestfishpart.go

@@ -163,11 +163,12 @@ func (d *SGuestfishDiskPartition) Umount() error {
 
 	var tries = 0
 	var err error
+	var output []byte
 	for tries < 10 {
 		tries += 1
-		output, err := procutils.NewCommand("umount", d.GetMountPath()).Output()
+		output, err = procutils.NewCommand("umount", d.GetMountPath()).Output()
 		if err != nil {
-			err = errors.Wrapf(err, "failed umount %s: %s %s", d.GetMountPath(), output, err)
+			err = errors.Wrapf(err, "failed umount %s: %s", d.GetMountPath(), output)
 			time.Sleep(time.Second * 1)
 		} else {
 			d.mounted = false

pkg/hostman/guestman/guest_create_from_remote.go

@@ -132,7 +132,7 @@ func (m *SGuestManager) GuestCreateFromCloudpods(
 		storageId := disksDesc[i].StorageId
 		storage := storageman.GetManager().GetStorage(storageId)
 		if storage == nil {
-			err = errors.Wrapf(err, "get storage %s", storageId)
+			err = errors.Errorf("get storage %s", storageId)
 			break
 		}
 		//var diskInfo jsonutils.JSONObject

pkg/hostman/guestman/pci.go

@@ -641,6 +641,9 @@ func (s *SKVMGuestInstance) ensurePciAddresses() error {
 	}
 	if s.Desc.VirtioSerial != nil {
 		err = s.ensureDevicePciAddress(s.Desc.VirtioSerial.PCIDevice, -1, nil)
+		if err != nil {
+			return errors.Wrap(err, "ensure virtio serial pci address")
+		}
 	}
 
 	if s.Desc.VdiDevice != nil && s.Desc.VdiDevice.Spice != nil {

pkg/hostman/guestman/qemu-kvm.go

@@ -2041,9 +2041,10 @@ func (s *SKVMGuestInstance) DeployFs(ctx context.Context, userCred mcclient.Toke
 		disk, e := storageman.GetManager().GetDiskByPath(diskPath)
 		if e != nil {
 			log.Errorf("failed get disk bypath %s %s", diskPath, e)
+			continue
 		}
 		if utils.IsInStringArray(disk.GetType(), []string{api.STORAGE_SLVM, api.STORAGE_CLVM}) {
-			if errDeactive := lvmutils.LVDeactivate(diskPath); err != nil {
+			if errDeactive := lvmutils.LVDeactivate(diskPath); errDeactive != nil {
 				log.Errorf("failed deactive disk %s: %s", diskPath, errDeactive)
 			}
 		}

pkg/hostman/monitor/qga/qga.go

@@ -410,6 +410,9 @@ func (qga *QemuGuestAgent) QgaGuestGetFsInfo() ([]GuestFsInfo, error) {
 		Execute: "guest-get-fsinfo",
 	}
 	rawResFsInfo, err := qga.execCmd(cmdFsInfo, true, -1)
+	if err != nil {
+		return nil, errors.Wrap(err, "exec guest-get-fsinfo")
+	}
 	resFsInfo := make([]GuestFsInfo, 0)
 	err = json.Unmarshal(*rawResFsInfo, &resFsInfo)
 	if err != nil {

pkg/hostman/storageman/disk_lvm.go

@@ -187,6 +187,9 @@ func (d *SLVMDisk) PostCreateFromRemoteHostImage(diskUrl string, snapshotId stri
 func (d *SLVMDisk) CreateFromRemoteHostImage(ctx context.Context, url string, size int64, encryptInfo *apis.SEncryptInfo) error {
 	log.Infof("Create from remote host image %s", url)
 	nbdPort, err := d.RequestExportNbdImage(ctx, url, encryptInfo)
+	if err != nil {
+		return errors.Wrap(err, "RequestExportNbdImage")
+	}
 	remoteHostIp := netutils2.ParseIpFromUrl(url)
 	remoteHostAndPort := net.JoinHostPort(remoteHostIp, strconv.Itoa(int(nbdPort)))
 	nbdImagePath := fmt.Sprintf("nbd://%s/%s", remoteHostAndPort, d.GetId())

pkg/hostman/storageman/storage_local.go

@@ -987,9 +987,9 @@ func (s *SLocalStorage) CloneDiskFromStorage(ctx context.Context, srcStorage ISt
 	if fullCopy {
 		_, err = srcImg.Clone(s.GetCloneTargetDiskPath(ctx, targetDiskId), qemuimgfmt.QCOW2, false)
 	} else {
-		newImg, err := qemuimg.NewQemuImage(accessPath)
-		if err != nil {
-			return nil, errors.Wrap(err, "failed new qemu image")
+		newImg, nerr := qemuimg.NewQemuImage(accessPath)
+		if nerr != nil {
+			return nil, errors.Wrap(nerr, "failed new qemu image")
 		}
 
 		err = newImg.CreateQcow2(srcImg.GetSizeMB(), false, "", encInfo.Key, qemuimg.EncryptFormatLuks, encInfo.Alg)

pkg/hostman/storageman/storage_lvm.go

@@ -604,9 +604,9 @@ func (s *SLVMStorage) CloneDiskFromStorage(ctx context.Context, srcStorage IStor
 	if fullCopy {
 		_, err = srcImg.Clone(accessPath, qemuimgfmt.QCOW2, false)
 	} else {
-		newImg, err := qemuimg.NewQemuImage(accessPath)
-		if err != nil {
-			return nil, errors.Wrap(err, "failed new qemu image")
+		newImg, nerr := qemuimg.NewQemuImage(accessPath)
+		if nerr != nil {
+			return nil, errors.Wrap(nerr, "failed new qemu image")
 		}
 
 		err = newImg.CreateQcow2(srcImg.GetSizeMB(), false, "", encInfo.Key, qemuimg.EncryptFormatLuks, encInfo.Alg)

pkg/keystone/models/roles.go

@@ -597,6 +597,9 @@ func (role *SRole) PerformSetPolicies(ctx context.Context, userCred mcclient.Tok
 	addedIds, updatedIds, deletedIds := stringutils2.Split(normalInputIds, existRpIds)
 
 	isBootStrap, err := RolePolicyManager.isBootstrapRolePolicy()
+	if err != nil {
+		return nil, errors.Wrap(err, "isBootstrapRolePolicy")
+	}
 	if !isBootStrap {
 		// validate
 		var newPolicyIds []string
@@ -702,6 +705,9 @@ func (role *SRole) PerformAddPolicy(ctx context.Context, userCred mcclient.Token
 	}
 
 	isBootStrap, err := RolePolicyManager.isBootstrapRolePolicy()
+	if err != nil {
+		return nil, errors.Wrap(err, "isBootstrapRolePolicy")
+	}
 	if !isBootStrap {
 		// validate
 		rps, err := RolePolicyManager.fetchByRoleId(role.Id)

pkg/keystone/tokens/token.go

@@ -306,6 +306,9 @@ func (t *SAuthToken) GetSimpleUserCred(token string) (mcclient.TokenCredential,
 		ret.ProjectDomainId = proj.DomainId
 		ret.ProjectDomain = proj.GetDomain().Name
 		roles, err = models.AssignmentManager.FetchUserProjectRoles(t.UserId, t.ProjectId)
+		if err != nil {
+			return nil, errors.Wrap(err, "AssignmentManager.FetchUserProjectRoles")
+		}
 	} else if len(t.DomainId) > 0 {
 		domain, err := models.DomainManager.FetchDomainById(t.DomainId)
 		if err != nil {
@@ -314,6 +317,9 @@ func (t *SAuthToken) GetSimpleUserCred(token string) (mcclient.TokenCredential,
 		ret.ProjectDomainId = t.DomainId
 		ret.ProjectDomain = domain.Name
 		roles, err = models.AssignmentManager.FetchUserProjectRoles(t.UserId, t.DomainId)
+		if err != nil {
+			return nil, errors.Wrap(err, "AssignmentManager.FetchUserProjectRoles")
+		}
 	}
 	roleStrs := make([]string, len(roles))
 	roleIdStrs := make([]string, len(roles))

pkg/llm/drivers/llm_client/ollama.go

@@ -267,6 +267,9 @@ func (o *ollama) Chat(ctx context.Context, mcpAgent *models.SMCPAgent, messages
 	}
 
 	httpReq, client, err := initRequestClient(ctx, mcpAgent.LLMUrl, mcpAgent.Model, false, ollamaMessages, ollamaTools)
+	if err != nil {
+		return nil, err
+	}
 
 	// 调用底层方法
 	return o.doChatRequest(ctx, httpReq, client)
@@ -585,6 +588,9 @@ func (o *ollama) ChatStream(ctx context.Context, mcpAgent *models.SMCPAgent, mes
 	}
 
 	httpReq, client, err := initRequestClient(ctx, mcpAgent.LLMUrl, mcpAgent.Model, true, ollamaMessages, ollamaTools)
+	if err != nil {
+		return err
+	}
 
 	return o.doChatStreamRequest(ctx, httpReq, client, onChunk)
 }

pkg/mcclient/modules/scheduler/mod_scheduler.go

@@ -165,7 +165,13 @@ func (this *SchedulerManager) CandidateList(s *mcclient.ClientSession, params js
 			return
 		}
 		free, err := resObj.Int("free")
+		if err != nil {
+			return
+		}
 		reserverd, err := resObj.Int("reserverd")
+		if err != nil {
+			return
+		}
 		total, err := resObj.Int("total")
 		if err != nil {
 			return

pkg/monitor/alerting/conditions/metricquery.go

@@ -212,7 +212,7 @@ func (query *MetricQueryCondition) ExecuteQuery(userCred mcclient.TokenCredentia
 
 		s := auth.GetSession(ctx, userCred, "")
 		ress, regionErr = firstCond.getOnecloudResources(s, scope, false)
-		if err != nil {
+		if regionErr != nil {
 			regionErr = errors.Wrap(regionErr, "get resources from region")
 			return
 		}

pkg/monitor/dbinit/measurements/metrics.csv

@@ -247,23 +247,23 @@ Measurement,MeasurementNote,ResourceType,Database,Metric,MetricNote,MetricUnit
 "vasmi","Vasmi GPU metrics","host","telegraf","eclk","eclk, MHz",""
 "vasmi","Vasmi GPU metrics","host","telegraf","gclk","gclk, MHz",""
 "vasmi","Vasmi GPU metrics","host","telegraf","aic_power","AIC power",""
-"npu_smi","Ascend NPU metrics","host","telegraf","temperature","NPU temperature",""
-"npu_smi","Ascend NPU metrics","host","telegraf","npu_real_time_power","NPU real time power",""
-"npu_smi","Ascend NPU metrics","host","telegraf","npu_utilization","NPU utilization","%"
-"npu_smi","Ascend NPU metrics","host","telegraf","hbm_usage_rate","NPU hbm usage rate","%"
-"npu_smi","Ascend NPU metrics","host","telegraf","hbm_capacity","NPU hbm capacity",""
-"npu_smi","Ascend NPU metrics","host","telegraf","aicore_usage_rate","NPU aicore usage rate","%s"
-"npu_smi","Ascend NPU metrics","host","telegraf","aivector_usage_rate","NPU aivector usage rate","%s"
-"npu_smi","Ascend NPU metrics","host","telegraf","aicube_usage_rate","NPU aicube usage rate","%s"
-"npu_smi","Ascend NPU metrics","host","telegraf","aicpu_usage_rate","NPU aicpu usage rate","%s"
-"npu_smi","Ascend NPU metrics","host","telegraf","hbm_bandwidth_usage_rate","NPU hbm bandwidth usage rate","%s"
-"hysmi","Hygon HCU metrics","host","telegraf","temperature_gpu","HCU temperature",""
-"hysmi","Hygon HCU metrics","host","telegraf","power_draw","HCU power draw",""
-"hysmi","Hygon HCU metrics","host","telegraf","power_cap","HCU power cap",""
-"hysmi","Hygon HCU metrics","host","telegraf","utilization_gpu","HCU utilization","%"
-"hysmi","Hygon HCU metrics","host","telegraf","utilization_memory","HCU memory utilization","%"
-"hysmi","Hygon HCU metrics","host","telegraf","utilization_encoder","HCU encoder utilization","%"
-"hysmi","Hygon HCU metrics","host","telegraf","utilization_decoder","HCU decoder utilization","%"
+"npu_smi","NPU metrics","host","telegraf","temperature","NPU temperature",""
+"npu_smi","NPU metrics","host","telegraf","npu_real_time_power","NPU real time power",""
+"npu_smi","NPU metrics","host","telegraf","npu_utilization","NPU utilization","%"
+"npu_smi","NPU metrics","host","telegraf","hbm_usage_rate","NPU hbm usage rate","%"
+"npu_smi","NPU metrics","host","telegraf","hbm_capacity","NPU hbm capacity",""
+"npu_smi","NPU metrics","host","telegraf","aicore_usage_rate","NPU aicore usage rate","%"
+"npu_smi","NPU metrics","host","telegraf","aivector_usage_rate","NPU aivector usage rate","%"
+"npu_smi","NPU metrics","host","telegraf","aicube_usage_rate","NPU aicube usage rate","%"
+"npu_smi","NPU metrics","host","telegraf","aicpu_usage_rate","NPU aicpu usage rate","%"
+"npu_smi","NPU metrics","host","telegraf","hbm_bandwidth_usage_rate","NPU hbm bandwidth usage rate",""
+"hysmi","Hygon DCU metrics","host","telegraf","temperature_gpu","DCU temperature",""
+"hysmi","Hygon DCU metrics","host","telegraf","power_draw","DCU power draw",""
+"hysmi","Hygon DCU metrics","host","telegraf","power_cap","DCU power cap",""
+"hysmi","Hygon DCU metrics","host","telegraf","utilization_gpu","DCU utilization","%"
+"hysmi","Hygon DCU metrics","host","telegraf","utilization_memory","DCU memory utilization","%"
+"hysmi","Hygon DCU metrics","host","telegraf","utilization_encoder","DCU encoder utilization","%"
+"hysmi","Hygon DCU metrics","host","telegraf","utilization_decoder","DCU decoder utilization","%"
 "worker","Worker queue","system","system","active_worker_cnt","Active Worker Count","NULL"
 "worker","Worker queue","system","system","max_worker_count","Max Worker Count","NULL"
 "worker","Worker queue","system","system","detach_worker_cnt","Detach worker Count","NULL"

pkg/monitor/models/alertpannel.go

@@ -174,9 +174,9 @@ func (panel *SAlertPanel) CustomizeCreate(
 	query jsonutils.JSONObject,
 	data jsonutils.JSONObject,
 ) error {
-	dashboardId, err := data.GetString("dashboard_id")
+	dashboardId, _ := data.GetString("dashboard_id")
 	if len(dashboardId) == 0 {
-		return errors.Wrap(err, "panel CustomizeCreate can not get dashboard_id")
+		return errors.Wrap(httperrors.ErrInputParameter, "panel CustomizeCreate can not get dashboard_id")
 	}
 	dash, _ := AlertDashBoardManager.getDashboardByid(dashboardId)
 	panel.ProjectId = dash.ProjectId

pkg/monitor/models/alertresource.go

@@ -334,6 +334,9 @@ func (res *SAlertResource) attachAlert(ctx context.Context, record *SAlertRecord
 	// create resource joint alert record into db
 	jm := GetAlertResourceAlertManager()
 	jObj, err := db.NewModelObject(jm)
+	if err != nil {
+		return errors.Wrap(err, "NewModelObject")
+	}
 	input := &monitor.AlertResourceAttachInput{
 		AlertResourceId: res.GetId(),
 		AlertId:         record.AlertId,

pkg/monitor/models/datasource.go

@@ -273,6 +273,9 @@ func (m *SDataSourceManager) getMetricDescriptions(influxdbMeasurements []monito
 		log.Errorln(errors.Wrap(err, "DataSourceManager getMetricDescriptions error"))
 	}
 	descriMeasurements, err := MetricMeasurementManager.getMeasurement(query)
+	if err != nil {
+		log.Errorln(errors.Wrap(err, "DataSourceManager getMeasurement error"))
+	}
 	if len(descriMeasurements) != 0 {
 
 		measurementsIns := make([]interface{}, len(descriMeasurements))
@@ -281,9 +284,6 @@ func (m *SDataSourceManager) getMetricDescriptions(influxdbMeasurements []monito
 		}
 		details := MetricMeasurementManager.FetchCustomizeColumns(context.Background(), userCred, jsonutils.NewDict(), measurementsIns,
 			stringutils2.NewSortedStrings([]string{}), true)
-		if err != nil {
-			log.Errorln(errors.Wrap(err, "DataSourceManager getMetricDescriptions error"))
-		}
 		for i, measureDes := range descriMeasurements {
 			for j, _ := range influxdbMeasurements {
 				if measureDes.Name == influxdbMeasurements[j].Measurement {

pkg/monitor/models/recordshield.go

@@ -194,6 +194,9 @@ func (shield *SAlertRecordShield) GetMoreDetails(ctx context.Context, out monito
 	// Alert May delete By someone
 	out.AlertName = commonAlert.Name
 	alertDetails, err := commonAlert.GetMoreDetails(ctx, monitor.CommonAlertDetails{})
+	if err != nil {
+		return out, errors.Wrap(err, "GetMoreDetails")
+	}
 	out.CommonAlertDetails = alertDetails
 
 	resources, err := MonitorResourceManager.GetMonitorResources(monitor.MonitorResourceListInput{ResId: []string{shield.ResId}})

pkg/scheduler/api/candidate.go

@@ -42,7 +42,13 @@ type ResultResource struct {
 
 func NewResultResourceString(free, reserverd, total string) (*ResultResource, error) {
 	f, err := strconv.ParseFloat(free, 64)
+	if err != nil {
+		return nil, err
+	}
 	r, err := strconv.ParseFloat(reserverd, 64)
+	if err != nil {
+		return nil, err
+	}
 	t, err := strconv.ParseFloat(total, 64)
 	if err != nil {
 		return nil, err

pkg/util/fileutils2/fileutils.go

@@ -315,10 +315,15 @@ func CleanFailedMountpoints() {
 	f, err := os.Open(mtfile)
 	if err != nil {
 		log.Errorf("CleanFailedMountpoints error: %s", err)
+		return
 	}
+	defer f.Close()
 	reader := bufio.NewReader(f)
-	line, _, err := reader.ReadLine()
-	for err != nil {
+	for {
+		line, _, err := reader.ReadLine()
+		if err != nil {
+			break
+		}
 		m := strings.Split(string(line), " ")
 		if len(m) > 1 {
 			mp := m[1]

pkg/util/nodeid/nodeid.go

@@ -107,6 +107,9 @@ func getLinuxCpuInfo() (string, error) {
 	}
 
 	lines, e := stringToLines(string(u))
+	if e != nil {
+		return "", e
+	}
 	filted := []string{}
 	for _, line := range lines {
 		l := strings.TrimSpace(line)

pkg/util/pod/logs/logs.go

@@ -384,9 +384,13 @@ func isContainerRunning(ctx context.Context, id string, r runtimeapi.RuntimeServ
 // the error is error happens during waiting new logs.
 func waitLogs(ctx context.Context, id string, w *fsnotify.Watcher, runtimeService runtimeapi.RuntimeServiceClient) (bool, bool, error) {
 	// no need to wait if the pod is not running
-	if running, err := isContainerRunning(ctx, id, runtimeService); !running {
+	running, err := isContainerRunning(ctx, id, runtimeService)
+	if err != nil {
 		return false, false, err
 	}
+	if !running {
+		return false, false, nil
+	}
 	errRetry := 5
 	for {
 		select {

pkg/util/redfish/redfish.go

@@ -310,6 +310,9 @@ func (r *SBaseRedfishClient) GetVirtualCdromJSON(ctx context.Context) (string, j
 	}
 	resp = r.IRedfishDriver().GetParent(resp)
 	vmList, err := resp.GetArray(r.IRedfishDriver().MemberKey())
+	if err != nil {
+		return "", nil, errors.Wrap(err, "GetArray VirtualMedia")
+	}
 	for i := len(vmList) - 1; i >= 0; i -= 1 {
 		path, _ := vmList[i].GetString(r.IRedfishDriver().LinkKey())
 		if len(path) == 0 {
@@ -719,9 +722,9 @@ func (r *SBaseRedfishClient) GetPower(ctx context.Context) ([]SPower, error) {
 		resp, err = r.Get(ctx, path)
 	} else {
 		_, resp, err = r.GetResource(ctx, "Chassis", "0", "Power")
-		if err != nil {
-			return nil, errors.Wrap(err, "GetResource")
-		}
+	}
+	if err != nil {
+		return nil, errors.Wrap(err, "GetPower")
 	}
 	powers := make([]SPower, 0)
 	err = resp.Unmarshal(&powers, "PowerControl")
@@ -739,9 +742,9 @@ func (r *SBaseRedfishClient) GetThermal(ctx context.Context) ([]STemperature, er
 		resp, err = r.Get(ctx, path)
 	} else {
 		_, resp, err = r.GetResource(ctx, "Chassis", "0", "Thermal")
-		if err != nil {
-			return nil, errors.Wrap(err, "GetResource")
-		}
+	}
+	if err != nil {
+		return nil, errors.Wrap(err, "GetThermal")
 	}
 	temps := make([]STemperature, 0)
 	err = resp.Unmarshal(&temps, "Temperatures")

pkg/util/samlutils/demo/service.go

@@ -75,6 +75,9 @@ func prepareServer() error {
 	}
 
 	err = parser.ParseArgs(os.Args[1:], false)
+	if err != nil {
+		return errors.Wrap(err, "ParseArgs")
+	}
 	options := parser.Options().(*Options)
 
 	if options.Help {

pkg/webconsole/server/sftp_server.go

@@ -30,6 +30,7 @@ import (
 
 	"yunion.io/x/cloudmux/pkg/cloudprovider"
 	"yunion.io/x/jsonutils"
+	"yunion.io/x/log"
 	"yunion.io/x/pkg/errors"
 
 	"yunion.io/x/onecloud/pkg/appsrv"
@@ -157,7 +158,7 @@ func HandleSftpList(ctx context.Context, w http.ResponseWriter, r *http.Request)
 						vv.LinkFile.IsRegular = stat.Mode().IsRegular()
 					}
 				} else {
-					err = httperrors.FsErrorNormalize(err)
+					log.Errorf("ReadLink %s: %v", vv.Path, httperrors.FsErrorNormalize(err))
 				}
 			}
 			ret = append(ret, vv)