bullmq 4.0.0-beta.2 → 4.0.0

package/src/classes/redis-connection.ts

@@ -1,127 +0,0 @@
-import { EventEmitter } from 'events';
-import IORedis, { Redis } from 'ioredis';
-import * as semver from 'semver';
-import { load } from '../commands';
-import { ConnectionOptions, RedisOptions } from '../interfaces';
-
-export class RedisConnection extends EventEmitter {
-  static minimumVersion = '5.0.0';
-  private _client: Redis;
-  private initializing: Promise<Redis>;
-
-  constructor(private opts?: ConnectionOptions) {
-    super();
-
-    if (!(opts instanceof IORedis)) {
-      this.opts = Object.assign(
-        {
-          port: 6379,
-          host: '127.0.0.1',
-          retryStrategy: function(times: number) {
-            return Math.min(Math.exp(times), 20000);
-          },
-        },
-        opts,
-      );
-    } else {
-      this._client = opts;
-    }
-
-    this.initializing = this.init();
-
-    this.initializing
-      .then(client => client.on('error', this.emit.bind(this)))
-      .catch(err => this.emit('error', err));
-  }
-
-  /**
-   * Waits for a redis client to be ready.
-   * @param {Redis} redis client
-   */
-  static async waitUntilReady(client: IORedis.Redis) {
-    return new Promise(function(resolve, reject) {
-      if (client.status === 'ready') {
-        resolve();
-      } else {
-        async function handleReady() {
-          client.removeListener('error', handleError);
-          await load(client);
-          resolve();
-        }
-
-        function handleError(err: Error) {
-          client.removeListener('ready', handleReady);
-          reject(err);
-        }
-
-        client.once('ready', handleReady);
-        client.once('error', handleError);
-      }
-    });
-  }
-
-  get client(): Promise<Redis> {
-    return this.initializing;
-  }
-
-  private async init() {
-    const opts = this.opts as RedisOptions;
-    if (!this._client) {
-      this._client = new IORedis(opts);
-    }
-
-    await RedisConnection.waitUntilReady(this._client);
-
-    if (opts.skipVersionCheck !== true) {
-      const version = await this.getRedisVersion();
-      if (semver.lt(version, RedisConnection.minimumVersion)) {
-        throw new Error(
-          `Redis version needs to be greater than ${RedisConnection.minimumVersion} Current: ${version}`,
-        );
-      }
-    }
-    return this._client;
-  }
-
-  async disconnect() {
-    const client = await this.client;
-    if (client.status !== 'end') {
-      let _resolve, _reject;
-
-      const disconnecting = new Promise((resolve, reject) => {
-        client.once('end', resolve);
-        client.once('error', reject);
-        _resolve = resolve;
-        _reject = reject;
-      });
-
-      client.disconnect();
-
-      try {
-        await disconnecting;
-      } finally {
-        client.removeListener('end', _resolve);
-        client.removeListener('error', _reject);
-      }
-    }
-  }
-
-  async reconnect() {
-    const client = await this.client;
-    return client.connect();
-  }
-
-  async close() {}
-
-  private async getRedisVersion() {
-    const doc = await this._client.info();
-    const prefix = 'redis_version:';
-    const lines = doc.split('\r\n');
-
-    for (let i = 0; i < lines.length; i++) {
-      if (lines[i].indexOf(prefix) === 0) {
-        return lines[i].substr(prefix.length);
-      }
-    }
-  }
-}

package/src/classes/repeat.ts

