bulltrackers-module 1.0.821 → 1.0.823

package/functions/computation-system-v3/config/bulltrackers.config.js

@@ -29,7 +29,7 @@ module.exports = {
         queueName: 'computation-triggers-new',
         dispatcherUrl: process.env.DISPATCHER_URL || 'https://europe-west1-stocks-12345.cloudfunctions.net/compute-dispatcher',
         workerUrl: process.env.WORKER_URL || process.env.DISPATCHER_URL || 'https://europe-west1-stocks-12345.cloudfunctions.net/compute-dispatcher',
-        serviceAccountEmail: process.env.GCP_SERVICE_ACCOUNT_EMAIL || '879684846540-compute@developer.gserviceaccount.com'
+        serviceAccountEmail: process.env.CLOUD_TASKS_SA_EMAIL || '879684846540-compute@developer.gserviceaccount.com'
     },
 
     storage: {

package/functions/computation-system-v3/framework/adapters/CloudTasks.js

@@ -1,10 +1,9 @@
 /**
- * @fileoverview Cloud Tasks Adapter (Extremely Verbose Debugging)
- * - Logs config on init.
- * - Logs full payload before creation.
- * - Logs raw gRPC errors.
+ * @fileoverview Cloud Tasks Adapter (V3 - Production Complete)
+ * Encapsulates Google Cloud Tasks interactions with full V2 feature parity.
  */
 
+
 class CloudTasksAdapter {
     constructor(client, config, logger = console) {
         this.client = client;
@@ -12,19 +11,22 @@ class CloudTasksAdapter {
         this.logger = logger;
         this.projectId = config.projectId;
         this.location = config.location || 'europe-west1';
-        this.queueName = config.queueName || 'computation-triggers-new';
+        this.queueName = config.queueName || 'computation-tasks-new';
         this.dispatcherUrl = config.dispatcherUrl;
-        this.workerUrl = config.workerUrl || config.dispatcherUrl;
-        this.serviceAccountEmail = 'super-admin-debug@stocks-12345.iam.gserviceaccount.com';
+        this.workerUrl = config.workerUrl || config.dispatcherUrl; // Fallback to dispatcher if not set
+        this.serviceAccountEmail = config.serviceAccountEmail;
 
+        // Internal concurrency limit for bulk operations
         this.concurrency = 20;
-        this._queuePath = null;
 
-        // [DEBUG] Log Configuration on Startup
-        this.logger.log(`\n[CloudTasks] INIT: Project=${this.projectId}, Location=${this.location}, Queue=${this.queueName}`);
-        this.logger.log(`[CloudTasks] INIT: ServiceAccount=${this.serviceAccountEmail} (Target Audience: ${this.dispatcherUrl})\n`);
+        // Cache queue path
+        this._queuePath = null;
     }
 
+    /**
+     * Get the full queue path (cached).
+     * @returns {string} Full queue path
+     */
     getQueuePath() {
         if (!this._queuePath) {
             this._queuePath = this.client.queuePath(this.projectId, this.location, this.queueName);
@@ -32,61 +34,91 @@ class CloudTasksAdapter {
         return this._queuePath;
     }
 
+    /**
+     * Create a task with OIDC authentication.
+     * @param {string} fullQueuePath - Full queue path from getQueuePath()
+     * @param {Object} payload - JSON payload for the task
+     * @param {Object} options - { scheduleTime: epochSeconds, name: string }
+     * @returns {Promise<Object>} Task response or { status: 'exists' }
+     */
     async createTask(fullQueuePath, payload, options = {}) {
-        const targetUrl = options.url || (payload.type === 'worker-batch' ? this.workerUrl : this.dispatcherUrl);
-        
-        // --- TEST MODIFICATION: STRIP COMPLEXITY ---
         const task = {
             httpRequest: {
                 httpMethod: 'POST',
-                url: targetUrl,
+                url: options.url || (payload.type === 'worker-batch' ? this.workerUrl : this.dispatcherUrl),
                 headers: { 'Content-Type': 'application/json' },
                 body: Buffer.from(JSON.stringify(payload)).toString('base64'),
-                // TEST 1: COMMENT OUT OIDC TOKEN
-                // oidcToken: {
-                //    serviceAccountEmail: this.serviceAccountEmail,
-                //    audience: targetUrl
-                // }
+                oidcToken: {
+                    serviceAccountEmail: this.serviceAccountEmail,
+                    audience: options.url || (payload.type === 'worker-batch' ? this.workerUrl : this.dispatcherUrl)
+                }
             }
         };
 
-        // TEST 2: DISABLE NAMING (Let Cloud Tasks assign a random ID)
-        // if (options.name) task.name = `${fullQueuePath}/tasks/${options.name}`;
-        if (options.scheduleTime) task.scheduleTime = { seconds: Math.floor(options.scheduleTime) };
+        // Optional: Named task for deduplication
+        if (options.name) {
+            task.name = `${fullQueuePath}/tasks/${options.name}`;
+        }
 
-        this.logger.log(`[CloudTasks] TEST MODE: Sending Naked Task (No OIDC, No Name) to ${targetUrl}`);
+        // Optional: Scheduled execution
+        if (options.scheduleTime) {
+            task.scheduleTime = {
+                seconds: Math.floor(options.scheduleTime)
+            };
+        }
 
         try {
-            const [response] = await this.client.createTask({ parent: fullQueuePath, task });
-            this.logger.log(`[CloudTasks] TEST SUCCESS: Created Task ${response.name}`);
+            const [response] = await this.client.createTask({
+                parent: fullQueuePath,
+                task
+            });
             return response;
         } catch (e) {
-            this.logger.error(`[CloudTasks] TEST FAILED: ${e.message}`);
+            // ALREADY_EXISTS (gRPC code 6 or HTTP 409)
+            if (e.code === 6 || e.code === 409) {
+                return { status: 'exists' };
+            }
             throw e;
         }
     }
 
+    /**
+     * Delete a task by full name.
+     * @param {string} taskName - Full task name
+     * @returns {Promise<boolean>} true if deleted, false if not found
+     */
     async deleteTask(taskName) {
         try {
             await this.client.deleteTask({ name: taskName });
             return true;
         } catch (e) {
-            if (e.code === 5) return false;
+            if (e.code === 5) return false; // NOT_FOUND
             throw e;
         }
     }
 
+    /**
+     * List all tasks in the queue (async iterator).
+     * @param {string} fullQueuePath - Queue path
+     * @yields {Object} Task object
+     */
     async *listTasks(fullQueuePath) {
         const iterable = this.client.listTasksAsync({
             parent: fullQueuePath,
             responseView: 'BASIC',
             pageSize: 1000
         });
+
         for await (const task of iterable) {
             yield task;
         }
     }
 
+    /**
+     * Bulk delete tasks with concurrency control.
+     * @param {string[]} taskNames - Array of full task names
+     * @returns {Promise<Object>} { success: number, failed: number }
+     */
     async bulkDelete(taskNames) {
         const results = { success: 0, failed: 0 };
         const chunkSize = this.concurrency;
@@ -107,11 +139,19 @@ class CloudTasksAdapter {
                 }
             }));
         }
+
         return results;
     }
 
+    /**
+     * Schedule a root computation task (Planner-compatible).
+     * @param {Object} taskData - { computation, date, hash, source, force }
+     * @returns {Promise<Object>} { status: 'scheduled' | 'exists' | 'error', id }
+     */
     async scheduleTask(taskData) {
         const { computation, targetDate, configHash, reason, runAtSeconds } = taskData;
+
+        // Generate deterministic task ID for deduplication
         const normalizedName = computation.toLowerCase().replace(/[^a-z0-9]/g, '');
         const hashSuffix = configHash ? configHash.substring(0, 8) : 'noHash';
         const taskId = `root-${normalizedName}-${targetDate}-${hashSuffix}`;
@@ -128,45 +168,82 @@ class CloudTasksAdapter {
         try {
             const queuePath = this.getQueuePath();
             const options = { name: taskId };
-            if (runAtSeconds) options.scheduleTime = runAtSeconds;
+
+            if (runAtSeconds) {
+                options.scheduleTime = runAtSeconds;
+            }
 
             const result = await this.createTask(queuePath, payload, options);
-            if (result.status === 'exists') return { status: 'exists', id: taskId };
+
+            if (result.status === 'exists') {
+                return { status: 'exists', id: taskId };
+            }
+
             return { status: 'scheduled', id: taskId };
+
         } catch (e) {
-            // [FIX] ACTUALLY LOG THE ERROR HERE
-            this.logger.error(`[CloudTasks] FAILED to schedule ${taskId}: ${e.message}`);
+            this.logger.error(`[CloudTasks] Schedule failed for ${computation}@${targetDate}: ${e.message}`);
             return { status: 'error', error: e.message, id: taskId };
         }
     }
 
+    /**
+     * List and clean stale tasks (Scheduler GC support).
+     * Removes tasks with outdated config hashes.
+     * @param {Map<string, string>} activeHashes - Map<computationName, currentHash>
+     * @returns {Promise<Object>} { deleted: number, activeKeys: Set<string> }
+     */
     async listAndClean(activeHashes) {
         const queuePath = this.getQueuePath();
         const tasksToDelete = [];
         const activeKeys = new Set();
+
         try {
             for await (const task of this.listTasks(queuePath)) {
+                // Parse task name to extract computation and hash
+                // Expected format: projects/.../tasks/root-{comp}-{date}-{hash}
                 const taskNameParts = task.name.split('/');
                 const taskId = taskNameParts[taskNameParts.length - 1];
+
+                // Extract hash from task ID
                 const match = taskId.match(/root-(.+?)-(\d{4}-\d{2}-\d{2})-([a-f0-9]+)/);
-                if (!match) { activeKeys.add(taskId); continue; }
+                if (!match) {
+                    // Unknown format, skip
+                    activeKeys.add(taskId);
+                    continue;
+                }
+
                 const [, compNormalized, date, hash] = match;
+
+                // Find matching computation in activeHashes
                 let isStale = true;
                 for (const [compName, currentHash] of activeHashes.entries()) {
                     const normalizedComp = compName.toLowerCase().replace(/[^a-z0-9]/g, '');
                     if (normalizedComp === compNormalized) {
-                        if (currentHash.startsWith(hash)) { isStale = false; activeKeys.add(taskId); }
+                        if (currentHash.startsWith(hash)) {
+                            // Task is current
+                            isStale = false;
+                            activeKeys.add(taskId);
+                        }
                         break;
                     }
                 }
-                if (isStale) tasksToDelete.push(task.name);
+
+                if (isStale) {
+                    tasksToDelete.push(task.name);
+                }
             }
+
+            // Bulk delete stale tasks
             let deleted = 0;
             if (tasksToDelete.length > 0) {
+                this.logger.log(`[CloudTasks] Cleaning ${tasksToDelete.length} stale tasks...`);
                 const result = await this.bulkDelete(tasksToDelete);
                 deleted = result.success;
             }
+
             return { deleted, activeKeys };
+
         } catch (e) {
             this.logger.error(`[CloudTasks] listAndClean failed: ${e.message}`);
             return { deleted: 0, activeKeys: new Set() };

package/package.json

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