bulltrackers-module 1.0.776 → 1.0.777

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

@@ -1,8 +1,9 @@
 /**
- * @fileoverview Scheduler V3.2: Smart Reconciliation & Tombstone Aware
+ * @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');
@@ -62,7 +63,6 @@ async function planComputations(req, res) {
         console.log(`[Planner] Reconciling window: ${windowStart.toISOString()} to ${windowEnd.toISOString()}`);
 
         // Helper to find Roots for any given computation (Pass 1..N)
-        // If a deep node (Pass 3) is stale, we must run its Pass 1 ancestor to regenerate the data.
         const manifestMap = new Map(manifest.map(m => [m.name, m]));
         const getRoots = (entry, visited = new Set()) => {
             if (visited.has(entry.name)) return [];
@@ -112,17 +112,19 @@ async function planComputations(req, res) {
                     
                     roots.forEach(root => {
                         // Unique Task Key: RootName + Date + Hash
-                        // Including Hash in key ensures we don't dedupe against a DIFFERENT version
                         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}`
                             });
                         }
                     });
@@ -164,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 {
@@ -204,75 +205,48 @@ async function runWatchdog(req, res) {
 
 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 = [];
-
-        // Increase pageSize to 1000 to minimize pagination calls/warnings
-        for await (const task of tasksClient.listTasksAsync({ 
-            parent, 
-            responseView: 'BASIC',
-            pageSize: 1000 
-        })) {
+        for await (const task of tasksClient.listTasksAsync({ parent, responseView: 'BASIC', pageSize: 1000 })) {
             const taskNameFull = task.name;
             const taskNameShort = taskNameFull.split('/').pop(); 
 
-            // 1. Handle ROOT Tasks: root-{kebabName}-{date}-{hash}
+            // 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}
+            // 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;
 }
 
@@ -286,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;
 }
 
@@ -339,14 +334,10 @@ async function dispatchTasks(tasks) {
             return { status: 'scheduled' };
             
         } catch (e) {
-            // ALREADY_EXISTS (6) or CONFLICT (409)
-            // This happens if we try to recreate a task that was recently deleted (Tombstone)
-            // or if it genuinely already exists.
             if (e.code === 6 || e.code === 409) {
-                console.warn(`[Planner] Task skipped (Already Exists/Tombstone): ${t.computation} @ ${t.targetDate}`);
+                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.776",
+  "version": "1.0.777",
   "description": "Helper Functions for Bulltrackers.",
   "main": "index.js",
   "files": [