@@ -1,212 +0,0 @@
-import { createHash } from 'crypto';
-import { JobsOptions, RepeatOptions } from '../interfaces';
-import { Job, QueueBase } from './';
-
-const parser = require('cron-parser');
-
-export class Repeat extends QueueBase {
-  async addNextRepeatableJob(
-    name: string,
-    data: any,
-    opts: JobsOptions,
-    skipCheckExists?: boolean,
-  ) {
-    const repeatOpts = { ...opts.repeat };
-    const prevMillis = repeatOpts.prevMillis || 0;
-    const currentCount = repeatOpts.count ? repeatOpts.count + 1 : 1;
-
-    if (
-      typeof repeatOpts.limit !== 'undefined' &&
-      currentCount > repeatOpts.limit
-    ) {
-      return;
-    }
-
-    let now = Date.now();
-    now = prevMillis < now ? now : prevMillis;
-
-    const nextMillis = getNextMillis(now, repeatOpts);
-
-    if (nextMillis) {
-      const repeatJobKey = getRepeatKey(name, repeatOpts);
-
-      let repeatableExists = true;
-
-      if (!skipCheckExists) {
-        // Check that the repeatable job hasn't been removed
-        // TODO: a lua script would be better here
-        const client = await this.client;
-        repeatableExists = !!(await client.zscore(
-          this.keys.repeat,
-          repeatJobKey,
-        ));
-      }
-
-      // The job could have been deleted since this check
-      if (repeatableExists) {
-        return this.createNextJob(
-          name,
-          nextMillis,
-          repeatJobKey,
-          { ...opts, repeat: repeatOpts },
-          data,
-          currentCount,
-        );
-      }
-    }
-  }
-
-  private async createNextJob(
-    name: string,
-    nextMillis: number,
-    repeatJobKey: string,
-    opts: JobsOptions,
-    data: any,
-    currentCount: number,
-  ) {
-    const client = await this.client;
-
-    //
-    // Generate unique job id for this iteration.
-    //
-    const jobId = getRepeatJobId(name, nextMillis, md5(repeatJobKey));
-    const now = Date.now();
-    const delay = nextMillis - now;
-
-    const mergedOpts = {
-      ...opts,
-      jobId,
-      delay: delay < 0 ? 0 : delay,
-      timestamp: now,
-      prevMillis: nextMillis,
-    };
-
-    mergedOpts.repeat = { ...opts.repeat, count: currentCount };
-
-    await client.zadd(this.keys.repeat, nextMillis.toString(), repeatJobKey);
-
-    return Job.create(this, name, data, mergedOpts);
-  }
-
-  async removeRepeatable(name: string, repeat: RepeatOptions, jobId?: string) {
-    const client = await this.client;
-
-    const repeatJobKey = getRepeatKey(name, repeat);
-    const repeatJobId = getRepeatJobId(name, '', md5(repeatJobKey));
-    const queueKey = this.keys[''];
-
-    return (<any>client).removeRepeatable(
-      this.keys.repeat,
-      this.keys.delayed,
-      repeatJobId,
-      repeatJobKey,
-      queueKey,
-    );
-  }
-
-  async removeRepeatableByKey(repeatJobKey: string) {
-    const client = await this.client;
-
-    const data = this._keyToData(repeatJobKey);
-    const queueKey = this.keys[''];
-
-    return (<any>client).removeRepeatable(
-      this.keys.repeat,
-      this.keys.delayed,
-      data.id,
-      repeatJobKey,
-      queueKey,
-    );
-  }
-
-  _keyToData(key: string) {
-    const data = key.split(':');
-
-    return {
-      key,
-      name: data[0],
-      id: data[1] || null,
-      endDate: parseInt(data[2]) || null,
-      tz: data[3] || null,
-      cron: data[4],
-    };
-  }
-
-  async getRepeatableJobs(start = 0, end = -1, asc = false) {
-    const client = await this.client;
-
-    const key = this.keys.repeat;
-    const result = asc
-      ? await client.zrange(key, start, end, 'WITHSCORES')
-      : await client.zrevrange(key, start, end, 'WITHSCORES');
-
-    const jobs = [];
-    for (let i = 0; i < result.length; i += 2) {
-      const data = result[i].split(':');
-      jobs.push({
-        key: result[i],
-        name: data[0],
-        id: data[1] || null,
-        endDate: parseInt(data[2]) || null,
-        tz: data[3] || null,
-        cron: data[4],
-        next: parseInt(result[i + 1]),
-      });
-    }
-    return jobs;
-  }
-
-  async getRepeatableCount() {
-    const client = await this.client;
-    return client.zcard(this.toKey('repeat'));
-  }
-}
-
-function getRepeatJobId(
-  name: string,
-  nextMillis: number | string,
-  namespace: string,
-) {
-  return `repeat:${name}:${namespace}:${nextMillis}`;
-}
-
-function getRepeatKey(name: string, repeat: RepeatOptions) {
-  const endDate = repeat.endDate ? new Date(repeat.endDate).getTime() : '';
-  const tz = repeat.tz || '';
-  const suffix = (repeat.cron ? repeat.cron : String(repeat.every)) || '';
-
-  return `${name}::${endDate}:${tz}:${suffix}`;
-}
-
-function getNextMillis(millis: number, opts: RepeatOptions) {
-  if (opts.cron && opts.every) {
-    throw new Error(
-      'Both .cron and .every options are defined for this repeatable job',
-    );
-  }
-
-  if (opts.every) {
-    return Math.floor(millis / opts.every) * opts.every + opts.every;
-  }
-
-  const currentDate =
-    opts.startDate && new Date(opts.startDate) > new Date(millis)
-      ? new Date(opts.startDate)
-      : new Date(millis);
-  const interval = parser.parseExpression(opts.cron, {
-    ...opts,
-    currentDate,
-  });
-
-  try {
-    return interval.next().getTime();
-  } catch (e) {
-    // Ignore error
-  }
-}
-
-function md5(str: string) {
-  return createHash('md5')
-    .update(str)
-    .digest('hex');
-}

package/src/classes/sandbox.ts

@@ -1,60 +0,0 @@
-const sandbox = (processFile: any, childPool: any) => {
-  return async function process(job: any) {
-    const child = await childPool.retain(processFile);
-    let msgHandler: any;
-    let exitHandler: any;
-
-    child.send({
-      cmd: 'start',
-      job: job.toJSON(),
-    });
-
-    const done = new Promise((resolve, reject) => {
-      msgHandler = (msg: any) => {
-        switch (msg.cmd) {
-          case 'completed':
-            resolve(msg.value);
-            break;
-          case 'failed':
-          case 'error': {
-            const err = new Error();
-            Object.assign(err, msg.value);
-            reject(err);
-            break;
-          }
-          case 'progress':
-            job.updateProgress(msg.value);
-            break;
-          case 'log':
-            job.log(msg.value);
-            break;
-        }
-      };
-
-      exitHandler = (exitCode: any, signal: any) => {
-        reject(
-          new Error('Unexpected exit code: ' + exitCode + ' signal: ' + signal),
-        );
-      };
-
-      child.on('message', msgHandler);
-      child.on('exit', exitHandler);
-    });
-
-    try {
-      await done;
-      return done;
-    } finally {
-      child.removeListener('message', msgHandler);
-      child.removeListener('exit', exitHandler);
-
-      if (child.exitCode !== null) {
-        childPool.remove(child);
-      } else {
-        childPool.release(child);
-      }
-    }
-  };
-};
-
-export default sandbox;