@nexrender/worker 1.54.5 → 1.56.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nexrender/worker",
-  "version": "1.54.5",
+  "version": "1.56.0",
   "author": "inlife",
   "main": "src/index.js",
   "homepage": "https://www.nexrender.com",
@@ -29,5 +29,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "3a39217ea769e9d086d65d8cd2538c14cc3826d6"
+  "gitHead": "1387723d3320220f66ead9e9ca081cb287a8d9b4"
 }

package/readme.md

@@ -96,4 +96,4 @@ Available settings (almost same as for `nexrender-core`):
 * `actions` - an object with keys corresponding to the `module` field when defining an action, value should be a function matching expected signature of an action. Used for defining actions programmatically without needing to package the action as a separate package
 * `cache` - boolean or string. Set the cache folder used by HTTP assets. If `true` will use the default path of `${workpath}/http-cache`, if set to a string it will be interpreted as a filesystem path to the cache folder.
 * `name` - string. An unique name (or not) to the `nexrender-worker`, and it will be identified in the `nexrender-server`. It can be used as an executor name on picked job(s) as well.
-
+* `handleInterruption` - boolean, if set to true, enables handling of interruption signals (SIGINT, SIGTERM). When an interruption signal is received, the worker will attempt to update the current job's state to 'queued' before shutting down. (false by default)

package/src/bin.js

