@unchainedshop/core-worker 1.1.3

package/src/workers/BaseWorker.ts

@@ -0,0 +1,116 @@
+import { IWorker, Work } from '@unchainedshop/types/worker';
+import later from 'later';
+import { log } from '@unchainedshop/logger';
+import os from 'os';
+import { WorkerDirector } from '../director/WorkerDirector';
+
+const { UNCHAINED_WORKER_ID } = process.env;
+
+const resolveWorkerId = (customWorkerId: string, type: string) =>
+  customWorkerId || UNCHAINED_WORKER_ID || `${os.hostname()}:${type}`;
+
+interface WorkerParams {
+  workerId: string;
+  worker: IWorker<any>;
+}
+
+export const BaseWorker: IWorker<WorkerParams> = {
+  key: 'shop.unchained.worker.base',
+  label: 'Base worker. Do not use this directly.',
+  version: '1.0',
+  type: 'BASE',
+
+  getFloorDate: (date = new Date()) => {
+    const floored = new Date(Math.floor(date.getTime() / 1000) * 1000);
+    return floored;
+  },
+
+  getInternalTypes() {
+    return WorkerDirector.getActivePluginTypes().filter((type) => type !== 'EXTERNAL');
+  },
+
+  actions: ({ workerId, worker }: WorkerParams, requestContext) => {
+    const resolvedWorkerId = resolveWorkerId(workerId, worker.type);
+    log(`${worker.key} -> Initialized: ${resolvedWorkerId}`);
+
+    const workerActions = {
+      start() {
+        throw new Error(`Not implemented on ${this.constructor.key}`);
+      },
+
+      stop() {
+        throw new Error(`Not implemented on ${this.constructor.key}`);
+      },
+
+      reset: async (referenceDate = new Date()) => {
+        await requestContext.modules.worker.markOldWorkAsFailed({
+          types: BaseWorker.getInternalTypes(),
+          worker: workerId,
+          referenceDate,
+        });
+      },
+
+      autorescheduleTypes: async ({ referenceDate }) => {
+        return Promise.all(
+          WorkerDirector.getAutoSchedules().map(async ([type, work]) => {
+            const { schedule, input, ...rest } = work;
+            const fixedSchedule = { ...schedule };
+            fixedSchedule.schedules[0].s = [0]; // ignore seconds, always run on second 0
+            const nextDate = later.schedule(fixedSchedule).next(1, referenceDate);
+            nextDate.setMilliseconds(0);
+            return requestContext.modules.worker.ensureOneWork({
+              type,
+              input: input(),
+              scheduled: nextDate,
+              worker: workerId,
+              ...rest,
+              retries: 0,
+            });
+          }),
+        );
+      },
+
+      process: async ({ maxWorkItemCount, referenceDate }) => {
+        await workerActions.autorescheduleTypes({
+          referenceDate,
+        });
+
+        const processRecursively = async (recursionCounter = 0) => {
+          if (maxWorkItemCount && maxWorkItemCount < recursionCounter) return null;
+
+          const work = await requestContext.modules.worker.allocateWork({
+            types: BaseWorker.getInternalTypes(),
+            worker: workerId,
+          });
+
+          let doneWork: Work | null = null;
+
+          if (work) {
+            const output = await requestContext.modules.worker.doWork(work, requestContext);
+
+            doneWork = await requestContext.modules.worker.finishWork(
+              work._id,
+              {
+                ...output,
+                finished: work.finished || new Date(),
+                started: work.started,
+                worker: workerId,
+              },
+              '0',
+            );
+          }
+
+          if (doneWork) return processRecursively(recursionCounter + 1);
+
+          return null;
+        };
+
+        await processRecursively();
+      },
+    };
+
+    workerActions.reset();
+
+    return workerActions;
+  },
+};

package/src/workers/EventListenerWorker.ts

@@ -0,0 +1,55 @@
+import { IWorker } from '@unchainedshop/types/worker';
+import { WorkerEventTypes } from '../director/WorkerEventTypes';
+import { WorkerDirector } from '../director/WorkerDirector';
+import { BaseWorker } from './BaseWorker';
+
+export const EventListenerWorker: IWorker<{ workerId: string }> = {
+  ...BaseWorker,
+
+  key: 'shop.unchained.worker.event-listener',
+  label: 'Allocates work on events. This worker does not make sense on multiple containers.',
+  version: '1.0',
+  type: 'EVENT_LISTENER',
+
+  actions: ({ workerId }, requestContext) => {
+    let onAdded: () => Promise<void>;
+    let onFinished: () => Promise<void>;
+
+    const baseWorkerActions = BaseWorker.actions(
+      { workerId, worker: EventListenerWorker },
+      requestContext,
+    );
+    return {
+      ...baseWorkerActions,
+
+      start() {
+        onAdded = async () => {
+          await baseWorkerActions.process({
+            maxWorkItemCount: 0,
+            referenceDate: EventListenerWorker.getFloorDate(),
+          });
+        };
+        onFinished = async () => {
+          await baseWorkerActions.process({
+            maxWorkItemCount: 0,
+            referenceDate: EventListenerWorker.getFloorDate(),
+          });
+        };
+
+        WorkerDirector.events.on(WorkerEventTypes.ADDED, onAdded);
+        WorkerDirector.events.on(WorkerEventTypes.FINISHED, onFinished);
+
+        setTimeout(async () => {
+          await baseWorkerActions.autorescheduleTypes({
+            referenceDate: EventListenerWorker.getFloorDate(),
+          });
+        }, 300);
+      },
+
+      stop() {
+        WorkerDirector.events.off(WorkerEventTypes.ADDED, onAdded);
+        WorkerDirector.events.off(WorkerEventTypes.FINISHED, onFinished);
+      },
+    };
+  },
+};

