All files / redis-smq-api/src/workers time-series.clean-up.worker.ts

92.15% Statements 47/51
62.5% Branches 10/16
100% Functions 22/22
97.91% Lines 47/48

Press n or j to go to the next uncovered block, b, p or k for the previous block.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136    57x 57x 57x 57x 57x 57x 57x 57x 57x 57x 57x 57x     57x 35x             35x     35x 45x     45x   45x   45x           35x       45x     27x     27x   27x   27x                 35x         27x     10x     10x         10x                       35x 45x 45x   45x   45x 45x   45x 45x 45x 45x         45x     27x       27x   27x 27x                             57x  
import { RedisClient } from 'redis-smq/dist/src/common/redis-client/redis-client';
import { ICallback, TQueueParams } from 'redis-smq/dist/types';
import { Worker } from 'redis-smq/dist/src/common/worker/worker';
import { eachOf, waterfall } from 'redis-smq/dist/src/util/async';
import { consumerQueues } from 'redis-smq/dist/src/lib/consumer/consumer-queues';
import { Queue } from 'redis-smq/dist/src/lib/queue-manager/queue';
import { GlobalAcknowledgedTimeSeries } from '../plugins/message-rate/consumer/global-acknowledged-time-series';
import { GlobalPublishedTimeSeries } from '../plugins/message-rate/producer/global-published-time-series';
import { GlobalDeadLetteredTimeSeries } from '../plugins/message-rate/consumer/global-dead-lettered-time-series';
import { QueueAcknowledgedTimeSeries } from '../plugins/message-rate/consumer/queue-acknowledged-time-series';
import { QueueDeadLetteredTimeSeries } from '../plugins/message-rate/consumer/queue-dead-lettered-time-series';
import { QueuePublishedTimeSeries } from '../plugins/message-rate/producer/queue-published-time-series';
import { ConsumerAcknowledgedTimeSeries } from '../plugins/message-rate/consumer/consumer-acknowledged-time-series';
import { ConsumerDeadLetteredTimeSeries } from '../plugins/message-rate/consumer/consumer-dead-lettered-time-series';
import { IMonitorWorkerParameters } from '../../types';
 
export class TimeSeriesCleanUpWorker extends Worker<IMonitorWorkerParameters> {
  protected enabled = true;
 
  constructor(
    redisClient: RedisClient,
    params: IMonitorWorkerParameters,
    managed: boolean,
  ) {
    super(redisClient, params, managed);
  }
 
  protected cleanUpGlobalTimeSeries = (cb: ICallback<void>): void => {
    waterfall(
      [
        (cb: ICallback<void>) =>
          GlobalAcknowledgedTimeSeries(this.redisClient).cleanUp(cb),
        (cb: ICallback<void>) =>
          GlobalPublishedTimeSeries(this.redisClient).cleanUp(cb),
        (cb: ICallback<void>) =>
          GlobalDeadLetteredTimeSeries(this.redisClient).cleanUp(cb),
      ],
      cb,
    );
  };
 
  protected cleanUpQueueTimeSeries = (
    queues: TQueueParams[],
    cb: ICallback<void>,
  ): void => {
    eachOf(
      queues,
      (queue, _, done) => {
        waterfall(
          [
            (cb: ICallback<void>) =>
              QueueAcknowledgedTimeSeries(this.redisClient, queue).cleanUp(cb),
            (cb: ICallback<void>) =>
              QueueDeadLetteredTimeSeries(this.redisClient, queue).cleanUp(cb),
            (cb: ICallback<void>) =>
              QueuePublishedTimeSeries(this.redisClient, queue).cleanUp(cb),
          ],
          done,
        );
      },
      cb,
    );
  };
 
  protected cleanUpConsumerTimeSeries = (
    consumerIds: string[],
    queue: TQueueParams,
    cb: ICallback<void>,
  ): void => {
    eachOf(
      consumerIds,
      (consumerId, _, done) => {
        waterfall(
          [
            (cb: ICallback<void>) =>
              ConsumerAcknowledgedTimeSeries(
                this.redisClient,
                consumerId,
              ).cleanUp(cb),
            (cb: ICallback<void>) =>
              ConsumerDeadLetteredTimeSeries(
                this.redisClient,
                consumerId,
              ).cleanUp(cb),
          ],
          done,
        );
      },
      cb,
    );
  };
 
  work = (cb: ICallback<void>): void => {
    if (this.enabled) {
      waterfall(
        [
          (cb: ICallback<void>) => this.cleanUpGlobalTimeSeries(cb),
          (cb: ICallback<TQueueParams[]>) =>
            Queue.list(this.redisClient, (err, reply) => {
              Iif (err) cb(err);
              else {
                const queues = reply ?? [];
                this.cleanUpQueueTimeSeries(queues, (err) => {
                  Iif (err) cb(err);
                  else cb(null, queues);
                });
              }
            }),
          (queues: TQueueParams[], cb: ICallback<void>) => {
            eachOf(
              queues,
              (queue, _, done) => {
                consumerQueues.getQueueConsumerIds(
                  this.redisClient,
                  queue,
                  (err, reply) => {
                    Iif (err) done(err);
                    else {
                      const consumerIds = reply ?? [];
                      this.cleanUpConsumerTimeSeries(consumerIds, queue, done);
                    }
                  },
                );
              },
              cb,
            );
          },
        ],
        cb,
      );
    } else Ecb();
  };
}
 
export default TimeSeriesCleanUpWorker;