ti2 1.0.95 → 1.0.96

package/worker/index.js

@@ -2,137 +2,209 @@ const throng = require('throng');
 require('util').inspect.defaultOptions.depth = null;
 const R = require('ramda');
 const { queue, saveResult } = require('./queue');
+const bookingsControllerFactory = require('../controllers/bookings');
+const mainAxios = require('axios'); // Generic axios instance for direct calls
 
 const workers = process.env.WEB_CONCURRENCY || 2;
 const maxJobsPerWorker = process.env.MAX_JOBS_PER_WORKER || 1;
 
-const worker = ({ plugins: pluginsParam }) => (id, disconnect) => {
-  console.log(`Started worker ${id}`);
+const worker = ({ plugins: pluginsParam }) => { // pluginsParam are instantiated plugins
+  // Initialize bookingsCtrl once per worker instance using the passed instantiated plugins.
+  const bookingsCtrl = bookingsControllerFactory(pluginsParam);
 
-  const bye = () => {
-    console.log(`Worker ${id} exiting`);
-    disconnect();
-    process.exit(0);
-  };
+  return (id, disconnect) => {
+    console.log(`Started worker ${id}`);
+
+    const bye = () => {
+      console.log(`Worker ${id} exiting`);
+      disconnect();
+      // Graceful shutdown of the queue connection
+      queue.close().then(() => process.exit(0)).catch(() => process.exit(1));
+    };
+
+    process.on('SIGTERM', bye);
+    process.on('SIGUSR2', bye);
+    process.on('SIGINT', bye); // Good for local development
+
+    queue.process(maxJobsPerWorker, async job => {
+      const {
+        data, // Full job.data object
+        id: jobId,
+      } = job;
 
-  process.on('SIGTERM', bye);
-  process.on('SIGUSR2', bye);
-  process.on('SIGINT', bye);
-
-  queue.process(maxJobsPerWorker, async job => {
-    const {
-      data: {
-        type = 'plugin',
-        pluginName,
-        inTesting,
-        payload = {}
-      },
-      id: jobId,
-      data: params,
-    } = job;
-    let resultValue;
-    const jobLog = msg => console.log(`job ${jobId} > `, msg)
-    const jobErr = msg => console.error(`job ${jobId} > `, msg)
-    jobLog(`of type ${type} started`);
-    if (type === 'api') {
+      // Destructure from data for clarity and to match existing patterns
       const {
-        method,
-        url,
-        payload,
-        headers,
-      } = params;
-      jobLog(`running method ${method} ${url}`)
-
-      let code, result, server;
-      const http = require('http');
-      const axios = require('axios');
+        type = 'plugin',        // Default job type if not specified
+        pluginName,             // Name of the plugin context for the job
+        inTesting,              // Flag if running in a testing environment
+        payload: jobDataPayload, // This is job.data.payload (e.g., { methodName: '...', args: {...} } or other plugin args)
+        method: jobDataMethod,   // This is job.data.method (e.g., 'searchProducts' for generic plugin calls)
+                                // Note: 'token' can also be a top-level property in data (data.token)
+      } = data;
+
+      let resultValue; // This will be set by all job type handlers
+      const jobLog = msg => console.log(`job ${jobId} (type: ${type}, plugin: ${pluginName || 'N/A'}) > `, msg);
+      const jobErr = msg => console.error(`job ${jobId} (type: ${type}, plugin: ${pluginName || 'N/A'}) > `, msg);
+      jobLog(`started`);
+
       try {
-        const app = await require('../index')({
-          pluginsInstantiated: pluginsParam,
-          startServer: false,
-          worker: false,
-        });
-
-        // Manually start server on random port
-        server = http.createServer(app);
-        await new Promise(resolve => server.listen(0, '127.0.0.1', resolve)); 
-        const { address, port } = server.address();
-        const baseURL = `http://${address}:${port}`;
-        jobLog(`Worker internal server for job ${jobId} listening on: ${baseURL}`);
-
-        // Extract token and body from payload
-        const { token, body } = payload || {};
-        const requestHeaders = {
-          ...R.omit(['content-length'], headers),
-          ...(token ? { Authorization: `Bearer ${token}` } : {})
-        };
-
-        // Use axios to make the request
-        const response = await axios({
-          method: method.toLowerCase(),
-          url: `${baseURL}${url}`,
-          data: R.omit(['backgroundJob'], payload),
-          headers: requestHeaders,
-          validateStatus: () => true, // Prevent axios from throwing on non-2xx status
-        });
-
-        code = response.status;
-        result = response.data;
-        jobLog(`Worker internal request for job ${jobId} completed with code ${code}`);
-      } catch (error) {
-        // Handle errors during app init or axios request
-        jobErr(`Worker internal request error for job ${jobId}:`, error.message);
-        // If axios error has response, use its status
-        code = R.pathOr(500, ['response', 'status'], error);
-        result = R.pathOr({ message: error.message }, ['response', 'data'], error);
-      } finally {
-        // Ensure server is closed if it was created
-        if (server) {
-          await new Promise(resolve => server.close(resolve));
-          jobLog(`Worker internal server for job ${jobId} closed.`);
+        if (type === 'api') {
+          // params is job.data, so data.method, data.url etc. are correct here
+          jobLog(`running method ${data.method} ${data.url}`);
+          let code, result, server;
+          const http = require('http');
+          const axios = require('axios'); // Local axios for API call type
+          try {
+            const app = await require('../index')({
+              pluginsInstantiated: pluginsParam, // Pass the already instantiated plugins
+              startServer: false,
+              worker: false,
+            });
+
+            server = http.createServer(app);
+            await new Promise(resolve => server.listen(0, '127.0.0.1', resolve));
+            const { address, port } = server.address();
+            const baseURL = `http://${address}:${port}`;
+            jobLog(`Worker internal server for job ${jobId} listening on: ${baseURL}`);
+
+            // data.payload is the payload for the API call job type
+            const { token: jwtTokenForHeader, ...requestBodyForWorker } = data.payload || {};
+
+            const requestHeaders = {
+              ...R.omit(['content-length', 'host', 'connection', 'accept-encoding'], data.headers),
+              ...(jwtTokenForHeader ? { Authorization: `Bearer ${jwtTokenForHeader}` } : {})
+            };
+
+            const response = await axios({
+              method: data.method.toLowerCase(),
+              url: `${baseURL}${data.url}`,
+              data: R.omit(['backgroundJob'], requestBodyForWorker),
+              headers: requestHeaders,
+              validateStatus: () => true,
+            });
+
+            code = response.status;
+            result = response.data;
+            jobLog(`Worker internal request for job ${jobId} completed with code ${code}`);
+          } catch (error) {
+            jobErr(`Worker internal request error for job ${jobId}: ${error.message}`);
+            code = R.pathOr(500, ['response', 'status'], error);
+            result = R.pathOr({ message: error.message }, ['response', 'data'], error);
+          } finally {
+            if (server) {
+              await new Promise(resolve => server.close(resolve));
+              jobLog(`Worker internal server for job ${jobId} closed.`);
+            }
+          }
+          resultValue = { code, result, success: code >= 200 && code < 300 };
+
+        } else if (type === 'callback') {
+          const { callbackUrl, request, result } = jobDataPayload; // jobDataPayload is job.data.payload
+          jobLog(`sending callback to ${callbackUrl}`);
+          await require('../lib/callback').sendCallback({
+            callbackUrl,
+            request,
+            result,
+          });
+          resultValue = { success: true };
+
+        } else if (type === 'plugin') {
+          // jobDataPayload is job.data.payload
+          // jobDataMethod is job.data.method (for generic plugin calls)
+
+          // Check for our specific controller-level background task
+          if (jobDataPayload && jobDataPayload.methodName === '$bookingsProductSearchInternal') {
+            jobLog(`Processing via bookingsCtrl.$bookingsProductSearchInternal`);
+            
+            const controllerArgs = jobDataPayload.args;
+            if (!controllerArgs) {
+              throw new Error('$bookingsProductSearchInternal job is missing "args" in its payload');
+            }
+
+            // Ensure appKey from args matches pluginName from job data if pluginName is used for context
+            if (pluginName && controllerArgs.appKey !== pluginName) {
+                jobErr(`Job data pluginName (${pluginName}) mismatch with args.appKey (${controllerArgs.appKey}). Using args.appKey for plugin context.`);
+            }
+            // If this job type implies a forced refresh, `forceRefresh: true` should be part of `controllerArgs`.
+            // The `backgroundJob` flag is removed from $bookingsProductSearch.
+            const executionPayload = {
+              ...controllerArgs, // Contains appKey, userId, hint, payload (for $bps), headers
+                                 // Potentially `forceRefresh: true` if needed for this job type.
+              axios: mainAxios,  // Provide the worker's generic axios instance
+              requestId: jobId,  // Use job ID for tracing
+              // plugins are already available to bookingsCtrl via its factory initialization
+            };
+            
+            resultValue = await bookingsCtrl.$bookingsProductSearch(executionPayload);
+            jobLog(`bookingsCtrl.$bookingsProductSearchInternal completed.`);
+
+          } else {
+            // Handle generic plugin method call
+            jobLog(`Processing plugin method: ${jobDataMethod} for plugin ${pluginName}`);
+            
+            const currentJobPlugins = await (async () => {
+              if (inTesting) {
+                const fakePlugin = require('../test/plugin');
+                const FakePluginClass = fakePlugin.default || fakePlugin;
+                return [...pluginsParam, new FakePluginClass({ name: pluginName })];
+              }
+              return pluginsParam;
+            })();
+
+            const thePlugin = currentJobPlugins.find(({ name }) => name === pluginName);
+
+            if (!thePlugin) {
+              throw new Error(`Plugin ${pluginName} not found for job ${jobId}.`);
+            }
+            if (!jobDataMethod || typeof thePlugin[jobDataMethod] !== 'function') {
+              throw new Error(`Method ${jobDataMethod} not found or not a function on plugin ${pluginName} for job ${jobId}.`);
+            }
+
+            // Execute the plugin method
+            const pluginMethodResult = await thePlugin[jobDataMethod]({
+              ...(jobDataPayload || {}), // Spread job.data.payload (e.g., contains inner 'payload' and 'userId')
+              token: data.token,         // Pass job.data.token
+              plugins: currentJobPlugins,
+              typeDefsAndQueries: bookingsControllerFactory.typeDefsAndQueries, // As per existing pattern
+              axios: mainAxios,          // Inject worker's axios instance
+              requestId: jobId,          // Inject job ID as requestId
+            });
+            
+            jobLog(`Plugin method ${jobDataMethod} for ${pluginName} completed.`);
+            resultValue = pluginMethodResult; // The primary result of the job is the plugin's output
+
+            // Post-processing step
+            if (data.postProcess) {
+              jobLog(`Initiating post-processing step: ${data.postProcess.controller}.${data.postProcess.action}`);
+              if (data.postProcess.controller === 'bookings' && bookingsCtrl[data.postProcess.action]) {
+                await bookingsCtrl[data.postProcess.action]({
+                  ...(data.postProcess.args || {}), // Spread static args from job data
+                  pluginResult: pluginMethodResult, // Pass the dynamic result from the plugin
+                  requestId: jobId,                 // Pass job ID for tracing in post-process
+                  // 'plugins' are already part of bookingsCtrl via its factory
+                });
+                jobLog(`Post-processing step ${data.postProcess.action} completed for job ${jobId}.`);
+              } else {
+                jobErr(`Post-processing action ${data.postProcess.action} on controller ${data.postProcess.controller} not found or controller not supported for job ${jobId}.`);
+                // Depending on requirements, this could throw an error to fail the job
+              }
+            }
+          }
+        } else {
+          jobErr(`Unknown job type: ${type} for job ${jobId}`);
+          throw new Error(`Unknown job type: ${type} for job ${jobId}`);
         }
+
+        jobLog(`completed`);
+        await saveResult({ id: jobId, resultValue });
+
+      } catch (error) {
+        jobErr(`Processing failed: ${error.message}`);
+        if (error.stack) jobErr(error.stack); // Log full stack for debugging
+        throw new Error(error.message) // Re-throw to mark job as failed in Bull (use a summarized mesage)
       }
-      resultValue = {
-        code,
-        result,
-        success: code >= 200 && code < 300,
-       };
-    } else if (type === 'callback') {
-      const {
-        callbackUrl,
-        request,
-        result,
-      } = payload;
-      jobLog(`job ${jobId} > sending callback to ${callbackUrl}`);
-      await require('../lib/callback').sendCallback({
-        callbackUrl,
-        request,
-        result,
-      });
-      resultValue = { success: true };
-    } else if (type === 'plugin') {
-      const {
-        method,
-        payload,
-      } = params;
-      const plugins = await (async () => {
-        if (inTesting) {
-          const fakePlugin = require('../test/plugin');
-          return [...pluginsParam, await new fakePlugin({ name: pluginName })];
-        }
-        return pluginsParam;
-      })();
-      const thePlugin = plugins.find(({ name }) => name === pluginName);
-      resultValue = await thePlugin[method]({
-        ...payload,
-        token: params.token,
-        plugins,
-        typeDefsAndQueries: require('../controllers/bookings').typeDefsAndQueries,
-      });
-    }
-    jobLog(`job ${jobId} > completed`);
-    await saveResult({ id: jobId, resultValue });
-  });
+    });
+  };
 };
 
 module.exports = async args => throng({

package/worker/queue.js

@@ -141,6 +141,7 @@ const jobStatus = async ({ jobId }) => {
     };
   }
 };
+
 module.exports = {
   addJob,
   allDone,