@serve.zone/dcrouter 11.0.39 → 11.0.40

package/dist_ts/radius/classes.accounting.manager.d.ts

@@ -0,0 +1,218 @@
+import type { StorageManager } from '../storage/index.js';
+/**
+ * RADIUS accounting session
+ */
+export interface IAccountingSession {
+    /** Unique session ID from RADIUS */
+    sessionId: string;
+    /** Username (often MAC address for MAB) */
+    username: string;
+    /** MAC address of the device */
+    macAddress?: string;
+    /** NAS IP address (switch/AP) */
+    nasIpAddress: string;
+    /** NAS port (physical or virtual) */
+    nasPort?: number;
+    /** NAS port type */
+    nasPortType?: string;
+    /** NAS identifier (name) */
+    nasIdentifier?: string;
+    /** Assigned VLAN */
+    vlanId?: number;
+    /** Assigned IP address (if any) */
+    framedIpAddress?: string;
+    /** Called station ID (usually BSSID for wireless) */
+    calledStationId?: string;
+    /** Calling station ID (usually client MAC) */
+    callingStationId?: string;
+    /** Session start time */
+    startTime: number;
+    /** Session end time (0 if active) */
+    endTime: number;
+    /** Last update time (interim accounting) */
+    lastUpdateTime: number;
+    /** Session status */
+    status: 'active' | 'stopped' | 'terminated';
+    /** Termination cause (if stopped) */
+    terminateCause?: string;
+    /** Input octets (bytes received by NAS from client) */
+    inputOctets: number;
+    /** Output octets (bytes sent by NAS to client) */
+    outputOctets: number;
+    /** Input packets */
+    inputPackets: number;
+    /** Output packets */
+    outputPackets: number;
+    /** Session duration in seconds */
+    sessionTime: number;
+    /** Service type */
+    serviceType?: string;
+}
+/**
+ * Accounting summary for a time period
+ */
+export interface IAccountingSummary {
+    /** Time period start */
+    periodStart: number;
+    /** Time period end */
+    periodEnd: number;
+    /** Total sessions */
+    totalSessions: number;
+    /** Active sessions */
+    activeSessions: number;
+    /** Total input bytes */
+    totalInputBytes: number;
+    /** Total output bytes */
+    totalOutputBytes: number;
+    /** Total session time (seconds) */
+    totalSessionTime: number;
+    /** Average session duration (seconds) */
+    averageSessionDuration: number;
+    /** Unique users/devices */
+    uniqueUsers: number;
+    /** Sessions by VLAN */
+    sessionsByVlan: Record<number, number>;
+    /** Top users by traffic */
+    topUsersByTraffic: Array<{
+        username: string;
+        totalBytes: number;
+    }>;
+}
+/**
+ * Accounting manager configuration
+ */
+export interface IAccountingManagerConfig {
+    /** Storage key prefix */
+    storagePrefix?: string;
+    /** Session retention period in days (default: 30) */
+    retentionDays?: number;
+    /** Enable detailed session logging */
+    detailedLogging?: boolean;
+    /** Maximum active sessions to track in memory */
+    maxActiveSessions?: number;
+}
+/**
+ * Manages RADIUS accounting data including:
+ * - Session tracking (start/stop/interim)
+ * - Data usage tracking (bytes in/out)
+ * - Session history and retention
+ * - Billing reports and summaries
+ */
+export declare class AccountingManager {
+    private activeSessions;
+    private config;
+    private storageManager?;
+    private stats;
+    constructor(config?: IAccountingManagerConfig, storageManager?: StorageManager);
+    /**
+     * Initialize the accounting manager
+     */
+    initialize(): Promise<void>;
+    /**
+     * Handle accounting start request
+     */
+    handleAccountingStart(data: {
+        sessionId: string;
+        username: string;
+        macAddress?: string;
+        nasIpAddress: string;
+        nasPort?: number;
+        nasPortType?: string;
+        nasIdentifier?: string;
+        vlanId?: number;
+        framedIpAddress?: string;
+        calledStationId?: string;
+        callingStationId?: string;
+        serviceType?: string;
+    }): Promise<void>;
+    /**
+     * Handle accounting interim update request
+     */
+    handleAccountingUpdate(data: {
+        sessionId: string;
+        inputOctets?: number;
+        outputOctets?: number;
+        inputPackets?: number;
+        outputPackets?: number;
+        sessionTime?: number;
+    }): Promise<void>;
+    /**
+     * Handle accounting stop request
+     */
+    handleAccountingStop(data: {
+        sessionId: string;
+        terminateCause?: string;
+        inputOctets?: number;
+        outputOctets?: number;
+        inputPackets?: number;
+        outputPackets?: number;
+        sessionTime?: number;
+    }): Promise<void>;
+    /**
+     * Get an active session by ID
+     */
+    getSession(sessionId: string): IAccountingSession | undefined;
+    /**
+     * Get all active sessions
+     */
+    getActiveSessions(): IAccountingSession[];
+    /**
+     * Get active sessions by username
+     */
+    getSessionsByUsername(username: string): IAccountingSession[];
+    /**
+     * Get active sessions by NAS IP
+     */
+    getSessionsByNas(nasIpAddress: string): IAccountingSession[];
+    /**
+     * Get active sessions by VLAN
+     */
+    getSessionsByVlan(vlanId: number): IAccountingSession[];
+    /**
+     * Get accounting summary for a time period
+     */
+    getSummary(startTime: number, endTime: number): Promise<IAccountingSummary>;
+    /**
+     * Get statistics
+     */
+    getStats(): {
+        activeSessions: number;
+        totalSessionsStarted: number;
+        totalSessionsStopped: number;
+        totalInputBytes: number;
+        totalOutputBytes: number;
+        interimUpdatesReceived: number;
+    };
+    /**
+     * Disconnect a session (admin action)
+     */
+    disconnectSession(sessionId: string, reason?: string): Promise<boolean>;
+    /**
+     * Clean up old archived sessions based on retention policy
+     */
+    cleanupOldSessions(): Promise<number>;
+    /**
+     * Find the oldest active session
+     */
+    private findOldestSession;
+    /**
+     * Evict a session from memory
+     */
+    private evictSession;
+    /**
+     * Load active sessions from storage
+     */
+    private loadActiveSessions;
+    /**
+     * Persist a session to storage
+     */
+    private persistSession;
+    /**
+     * Archive a completed session
+     */
+    private archiveSession;
+    /**
+     * Get archived sessions for a time period
+     */
+    private getArchivedSessions;
+}

