@eleven-am/transcoder/dist/distributed/distributedSegmentProcessor.d.ts

High-performance HLS transcoding library with hardware acceleration, intelligent client management, and distributed processing support for Node.js

import { RedisClientType } from 'redis';
import { DistributedConfig, ISegmentProcessor, SegmentProcessingData, SegmentProcessingResult } from './interfaces';
import { RedisSegmentClaimManager } from './redisSegmentClaimManager';
/**
 * Distributed segment processor - coordinate segment processing across multiple nodes
 * Falls back to local processing if Redis is unavailable
 */
export declare class DistributedSegmentProcessor implements ISegmentProcessor {
    private readonly redis;
    private readonly claimManager;
    private readonly localProcessor;
    private readonly workerId;
    private readonly claimRenewalInterval;
    private readonly segmentTimeout;
    private readonly fallbackToLocal;
    private readonly fileWaitTimeout;
    private disposed;
    private readonly MAX_ACTIVE_RENEWALS;
    private activeRenewals;
    constructor(redis: RedisClientType, config?: DistributedConfig);
    processSegment(data: SegmentProcessingData): Promise<SegmentProcessingResult>;
    isHealthy(): Promise<boolean>;
    getMode(): 'local' | 'distributed';
    dispose(): Promise<void>;
    /**
     * Get all currently claimed segments
     * Public method for work stealing processor
     */
    getClaimedSegments(): Promise<Array<{
        segmentKey: string;
        workerId: string;
        claimTime: number;
        expiresAt: number;
        outputPath: string;
    }>>;
    /**
     * Force claim a segment
     * Public method for work stealing processor
     */
    forceClaimSegment(segmentKey: string, workerId: string, outputPath?: string): Promise<boolean>;
    private createCachedResult;
    private createFileNotFoundResult;
    private checkSegmentExistsOnDisk;
    private checkRedisCompletionStatus;
    private waitForFileTask;
    private claimSegmentTask;
    private setupClaimRenewal;
    private processSegmentLocally;
    private markSegmentComplete;
    private publishSegmentComplete;
    private handleSuccessfulProcessing;
    private waitForSegmentCompletionTask;
    private cleanupClaimAndTimer;
    private handleRedisErrorWithFallback;
    private checkRedisConnection;
    private determineHealthStatus;
    private createCompletionState;
    private cleanupSubscriptions;
    private subscribeToCompletion;
    private createPeriodicFileCheck;
    private createTimeoutPromise;
    private createSuccessResult;
    private createTimeoutResult;
    private createErrorResult;
    private waitForSegmentCompletion;
    private delay;
    private checkFileWithRetry;
    private waitForFile;
    private checkFileAccess;
    private segmentExists;
    private isRedisError;
    /**
     * Get the claim manager instance
     * Public method for work stealing processor
     */
    getClaimManager(): RedisSegmentClaimManager;
    private evictOldestRenewal;
    private cleanupRenewal;
    private clearAllRenewals;
}
//# sourceMappingURL=distributedSegmentProcessor.d.ts.map