@@ -29,6 +29,7 @@ const args = arg({
     '--tolerate-empty-queues':  Number,
     '--stop-at-time':           String,
     '--stop-days':              String,
+    '--wait-between-jobs':      Number,
 
     '--skip-cleanup':           Boolean,
     '--skip-render':            Boolean,
@@ -48,6 +49,8 @@ const args = arg({
     '--aerender-parameter':     [String],
     '--language':               String,
 
+    '--handle-interruption':     Boolean,
+
     // Aliases
     '-v':           '--version',
     '-t':           '--tag-selector',
@@ -126,15 +129,15 @@ if (args['--help']) {
     --tolerate-empty-queues                 worker will check an empty queue this many times before exiting (if that option has
                                             been set using --exit-on-empty-queues). Defaults to zero. If specified will be used instead of
                                             NEXRENDER_TOLERATE_EMPTY_QUEUES env variable
-                                            
+
     --stop-at-time                          worker will exit at the given time if given.
-                                            example: 5:00 will stop at 5 am local time.  
-    
+                                            example: 5:00 will stop at 5 am local time.
+
     --stop-days                             comma separated list of weekdays when to stop. Must be used together with --stop-at-time
                                             0 is sunday, 6 is saturday
                                             example: --stop-at-time=5:00 stop-days=1,2,3,4,5
-                                            will stop at 5 am but not on weekend                                          
-                                            
+                                            will stop at 5 am but not on weekend
+
     --no-license                            prevents creation of the ae_render_only_node.txt file (enabled by default),
                                             which allows free usage of trial version of Adobe After Effects
 
@@ -152,6 +155,8 @@ if (args['--help']) {
     --polling                               amount of miliseconds to wait before checking queued projects from the api,
                                             if specified will be used instead of NEXRENDER_API_POLLING env variable
 
+    --wait-between-jobs                     amount of miliseconds to wait before checking queued projects from the api
+
     --header                                Define custom header that the worker will use to communicate with nexrender-server.
                                             Accepted format follows curl or wget request header definition,
                                             eg. --header="Some-Custom-Header: myCustomValue".
@@ -178,8 +183,8 @@ if (args['--help']) {
     --aerender-parameter, --ae              forward parameter to aerender (see Adobe site). Parameters with arguments have to be
                                             enclosed in single quotes. For example:
                                             nexrender --aerender-parameter 'close SAVE_CHANGES' --ae 'i 10' job.json
-                                            
-    --language                              language of local after effects installation. currently only en and de are supported                                        
+
+    --language                              language of local after effects installation. currently only en and de are supported
 
 
   {bold ENV VARS}
@@ -190,6 +195,7 @@ if (args['--help']) {
 
       {bold $} NEXRENDER_API_POLLING=1000 {cyan nexrender-worker}
 `);
+
     process.exit(2);
 }
 
@@ -234,6 +240,7 @@ opt('tolerateEmptyQueues',  '--tolerate-empty-queues');
 opt('exitOnEmptyQueue',     '--exit-on-empty-queue');
 opt('stopAtTime',           '--stop-at-time');
 opt('stopDays',             '--stop-days');
+opt('waitBetweenJobs',      '--wait-between-jobs');
 opt('maxMemoryPercent',     '--max-memory-percent');
 opt('imageCachePercent',    '--image-cache-percent');
 opt('polling',              '--polling');
@@ -241,6 +248,7 @@ opt('wslMap',               '--wsl-map');
 opt('aeParams',             '--aerender-parameter');
 opt('tagSelector',          '--tag-selector');
 opt('language',             '--language');
+opt('handleInterruption',    '--handle-interruption');
 
 if(args['--cache-path']){
     opt('cache', '--cache-path');

package/src/instance.js

@@ -13,13 +13,32 @@ const createWorker = () => {
     let active = false;
     let settingsRef = null;
     let stop_datetime = null;
+    let currentJob = null;
+    let client = null;
+
+    // New function to handle interruption
+    const handleInterruption = async () => {
+        if (currentJob) {
+            settingsRef.logger.log(`[${currentJob.uid}] Interruption signal received. Updating job state to 'queued'...`);
+            currentJob.onRenderProgress = null;
+            currentJob.state = 'queued';
+            try {
+                await client.updateJob(currentJob.uid, getRenderingStatus(currentJob));
+                settingsRef.logger.log(`[${currentJob.uid}] Job state updated to 'queued' successfully.`);
+            } catch (err) {
+                settingsRef.logger.error(`[${currentJob.uid}] Failed to update job state: ${err.message}`);
+            }
+        }
+        active = false;
+        process.exit(0);
+    };
 
     const nextJob = async (client, settings) => {
         do {
             try {
                 if (stop_datetime !== null && new Date() > stop_datetime) {
                     active = false;
-                    return
+                    return null
                 }
 
                 let job = await (settings.tagSelector ?
@@ -63,6 +82,7 @@ const createWorker = () => {
             process: 'nexrender-worker',
             stopOnError: false,
             logger: console,
+            handleInterruption: false,
         }, settings))
 
         settingsRef = settings;
@@ -85,7 +105,7 @@ const createWorker = () => {
         headers = headers || {};
         headers['user-agent'] = ('nexrender-worker/' + pkg.version + ' ' + (headers['user-agent'] || '')).trim();
 
-        const client = createClient({ host, secret, headers, name: settings.name });
+        client = createClient({ host, secret, headers, name: settings.name });
 
         settings.track('Worker Started', {
             worker_tags_set: !!settings.tagSelector,
@@ -114,95 +134,111 @@ const createWorker = () => {
             }
         }
 
-        do {
+        // Set up interruption handlers if enabled
+        if (settings.handleInterruption) {
+            process.on('SIGINT', handleInterruption);
+            process.on('SIGTERM', handleInterruption);
+            settingsRef.logger.log('Interruption handling enabled.');
+        }
 
-            let job = await nextJob(client, settings);
+        do {
+            currentJob = await nextJob(client, settings);
 
             // if the worker has been deactivated, exit this loop
             if (!active) break;
 
             settings.track('Worker Job Started', {
-                job_id: job.uid, // anonymized internally
+                job_id: currentJob.uid, // anonymized internally
             })
 
-            job.state = 'started';
-            job.startedAt = new Date()
+            currentJob.state = 'started';
+            currentJob.startedAt = new Date()
 
             try {
-                await client.updateJob(job.uid, job)
+                await client.updateJob(currentJob.uid, currentJob)
             } catch (err) {
-                console.log(`[${job.uid}] error while updating job state to ${job.state}. Job abandoned.`)
-                console.log(`[${job.uid}] error stack: ${err.stack}`)
+                console.log(`[${currentJob.uid}] error while updating job state to ${currentJob.state}. Job abandoned.`)
+                console.log(`[${currentJob.uid}] error stack: ${err.stack}`)
                 continue;
             }
 
             try {
-                job.onRenderProgress = (job) => {
+                currentJob.onRenderProgress = (currentJob) => {
                     try {
                         /* send render progress to our server */
-                        client.updateJob(job.uid, getRenderingStatus(job));
+                        client.updateJob(currentJob.uid, getRenderingStatus(currentJob));
 
                         if (settings.onRenderProgress) {
-                            settings.onRenderProgress(job);
+                            settings.onRenderProgress(currentJob);
                         }
                     } catch (err) {
                         if (settings.stopOnError) {
                             throw err;
                         } else {
-                            console.log(`[${job.uid}] error occurred: ${err.stack}`)
-                            console.log(`[${job.uid}] render proccess stopped with error...`)
-                            console.log(`[${job.uid}] continue listening next job...`)
+                            console.log(`[${currentJob.uid}] error occurred: ${err.stack}`)
+                            console.log(`[${currentJob.uid}] render proccess stopped with error...`)
+                            console.log(`[${currentJob.uid}] continue listening next job...`)
                         }
                     }
                 }
 
-                job.onRenderError = (job, err /* on render error */) => {
-                    job.error = [].concat(job.error || [], [err.toString()]);
+                currentJob.onRenderError = (currentJob, err /* on render error */) => {
+                    currentJob.error = [].concat(currentJob.error || [], [err.toString()]);
 
                     if (settings.onRenderError) {
-                        settings.onRenderError(job, err);
+                        settings.onRenderError(currentJob, err);
                     }
                 }
 
-                job = await render(job, settings); {
-                    job.state = 'finished';
-                    job.finishedAt = new Date();
+                currentJob = await render(currentJob, settings); {
+                    currentJob.state = 'finished';
+                    currentJob.finishedAt = new Date();
                     if (settings.onFinished) {
-                        settings.onFinished(job);
+                        settings.onFinished(currentJob);
                     }
                 }
 
-                settings.track('Worker Job Finished', { job_id: job.uid })
+                settings.track('Worker Job Finished', { job_id: currentJob.uid })
 
-                await client.updateJob(job.uid, getRenderingStatus(job))
+                await client.updateJob(currentJob.uid, getRenderingStatus(currentJob))
             } catch (err) {
-                job.error = [].concat(job.error || [], [err.toString()]);
-                job.errorAt = new Date();
-                job.state = 'error';
+                currentJob.error = [].concat(currentJob.error || [], [err.toString()]);
+                currentJob.errorAt = new Date();
+                currentJob.state = 'error';
 
-                settings.track('Worker Job Error', { job_id: job.uid });
+                settings.track('Worker Job Error', { job_id: currentJob.uid });
 
                 if (settings.onError) {
-                    settings.onError(job, err);
+                    settings.onError(currentJob, err);
                 }
 
                 try {
-                    await client.updateJob(job.uid, getRenderingStatus(job))
+                    await client.updateJob(currentJob.uid, getRenderingStatus(currentJob))
                 }
                 catch (e) {
-                    console.log(`[${job.uid}] error while updating job state to ${job.state}. Job abandoned.`)
-                    console.log(`[${job.uid}] error stack: ${e.stack}`)
+                    console.log(`[${currentJob.uid}] error while updating job state to ${currentJob.state}. Job abandoned.`)
+                    console.log(`[${currentJob.uid}] error stack: ${e.stack}`)
                 }
 
                 if (settings.stopOnError) {
                     throw err;
                 } else {
-                    console.log(`[${job.uid}] error occurred: ${err.stack}`)
-                    console.log(`[${job.uid}] render proccess stopped with error...`)
-                    console.log(`[${job.uid}] continue listening next job...`)
+                    console.log(`[${currentJob.uid}] error occurred: ${err.stack}`)
+                    console.log(`[${currentJob.uid}] render proccess stopped with error...`)
+                    console.log(`[${currentJob.uid}] continue listening next job...`)
                 }
             }
+
+            if (settings.waitBetweenJobs) {
+                await delay(settings.waitBetweenJobs);
+            }
         } while (active)
+
+        // Clean up interruption handlers
+        if (settings.handleInterruption) {
+            process.removeListener('SIGINT', handleInterruption);
+            process.removeListener('SIGTERM', handleInterruption);
+        }
     }
 
     /**