740 lines
23 KiB
TypeScript
740 lines
23 KiB
TypeScript
import * as plugins from '../../plugins.js';
|
|
import { EventEmitter } from 'node:events';
|
|
import { logger } from '../../logger.js';
|
|
import {
|
|
SecurityLogger,
|
|
SecurityLogLevel,
|
|
SecurityEventType
|
|
} from '../../security/index.js';
|
|
import { UnifiedDeliveryQueue, type IQueueItem } from './classes.delivery.queue.js';
|
|
import type { Email } from '../core/classes.email.js';
|
|
import type { UnifiedEmailServer } from '../routing/classes.unified.email.server.js';
|
|
import { RustSecurityBridge } from '../../security/classes.rustsecuritybridge.js';
|
|
|
|
/**
|
|
* Delivery status enumeration
|
|
*/
|
|
export enum DeliveryStatus {
|
|
PENDING = 'pending',
|
|
DELIVERING = 'delivering',
|
|
DELIVERED = 'delivered',
|
|
DEFERRED = 'deferred',
|
|
FAILED = 'failed'
|
|
}
|
|
|
|
/**
|
|
* Delivery handler interface
|
|
*/
|
|
export interface IDeliveryHandler {
|
|
deliver(item: IQueueItem): Promise<any>;
|
|
}
|
|
|
|
/**
|
|
* Delivery options
|
|
*/
|
|
export interface IMultiModeDeliveryOptions {
|
|
// Connection options
|
|
connectionPoolSize?: number;
|
|
socketTimeout?: number;
|
|
|
|
// Delivery behavior
|
|
concurrentDeliveries?: number;
|
|
sendTimeout?: number;
|
|
|
|
// TLS options
|
|
verifyCertificates?: boolean;
|
|
tlsMinVersion?: string;
|
|
|
|
// Mode-specific handlers
|
|
forwardHandler?: IDeliveryHandler;
|
|
deliveryHandler?: IDeliveryHandler;
|
|
processHandler?: IDeliveryHandler;
|
|
|
|
// Rate limiting
|
|
globalRateLimit?: number;
|
|
perPatternRateLimit?: Record<string, number>;
|
|
|
|
// Bounce handling
|
|
processBounces?: boolean;
|
|
bounceHandler?: {
|
|
processSmtpFailure: (recipient: string, smtpResponse: string, options: any) => Promise<any>;
|
|
};
|
|
|
|
// Event hooks
|
|
onDeliveryStart?: (item: IQueueItem) => Promise<void>;
|
|
onDeliverySuccess?: (item: IQueueItem, result: any) => Promise<void>;
|
|
onDeliveryFailed?: (item: IQueueItem, error: string) => Promise<void>;
|
|
}
|
|
|
|
/**
|
|
* Delivery system statistics
|
|
*/
|
|
export interface IDeliveryStats {
|
|
activeDeliveries: number;
|
|
totalSuccessful: number;
|
|
totalFailed: number;
|
|
avgDeliveryTime: number;
|
|
byMode: {
|
|
forward: {
|
|
successful: number;
|
|
failed: number;
|
|
};
|
|
mta: {
|
|
successful: number;
|
|
failed: number;
|
|
};
|
|
process: {
|
|
successful: number;
|
|
failed: number;
|
|
};
|
|
};
|
|
rateLimiting: {
|
|
currentRate: number;
|
|
globalLimit: number;
|
|
throttled: number;
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Handles delivery for all email processing modes
|
|
*/
|
|
export class MultiModeDeliverySystem extends EventEmitter {
|
|
private queue: UnifiedDeliveryQueue;
|
|
private options: Required<IMultiModeDeliveryOptions>;
|
|
private stats: IDeliveryStats;
|
|
private deliveryTimes: number[] = [];
|
|
private activeDeliveries: Set<string> = new Set();
|
|
private running: boolean = false;
|
|
private throttled: boolean = false;
|
|
private rateLimitLastCheck: number = Date.now();
|
|
private rateLimitCounter: number = 0;
|
|
private emailServer?: UnifiedEmailServer;
|
|
|
|
/**
|
|
* Create a new multi-mode delivery system
|
|
* @param queue Unified delivery queue
|
|
* @param options Delivery options
|
|
* @param emailServer Optional reference to unified email server for outbound delivery
|
|
*/
|
|
constructor(queue: UnifiedDeliveryQueue, options: IMultiModeDeliveryOptions, emailServer?: UnifiedEmailServer) {
|
|
super();
|
|
|
|
this.queue = queue;
|
|
this.emailServer = emailServer;
|
|
|
|
// Set default options
|
|
this.options = {
|
|
connectionPoolSize: options.connectionPoolSize || 10,
|
|
socketTimeout: options.socketTimeout || 30000, // 30 seconds
|
|
concurrentDeliveries: options.concurrentDeliveries || 10,
|
|
sendTimeout: options.sendTimeout || 60000, // 1 minute
|
|
verifyCertificates: options.verifyCertificates !== false, // Default to true
|
|
tlsMinVersion: options.tlsMinVersion || 'TLSv1.2',
|
|
forwardHandler: options.forwardHandler || {
|
|
deliver: this.handleForwardDelivery.bind(this)
|
|
},
|
|
deliveryHandler: options.deliveryHandler || {
|
|
deliver: this.handleMtaDelivery.bind(this)
|
|
},
|
|
processHandler: options.processHandler || {
|
|
deliver: this.handleProcessDelivery.bind(this)
|
|
},
|
|
globalRateLimit: options.globalRateLimit || 100, // 100 emails per minute
|
|
perPatternRateLimit: options.perPatternRateLimit || {},
|
|
processBounces: options.processBounces !== false, // Default to true
|
|
bounceHandler: options.bounceHandler || null,
|
|
onDeliveryStart: options.onDeliveryStart || (async () => {}),
|
|
onDeliverySuccess: options.onDeliverySuccess || (async () => {}),
|
|
onDeliveryFailed: options.onDeliveryFailed || (async () => {})
|
|
};
|
|
|
|
// Initialize statistics
|
|
this.stats = {
|
|
activeDeliveries: 0,
|
|
totalSuccessful: 0,
|
|
totalFailed: 0,
|
|
avgDeliveryTime: 0,
|
|
byMode: {
|
|
forward: {
|
|
successful: 0,
|
|
failed: 0
|
|
},
|
|
mta: {
|
|
successful: 0,
|
|
failed: 0
|
|
},
|
|
process: {
|
|
successful: 0,
|
|
failed: 0
|
|
}
|
|
},
|
|
rateLimiting: {
|
|
currentRate: 0,
|
|
globalLimit: this.options.globalRateLimit,
|
|
throttled: 0
|
|
}
|
|
};
|
|
|
|
// Set up event listeners
|
|
this.queue.on('itemsReady', this.processItems.bind(this));
|
|
}
|
|
|
|
/**
|
|
* Start the delivery system
|
|
*/
|
|
public async start(): Promise<void> {
|
|
logger.log('info', 'Starting MultiModeDeliverySystem');
|
|
|
|
if (this.running) {
|
|
logger.log('warn', 'MultiModeDeliverySystem is already running');
|
|
return;
|
|
}
|
|
|
|
this.running = true;
|
|
|
|
// Emit started event
|
|
this.emit('started');
|
|
logger.log('info', 'MultiModeDeliverySystem started successfully');
|
|
}
|
|
|
|
/**
|
|
* Stop the delivery system
|
|
*/
|
|
public async stop(): Promise<void> {
|
|
logger.log('info', 'Stopping MultiModeDeliverySystem');
|
|
|
|
if (!this.running) {
|
|
logger.log('warn', 'MultiModeDeliverySystem is already stopped');
|
|
return;
|
|
}
|
|
|
|
this.running = false;
|
|
|
|
// Wait for active deliveries to complete
|
|
if (this.activeDeliveries.size > 0) {
|
|
logger.log('info', `Waiting for ${this.activeDeliveries.size} active deliveries to complete`);
|
|
|
|
// Wait for a maximum of 30 seconds
|
|
await new Promise<void>(resolve => {
|
|
const checkInterval = setInterval(() => {
|
|
if (this.activeDeliveries.size === 0) {
|
|
clearInterval(checkInterval);
|
|
clearTimeout(forceTimeout);
|
|
resolve();
|
|
}
|
|
}, 1000);
|
|
|
|
// Force resolve after 30 seconds
|
|
const forceTimeout = setTimeout(() => {
|
|
clearInterval(checkInterval);
|
|
resolve();
|
|
}, 30000);
|
|
});
|
|
}
|
|
|
|
// Emit stopped event
|
|
this.emit('stopped');
|
|
logger.log('info', 'MultiModeDeliverySystem stopped successfully');
|
|
}
|
|
|
|
/**
|
|
* Process ready items from the queue
|
|
* @param items Queue items ready for processing
|
|
*/
|
|
private async processItems(items: IQueueItem[]): Promise<void> {
|
|
if (!this.running) {
|
|
return;
|
|
}
|
|
|
|
// Check if we're already at max concurrent deliveries
|
|
if (this.activeDeliveries.size >= this.options.concurrentDeliveries) {
|
|
logger.log('debug', `Already at max concurrent deliveries (${this.activeDeliveries.size})`);
|
|
return;
|
|
}
|
|
|
|
// Check rate limiting
|
|
if (this.checkRateLimit()) {
|
|
logger.log('debug', 'Rate limit exceeded, throttling deliveries');
|
|
return;
|
|
}
|
|
|
|
// Calculate how many more deliveries we can start
|
|
const availableSlots = this.options.concurrentDeliveries - this.activeDeliveries.size;
|
|
const itemsToProcess = items.slice(0, availableSlots);
|
|
|
|
if (itemsToProcess.length === 0) {
|
|
return;
|
|
}
|
|
|
|
logger.log('info', `Processing ${itemsToProcess.length} items for delivery`);
|
|
|
|
// Process each item
|
|
for (const item of itemsToProcess) {
|
|
// Mark as processing
|
|
await this.queue.markProcessing(item.id);
|
|
|
|
// Add to active deliveries
|
|
this.activeDeliveries.add(item.id);
|
|
this.stats.activeDeliveries = this.activeDeliveries.size;
|
|
|
|
// Deliver asynchronously
|
|
this.deliverItem(item).catch(err => {
|
|
logger.log('error', `Unhandled error in delivery: ${err.message}`);
|
|
});
|
|
}
|
|
|
|
// Update statistics
|
|
this.emit('statsUpdated', this.stats);
|
|
}
|
|
|
|
/**
|
|
* Deliver an item from the queue
|
|
* @param item Queue item to deliver
|
|
*/
|
|
private async deliverItem(item: IQueueItem): Promise<void> {
|
|
const startTime = Date.now();
|
|
|
|
try {
|
|
// Call delivery start hook
|
|
await this.options.onDeliveryStart(item);
|
|
|
|
// Emit delivery start event
|
|
this.emit('deliveryStart', item);
|
|
logger.log('info', `Starting delivery of item ${item.id}, mode: ${item.processingMode}`);
|
|
|
|
// Choose the appropriate handler based on mode
|
|
let result: any;
|
|
|
|
switch (item.processingMode) {
|
|
case 'forward':
|
|
result = await this.options.forwardHandler.deliver(item);
|
|
break;
|
|
|
|
case 'mta':
|
|
result = await this.options.deliveryHandler.deliver(item);
|
|
break;
|
|
|
|
case 'process':
|
|
result = await this.options.processHandler.deliver(item);
|
|
break;
|
|
|
|
default:
|
|
throw new Error(`Unknown processing mode: ${item.processingMode}`);
|
|
}
|
|
|
|
// Mark as delivered
|
|
await this.queue.markDelivered(item.id);
|
|
|
|
// Update statistics
|
|
this.stats.totalSuccessful++;
|
|
this.stats.byMode[item.processingMode].successful++;
|
|
|
|
// Calculate delivery time
|
|
const deliveryTime = Date.now() - startTime;
|
|
this.deliveryTimes.push(deliveryTime);
|
|
this.updateDeliveryTimeStats();
|
|
|
|
// Call delivery success hook
|
|
await this.options.onDeliverySuccess(item, result);
|
|
|
|
// Emit delivery success event
|
|
this.emit('deliverySuccess', item, result);
|
|
logger.log('info', `Item ${item.id} delivered successfully in ${deliveryTime}ms`);
|
|
|
|
SecurityLogger.getInstance().logEvent({
|
|
level: SecurityLogLevel.INFO,
|
|
type: SecurityEventType.EMAIL_DELIVERY,
|
|
message: 'Email delivery successful',
|
|
details: {
|
|
itemId: item.id,
|
|
mode: item.processingMode,
|
|
routeName: item.route?.name || 'unknown',
|
|
deliveryTime
|
|
},
|
|
success: true
|
|
});
|
|
} catch (error: any) {
|
|
// Calculate delivery attempt time even for failures
|
|
const deliveryTime = Date.now() - startTime;
|
|
|
|
// Mark as failed
|
|
await this.queue.markFailed(item.id, error.message);
|
|
|
|
// Update statistics
|
|
this.stats.totalFailed++;
|
|
this.stats.byMode[item.processingMode].failed++;
|
|
|
|
// Call delivery failed hook
|
|
await this.options.onDeliveryFailed(item, error.message);
|
|
|
|
// Process as bounce if enabled and we have a bounce handler
|
|
if (this.options.processBounces && this.options.bounceHandler) {
|
|
try {
|
|
const email = item.processingResult as Email;
|
|
|
|
// Extract recipient and error message
|
|
// For multiple recipients, we'd need more sophisticated parsing
|
|
const recipient = email.to.length > 0 ? email.to[0] : '';
|
|
|
|
if (recipient) {
|
|
logger.log('info', `Processing delivery failure as bounce for recipient ${recipient}`);
|
|
|
|
// Process SMTP failure through bounce handler
|
|
await this.options.bounceHandler.processSmtpFailure(
|
|
recipient,
|
|
error.message,
|
|
{
|
|
sender: email.from,
|
|
originalEmailId: item.id,
|
|
headers: email.headers
|
|
}
|
|
);
|
|
|
|
logger.log('info', `Bounce record created for failed delivery to ${recipient}`);
|
|
}
|
|
} catch (bounceError) {
|
|
logger.log('error', `Failed to process bounce: ${bounceError.message}`);
|
|
}
|
|
}
|
|
|
|
// Emit delivery failed event
|
|
this.emit('deliveryFailed', item, error);
|
|
logger.log('error', `Item ${item.id} delivery failed: ${error.message}`);
|
|
|
|
SecurityLogger.getInstance().logEvent({
|
|
level: SecurityLogLevel.ERROR,
|
|
type: SecurityEventType.EMAIL_DELIVERY,
|
|
message: 'Email delivery failed',
|
|
details: {
|
|
itemId: item.id,
|
|
mode: item.processingMode,
|
|
routeName: item.route?.name || 'unknown',
|
|
error: error.message,
|
|
deliveryTime
|
|
},
|
|
success: false
|
|
});
|
|
} finally {
|
|
// Remove from active deliveries
|
|
this.activeDeliveries.delete(item.id);
|
|
this.stats.activeDeliveries = this.activeDeliveries.size;
|
|
|
|
// Update statistics
|
|
this.emit('statsUpdated', this.stats);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Default handler for forward mode delivery
|
|
* @param item Queue item
|
|
*/
|
|
private async handleForwardDelivery(item: IQueueItem): Promise<any> {
|
|
logger.log('info', `Forward delivery for item ${item.id}`);
|
|
|
|
const email = item.processingResult as Email;
|
|
const route = item.route;
|
|
|
|
// Get target server information
|
|
const targetServer = route?.action.forward?.host;
|
|
const targetPort = route?.action.forward?.port || 25;
|
|
|
|
if (!targetServer) {
|
|
throw new Error('No target server configured for forward mode');
|
|
}
|
|
|
|
logger.log('info', `Forwarding email to ${targetServer}:${targetPort}`);
|
|
|
|
try {
|
|
if (!this.emailServer) {
|
|
throw new Error('No email server available for forward delivery');
|
|
}
|
|
|
|
// Build DKIM options from route config
|
|
const dkimDomain = item.route?.action.options?.mtaOptions?.dkimSign
|
|
? (item.route.action.options.mtaOptions.dkimOptions?.domainName || email.from.split('@')[1])
|
|
: undefined;
|
|
const dkimSelector = item.route?.action.options?.mtaOptions?.dkimOptions?.keySelector || 'default';
|
|
|
|
// Build auth options from route forward config
|
|
const auth = route?.action.forward?.auth as { user: string; pass: string } | undefined;
|
|
|
|
// Send via Rust SMTP client
|
|
const result = await this.emailServer.sendOutboundEmail(targetServer, targetPort, email, {
|
|
auth,
|
|
dkimDomain,
|
|
dkimSelector,
|
|
});
|
|
|
|
logger.log('info', `Email forwarded successfully to ${targetServer}:${targetPort}`);
|
|
|
|
return {
|
|
targetServer,
|
|
targetPort,
|
|
recipients: result.accepted.length,
|
|
messageId: result.messageId,
|
|
rejectedRecipients: result.rejected,
|
|
};
|
|
} catch (error: any) {
|
|
logger.log('error', `Failed to forward email: ${error.message}`);
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Default handler for MTA mode delivery
|
|
* @param item Queue item
|
|
*/
|
|
private async handleMtaDelivery(item: IQueueItem): Promise<any> {
|
|
logger.log('info', `MTA delivery for item ${item.id}`);
|
|
|
|
const email = item.processingResult as Email;
|
|
const route = item.route;
|
|
|
|
try {
|
|
// Apply DKIM signing if configured in the route
|
|
if (item.route?.action.options?.mtaOptions?.dkimSign) {
|
|
await this.applyDkimSigning(email, item.route.action.options.mtaOptions);
|
|
}
|
|
|
|
// In a full implementation, this would use the MTA service
|
|
// For now, we'll simulate a successful delivery
|
|
|
|
logger.log('info', `Email processed by MTA: ${email.subject} to ${email.getAllRecipients().join(', ')}`);
|
|
|
|
// Note: The MTA implementation would handle actual local delivery
|
|
|
|
// Simulate successful delivery
|
|
return {
|
|
recipients: email.getAllRecipients().length,
|
|
subject: email.subject,
|
|
dkimSigned: !!item.route?.action.options?.mtaOptions?.dkimSign
|
|
};
|
|
} catch (error: any) {
|
|
logger.log('error', `Failed to process email in MTA mode: ${error.message}`);
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Default handler for process mode delivery
|
|
* @param item Queue item
|
|
*/
|
|
private async handleProcessDelivery(item: IQueueItem): Promise<any> {
|
|
logger.log('info', `Process delivery for item ${item.id}`);
|
|
|
|
const email = item.processingResult as Email;
|
|
const route = item.route;
|
|
|
|
try {
|
|
// Apply content scanning if enabled
|
|
if (route?.action.options?.contentScanning && route?.action.options?.scanners && route.action.options.scanners.length > 0) {
|
|
logger.log('info', 'Performing content scanning');
|
|
|
|
// Apply each scanner
|
|
for (const scanner of route.action.options.scanners) {
|
|
switch (scanner.type) {
|
|
case 'spam':
|
|
logger.log('info', 'Scanning for spam content');
|
|
// Implement spam scanning
|
|
break;
|
|
|
|
case 'virus':
|
|
logger.log('info', 'Scanning for virus content');
|
|
// Implement virus scanning
|
|
break;
|
|
|
|
case 'attachment':
|
|
logger.log('info', 'Scanning attachments');
|
|
|
|
// Check for blocked extensions
|
|
if (scanner.blockedExtensions && scanner.blockedExtensions.length > 0) {
|
|
for (const attachment of email.attachments) {
|
|
const ext = this.getFileExtension(attachment.filename);
|
|
if (scanner.blockedExtensions.includes(ext)) {
|
|
if (scanner.action === 'reject') {
|
|
throw new Error(`Blocked attachment type: ${ext}`);
|
|
} else { // tag
|
|
email.addHeader('X-Attachment-Warning', `Potentially unsafe attachment: ${attachment.filename}`);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Apply transformations if defined
|
|
if (route?.action.options?.transformations && route?.action.options?.transformations.length > 0) {
|
|
logger.log('info', 'Applying email transformations');
|
|
|
|
for (const transform of route.action.options.transformations) {
|
|
switch (transform.type) {
|
|
case 'addHeader':
|
|
if (transform.header && transform.value) {
|
|
email.addHeader(transform.header, transform.value);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Apply DKIM signing if configured (after all transformations)
|
|
if (item.route?.action.options?.mtaOptions?.dkimSign || item.route?.action.process?.dkim) {
|
|
await this.applyDkimSigning(email, item.route.action.options?.mtaOptions || {});
|
|
}
|
|
|
|
logger.log('info', `Email successfully processed in store-and-forward mode`);
|
|
|
|
// Simulate successful delivery
|
|
return {
|
|
recipients: email.getAllRecipients().length,
|
|
subject: email.subject,
|
|
scanned: !!route?.action.options?.contentScanning,
|
|
transformed: !!(route?.action.options?.transformations && route?.action.options?.transformations.length > 0),
|
|
dkimSigned: !!(item.route?.action.options?.mtaOptions?.dkimSign || item.route?.action.process?.dkim)
|
|
};
|
|
} catch (error: any) {
|
|
logger.log('error', `Failed to process email: ${error.message}`);
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get file extension from filename
|
|
*/
|
|
private getFileExtension(filename: string): string {
|
|
return filename.substring(filename.lastIndexOf('.')).toLowerCase();
|
|
}
|
|
|
|
/**
|
|
* Apply DKIM signing to an email
|
|
*/
|
|
private async applyDkimSigning(email: Email, mtaOptions: any): Promise<void> {
|
|
if (!this.emailServer) {
|
|
logger.log('warn', 'Cannot apply DKIM signing without email server reference');
|
|
return;
|
|
}
|
|
|
|
const domainName = mtaOptions.dkimOptions?.domainName || email.from.split('@')[1];
|
|
const keySelector = mtaOptions.dkimOptions?.keySelector || 'default';
|
|
|
|
try {
|
|
// Ensure DKIM keys exist for the domain
|
|
await this.emailServer.dkimCreator.handleDKIMKeysForDomain(domainName);
|
|
|
|
// Get the private key
|
|
const dkimPrivateKey = (await this.emailServer.dkimCreator.readDKIMKeys(domainName)).privateKey;
|
|
|
|
// Convert Email to raw format for signing
|
|
const rawEmail = email.toRFC822String();
|
|
|
|
// Sign via Rust bridge
|
|
const bridge = RustSecurityBridge.getInstance();
|
|
const signResult = await bridge.signDkim({
|
|
rawMessage: rawEmail,
|
|
domain: domainName,
|
|
selector: keySelector,
|
|
privateKey: dkimPrivateKey,
|
|
});
|
|
|
|
if (signResult.header) {
|
|
email.addHeader('DKIM-Signature', signResult.header);
|
|
logger.log('info', `Successfully added DKIM signature for ${domainName}`);
|
|
}
|
|
} catch (error) {
|
|
logger.log('error', `Failed to apply DKIM signature: ${error.message}`);
|
|
// Don't throw - allow email to be sent without DKIM if signing fails
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Update delivery time statistics
|
|
*/
|
|
private updateDeliveryTimeStats(): void {
|
|
if (this.deliveryTimes.length === 0) return;
|
|
|
|
// Keep only the last 1000 delivery times
|
|
if (this.deliveryTimes.length > 1000) {
|
|
this.deliveryTimes = this.deliveryTimes.slice(-1000);
|
|
}
|
|
|
|
// Calculate average
|
|
const sum = this.deliveryTimes.reduce((acc, time) => acc + time, 0);
|
|
this.stats.avgDeliveryTime = sum / this.deliveryTimes.length;
|
|
}
|
|
|
|
/**
|
|
* Check if rate limit is exceeded
|
|
* @returns True if rate limited, false otherwise
|
|
*/
|
|
private checkRateLimit(): boolean {
|
|
const now = Date.now();
|
|
const elapsed = now - this.rateLimitLastCheck;
|
|
|
|
// Reset counter if more than a minute has passed
|
|
if (elapsed >= 60000) {
|
|
this.rateLimitLastCheck = now;
|
|
this.rateLimitCounter = 0;
|
|
this.throttled = false;
|
|
this.stats.rateLimiting.currentRate = 0;
|
|
return false;
|
|
}
|
|
|
|
// Check if we're already throttled
|
|
if (this.throttled) {
|
|
return true;
|
|
}
|
|
|
|
// Increment counter
|
|
this.rateLimitCounter++;
|
|
|
|
// Calculate current rate (emails per minute)
|
|
const rate = (this.rateLimitCounter / elapsed) * 60000;
|
|
this.stats.rateLimiting.currentRate = rate;
|
|
|
|
// Check if rate limit is exceeded
|
|
if (rate > this.options.globalRateLimit) {
|
|
this.throttled = true;
|
|
this.stats.rateLimiting.throttled++;
|
|
|
|
// Schedule throttle reset
|
|
const resetDelay = 60000 - elapsed;
|
|
setTimeout(() => {
|
|
this.throttled = false;
|
|
this.rateLimitLastCheck = Date.now();
|
|
this.rateLimitCounter = 0;
|
|
this.stats.rateLimiting.currentRate = 0;
|
|
}, resetDelay);
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Update delivery options
|
|
* @param options New options
|
|
*/
|
|
public updateOptions(options: Partial<IMultiModeDeliveryOptions>): void {
|
|
this.options = {
|
|
...this.options,
|
|
...options
|
|
};
|
|
|
|
// Update rate limit statistics
|
|
if (options.globalRateLimit) {
|
|
this.stats.rateLimiting.globalLimit = options.globalRateLimit;
|
|
}
|
|
|
|
logger.log('info', 'MultiModeDeliverySystem options updated');
|
|
}
|
|
|
|
/**
|
|
* Get delivery statistics
|
|
*/
|
|
public getStats(): IDeliveryStats {
|
|
return { ...this.stats };
|
|
}
|
|
} |