@bitblit/ratchet-epsilon-common 6.0.145-alpha → 6.0.147-alpha

package/src/background/background-queue-response-internal.ts

@@ -0,0 +1,9 @@
+import { BackgroundProcessHandling } from './background-process-handling.js';
+
+export interface BackgroundQueueResponseInternal {
+  processHandling: BackgroundProcessHandling;
+  startProcessorRequested: boolean;
+  success: boolean;
+  resultId: string;
+  error: string;
+}

package/src/background/background-validator.ts

@@ -0,0 +1,105 @@
+import { ModelValidator } from '@bitblit/ratchet-misc/model-validator/model-validator';
+import { Logger } from '@bitblit/ratchet-common/logger/logger';
+import { ErrorRatchet } from '@bitblit/ratchet-common/lang/error-ratchet';
+import { StringRatchet } from '@bitblit/ratchet-common/lang/string-ratchet';
+import { BackgroundConfig } from '../config/background/background-config.js';
+import { BackgroundEntry } from './background-entry.js';
+import { BackgroundProcessor } from '../config/background/background-processor.js';
+import { BackgroundAwsConfig } from '../config/background/background-aws-config.js';
+
+/**
+ * Handles all submission of work to the background processing system.
+ */
+export class BackgroundValidator {
+  constructor(
+    private cfg: BackgroundConfig,
+    private modelValidator: ModelValidator,
+  ) {}
+
+  public findProcessor(typeName: string): BackgroundProcessor<any> {
+    const rval: BackgroundProcessor<any> = this.cfg.processors.find((s) => s.typeName === typeName);
+    return rval;
+  }
+
+  public validType(type: string): boolean {
+    return !!this.findProcessor(type);
+  }
+
+  public validateEntry<T>(entry: BackgroundEntry<T>): string[] {
+    const rval: string[] = [];
+    if (!entry) {
+      rval.push('Entry is null');
+    } else if (!StringRatchet.trimToNull(entry.type)) {
+      rval.push('Entry type is null or empty');
+      const proc: BackgroundProcessor<any> = this.findProcessor(entry.type);
+
+      if (!proc) {
+        rval.push('Entry type is invalid');
+      }
+    }
+    return rval;
+  }
+
+  public validateEntryAndThrowException<T>(entry: BackgroundEntry<T>): void {
+    const errors: string[] = this.validateEntry(entry);
+    if (errors.length > 0) {
+      Logger.warn('Invalid entry %j : errors : %j', entry, errors);
+      ErrorRatchet.throwFormattedErr('Invalid entry %j : errors : %j', entry, errors);
+    }
+  }
+
+  public static validateAndMapProcessors(
+    processorInput: BackgroundProcessor<any>[],
+    _modelValidator: ModelValidator,
+  ): Map<string, BackgroundProcessor<any>> {
+    const rval: Map<string, BackgroundProcessor<any>> = new Map<string, BackgroundProcessor<any>>();
+    processorInput.forEach((p, idx) => {
+      if (!p) {
+        ErrorRatchet.throwFormattedErr('Null processor provided at index %d', idx);
+      }
+      if (!StringRatchet.trimToNull(p.typeName)) {
+        ErrorRatchet.throwFormattedErr('Processor at index %d defines no name', idx);
+      }
+
+      if (rval.has(p.typeName)) {
+        ErrorRatchet.throwFormattedErr('More than one processor defined for type %s', p.typeName);
+      }
+
+      rval.set(p.typeName, p);
+    });
+    return rval;
+  }
+
+  public static validateAwsConfig(cfg: BackgroundAwsConfig): string[] {
+    const rval: string[] = [];
+    if (!cfg) {
+      rval.push('Null config');
+    } else {
+      if (!cfg.notificationArn) {
+        rval.push('AWS config missing notificationArn');
+      }
+      if (!cfg.queueUrl) {
+        rval.push('AWS config missing queueUrl');
+      }
+      if (
+        (cfg.sendNotificationOnBackgroundError || cfg.sendNotificationOnBackgroundValidationFailure) &&
+        !cfg.backgroundProcessFailureSnsArn
+      ) {
+        rval.push('At least one send notification flag set to true but no sns arn set');
+      }
+    }
+    return rval;
+  }
+
+  public static validateConfig(cfg: BackgroundConfig): string[] {
+    const rval: string[] = [];
+    if (!cfg) {
+      rval.push('Null config');
+    } else {
+      if (!cfg.processors || cfg.processors.length === 0) {
+        rval.push('No processes specified');
+      }
+    }
+    return rval;
+  }
+}

