backup(nas): collapse N+1 chain queries when sweeping delete-pending ancestors

Address abh1sar review on PR #13074 (NASBackupProvider.java:995). The previous
sweep/cascade path called findChainParent in a loop, each one issuing a fresh
listByVmId — O(N) DB calls per chain walk.

Add getChainOrderedLeafToRoot(member) which materialises the full chain (every
backup row sharing CHAIN_ID) via a single listByVmId, sorted leaf-first by
CHAIN_POSITION. Rewrite deleteLeafBackupAndSweepPendingAncestors to snapshot
that chain BEFORE the leaf delete (so the in-memory list stays resolvable
after the row is gone), then iterate ancestors from the snapshot. Rewrite
cascadeDeleteSubtree as a plain leaf-first walk of the ordered chain — NAS
backups are a linear chain, no tree-walking needed.

findChainParent is kept (the parent-row lookup is still a useful primitive)
with a Javadoc note recommending the new method when iterating.

Author: jmsperu

plugins/backup/nas/src/main/java/org/apache/cloudstack/backup/NASBackupProvider.java

@@ -935,6 +935,9 @@ private List<Backup> findLiveChildren(Backup parent) {
     /**
      * Look up this backup's immediate parent in the chain (by {@code PARENT_BACKUP_ID}).
      * Returns {@code null} if this is the full (no parent) or the parent row is gone.
+     *
+     * <p>Prefer {@link #getChainOrderedLeafToRoot(Backup)} when walking the whole chain —
+     * this method hits the DB on each call and is O(N²) when used in a loop.
      */
     private Backup findChainParent(Backup backup) {
         String parentUuid = readDetail(backup, NASBackupChainKeys.PARENT_BACKUP_ID);
@@ -949,6 +952,33 @@ private Backup findChainParent(Backup backup) {
         return null;
     }
 
+    /**
+     * Return the chain containing {@code member}, ordered leaf-first
+     * (highest {@code CHAIN_POSITION} → root).
+     *
+     * <p>Materialises the chain via a single {@link BackupDao#listByVmId} call. Callers that
+     * previously walked the chain by repeatedly calling {@link #findChainParent} were doing
+     * O(N) {@code listByVmId} calls (one per ancestor); this collapses that to one.
+     *
+     * <p>If {@code member} has no {@code CHAIN_ID} metadata it is returned as a one-element
+     * list (it is its own degenerate chain).
+     */
+    private List<Backup> getChainOrderedLeafToRoot(Backup member) {
+        String chainId = readDetail(member, NASBackupChainKeys.CHAIN_ID);
+        if (chainId == null) {
+            return Collections.singletonList(member);
+        }
+        List<Backup> chain = new ArrayList<>();
+        for (Backup b : backupDao.listByVmId(null, member.getVmId())) {
+            if (chainId.equals(readDetail(b, NASBackupChainKeys.CHAIN_ID))) {
+                chain.add(b);
+            }
+        }
+        // Descending CHAIN_POSITION = leaf-first (highest position = furthest from root).
+        chain.sort((a, b) -> Integer.compare(chainPosition(b), chainPosition(a)));
+        return chain;
+    }
+
     /**
      * Physically delete the leaf {@code backup}, then walk up the chain while each ancestor
      * is in delete-pending state. Mirrors the snapshot subsystem pattern: once a leaf is
@@ -959,48 +989,56 @@ private Backup findChainParent(Backup backup) {
      * live-children check is needed inside the loop.
      */
     private boolean deleteLeafBackupAndSweepPendingAncestors(Backup backup, BackupRepository repo, Host host) {
-        // Record the parent BEFORE the delete — deleteBackupFileAndRow removes the backup row,
-        // after which findChainParent can't resolve PARENT_BACKUP_ID.
-        Backup parent = findChainParent(backup);
+        // Snapshot the chain BEFORE the leaf delete — deleteBackupFileAndRow removes the row,
+        // after which the in-memory list still resolves but the DB no longer would.
+        List<Backup> chain = getChainOrderedLeafToRoot(backup);
         if (!deleteBackupFileAndRow(backup, repo, host)) {
             return false;
         }
-        while (parent != null && isDeletePending(parent)) {
-            Backup nextParent = findChainParent(parent);
-            if (!deleteBackupFileAndRow(parent, repo, host)) {
+        // Walk the snapshot from leaf+1 upward, deleting tombstoned ancestors until a live
+        // one is reached or the root is past.
+        int leafIdx = indexOfBackupById(chain, backup.getId());
+        if (leafIdx < 0) {
+            // Leaf wasn't in its own CHAIN_ID list — degenerate case, nothing more to sweep.
+            return true;
+        }
+        for (int i = leafIdx + 1; i < chain.size(); i++) {
+            Backup ancestor = chain.get(i);
+            if (!isDeletePending(ancestor)) {
+                break;
+            }
+            if (!deleteBackupFileAndRow(ancestor, repo, host)) {
                 // Stop the sweep; the rest of the tombstoned chain will be collected on a
                 // future delete that re-runs the sweep.
                 return true;
             }
-            parent = nextParent;
         }
         return true;
     }
 
     /**
      * Forced delete of {@code root}'s entire chain, leaf-first. NAS backups form a linear
-     * chain (full → inc → inc → …), not a tree, so we don't need BFS — find the tail
-     * (highest {@code CHAIN_POSITION} for {@code root}'s {@code CHAIN_ID}) and delete down.
-     * Each {@code rm} runs against a chain that still resolves.
+     * chain (full → inc → inc → …), not a tree, so we just walk the ordered chain and
+     * delete each member without re-querying parents.
      */
     private boolean cascadeDeleteSubtree(Backup root, BackupRepository repo, Host host) {
-        Backup tail = findChainTail(root);
-        if (tail == null) {
-            return false;
-        }
-        // Walk leaf → root via PARENT_BACKUP_ID, deleting unconditionally. We re-fetch parent
-        // before each delete because deleteBackupFileAndRow removes the backup row.
-        Backup current = tail;
-        while (current != null) {
-            Backup nextParent = findChainParent(current);
-            if (!deleteBackupFileAndRow(current, repo, host)) {
+        for (Backup b : getChainOrderedLeafToRoot(root)) {
+            if (!deleteBackupFileAndRow(b, repo, host)) {
                 return false;
             }
-            current = nextParent;
         }
         return true;
     }
 
+    private static int indexOfBackupById(List<Backup> chain, long id) {
+        for (int i = 0; i < chain.size(); i++) {
+            if (chain.get(i).getId() == id) {
+                return i;
+            }
+        }
+        return -1;
+    }
+
     /**
      * Return the backup with the highest {@code CHAIN_POSITION} sharing {@code root}'s
      * {@code CHAIN_ID}. Returns {@code root} if it has no chain metadata or is itself the tail.