Class RpcRequestHandlerImpl

backend/Src/ClientIO/RpcRequestHandler.ts:113–639

    exp: number;
}
export class RpcRequestHandlerImpl extends RpcRequestHandler {
    public static pluginListenerInterceptFn: (e: LiveStream) => boolean;
    private readonly BEFORE_EXP = 5;
    private sessionProlongationTask: NodeJS.Timeout | null = null;
    private FindDanglingEntries = memoizee(FindDanglingEntries, { max: 1, maxAge: 1000 });
    private session: Unicaster | null = null;
    public constructor(
        client: Socket,
        private broadcaster: Broadcaster,
        private observables: TrackedStreamCollection,
        private pluginManager: PluginManager,
        private pluginManagerController: PluginManagerController,
        private pluginManagerListener: PluginManagerListener,
        private storage: SqliteAdapter,
        private linkedStreams: StreamDispatcher,
        private archive: ArchiveRecord[],
        private archiveRefCounter: LinkCounter<string>,
        private clipProgress: Map<string, ClipProgressState>,
        private archiveFilters: Map<number, Filter>,
        private observablesFilters: Map<number, Filter>,
        private recorder: RecordingService,
        private systemResources: SystemResourcesMonitor,
        private notificationCenter: NotificationCenter,
        private settings: Settings,
        private app: AppFacade,
        private shutdown: () => void) {
        super(client);
        this.session = new Unicaster(this.client);
        this.client.once('disconnect', () => this.OnDisconnect());
        this.SendSnapshot();
    }

    private SendSnapshot() {
        const SerializeObservable = (x: ObservableStream) => ({
            uri: x.url,
            lastSeen: x.lastSeen,
            plugins: x.plugins.map(p => p.name)
        });
        this.session?.Snapshot({
            activeRecords: this.recorder.Records,
            archive: this.archive.map(x => ({ ...x, tags: [...x.tags] })),
            clipProgress: [...this.clipProgress.values()],
            observables: [...this.observables.values()].map(SerializeObservable),
            plugins: this.pluginManager.Plugins.map(x => ({ id: x.id, name: x.name, enabled: x.enabled })),
            archiveFilters: [...this.archiveFilters.values()],
            observablesFilters: [...this.observablesFilters.values()],
            systemResources: this.systemResources.Info,
            startTime: C.StartTime,
            defaultAccess: C.DefaultAccess,
            storageQuota: this.settings.StorageQuota,
            instanceQuota: this.settings.InstanceQuota,
            downloadSpeedQuota: this.settings.DownloadSpeedQuota
        });
    }

    private KnownRecords() {
        return [...this.recorder.Records.map(x => x.filename), ...this.archive.map(x => x.filename)];
    }