package/src/background/epsilon-background-process-error.ts

@@ -0,0 +1,110 @@
+import { StringRatchet } from '@bitblit/ratchet-common/lang/string-ratchet';
+
+export class EpsilonBackgroundProcessError<T = void> extends Error {
+  private static readonly EPSILON_BACKGROUND_PROCESS_ERROR_FLAG_KEY: string = '__epsilonBackgroundProcessErrorFlag';
+  private _errors: string[];
+  private _detailErrorCode: number;
+  private _details: T;
+  private _requestId: string;
+  private _wrappedError: Error;
+
+  constructor(...errors: string[]) {
+    super(EpsilonBackgroundProcessError.combineErrorStringsWithDefault(errors));
+    Object.setPrototypeOf(this, EpsilonBackgroundProcessError.prototype);
+    this._errors = errors;
+    this[EpsilonBackgroundProcessError.EPSILON_BACKGROUND_PROCESS_ERROR_FLAG_KEY] = true; // Just used to tell if one has been wrapped
+  }
+
+  public static combineErrorStringsWithDefault(errors: string[], defMessage: string = 'Internal Server Error'): string {
+    return errors && errors.length > 0 ? errors.join(',') : defMessage;
+  }
+
+  public setFormattedErrorMessage(format: string, ...input: any[]): void {
+    const msg: string = StringRatchet.format(format, ...input);
+    this.errors = [msg];
+  }
+
+  public withFormattedErrorMessage(format: string, ...input: any[]): EpsilonBackgroundProcessError<T> {
+    this.setFormattedErrorMessage(format, ...input);
+    return this;
+  }
+
+  public withErrors(errors: string[]): EpsilonBackgroundProcessError<T> {
+    this.errors = errors; // Call setter
+    return this;
+  }
+
+  public withDetailErrorCode(detailErrorCode: number): EpsilonBackgroundProcessError<T> {
+    this._detailErrorCode = detailErrorCode; // Call setter
+    return this;
+  }
+
+  public withDetails(details: T): EpsilonBackgroundProcessError<T> {
+    this._details = details; // Call setter
+    return this;
+  }
+
+  public withRequestId(requestId: string): EpsilonBackgroundProcessError<T> {
+    this._requestId = requestId; // Call setter
+    return this;
+  }
+
+  public withWrappedError(err: Error): EpsilonBackgroundProcessError<T> {
+    this._wrappedError = err; // Call setter
+    return this;
+  }
+
+  public isWrappedError(): boolean {
+    return !!this._wrappedError;
+  }
+
+  public static wrapError<T = void>(err: Error): EpsilonBackgroundProcessError<T> {
+    let rval: EpsilonBackgroundProcessError<T> = null;
+    if (EpsilonBackgroundProcessError.objectIsEpsilonBackgroundProcessError(err)) {
+      rval = err as EpsilonBackgroundProcessError<T>;
+    } else {
+      rval = new EpsilonBackgroundProcessError<T>(err.message).withWrappedError(err);
+    }
+    return rval;
+  }
+
+  public static objectIsEpsilonBackgroundProcessError(obj: any): boolean {
+    return obj && obj[EpsilonBackgroundProcessError.EPSILON_BACKGROUND_PROCESS_ERROR_FLAG_KEY] === true;
+  }
+
+  set errors(value: string[]) {
+    this._errors = value || ['Internal Server Error'];
+    this.message = EpsilonBackgroundProcessError.combineErrorStringsWithDefault(this._errors);
+  }
+  get errors(): string[] {
+    return this._errors;
+  }
+
+  set detailErrorCode(value: number) {
+    this._detailErrorCode = value;
+  }
+  get detailErrorCode(): number {
+    return this._detailErrorCode;
+  }
+
+  set details(value: T) {
+    this._details = value;
+  }
+  get details(): T {
+    return this._details;
+  }
+
+  set requestId(value: string) {
+    this._requestId = value || 'MISSING';
+  }
+  get requestId(): string {
+    return this._requestId;
+  }
+
+  set wrappedError(value: Error) {
+    this._wrappedError = value;
+  }
+  get wrappedError(): Error {
+    return this._wrappedError;
+  }
+}

