bulltrackers-module 1.0.775 → 1.0.777

package/functions/computation-system-v2/handlers/scheduler.js

@@ -1,8 +1,9 @@
 /**
- * @fileoverview Scheduler V3.1: Reconciler with Active Garbage Collection
- * * * 1. Reconcile: Iterates a time window (Past -> Future) to ensure valid tasks exist.
- * * 2. Purge: Scans the queue for "Orphans" (tasks for deleted computations) and deletes them.
+ * @fileoverview Scheduler V3.3: Smart Reconciliation & Future-Aligned Backfills
+ * * * 1. Reconcile: Checks ENTIRE graph for stale hashes, triggers ROOTS if needed.
+ * * 2. Purge: Actively removes tasks that don't match the current deployment hash.
  * * 3. Watchdog: Recovers "Zombie" tasks (running but stuck).
+ * * * UPDATE: Backfills now respect the 'next available window' instead of running instantly.
  */
 
 const { CloudTasksClient } = require('@google-cloud/tasks');
@@ -41,8 +42,10 @@ async function initialize() {
 
     console.log(`[Scheduler] Loaded ${manifest.length} computations.`);
 }
+
 /**
- * REPLACEMENT for planComputations
+ * ENTRY POINT 1: The Planner
+ * Trigger: Cloud Scheduler -> "0 * * * *" (Hourly)
  */
 async function planComputations(req, res) {
     try {
@@ -106,18 +109,22 @@ async function planComputations(req, res) {
                 if (reason) {
                     // If entry is stale, we must schedule its ROOT(s) to trigger the chain
                     const roots = getRoots(entry);
-
+                    
                     roots.forEach(root => {
+                        // Unique Task Key: RootName + Date + Hash
                         const taskKey = `root-${toKebab(root.originalName)}-${dateStr}-${root.hash}`;
-
+                        
                         if (!tasksToSchedule.has(taskKey)) {
+                            // NEW: Calculate the NEXT valid run window instead of using the past date
+                            const runAt = getNextRunWindow(root.schedule, dateObj);
+
                             tasksToSchedule.set(taskKey, {
                                 computation: root.originalName,
                                 targetDate: dateStr,
-                                runAtSeconds: getRunTimeSeconds(root.schedule, dateObj),
+                                runAtSeconds: runAt,
                                 configHash: root.hash,
                                 queuePath: getQueuePath(),
-                                reason: `TRIGGERED_BY_${entry.name}_${reason}` // Track what triggered this root
+                                reason: `TRIGGERED_BY_${entry.name}_${reason}`
                             });
                         }
                     });
@@ -126,24 +133,28 @@ async function planComputations(req, res) {
         })));
 
         // --- PHASE 2: GARBAGE COLLECTION ---
-        // (Keep your existing GC logic here)
         console.log('[Planner] Starting Garbage Collection...');
         const deletedCount = await cleanupOrphanedTasks();
 
         // --- PHASE 3: DISPATCH ---
         const taskList = Array.from(tasksToSchedule.values());
         let scheduledCount = 0;
+        let existsCount = 0;
+
         if (taskList.length > 0) {
             const results = await dispatchTasks(taskList);
             scheduledCount = results.filter(r => r.status === 'scheduled').length;
+            existsCount = results.filter(r => r.status === 'exists').length;
         }
 
-        console.log(`[Planner] Complete. Scheduled: ${scheduledCount}, Deleted Orphans: ${deletedCount}`);
-
+        console.log(`[Planner] Complete. Scheduled: ${scheduledCount} (Exists/Tombstoned: ${existsCount}), Deleted Orphans: ${deletedCount}`);
+        
         return res.status(200).json({
             status: 'success',
             window: `${PLANNING_LOOKBACK_DAYS}d back`,
             scheduled: scheduledCount,
+            exists: existsCount,
+            deleted: deletedCount,
             stats
         });
 
@@ -155,7 +166,6 @@ async function planComputations(req, res) {
 
 /**
  * ENTRY POINT 2: The Watchdog
- * Trigger: Cloud Scheduler -> "*\/15 * * * *" (Every 15 mins)
  */
 async function runWatchdog(req, res) {
     try {
@@ -188,85 +198,55 @@ async function runWatchdog(req, res) {
         return res.status(500).json({ error: error.message });
     }
 }
+
 // =============================================================================
 // ACTIVE GARBAGE COLLECTION LOGIC
 // =============================================================================
 
 async function cleanupOrphanedTasks() {
     const parent = getQueuePath();
-
-    // Create a map of { kebabName: activeHash } for O(1) lookups
-    const activeComputations = new Map(
-        manifest.map(m => [toKebab(m.originalName), m.hash])
-    );
-
+    const activeComputations = new Map(manifest.map(m => [toKebab(m.originalName), m.hash]));
     const limit = pLimit(CLOUD_TASKS_CONCURRENCY);
     let deletedCount = 0;
 
     try {
         const tasksToDelete = [];
-
-        // Note: listTasksAsync handles pagination, but if you have thousands of tasks,
-        // you might eventually need to handle page tokens explicitly if the library version is old.
-        for await (const task of tasksClient.listTasksAsync({
-            parent,
-            responseView: 'BASIC',
-            pageSize: 1000 // Increase page size to capture more per request
-        })) {
+        for await (const task of tasksClient.listTasksAsync({ parent, responseView: 'BASIC', pageSize: 1000 })) {
             const taskNameFull = task.name;
-            const taskNameShort = taskNameFull.split('/').pop();
+            const taskNameShort = taskNameFull.split('/').pop(); 
 
-            // 1. Handle ROOT Tasks: root-{kebabName}-{date}-{hash}
-            // We capture the name AND the hash at the end
+            // 1. Root Tasks
             const rootMatch = taskNameShort.match(/^root-(.+)-\d{4}-\d{2}-\d{2}-(.+)$/);
-
             if (rootMatch) {
                 const [_, kebabName, taskHash] = rootMatch;
                 const activeHash = activeComputations.get(kebabName);
-
-                // DELETE IF:
-                // A) Computation removed from manifest (!activeHash)
-                // B) Hash mismatch (Old deployment/Stale) (activeHash !== taskHash)
-                if (!activeHash || activeHash !== taskHash) {
-                    tasksToDelete.push(taskNameFull);
-                }
+                if (!activeHash || activeHash !== taskHash) tasksToDelete.push(taskNameFull);
                 continue;
             }
 
-            // 2. Handle RECOVERY Tasks: recovery-{kebabName}-{date}-{timestamp}
-            // We only delete these if the computation is completely gone.
-            // (Timestamps won't match a config hash, so we just check existence)
+            // 2. Recovery Tasks
             const recoveryMatch = taskNameShort.match(/^recovery-(.+)-\d{4}-\d{2}-\d{2}-/);
-
             if (recoveryMatch) {
                 const [_, kebabName] = recoveryMatch;
-                if (!activeComputations.has(kebabName)) {
-                    tasksToDelete.push(taskNameFull);
-                }
+                if (!activeComputations.has(kebabName)) tasksToDelete.push(taskNameFull);
             }
         }
 
         if (tasksToDelete.length === 0) return 0;
-
         console.log(`[Planner] 🗑️ Found ${tasksToDelete.length} stale/orphaned tasks. Deleting...`);
 
-        // 3. Delete in parallel
         await Promise.all(tasksToDelete.map(name => limit(async () => {
             try {
                 await tasksClient.deleteTask({ name });
                 deletedCount++;
             } catch (e) {
-                // Ignore "NOT_FOUND" errors in case of race conditions
-                if (e.code !== 5) {
-                    console.warn(`[Planner] Failed to delete ${name}: ${e.message}`);
-                }
+                if (e.code !== 5) console.warn(`[Planner] Failed to delete ${name}: ${e.message}`);
             }
         })));
 
     } catch (e) {
         console.error(`[Planner] GC Error: ${e.message}`);
     }
-
     return deletedCount;
 }
 
@@ -280,10 +260,31 @@ function shouldRunOnDate(schedule, dateObj) {
     return true;
 }
 
-function getRunTimeSeconds(schedule, dateObj) {
+/**
+ * Calculates the run time. 
+ * If the Target Date's schedule is in the PAST, it projects execution to the NEXT available window (Today or Tomorrow).
+ */
+function getNextRunWindow(schedule, targetDateObj) {
     const [h, m] = (schedule.time || '02:00').split(':').map(Number);
-    const runTime = new Date(dateObj);
+    
+    // 1. Calculate the ideal run time on the TARGET date
+    let runTime = new Date(targetDateObj);
     runTime.setUTCHours(h, m, 0, 0);
+
+    const now = Date.now();
+
+    // 2. If ideal time is in the past, move it to the *next* occurrence relative to NOW
+    if (runTime.getTime() < now) {
+        const nextWindow = new Date();
+        nextWindow.setUTCHours(h, m, 0, 0);
+        
+        // If today's window has passed, move to tomorrow
+        if (nextWindow.getTime() <= now) {
+            nextWindow.setUTCDate(nextWindow.getUTCDate() + 1);
+        }
+        return nextWindow.getTime() / 1000;
+    }
+
     return runTime.getTime() / 1000;
 }
 
@@ -302,10 +303,10 @@ async function dispatchTasks(tasks) {
 
     return Promise.all(tasks.map(t => limit(async () => {
         try {
-            const name = t.isRecovery
+            const name = t.isRecovery 
                 ? `recovery-${toKebab(t.computation)}-${t.targetDate}-${Date.now()}`
                 : `root-${toKebab(t.computation)}-${t.targetDate}-${t.configHash}`;
-
+            
             const taskName = `${t.queuePath}/tasks/${name}`;
 
             const payload = {
@@ -331,8 +332,12 @@ async function dispatchTasks(tasks) {
 
             await tasksClient.createTask({ parent: t.queuePath, task });
             return { status: 'scheduled' };
+            
         } catch (e) {
-            if (e.code === 6 || e.code === 409) return { status: 'exists' };
+            if (e.code === 6 || e.code === 409) {
+                console.warn(`[Planner] Task name collision (Tombstone?): ${t.computation} @ ${t.targetDate}`);
+                return { status: 'exists' };
+            }
             console.error(`[Planner] Failed task ${t.computation}: ${e.message}`);
             return { status: 'error' };
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bulltrackers-module",
-  "version": "1.0.775",
+  "version": "1.0.777",
   "description": "Helper Functions for Bulltrackers.",
   "main": "index.js",
   "files": [