package/dist_ts/radius/classes.accounting.manager.js

@@ -0,0 +1,417 @@
+import * as plugins from '../plugins.js';
+import { logger } from '../logger.js';
+/**
+ * Manages RADIUS accounting data including:
+ * - Session tracking (start/stop/interim)
+ * - Data usage tracking (bytes in/out)
+ * - Session history and retention
+ * - Billing reports and summaries
+ */
+export class AccountingManager {
+    activeSessions = new Map();
+    config;
+    storageManager;
+    // Counters for statistics
+    stats = {
+        totalSessionsStarted: 0,
+        totalSessionsStopped: 0,
+        totalInputBytes: 0,
+        totalOutputBytes: 0,
+        interimUpdatesReceived: 0,
+    };
+    constructor(config, storageManager) {
+        this.config = {
+            storagePrefix: config?.storagePrefix ?? '/radius/accounting',
+            retentionDays: config?.retentionDays ?? 30,
+            detailedLogging: config?.detailedLogging ?? false,
+            maxActiveSessions: config?.maxActiveSessions ?? 10000,
+        };
+        this.storageManager = storageManager;
+    }
+    /**
+     * Initialize the accounting manager
+     */
+    async initialize() {
+        if (this.storageManager) {
+            await this.loadActiveSessions();
+        }
+        logger.log('info', `AccountingManager initialized with ${this.activeSessions.size} active sessions`);
+    }
+    /**
+     * Handle accounting start request
+     */
+    async handleAccountingStart(data) {
+        const now = Date.now();
+        const session = {
+            sessionId: data.sessionId,
+            username: data.username,
+            macAddress: data.macAddress,
+            nasIpAddress: data.nasIpAddress,
+            nasPort: data.nasPort,
+            nasPortType: data.nasPortType,
+            nasIdentifier: data.nasIdentifier,
+            vlanId: data.vlanId,
+            framedIpAddress: data.framedIpAddress,
+            calledStationId: data.calledStationId,
+            callingStationId: data.callingStationId,
+            serviceType: data.serviceType,
+            startTime: now,
+            endTime: 0,
+            lastUpdateTime: now,
+            status: 'active',
+            inputOctets: 0,
+            outputOctets: 0,
+            inputPackets: 0,
+            outputPackets: 0,
+            sessionTime: 0,
+        };
+        // Check if we're at capacity
+        if (this.activeSessions.size >= this.config.maxActiveSessions) {
+            // Remove oldest session
+            const oldest = this.findOldestSession();
+            if (oldest) {
+                await this.evictSession(oldest);
+            }
+        }
+        this.activeSessions.set(data.sessionId, session);
+        this.stats.totalSessionsStarted++;
+        if (this.config.detailedLogging) {
+            logger.log('info', `Accounting Start: session=${data.sessionId}, user=${data.username}, NAS=${data.nasIpAddress}`);
+        }
+        // Persist session
+        if (this.storageManager) {
+            await this.persistSession(session);
+        }
+    }
+    /**
+     * Handle accounting interim update request
+     */
+    async handleAccountingUpdate(data) {
+        const session = this.activeSessions.get(data.sessionId);
+        if (!session) {
+            logger.log('warn', `Interim update for unknown session: ${data.sessionId}`);
+            return;
+        }
+        // Update session metrics
+        if (data.inputOctets !== undefined) {
+            session.inputOctets = data.inputOctets;
+        }
+        if (data.outputOctets !== undefined) {
+            session.outputOctets = data.outputOctets;
+        }
+        if (data.inputPackets !== undefined) {
+            session.inputPackets = data.inputPackets;
+        }
+        if (data.outputPackets !== undefined) {
+            session.outputPackets = data.outputPackets;
+        }
+        if (data.sessionTime !== undefined) {
+            session.sessionTime = data.sessionTime;
+        }
+        session.lastUpdateTime = Date.now();
+        this.stats.interimUpdatesReceived++;
+        if (this.config.detailedLogging) {
+            logger.log('debug', `Accounting Interim: session=${data.sessionId}, in=${data.inputOctets}, out=${data.outputOctets}`);
+        }
+        // Update persisted session
+        if (this.storageManager) {
+            await this.persistSession(session);
+        }
+    }
+    /**
+     * Handle accounting stop request
+     */
+    async handleAccountingStop(data) {
+        const session = this.activeSessions.get(data.sessionId);
+        if (!session) {
+            logger.log('warn', `Stop for unknown session: ${data.sessionId}`);
+            return;
+        }
+        // Update final metrics
+        if (data.inputOctets !== undefined) {
+            session.inputOctets = data.inputOctets;
+        }
+        if (data.outputOctets !== undefined) {
+            session.outputOctets = data.outputOctets;
+        }
+        if (data.inputPackets !== undefined) {
+            session.inputPackets = data.inputPackets;
+        }
+        if (data.outputPackets !== undefined) {
+            session.outputPackets = data.outputPackets;
+        }
+        if (data.sessionTime !== undefined) {
+            session.sessionTime = data.sessionTime;
+        }
+        session.endTime = Date.now();
+        session.lastUpdateTime = session.endTime;
+        session.status = 'stopped';
+        session.terminateCause = data.terminateCause;
+        // Update global stats
+        this.stats.totalSessionsStopped++;
+        this.stats.totalInputBytes += session.inputOctets;
+        this.stats.totalOutputBytes += session.outputOctets;
+        if (this.config.detailedLogging) {
+            logger.log('info', `Accounting Stop: session=${data.sessionId}, duration=${session.sessionTime}s, in=${session.inputOctets}, out=${session.outputOctets}`);
+        }
+        // Archive the session
+        if (this.storageManager) {
+            await this.archiveSession(session);
+        }
+        // Remove from active sessions
+        this.activeSessions.delete(data.sessionId);
+    }
+    /**
+     * Get an active session by ID
+     */
+    getSession(sessionId) {
+        return this.activeSessions.get(sessionId);
+    }
+    /**
+     * Get all active sessions
+     */
+    getActiveSessions() {
+        return Array.from(this.activeSessions.values());
+    }
+    /**
+     * Get active sessions by username
+     */
+    getSessionsByUsername(username) {
+        return Array.from(this.activeSessions.values()).filter(s => s.username === username);
+    }
+    /**
+     * Get active sessions by NAS IP
+     */
+    getSessionsByNas(nasIpAddress) {
+        return Array.from(this.activeSessions.values()).filter(s => s.nasIpAddress === nasIpAddress);
+    }
+    /**
+     * Get active sessions by VLAN
+     */
+    getSessionsByVlan(vlanId) {
+        return Array.from(this.activeSessions.values()).filter(s => s.vlanId === vlanId);
+    }
+    /**
+     * Get accounting summary for a time period
+     */
+    async getSummary(startTime, endTime) {
+        // Get archived sessions for the time period
+        const archivedSessions = await this.getArchivedSessions(startTime, endTime);
+        // Combine with active sessions that started within the period
+        const activeSessions = Array.from(this.activeSessions.values()).filter(s => s.startTime >= startTime && s.startTime <= endTime);
+        const allSessions = [...archivedSessions, ...activeSessions];
+        // Calculate summary
+        let totalInputBytes = 0;
+        let totalOutputBytes = 0;
+        let totalSessionTime = 0;
+        const uniqueUsers = new Set();
+        const sessionsByVlan = {};
+        const userTraffic = {};
+        for (const session of allSessions) {
+            totalInputBytes += session.inputOctets;
+            totalOutputBytes += session.outputOctets;
+            totalSessionTime += session.sessionTime;
+            uniqueUsers.add(session.username);
+            if (session.vlanId !== undefined) {
+                sessionsByVlan[session.vlanId] = (sessionsByVlan[session.vlanId] || 0) + 1;
+            }
+            const userBytes = session.inputOctets + session.outputOctets;
+            userTraffic[session.username] = (userTraffic[session.username] || 0) + userBytes;
+        }
+        // Top users by traffic
+        const topUsersByTraffic = Object.entries(userTraffic)
+            .sort((a, b) => b[1] - a[1])
+            .slice(0, 10)
+            .map(([username, totalBytes]) => ({ username, totalBytes }));
+        return {
+            periodStart: startTime,
+            periodEnd: endTime,
+            totalSessions: allSessions.length,
+            activeSessions: activeSessions.length,
+            totalInputBytes,
+            totalOutputBytes,
+            totalSessionTime,
+            averageSessionDuration: allSessions.length > 0 ? totalSessionTime / allSessions.length : 0,
+            uniqueUsers: uniqueUsers.size,
+            sessionsByVlan,
+            topUsersByTraffic,
+        };
+    }
+    /**
+     * Get statistics
+     */
+    getStats() {
+        return {
+            activeSessions: this.activeSessions.size,
+            ...this.stats,
+        };
+    }
+    /**
+     * Disconnect a session (admin action)
+     */
+    async disconnectSession(sessionId, reason = 'AdminReset') {
+        const session = this.activeSessions.get(sessionId);
+        if (!session) {
+            return false;
+        }
+        await this.handleAccountingStop({
+            sessionId,
+            terminateCause: reason,
+            sessionTime: Math.floor((Date.now() - session.startTime) / 1000),
+        });
+        return true;
+    }
+    /**
+     * Clean up old archived sessions based on retention policy
+     */
+    async cleanupOldSessions() {
+        if (!this.storageManager) {
+            return 0;
+        }
+        const cutoffTime = Date.now() - this.config.retentionDays * 24 * 60 * 60 * 1000;
+        let deletedCount = 0;
+        try {
+            const keys = await this.storageManager.list(`${this.config.storagePrefix}/archive/`);
+            for (const key of keys) {
+                try {
+                    const session = await this.storageManager.getJSON(key);
+                    if (session && session.endTime > 0 && session.endTime < cutoffTime) {
+                        await this.storageManager.delete(key);
+                        deletedCount++;
+                    }
+                }
+                catch (error) {
+                    // Ignore individual errors
+                }
+            }
+            if (deletedCount > 0) {
+                logger.log('info', `Cleaned up ${deletedCount} old accounting sessions`);
+            }
+        }
+        catch (error) {
+            logger.log('error', `Failed to cleanup old sessions: ${error.message}`);
+        }
+        return deletedCount;
+    }
+    /**
+     * Find the oldest active session
+     */
+    findOldestSession() {
+        let oldestTime = Infinity;
+        let oldestSessionId = null;
+        for (const [sessionId, session] of this.activeSessions) {
+            if (session.lastUpdateTime < oldestTime) {
+                oldestTime = session.lastUpdateTime;
+                oldestSessionId = sessionId;
+            }
+        }
+        return oldestSessionId;
+    }
+    /**
+     * Evict a session from memory
+     */
+    async evictSession(sessionId) {
+        const session = this.activeSessions.get(sessionId);
+        if (session) {
+            session.status = 'terminated';
+            session.terminateCause = 'SessionEvicted';
+            session.endTime = Date.now();
+            if (this.storageManager) {
+                await this.archiveSession(session);
+            }
+            this.activeSessions.delete(sessionId);
+            logger.log('warn', `Evicted session ${sessionId} due to capacity limit`);
+        }
+    }
+    /**
+     * Load active sessions from storage
+     */
+    async loadActiveSessions() {
+        if (!this.storageManager) {
+            return;
+        }
+        try {
+            const keys = await this.storageManager.list(`${this.config.storagePrefix}/active/`);
+            for (const key of keys) {
+                try {
+                    const session = await this.storageManager.getJSON(key);
+                    if (session && session.status === 'active') {
+                        this.activeSessions.set(session.sessionId, session);
+                    }
+                }
+                catch (error) {
+                    // Ignore individual errors
+                }
+            }
+        }
+        catch (error) {
+            logger.log('warn', `Failed to load active sessions: ${error.message}`);
+        }
+    }
+    /**
+     * Persist a session to storage
+     */
+    async persistSession(session) {
+        if (!this.storageManager) {
+            return;
+        }
+        const key = `${this.config.storagePrefix}/active/${session.sessionId}.json`;
+        try {
+            await this.storageManager.setJSON(key, session);
+        }
+        catch (error) {
+            logger.log('error', `Failed to persist session ${session.sessionId}: ${error.message}`);
+        }
+    }
+    /**
+     * Archive a completed session
+     */
+    async archiveSession(session) {
+        if (!this.storageManager) {
+            return;
+        }
+        try {
+            // Remove from active
+            const activeKey = `${this.config.storagePrefix}/active/${session.sessionId}.json`;
+            await this.storageManager.delete(activeKey);
+            // Add to archive with date-based path
+            const date = new Date(session.endTime);
+            const archiveKey = `${this.config.storagePrefix}/archive/${date.getFullYear()}/${String(date.getMonth() + 1).padStart(2, '0')}/${String(date.getDate()).padStart(2, '0')}/${session.sessionId}.json`;
+            await this.storageManager.setJSON(archiveKey, session);
+        }
+        catch (error) {
+            logger.log('error', `Failed to archive session ${session.sessionId}: ${error.message}`);
+        }
+    }
+    /**
+     * Get archived sessions for a time period
+     */
+    async getArchivedSessions(startTime, endTime) {
+        if (!this.storageManager) {
+            return [];
+        }
+        const sessions = [];
+        try {
+            const keys = await this.storageManager.list(`${this.config.storagePrefix}/archive/`);
+            for (const key of keys) {
+                try {
+                    const session = await this.storageManager.getJSON(key);
+                    if (session &&
+                        session.endTime > 0 &&
+                        session.startTime <= endTime &&
+                        session.endTime >= startTime) {
+                        sessions.push(session);
+                    }
+                }
+                catch (error) {
+                    // Ignore individual errors
+                }
+            }
+        }
+        catch (error) {
+            logger.log('warn', `Failed to get archived sessions: ${error.message}`);
+        }
+        return sessions;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.accounting.manager.js","sourceRoot":"","sources":["../../../ts/radius/classes.accounting.manager.ts"],"names":[],"mappings":"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"}