package/src/background/internal-background-entry.ts

@@ -0,0 +1,10 @@
+import { BackgroundEntry } from './background-entry.js';
+
+export interface InternalBackgroundEntry<T> extends BackgroundEntry<T> {
+  guid: string;
+  createdEpochMS: number;
+  traceId: string;
+  traceDepth: number;
+
+  meta?: Record<string, string>;
+}

package/src/background/manager/abstract-background-manager.ts

@@ -0,0 +1,120 @@
+import { Logger } from '@bitblit/ratchet-common/logger/logger';
+import { RequireRatchet } from '@bitblit/ratchet-common/lang/require-ratchet';
+import { ErrorRatchet } from '@bitblit/ratchet-common/lang/error-ratchet';
+import { StringRatchet } from '@bitblit/ratchet-common/lang/string-ratchet';
+import { BackgroundEntry } from '../background-entry.js';
+import { InternalBackgroundEntry } from '../internal-background-entry.js';
+import { DateTime } from 'luxon';
+import { ContextUtil } from '../../util/context-util.js';
+import { BackgroundManagerLike } from './background-manager-like.js';
+
+/**
+ * Handles all submission of work to the background processing system.
+ *
+ * Note that this does NOT validate the input, it just passes it along.  This is
+ * because it creates a circular reference to the processors if we try since they
+ * define the type and validation.
+ */
+export abstract class AbstractBackgroundManager implements BackgroundManagerLike {
+  abstract addEntryToQueue<T>(entry: BackgroundEntry<T>, fireStartMessage?: boolean): Promise<string>;
+  abstract fireImmediateProcessRequest<T>(entry: BackgroundEntry<T>): Promise<string>;
+  abstract fireStartProcessingRequest(): Promise<string>;
+  abstract fetchApproximateNumberOfQueueEntries(): Promise<number>;
+  abstract backgroundManagerName: string;
+  abstract takeEntryFromBackgroundQueue(): Promise<InternalBackgroundEntry<any>[]>;
+
+  public createEntry<T>(type: string, data?: T): BackgroundEntry<T> {
+    const rval: BackgroundEntry<T> = {
+      type: type,
+      data: data,
+    };
+    return rval;
+  }
+
+  public async wrapEntryForInternal<T>(
+    entry: BackgroundEntry<T>,
+    overrideTraceId?: string,
+    overrideTraceDepth?: number,
+  ): Promise<InternalBackgroundEntry<T>> {
+    const rval: InternalBackgroundEntry<T> = Object.assign({}, entry, {
+      createdEpochMS: new Date().getTime(),
+      guid: AbstractBackgroundManager.generateBackgroundGuid(),
+      traceId: overrideTraceId || ContextUtil.currentTraceId(), // || cuz no empty strings allowed
+      traceDepth: overrideTraceDepth || ContextUtil.currentTraceDepth() + 1, // || no 0 allowed either
+    });
+    return rval;
+  }
+
+  public async addEntryToQueueByParts<T>(type: string, data?: T, fireStartMessage?: boolean): Promise<string> {
+    let rval: string = null;
+    const entry: BackgroundEntry<T> = this.createEntry(type, data);
+    if (entry) {
+      rval = await this.addEntryToQueue(entry, fireStartMessage);
+    }
+    return rval;
+  }
+
+  public async addEntriesToQueue(entries: BackgroundEntry<any>[], fireStartMessage?: boolean): Promise<string[]> {
+    const rval: string[] = [];
+    for (const eVal of entries) {
+      //for (let i = 0; i < entries.length; i++) {
+      try {
+        // Always defer the fire to after the last enqueue
+        const tmp: string = await this.addEntryToQueue(eVal, false);
+        rval.push(tmp);
+      } catch (err) {
+        Logger.error('Error processing %j : %s', eVal, err);
+        rval.push(err['message']);
+      }
+
+      if (fireStartMessage) {
+        const fireResult: string = await this.fireStartProcessingRequest();
+        Logger.silly('FireResult : %s', fireResult);
+      }
+    }
+    return rval;
+  }
+
+  public async fireImmediateProcessRequestByParts<T>(type: string, data?: T): Promise<string> {
+    let rval: string = null;
+    const entry: BackgroundEntry<T> = this.createEntry(type, data);
+    if (entry) {
+      rval = await this.fireImmediateProcessRequest(entry);
+    }
+    return rval;
+  }
+
+  public static generateBackgroundGuid(targetEpochMS: number = new Date().getTime()): string {
+    const dt: DateTime = DateTime.fromMillis(targetEpochMS);
+    return dt.toFormat('yyyy-MM-dd-HH-mm-ss-') + StringRatchet.createType4Guid();
+  }
+
+  public static backgroundGuidToPath(prefix: string, guid: string): string {
+    let path: string = StringRatchet.trimToEmpty(prefix);
+    if (path.length && !path.endsWith('/')) {
+      path += '/';
+    }
+    path += guid.substring(0, 4) + '/' + guid.substring(5, 7) + '/' + guid.substring(8, 10) + '/';
+    path += guid + '.json';
+    return path;
+  }
+
+  public static pathToBackgroundGuid(prefix: string, path: string): string {
+    RequireRatchet.notNullOrUndefined(path, 'path');
+    let start: number = 0;
+    if (!path.endsWith('.json')) {
+      ErrorRatchet.throwFormattedErr('Cannot extract guid, does not end with .json : %s : %s', path, prefix);
+    }
+    if (StringRatchet.trimToNull(prefix)) {
+      if (!path.startsWith(prefix)) {
+        ErrorRatchet.throwFormattedErr('Cannot extract guid, does not start with prefix : %s : %s', path, prefix);
+      }
+      start = prefix.length;
+      if (!prefix.endsWith('/')) {
+        start++;
+      }
+    }
+    start += 11;
+    return path.substring(start, path.length - 5); // strip prefix and .json at the end
+  }
+}

