<fix>[conf]: update global-error

.gitignore

@@ -34,3 +34,6 @@ envDSLTree
 test/zstack-integration-test-result/
 premium/test-premium/zstack-api.log
 **/bin/
+CLAUDE.md
+.claude/*
+.m2/

VERSION

@@ -1,3 +1,3 @@
 MAJOR=5
 MINOR=5
-UPDATE=6
+UPDATE=16

compute/src/main/java/org/zstack/compute/allocator/DesignatedHostAllocatorFlow.java

@@ -1,6 +1,7 @@
 package org.zstack.compute.allocator;
 
 import org.apache.commons.collections.CollectionUtils;
+import org.apache.commons.lang.StringUtils;
 import org.springframework.beans.factory.annotation.Autowire;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Configurable;
@@ -81,30 +82,44 @@ public void allocate() {
         List<String> clusterUuids = (List<String>) spec.getExtraData().get(HostAllocatorConstant.LocationSelector.cluster);
         String hostUuid = (String) spec.getExtraData().get(HostAllocatorConstant.LocationSelector.host);
 
-        if (zoneUuid == null && CollectionUtils.isEmpty(clusterUuids) && hostUuid == null && spec.getHypervisorType() == null) {
+        String hypervisorType = spec.getHypervisorType();
+
+        // normalize empty strings to null — treat empty string as "not specified"
+        zoneUuid = StringUtils.isEmpty(zoneUuid) ? null : zoneUuid;
+        hostUuid = StringUtils.isEmpty(hostUuid) ? null : hostUuid;
+        hypervisorType = StringUtils.isEmpty(hypervisorType) ? null : hypervisorType;
+        if (!CollectionUtils.isEmpty(clusterUuids)) {
+            clusterUuids = new ArrayList<>(clusterUuids);
+            clusterUuids.removeIf(s -> s == null || s.isEmpty());
+            if (clusterUuids.isEmpty()) {
+                clusterUuids = null;
+            }
+        }
+
+        if (zoneUuid == null && CollectionUtils.isEmpty(clusterUuids) && hostUuid == null && hypervisorType == null) {
             next(candidates);
             return;
         }
 
         if (amITheFirstFlow()) {
-            candidates = allocate(zoneUuid, clusterUuids, hostUuid, spec.getHypervisorType());
+            candidates = allocate(zoneUuid, clusterUuids, hostUuid, hypervisorType);
         } else {
-            candidates = allocate(candidates, zoneUuid, clusterUuids, hostUuid, spec.getHypervisorType());
+            candidates = allocate(candidates, zoneUuid, clusterUuids, hostUuid, hypervisorType);
         }
 
         if (candidates.isEmpty()) {
             StringBuilder args = new StringBuilder();
             if (zoneUuid != null) {
                 args.append(String.format("zoneUuid=%s", zoneUuid)).append(" ");
             }
-            if (!clusterUuids.isEmpty()) {
+            if (!CollectionUtils.isEmpty(clusterUuids)) {
                 args.append(String.format("clusterUuid in %s", clusterUuids)).append(" ");
             }
             if (hostUuid != null) {
                 args.append(String.format("hostUuid=%s", hostUuid)).append(" ");
             }
-            if (spec.getHypervisorType() != null) {
-                args.append(String.format("hypervisorType=%s", spec.getHypervisorType())).append(" ");
+            if (hypervisorType != null) {
+                args.append(String.format("hypervisorType=%s", hypervisorType)).append(" ");
             }
             fail(Platform.operr(ORG_ZSTACK_COMPUTE_ALLOCATOR_10036, "No host with %s found", args));
         } else {

compute/src/main/java/org/zstack/compute/allocator/QuotaAllocatorFlow.java

@@ -4,6 +4,8 @@
 import org.springframework.beans.factory.annotation.Configurable;
 import org.zstack.compute.vm.VmQuotaOperator;
 import org.zstack.header.allocator.AbstractHostAllocatorFlow;
+import org.zstack.header.errorcode.ErrorCode;
+import org.zstack.header.errorcode.OperationFailureException;
 import org.zstack.header.identity.AccountConstant;
 import org.zstack.identity.Account;
 import org.zstack.identity.QuotaUtil;
@@ -51,6 +53,12 @@ public void allocate() {
         }
 
         throwExceptionIfIAmTheFirstFlow();
+        // skip checkquota if the operator is admin
+        String currentAccountUuid = spec.getAccountUuid();
+        if (currentAccountUuid != null && AccountConstant.isAdminPermission(currentAccountUuid)) {
+            next(candidates);
+            return;
+        }
 
         final String vmInstanceUuid = spec.getVmInstance().getUuid();
         final String accountUuid = Account.getAccountUuidOfResource(vmInstanceUuid);
@@ -60,21 +68,27 @@ public void allocate() {
         }
 
         if (!spec.isFullAllocate()) {
-            new VmQuotaOperator().checkVmCupAndMemoryCapacity(accountUuid,
+            ErrorCode error = new VmQuotaOperator().checkVmCupAndMemoryCapacityWithResult(accountUuid,
                     accountUuid,
                     spec.getCpuCapacity(),
                     spec.getMemoryCapacity(),
                     new QuotaUtil().makeQuotaPairs(accountUuid));
+            if (error != null) {
+                throw new OperationFailureException(error);
+            }
 
             next(candidates);
             return;
         }
 
-        new VmQuotaOperator().checkVmInstanceQuota(
+        ErrorCode error = new VmQuotaOperator().checkVmInstanceQuotaWithResult(
                 accountUuid,
                 accountUuid,
                 vmInstanceUuid,
                 new QuotaUtil().makeQuotaPairs(accountUuid));
+        if (error != null) {
+            throw new OperationFailureException(error);
+        }
         next(candidates);
     }
 }

compute/src/main/java/org/zstack/compute/host/HostManagerImpl.java

@@ -102,6 +102,8 @@ public class HostManagerImpl extends AbstractService implements HostManager, Man
     private Future reportHostCapacityTask;
     private Future refreshHostPowerStatusTask;
 
+    private static final List<String> SKIP_ARCH_CHECK_HYPERVISOR_TYPES = Arrays.asList("baremetal2", "baremetal2Dpu");
+
     static {
         allowedMessageAfterSoftDeletion.add(HostDeletionMsg.class);
     }
@@ -472,7 +474,7 @@ public void run(MessageReply reply) {
             @Override
             public boolean skip(Map data) {
                 // no need to check baremetal2 gateway architecture with the cluster architecture
-                return vo.getHypervisorType().equals("baremetal2");
+                return SKIP_ARCH_CHECK_HYPERVISOR_TYPES.contains(cluster.getHypervisorType());
             }
 
             @Override

compute/src/main/java/org/zstack/compute/vm/MigrateVmLongJob.java

@@ -1,27 +1,34 @@
 package org.zstack.compute.vm;
 
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
 import org.apache.logging.log4j.ThreadContext;
 import org.springframework.beans.factory.annotation.Autowire;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Configurable;
-import org.zstack.core.Platform;
 import org.zstack.core.cloudbus.CloudBus;
 import org.zstack.core.cloudbus.CloudBusCallBack;
 import org.zstack.core.db.DatabaseFacade;
+import org.zstack.core.db.Q;
+import org.zstack.core.thread.ThreadFacade;
 import org.zstack.header.Constants;
 import org.zstack.header.core.Completion;
 import org.zstack.header.core.ReturnValueCompletion;
-import org.zstack.header.longjob.LongJobErrors;
-import org.zstack.header.longjob.LongJobFor;
-import org.zstack.header.longjob.LongJobVO;
+import org.zstack.header.errorcode.ErrorCode;
+import org.zstack.header.longjob.*;
 import org.zstack.header.message.APIEvent;
 import org.zstack.header.message.MessageReply;
 import org.zstack.header.vm.*;
-import org.zstack.header.longjob.LongJob;
-import org.zstack.longjob.LongJobUtils;
+import org.zstack.header.volume.GetVolumeTaskMsg;
+import org.zstack.header.volume.GetVolumeTaskReply;
+import org.zstack.header.volume.VolumeConstant;
+import org.zstack.header.volume.VolumeVO;
+import org.zstack.header.volume.VolumeVO_;
 import org.zstack.utils.gson.JSONObjectUtil;
 
-import static org.zstack.core.Platform.err;
+import java.util.*;
+import java.util.concurrent.TimeUnit;
+
 import static org.zstack.core.Platform.operr;
 
 
@@ -31,16 +38,152 @@
 @LongJobFor(APIMigrateVmMsg.class)
 @Configurable(preConstruction = true, autowire = Autowire.BY_TYPE)
 public class MigrateVmLongJob implements LongJob {
+    private static final Logger logger = LogManager.getLogger(MigrateVmLongJob.class);
+    private static final int WAIT_CHAIN_TASK_EXIT_MAX_RETRIES = 30;
+    private static final long WAIT_CHAIN_TASK_EXIT_INTERVAL_SECS = 1;
+
     @Autowired
     protected CloudBus bus;
     @Autowired
     protected DatabaseFacade dbf;
+    @Autowired
+    private ThreadFacade thdf;
 
     protected String auditResourceUuid;
 
     @Override
     public void start(LongJobVO job, ReturnValueCompletion<APIEvent> completion) {
         MigrateVmInnerMsg msg = JSONObjectUtil.toObject(job.getJobData(), MigrateVmInnerMsg.class);
+
+        List<String> backupTaskLongJobUuids = getBackupTaskLongJobUuids(job.getJobData());
+        if (backupTaskLongJobUuids != null && !backupTaskLongJobUuids.isEmpty()) {
+            logger.info(String.format("migrate vm[uuid:%s] longjob has %d backup longjobs to cancel first",
+                    msg.getVmInstanceUuid(), backupTaskLongJobUuids.size()));
+            cancelBackupLongJobsThenMigrate(backupTaskLongJobUuids, msg, completion);
+        } else {
+            doMigrate(msg, completion);
+        }
+    }
+
+    private List<String> getBackupTaskLongJobUuids(String jobData) {
+        Map<String, Object> raw = JSONObjectUtil.toObject(jobData, LinkedHashMap.class);
+        Object uuids = raw == null ? null : raw.get("backupTaskLongJobUuids");
+        if (!(uuids instanceof List<?>)) {
+            return null;
+        }
+
+        List<String> result = new ArrayList<>();
+        for (Object item : (List<?>) uuids) {
+            if (item == null) {
+                continue;
+            }
+            String uuid = String.valueOf(item).trim();
+            if (!uuid.isEmpty()) {
+                result.add(uuid);
+            }
+        }
+        return result.isEmpty() ? null : result;
+    }
+
+    private void cancelBackupLongJobsThenMigrate(List<String> backupTaskLongJobUuids,
+                                                  MigrateVmInnerMsg msg,
+                                                  ReturnValueCompletion<APIEvent> completion) {
+        cancelBackupLongJobs(backupTaskLongJobUuids.iterator(), new Completion(completion) {
+            @Override
+            public void success() {
+                waitForVolumeChainTasksExit(msg.getVmInstanceUuid(), WAIT_CHAIN_TASK_EXIT_MAX_RETRIES,
+                        new Completion(completion) {
+                    @Override
+                    public void success() {
+                        doMigrate(msg, completion);
+                    }
+
+                    @Override
+                    public void fail(ErrorCode errorCode) {
+                        completion.fail(errorCode);
+                    }
+                });
+            }
+
+            @Override
+            public void fail(ErrorCode errorCode) {
+                logger.warn(String.format("failed to cancel backup longjobs for vm[uuid:%s], " +
+                        "attempting migration anyway: %s", msg.getVmInstanceUuid(), errorCode));
+                doMigrate(msg, completion);
+            }
+        });
+    }
+
+    private void cancelBackupLongJobs(Iterator<String> it, Completion completion) {
+        if (!it.hasNext()) {
+            completion.success();
+            return;
+        }
+
+        String longJobUuid = it.next();
+        CancelLongJobMsg cmsg = new CancelLongJobMsg();
+        cmsg.setUuid(longJobUuid);
+        bus.makeLocalServiceId(cmsg, LongJobConstants.SERVICE_ID);
+        bus.send(cmsg, new CloudBusCallBack(completion) {
+            @Override
+            public void run(MessageReply reply) {
+                if (!reply.isSuccess()) {
+                    logger.warn(String.format("failed to cancel backup longjob[uuid:%s]: %s",
+                            longJobUuid, reply.getError()));
+                }
+                cancelBackupLongJobs(it, completion);
+            }
+        });
+    }
+
+    private void waitForVolumeChainTasksExit(String vmUuid, int retriesLeft, Completion completion) {
+        List<String> volUuids = Q.New(VolumeVO.class)
+                .eq(VolumeVO_.vmInstanceUuid, vmUuid)
+                .select(VolumeVO_.uuid)
+                .listValues();
+
+        if (volUuids.isEmpty()) {
+            completion.success();
+            return;
+        }
+
+        GetVolumeTaskMsg gmsg = new GetVolumeTaskMsg();
+        gmsg.setVolumeUuids(volUuids);
+        bus.makeLocalServiceId(gmsg, VolumeConstant.SERVICE_ID);
+        bus.send(gmsg, new CloudBusCallBack(completion) {
+            @Override
+            public void run(MessageReply reply) {
+                if (!reply.isSuccess()) {
+                    completion.fail(reply.getError());
+                    return;
+                }
+
+                GetVolumeTaskReply gr = reply.castReply();
+                boolean hasRunningTasks = gr.getResults().values().stream()
+                        .anyMatch(info -> !info.getRunningTask().isEmpty());
+
+                if (!hasRunningTasks) {
+                    completion.success();
+                    return;
+                }
+
+                if (retriesLeft <= 0) {
+                    completion.fail(operr(
+                            "timeout waiting for volume backup chain tasks to exit for vm[uuid:%s]", vmUuid));
+                    return;
+                }
+
+                logger.debug(String.format(
+                        "volumes of vm[uuid:%s] still have running tasks, retry in %ds (retries left: %d)",
+                        vmUuid, WAIT_CHAIN_TASK_EXIT_INTERVAL_SECS, retriesLeft));
+                thdf.submitTimeoutTask(
+                        () -> waitForVolumeChainTasksExit(vmUuid, retriesLeft - 1, completion),
+                        TimeUnit.SECONDS, WAIT_CHAIN_TASK_EXIT_INTERVAL_SECS);
+            }
+        });
+    }
+
+    private void doMigrate(MigrateVmInnerMsg msg, ReturnValueCompletion<APIEvent> completion) {
         bus.makeTargetServiceIdByResourceUuid(msg, VmInstanceConstant.SERVICE_ID, msg.getVmInstanceUuid());
         bus.send(msg, new CloudBusCallBack(completion) {
             @Override