@arela/uploader 1.0.15 → 1.0.17

package/src/services/PipelineApiService.js

@@ -0,0 +1,268 @@
+import { Agent } from 'http';
+import { Agent as HttpsAgent } from 'https';
+import fetch from 'node-fetch';
+
+import appConfig from '../config/config.js';
+import logger from './LoggingService.js';
+
+/**
+ * Pipeline API Service
+ * Handles HTTP communication with the API for pipeline job polling.
+ * Used by the poll worker mode as an alternative to Redis/BullMQ.
+ */
+export class PipelineApiService {
+  /**
+   * @param {string|null} apiTarget - API target for polling: 'agencia' recommended
+   */
+  constructor(apiTarget = 'agencia') {
+    this.apiTarget = apiTarget;
+    const apiConfig = appConfig.getApiConfig(apiTarget);
+    this.baseUrl = apiConfig.baseUrl;
+    this.token = apiConfig.token;
+
+    // Get API connection settings
+    const maxApiConnections = parseInt(process.env.MAX_API_CONNECTIONS) || 5;
+    const connectionTimeout =
+      parseInt(process.env.API_CONNECTION_TIMEOUT) || 30000;
+
+    // Retry configuration
+    this.maxRetries = parseInt(process.env.API_MAX_RETRIES) || 3;
+    this.retryDelay = parseInt(process.env.API_RETRY_DELAY) || 1000;
+
+    // Initialize HTTP agents for connection pooling
+    this.httpAgent = new Agent({
+      keepAlive: true,
+      keepAliveMsecs: 30000,
+      maxSockets: maxApiConnections,
+      timeout: connectionTimeout,
+    });
+
+    this.httpsAgent = new HttpsAgent({
+      keepAlive: true,
+      keepAliveMsecs: 30000,
+      maxSockets: maxApiConnections,
+      timeout: connectionTimeout,
+    });
+
+    logger.debug(
+      `🔗 Pipeline API Service configured for ${apiTarget} → ${this.baseUrl}`,
+    );
+  }
+
+  /**
+   * Get the appropriate HTTP agent based on URL protocol
+   * @private
+   */
+  #getAgent(url) {
+    return url.startsWith('https://') ? this.httpsAgent : this.httpAgent;
+  }
+
+  /**
+   * Make an HTTP request with retry logic
+   * @private
+   */
+  async #request(method, endpoint, body = null, retries = 0) {
+    const url = `${this.baseUrl}${endpoint}`;
+
+    try {
+      const options = {
+        method,
+        headers: {
+          'Content-Type': 'application/json',
+          'x-api-key': this.token,
+        },
+        agent: this.#getAgent(url),
+      };
+
+      if (body) {
+        options.body = JSON.stringify(body);
+      }
+
+      const response = await fetch(url, options);
+
+      if (!response.ok) {
+        // Handle non-2xx responses
+        if (response.status === 404) {
+          return null; // Resource not found is not an error for polling
+        }
+
+        const errorText = await response.text();
+        throw new Error(
+          `HTTP ${response.status}: ${response.statusText} - ${errorText}`,
+        );
+      }
+
+      // Check if response has content
+      const contentType = response.headers.get('content-type');
+      if (contentType && contentType.includes('application/json')) {
+        return response.json();
+      }
+
+      return { success: true };
+    } catch (error) {
+      // Retry on network errors
+      if (retries < this.maxRetries && this.#isRetryableError(error)) {
+        logger.debug(
+          `⚠️ Retrying request (${retries + 1}/${this.maxRetries}): ${error.message}`,
+        );
+        await this.#sleep(this.retryDelay * (retries + 1));
+        return this.#request(method, endpoint, body, retries + 1);
+      }
+
+      throw error;
+    }
+  }
+
+  /**
+   * Check if error is retryable
+   * @private
+   */
+  #isRetryableError(error) {
+    const retryableCodes = [
+      'ECONNRESET',
+      'ETIMEDOUT',
+      'ECONNREFUSED',
+      'ENOTFOUND',
+      'EAI_AGAIN',
+    ];
+    return (
+      retryableCodes.includes(error.code) ||
+      (error.message && error.message.includes('timeout'))
+    );
+  }
+
+  /**
+   * Sleep for specified milliseconds
+   * @private
+   */
+  #sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+
+  // =====================
+  // Public API Methods
+  // =====================
+
+  /**
+   * Get the next available job for this server
+   * @param {string} serverId - Server identifier
+   * @returns {Promise<Object|null>} Job data or null if no jobs available
+   */
+  async getNextJob(serverId) {
+    try {
+      const result = await this.#request(
+        'GET',
+        `/api/uploader/pipeline/worker/jobs/next?serverId=${encodeURIComponent(serverId)}`,
+      );
+      return result;
+    } catch (error) {
+      logger.error(`❌ Failed to get next job: ${error.message}`);
+      return null;
+    }
+  }
+
+  /**
+   * Update job progress
+   * @param {string} jobId - Job UUID
+   * @param {number} progress - Progress percentage (0-100)
+   * @param {string} message - Progress message
+   * @param {string} currentFile - Current file being processed
+   * @param {string} currentStep - Current pipeline step
+   * @returns {Promise<boolean>} Success status
+   */
+  async updateProgress(jobId, progress, message, currentFile, currentStep) {
+    try {
+      await this.#request(
+        'PATCH',
+        `/api/uploader/pipeline/worker/jobs/${jobId}/progress`,
+        {
+          progress,
+          message,
+          currentFile,
+          currentStep,
+        },
+      );
+      return true;
+    } catch (error) {
+      logger.warn(`⚠️ Failed to update progress: ${error.message}`);
+      return false;
+    }
+  }
+
+  /**
+   * Mark job as completed
+   * @param {string} jobId - Job UUID
+   * @param {Object} result - Result data
+   * @returns {Promise<boolean>} Success status
+   */
+  async completeJob(jobId, result = {}) {
+    try {
+      await this.#request(
+        'PATCH',
+        `/api/uploader/pipeline/worker/jobs/${jobId}/complete`,
+        {
+          status: 'completed',
+          result,
+        },
+      );
+      logger.success(`✅ Job ${jobId} marked as completed`);
+      return true;
+    } catch (error) {
+      logger.error(`❌ Failed to complete job: ${error.message}`);
+      return false;
+    }
+  }
+
+  /**
+   * Mark job as failed
+   * @param {string} jobId - Job UUID
+   * @param {string} errorMessage - Error description
+   * @returns {Promise<boolean>} Success status
+   */
+  async failJob(jobId, errorMessage) {
+    try {
+      await this.#request(
+        'PATCH',
+        `/api/uploader/pipeline/worker/jobs/${jobId}/complete`,
+        {
+          status: 'failed',
+          error: errorMessage,
+        },
+      );
+      logger.error(`❌ Job ${jobId} marked as failed: ${errorMessage}`);
+      return true;
+    } catch (error) {
+      logger.error(`❌ Failed to mark job as failed: ${error.message}`);
+      return false;
+    }
+  }
+
+  /**
+   * Send a heartbeat to keep the worker alive during long-running jobs
+   * @param {string} serverId - Server identifier
+   * @param {'online'|'busy'} status - Worker status
+   * @returns {Promise<boolean>} Success status
+   */
+  async sendHeartbeat(serverId, status = 'busy') {
+    try {
+      await this.#request('POST', '/api/uploader/pipeline/worker/heartbeat', {
+        serverId,
+        status,
+      });
+      return true;
+    } catch (error) {
+      logger.warn(`⚠️ Failed to send heartbeat: ${error.message}`);
+      return false;
+    }
+  }
+
+  /**
+   * Close connections and cleanup
+   */
+  destroy() {
+    this.httpAgent.destroy();
+    this.httpsAgent.destroy();
+  }
+}
+
+export default PipelineApiService;