package/src/background/manager/aws-large-payload-s3-sqs-sns-background-manager.ts

@@ -0,0 +1,87 @@
+import { SQSClient } from '@aws-sdk/client-sqs';
+import { BackgroundEntry } from '../background-entry.js';
+import { BackgroundAwsConfig } from '../../config/background/background-aws-config.js';
+import { InternalBackgroundEntry } from '../internal-background-entry.js';
+import { SNSClient } from '@aws-sdk/client-sns';
+import { AwsSqsSnsBackgroundManager } from './aws-sqs-sns-background-manager.js';
+import { S3CacheRatchetLike } from '@bitblit/ratchet-aws/s3/s3-cache-ratchet-like';
+import { Logger } from '@bitblit/ratchet-common/logger/logger';
+import { ErrorRatchet } from '@bitblit/ratchet-common/lang/error-ratchet';
+import { StringRatchet } from '@bitblit/ratchet-common/lang/string-ratchet';
+
+/**
+ * Handles all submission of work to the background processing system.
+ *
+ * Note that this does NOT validate the input, it just passes it along.  This is
+ * because it creates a circular reference to the processors if we try since they
+ * define the type and validation.
+ */
+export class AwsLargePayloadS3SqsSnsBackgroundManager extends AwsSqsSnsBackgroundManager {
+  // SQS and SNS payload limit is (256 * 1024). Set threshold lower to allow extra metadata
+  private static readonly LARGE_MESSAGE_SIZE_THRESHOLD: number = 250_000;
+  private static readonly LARGE_MESSAGE_S3_PATH_META_KEY: string = 'S3_STORAGE_KEY';
+
+  constructor(
+    _awsConfig: BackgroundAwsConfig,
+    _sqs: SQSClient,
+    _sns: SNSClient,
+    private _s3: S3CacheRatchetLike,
+    private pathPrefix: string = '',
+  ) {
+    super(_awsConfig, _sqs, _sns);
+    if (!_s3) {
+      ErrorRatchet.throwFormattedErr('Cannot start - no s3Client provided');
+    }
+    if (!StringRatchet.trimToNull(_s3.getDefaultBucket())) {
+      ErrorRatchet.throwFormattedErr('Cannot start - no default bucket provided');
+    }
+    if (!pathPrefix && pathPrefix.endsWith('/')) {
+      ErrorRatchet.throwFormattedErr('Path prefix may not end with /');
+    }
+  }
+
+  public readonly backgroundManagerName: string = 'AwsLargePayloadS3SqsSnsBackgroundManager';
+
+  public get s3(): S3CacheRatchetLike {
+    return this._s3;
+  }
+
+  public async wrapEntryForInternal<T>(
+    entry: BackgroundEntry<T>,
+    overrideTraceId?: string,
+    overrideTraceDepth?: number,
+  ): Promise<InternalBackgroundEntry<T>> {
+    const rval: InternalBackgroundEntry<T> = await super.wrapEntryForInternal(entry, overrideTraceId, overrideTraceDepth);
+
+    const payloadApproximateSize: number = Buffer.byteLength(JSON.stringify(rval), 'utf-8');
+    if (payloadApproximateSize > AwsLargePayloadS3SqsSnsBackgroundManager.LARGE_MESSAGE_SIZE_THRESHOLD) {
+      Logger.info('Message payload is above LARGE_MESSAGE_SIZE_THRESHOLD. Uploading to s3.');
+      rval.meta = rval.meta || {};
+      const pathToData: string = await this.writeMessageToS3(rval.guid, rval.data);
+      rval.meta[AwsLargePayloadS3SqsSnsBackgroundManager.LARGE_MESSAGE_S3_PATH_META_KEY] = pathToData;
+      rval.data = undefined;
+    }
+
+    return rval;
+  }
+
+  private async writeMessageToS3(guid: string, entry: unknown): Promise<string> {
+    let s3FilePath: string = StringRatchet.trimToNull(this.pathPrefix) ? this.pathPrefix + '/' : '';
+    s3FilePath += guid + '.json';
+    await this.s3.writeObjectToCacheFile(s3FilePath, entry);
+    return s3FilePath;
+  }
+
+  public async modifyPayloadPreProcess<T>(entry: InternalBackgroundEntry<T>): Promise<InternalBackgroundEntry<T>> {
+    if (entry?.meta?.[AwsLargePayloadS3SqsSnsBackgroundManager.LARGE_MESSAGE_S3_PATH_META_KEY]) {
+      Logger.silly('Restoring large data from %s', entry.meta[AwsLargePayloadS3SqsSnsBackgroundManager.LARGE_MESSAGE_S3_PATH_META_KEY]);
+      const parsed: T = await this._s3.fetchCacheFileAsObject<T>(
+        entry.meta[AwsLargePayloadS3SqsSnsBackgroundManager.LARGE_MESSAGE_S3_PATH_META_KEY],
+      );
+      entry.data = parsed;
+      //eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+      delete entry.meta[AwsLargePayloadS3SqsSnsBackgroundManager.LARGE_MESSAGE_S3_PATH_META_KEY];
+    }
+    return entry;
+  }
+}