package/src/workers/IntervalWorker.ts

@@ -0,0 +1,57 @@
+import { Context } from '@unchainedshop/types/api';
+import { IWorker, WorkerSchedule } from '@unchainedshop/types/worker';
+import later from 'later';
+import { BaseWorker } from './BaseWorker';
+
+const { NODE_ENV } = process.env;
+
+interface WorkerParams {
+  workerId: string;
+  batchCount?: number;
+  schedule: WorkerSchedule | string;
+}
+
+const defaultSchedule = later.parse.text(
+  NODE_ENV !== 'production' ? 'every 2 seconds' : 'every 30 seconds',
+) as WorkerSchedule;
+
+export const scheduleToInterval = (scheduleRaw: WorkerSchedule | string) => {
+  const referenceDate = new Date(1000);
+  const schedule = typeof scheduleRaw === 'string' ? later.parse.text(scheduleRaw) : scheduleRaw;
+  const [one, two] = later.schedule(schedule).next(2, referenceDate);
+  const diff = new Date(two).getTime() - new Date(one).getTime();
+  return Math.min(1000 * 60 * 60, diff); // at least once every hour!
+};
+
+export const IntervalWorker: IWorker<WorkerParams> = {
+  ...BaseWorker,
+
+  key: 'shop.unchained.worker.cron',
+  label: 'Allocates work on fixed intervals with native node setInterval',
+  version: '1.0',
+  type: 'CRON',
+
+  actions: ({ workerId, batchCount = 0, schedule = defaultSchedule }, requestContext: Context) => {
+    const baseWorkerActions = BaseWorker.actions({ workerId, worker: IntervalWorker }, requestContext);
+
+    const intervalDelay = scheduleToInterval(schedule);
+    let intervalHandle: NodeJS.Timer;
+
+    return {
+      ...baseWorkerActions,
+
+      start() {
+        intervalHandle = setInterval(() => {
+          baseWorkerActions.process({
+            maxWorkItemCount: batchCount,
+            referenceDate: IntervalWorker.getFloorDate(),
+          });
+        }, intervalDelay);
+      },
+
+      stop() {
+        clearInterval(intervalHandle);
+      },
+    };
+  },
+};

package/tests/worker-index.test.ts

@@ -0,0 +1,32 @@
+import { Db } from '@unchainedshop/types/common';
+import { WorkerModule } from '@unchainedshop/types/worker';
+import { assert } from 'chai';
+import {
+  configureWorkerModule,
+  WorkerDirector,
+} from '@unchainedshop/core-worker';
+import { initDb } from 'meteor/unchained:mongodb';
+
+import { ExternalWorkerPlugin } from '../plugins/external';
+
+describe('Test exports', () => {
+  let module: WorkerModule;
+  let db: Db;
+
+  before(async () => {
+    db = await initDb();
+    module = await configureWorkerModule({ db }).catch((error) => {
+      console.warn('ERROR', error);
+      return null;
+    });
+    assert.ok(module);
+  });
+
+  it('Check queries', () => {
+    assert.isFunction(module.addWork);
+  });
+
+  it('Check director', () => {
+    WorkerDirector.doWork({ type: ExternalWorkerPlugin.type });
+  });
+});

package/tsconfig.build.json

@@ -0,0 +1,26 @@
+{
+  "compilerOptions": {
+    "allowJs": true,
+    "allowSyntheticDefaultImports": true,
+    "declaration": true,
+    "esModuleInterop": true,
+    "experimentalDecorators": true,
+    "forceConsistentCasingInFileNames": true,
+    "lib": ["esnext"],
+    "module": "esnext",
+    "moduleResolution": "node",
+    "noImplicitReturns": true,
+    "noUnusedLocals": false,
+    "outDir": "lib",
+    "preserveWatchOutput": true,
+    "skipLibCheck": true,
+    "sourceMap": true,
+    "target": "esnext",
+    "types": ["node"],
+    "baseUrl": ".", // This must be specified if "paths" is.
+    "paths": {
+      "meteor/unchained:*": ["node_modules/@unchainedshop/types/index.d.ts"]
+    }
+  },
+  "include": ["src"]
+}

package/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "./tsconfig.build.json",
+  "compilerOptions": {
+    "noEmit": true,
+    "types": ["node", "mocha"]
+  },
+  "include": ["src", "tests", "plugins"]
+}