Skip to content

A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.

TypeScript fluxerfluxerapp
3.5 KB
Raw Blame
// SPDX-License-Identifier: AGPL-3.0-or-later

import {Logger} from '@app/features/platform/utils/AppLogger';

export interface QueueEntry<TMessage, TResult> {
	message: TMessage;
	success: (result?: TResult, error?: unknown) => void;
}

interface RetryInfo {
	retryAfter?: number;
}

export interface QueueConfig {
	logger?: Logger;
	defaultRetryAfter?: number;
}

export abstract class Queue<TMessage, TResult = void> {
	protected readonly logger: Logger;
	protected readonly defaultRetryAfter: number;
	protected readonly queue: Array<QueueEntry<TMessage, TResult>>;
	private retryTimerId: number | null;
	private isDraining: boolean;

	constructor(config: QueueConfig = {}) {
		this.logger = config.logger ?? new Logger('Queue');
		this.defaultRetryAfter = config.defaultRetryAfter ?? 100;
		this.queue = [];
		this.retryTimerId = null;
		this.isDraining = false;
	}

	protected abstract drain(
		message: TMessage,
		complete: (retry: RetryInfo | null, result?: TResult, error?: unknown) => void,
	): Promise<unknown> | undefined;

	enqueue(message: TMessage, success: (result?: TResult, error?: unknown) => void): void {
		this.queue.push({message, success});
		this.maybeProcessNext();
	}

	get queueLength(): number {
		return this.queue.length;
	}

	clear(): void {
		if (this.retryTimerId !== null) {
			clearTimeout(this.retryTimerId);
			this.retryTimerId = null;
		}
		this.queue.length = 0;
		this.isDraining = false;
	}

	peek(): TMessage | undefined {
		return this.queue[0]?.message;
	}

	private maybeProcessNext(): void {
		if (this.retryTimerId !== null || this.queue.length === 0 || this.isDraining) {
			return;
		}
		const entry = this.queue.shift();
		if (!entry) {
			this.isDraining = false;
			return;
		}
		this.isDraining = true;
		const {message, success} = entry;
		let hasCompleted = false;
		let drainResult: Promise<unknown> | undefined;
		const complete = (retry: RetryInfo | null, result?: TResult, error?: unknown): void => {
			if (hasCompleted) {
				this.logger.warn('Queue completion callback invoked more than once; ignoring extra call');
				return;
			}
			hasCompleted = true;
			this.isDraining = false;
			this.logger.info(
				`Finished processing queued item; ${this.queue.length} ${this.queue.length === 1 ? 'item' : 'items'} remaining in queue`,
			);
			if (retry === null) {
				setTimeout(() => this.maybeProcessNext(), 0);
				try {
					success(result, error);
				} catch (callbackError) {
					this.logger.error('Error in queue success callback', callbackError);
				}
				return;
			}
			const delay = retry.retryAfter ?? this.defaultRetryAfter;
			this.logger.info(
				`Pausing queue processing for ${delay}ms due to retry request; ${this.queue.length} ${this.queue.length === 1 ? 'item' : 'items'} waiting`,
			);
			this.retryTimerId = window.setTimeout(() => {
				this.queue.unshift(entry);
				this.retryTimerId = null;
				this.maybeProcessNext();
			}, delay);
		};
		this.logger.info(
			`Processing queued item; ${this.queue.length} ${this.queue.length === 1 ? 'item' : 'items'} left after dequeue`,
		);
		try {
			drainResult = this.drain(message, complete);
		} catch (error) {
			this.logger.error('Unhandled error while draining queue item', error);
			if (!hasCompleted) {
				complete(null, undefined, error);
			}
		}
		if (drainResult && typeof drainResult.catch === 'function') {
			void drainResult.catch((error) => {
				this.logger.error('Unhandled error while draining queue item', error);
				if (!hasCompleted) {
					complete(null, undefined, error);
				}
			});
		}
	}
}