package/src/background/manager/aws-sqs-sns-background-manager.ts

@@ -0,0 +1,201 @@
+import { Logger } from '@bitblit/ratchet-common/logger/logger';
+import { ErrorRatchet } from '@bitblit/ratchet-common/lang/error-ratchet';
+import {
+  DeleteMessageCommand,
+  DeleteMessageCommandOutput,
+  GetQueueAttributesCommand,
+  GetQueueAttributesCommandOutput,
+  GetQueueAttributesRequest,
+  GetQueueAttributesResult,
+  ReceiveMessageCommand,
+  ReceiveMessageCommandOutput,
+  SendMessageCommand,
+  SendMessageCommandOutput,
+  SQSClient,
+} from '@aws-sdk/client-sqs';
+import { BackgroundEntry } from '../background-entry.js';
+import { BackgroundAwsConfig } from '../../config/background/background-aws-config.js';
+import { EpsilonConstants } from '../../epsilon-constants.js';
+import { InternalBackgroundEntry } from '../internal-background-entry.js';
+import { AbstractBackgroundManager } from './abstract-background-manager.js';
+import { BackgroundValidator } from '../background-validator.js';
+import { PublishCommand, PublishCommandOutput, SNSClient } from '@aws-sdk/client-sns';
+import { NumberRatchet } from '@bitblit/ratchet-common/lang/number-ratchet';
+
+/**
+ * Handles all submission of work to the background processing system.
+ *
+ * Note that this does NOT validate the input, it just passes it along.  This is
+ * because it creates a circular reference to the processors if we try since they
+ * define the type and validation.
+ */
+export class AwsSqsSnsBackgroundManager extends AbstractBackgroundManager {
+  constructor(
+    private _awsConfig: BackgroundAwsConfig,
+    private _sqs: SQSClient,
+    private _sns: SNSClient,
+  ) {
+    super();
+    const cfgErrors: string[] = BackgroundValidator.validateAwsConfig(_awsConfig);
+    if (cfgErrors.length) {
+      ErrorRatchet.throwFormattedErr('Cannot start - invalid AWS config : %j', cfgErrors);
+    }
+  }
+
+  public readonly backgroundManagerName: string = 'AwsSqsSnsBackgroundManager';
+
+  public get awsConfig(): BackgroundAwsConfig {
+    return this._awsConfig;
+  }
+
+  public get sqs(): SQSClient {
+    return this._sqs;
+  }
+
+  public get sns(): SNSClient {
+    return this._sns;
+  }
+
+  public async addEntryToQueue<T>(entry: BackgroundEntry<T>, fireStartMessage?: boolean): Promise<string> {
+    try {
+      const wrapped: InternalBackgroundEntry<T> = await this.wrapEntryForInternal(entry);
+      const rval: string = wrapped.guid;
+      // Guard against bad entries up front
+      const params = {
+        DelaySeconds: 0,
+        MessageBody: JSON.stringify(wrapped),
+        MessageGroupId: entry.type,
+        QueueUrl: this.awsConfig.queueUrl,
+      };
+
+      Logger.info('Add entry to queue (remote) : %j : Start : %s', params, fireStartMessage);
+      const result: SendMessageCommandOutput = await this.sqs.send(new SendMessageCommand(params));
+
+      if (fireStartMessage) {
+        const fireResult: string = await this.fireStartProcessingRequest();
+        Logger.silly('FireResult : %s', fireResult);
+      }
+
+      Logger.info('Background process %s using message id %s', rval, result.MessageId);
+      return rval;
+    } catch (error) {
+      Logger.error('Error inserting background entry into SQS queue : %j', error);
+      throw new Error('Error inserting background entry into SQS queue : ' + error['code'] + ' : ' + error['name']);
+    }
+  }
+
+  public async fireImmediateProcessRequest<T>(entry: BackgroundEntry<T>): Promise<string> {
+    try {
+      const wrapped: InternalBackgroundEntry<T> = await this.wrapEntryForInternal(entry);
+      const rval: string = wrapped.guid;
+      // Guard against bad entries up front
+      Logger.info('Fire immediately (remote) : %j ', entry);
+      const toWrite: any = {
+        type: EpsilonConstants.BACKGROUND_SNS_IMMEDIATE_RUN_FLAG,
+        backgroundEntry: wrapped,
+      };
+      const msg: string = JSON.stringify(toWrite);
+      const snsId: string = await this.writeMessageToSnsTopic(msg);
+      Logger.debug('Background guid %s Wrote message : %s to SNS : %s', rval, msg, snsId);
+      return rval;
+    } catch (err) {
+      Logger.error(
+        'Failed to fireImmediateProcessRequest : SQS: %s SNS: %s :',
+        this?._awsConfig?.queueUrl,
+        this?._awsConfig?.notificationArn,
+        err,
+        err,
+      );
+      throw new Error('Failed to fireImmediateProcessRequest : : ' + err['code'] + ' : ' + err['name']);
+    }
+  }
+
+  public async fireStartProcessingRequest(): Promise<string> {
+    let rval: string = null;
+    try {
+      Logger.info('Fire start processing request (remote)');
+      rval = await this.writeMessageToSnsTopic(EpsilonConstants.BACKGROUND_SNS_START_MARKER);
+    } catch (err) {
+      Logger.error(
+        'Failed to fireStartProcessingRequest : SQS: %s SNS: %s :',
+        this?._awsConfig?.queueUrl,
+        this?._awsConfig?.notificationArn,
+        err,
+        err,
+      );
+    }
+    return rval;
+  }
+
+  public async fetchApproximateNumberOfQueueEntries(): Promise<number> {
+    let rval: number = null;
+    const all: GetQueueAttributesResult = await this.fetchCurrentQueueAttributes();
+    rval = NumberRatchet.safeNumber(all.Attributes['ApproximateNumberOfMessages']);
+    return rval;
+  }
+
+  public async fetchCurrentQueueAttributes(): Promise<GetQueueAttributesCommandOutput> {
+    let rval: GetQueueAttributesCommandOutput = null;
+    const req: GetQueueAttributesRequest = {
+      AttributeNames: ['All'],
+      QueueUrl: this.awsConfig.queueUrl,
+    };
+
+    rval = await this.sqs.send(new GetQueueAttributesCommand(req));
+    return rval;
+  }
+
+  public async writeMessageToSnsTopic(message: string): Promise<string> {
+    let rval: string = null;
+    const params = {
+      Message: message,
+      TopicArn: this.awsConfig.notificationArn,
+    };
+
+    Logger.debug('Writing message to SNS topic : j', params);
+    const result: PublishCommandOutput = await this.sns.send(new PublishCommand(params));
+    rval = result.MessageId;
+    return rval;
+  }
+
+  public async takeEntryFromBackgroundQueue(): Promise<InternalBackgroundEntry<any>[]> {
+    const rval: InternalBackgroundEntry<any>[] = [];
+
+    const params = {
+      MaxNumberOfMessages: 1,
+      QueueUrl: this.awsConfig.queueUrl,
+      VisibilityTimeout: 300,
+      WaitTimeSeconds: 0,
+    };
+
+    const message: ReceiveMessageCommandOutput = await this.sqs.send(new ReceiveMessageCommand(params));
+    if (message && message.Messages && message.Messages.length > 0) {
+      for (const m of message.Messages) {
+        //for (let i = 0; i < message.Messages.length; i++) {
+        //const m: Message = message.Messages[i];
+        try {
+          const parsedBody: InternalBackgroundEntry<any> = JSON.parse(m.Body);
+          if (!parsedBody.type) {
+            Logger.warn('Dropping invalid background entry : %j', parsedBody);
+          } else {
+            rval.push(parsedBody);
+          }
+
+          Logger.debug('Removing message from queue');
+          const delParams = {
+            QueueUrl: this.awsConfig.queueUrl,
+            ReceiptHandle: m.ReceiptHandle,
+          };
+          const delResult: DeleteMessageCommandOutput = await this.sqs.send(new DeleteMessageCommand(delParams));
+          Logger.silly('Delete result : %j', delResult);
+        } catch (err) {
+          Logger.warn('Error parsing message, dropping : %j', m, err);
+        }
+      }
+    } else {
+      Logger.debug('No messages found (likely end of recursion)');
+    }
+
+    return rval;
+  }
+}