wative 1.2.8 → 1.2.11

package/src/ssh/service_manager.ts

@@ -1,685 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import { SSHConfigManager } from './config_manager';
-import { WativeWielderServer } from './wative_server';
-import { SSHServiceConfig, ServiceInstance } from './types';
-// Removed PasswordManager import - using in-memory password management
-import * as log4js from 'log4js';
-import { inputPasswordWithoutValidator } from '../utils';
-import { WativeCore } from 'wative-core';
-import { spawn } from 'child_process';
-import * as net from 'net';
-
-export class SSHServiceManager {
-    private configManager: SSHConfigManager;
-    private runningServices: Map<string, ServiceInstance> = new Map();
-    private logger!: log4js.Logger;
-    private pidDir: string;
-
-    constructor(configDir?: string, keystorePath?: string) {
-        this.configManager = new SSHConfigManager(configDir, keystorePath);
-        this.pidDir = path.join(this.configManager.getKeystorePath(), 'ssh', 'pids');
-        this.ensurePidDir();
-        this.setupLogger();
-    }
-
-    /**
-     * 确保 PID 目录存在
-     */
-    private ensurePidDir(): void {
-        if (!fs.existsSync(this.pidDir)) {
-            fs.mkdirSync(this.pidDir, { recursive: true });
-        }
-    }
-
-    /**
-     * 检查端口是否被占用
-     * @param port 要检查的端口号
-     * @param host 主机地址，默认为 '127.0.0.1'
-     * @returns Promise<boolean> 如果端口被占用返回 true，否则返回 false
-     */
-    private async isPortInUse(port: number, host: string = '127.0.0.1'): Promise<boolean> {
-        return new Promise((resolve) => {
-            const server = net.createServer();
-            
-            server.listen(port, host, () => {
-                server.once('close', () => {
-                    resolve(false); // 端口未被占用
-                });
-                server.close();
-            });
-            
-            server.on('error', (err: any) => {
-                if (err.code === 'EADDRINUSE') {
-                    resolve(true); // 端口被占用
-                } else {
-                    resolve(false); // 其他错误，假设端口可用
-                }
-            });
-        });
-    }
-
-    /**
-     * 获取服务的 PID 文件路径
-     */
-    private getPidFilePath(serviceName: string): string {
-        return path.join(this.pidDir, `${serviceName}.pid`);
-    }
-
-    /**
-     * 写入 PID 文件
-     */
-    private writePidFile(serviceName: string, pid: number): void {
-        const pidFilePath = this.getPidFilePath(serviceName);
-        fs.writeFileSync(pidFilePath, pid.toString());
-    }
-
-    /**
-     * 读取 PID 文件
-     */
-    private readPidFile(serviceName: string): number | null {
-        const pidFilePath = this.getPidFilePath(serviceName);
-        if (!fs.existsSync(pidFilePath)) {
-            return null;
-        }
-        try {
-            const pidStr = fs.readFileSync(pidFilePath, 'utf8').trim();
-            return parseInt(pidStr, 10);
-        } catch (error) {
-            return null;
-        }
-    }
-
-    /**
-     * 删除 PID 文件
-     */
-    private removePidFile(serviceName: string): void {
-        const pidFilePath = this.getPidFilePath(serviceName);
-        if (fs.existsSync(pidFilePath)) {
-            fs.unlinkSync(pidFilePath);
-        }
-    }
-
-    /**
-     * 检查进程是否存在
-     */
-    private isProcessRunning(pid: number): boolean {
-        try {
-            process.kill(pid, 0);
-            return true;
-        } catch (error) {
-            return false;
-        }
-    }
-
-    /**
-     * 启动指定的 SSH 服务
-     */
-    public async startService(serviceName: string, passwords?: { [keystoreId: string]: string }): Promise<void> {
-        if (this.runningServices.has(serviceName)) {
-            throw new Error(`Service '${serviceName}' is already running.`);
-        }
-
-        const config = this.configManager.loadServiceConfig(serviceName);
-        
-        // 检查端口是否被占用
-        const portInUse = await this.isPortInUse(config.ssh.port, config.ssh.listen);
-        if (portInUse) {
-            const errorMessage = `Port ${config.ssh.port} on ${config.ssh.listen} is already in use. Cannot start SSH service '${serviceName}'.`;
-            this.logger.error(errorMessage);
-            console.error(`Error: ${errorMessage}`);
-            throw new Error(errorMessage);
-        }
-        
-        this.logger.info(`Port ${config.ssh.port} on ${config.ssh.listen} is available for service '${serviceName}'`);
-
-        // 如果没有提供密码，则交互式输入
-        const keystorePasswords = passwords || await this.promptForPasswords(config.keystore.allowed_keystores);
-
-        // 验证密码
-        const validationResults = await this.configManager.validateKeystorePasswords(
-            config.keystore.allowed_keystores,
-            keystorePasswords
-        );
-
-        const invalidKeystores = Object.entries(validationResults)
-            .filter(([_, isValid]) => !isValid)
-            .map(([keystoreId, _]) => keystoreId);
-
-        if (invalidKeystores.length > 0) {
-            throw new Error(`Invalid passwords for keystores: ${invalidKeystores.join(', ')}`);
-        }
-
-        // 创建服务实例
-        const server = this.createServerInstance(config, keystorePasswords);
-
-        // 启动服务
-        server.listen(config.ssh.listen, config.ssh.port);
-        
-        // 写入 PID 文件
-        this.writePidFile(serviceName, process.pid);
-        
-        this.logger.info(`SSH service '${serviceName}' started on ${config.ssh.listen}:${config.ssh.port}`);
-        console.log(`SSH service '${serviceName}' is now running in the background on ${config.ssh.listen}:${config.ssh.port}`);
-
-        const serviceInstance: ServiceInstance = {
-            config,
-            passwords: keystorePasswords,
-            server
-        };
-
-        this.runningServices.set(serviceName, serviceInstance);
-        
-        // 设置服务特定的日志文件
-        this.setupServiceLogger(serviceName);
-    }
-
-    /**
-     * 停止指定的 SSH 服务
-     */
-    public async stopService(serviceName: string): Promise<void> {
-        const serviceInstance = this.runningServices.get(serviceName);
-        const pid = this.readPidFile(serviceName);
-        
-        // 检查daemon模式的PID文件
-        const daemonPidFile = path.join(this.pidDir, `${serviceName}-daemon.pid`);
-        const watcherPidFile = path.join(this.pidDir, `${serviceName}-watcher.pid`);
-        let daemonPid: number | null = null;
-        let watcherPid: number | null = null;
-        
-        if (fs.existsSync(daemonPidFile)) {
-            const pidContent = fs.readFileSync(daemonPidFile, 'utf8').trim();
-            if (pidContent) {
-                daemonPid = parseInt(pidContent);
-            }
-        }
-        
-        if (fs.existsSync(watcherPidFile)) {
-            const pidContent = fs.readFileSync(watcherPidFile, 'utf8').trim();
-            if (pidContent) {
-                watcherPid = parseInt(pidContent);
-            }
-        }
-
-        // 如果服务在内存中运行
-        if (serviceInstance) {
-            // 停止服务器
-            if (serviceInstance.server && serviceInstance.server.close) {
-                serviceInstance.server.close();
-            }
-            this.runningServices.delete(serviceName);
-        }
-        // 如果是daemon模式的服务，优先停止监控器进程
-        else if (watcherPid && this.isProcessRunning(watcherPid)) {
-            try {
-                // 停止监控器进程，监控器会自动停止SSH服务进程
-                process.kill(watcherPid, 'SIGTERM');
-                // 等待一段时间后强制杀死
-                setTimeout(() => {
-                    if (this.isProcessRunning(watcherPid!)) {
-                        process.kill(watcherPid!, 'SIGKILL');
-                    }
-                    // 清理PID文件
-                    try {
-                        if (fs.existsSync(watcherPidFile)) fs.unlinkSync(watcherPidFile);
-                        if (fs.existsSync(daemonPidFile)) fs.unlinkSync(daemonPidFile);
-                    } catch (e) {}
-                }, 5000);
-            } catch (error) {
-                // 进程可能已经不存在，尝试直接停止SSH服务进程
-                if (daemonPid && this.isProcessRunning(daemonPid)) {
-                    try {
-                        process.kill(daemonPid, 'SIGTERM');
-                        setTimeout(() => {
-                            if (this.isProcessRunning(daemonPid!)) {
-                                process.kill(daemonPid!, 'SIGKILL');
-                            }
-                        }, 5000);
-                    } catch (e) {}
-                }
-                // 清理PID文件
-                try {
-                    if (fs.existsSync(watcherPidFile)) fs.unlinkSync(watcherPidFile);
-                    if (fs.existsSync(daemonPidFile)) fs.unlinkSync(daemonPidFile);
-                } catch (e) {}
-            }
-        }
-        // 如果只有SSH服务进程在运行
-        else if (daemonPid && this.isProcessRunning(daemonPid)) {
-            try {
-                process.kill(daemonPid, 'SIGTERM');
-                // 等待一段时间后强制杀死
-                setTimeout(() => {
-                    if (this.isProcessRunning(daemonPid!)) {
-                        process.kill(daemonPid!, 'SIGKILL');
-                    }
-                }, 5000);
-                // 删除daemon PID文件
-                if (fs.existsSync(daemonPidFile)) fs.unlinkSync(daemonPidFile);
-            } catch (error) {
-                // 进程可能已经不存在
-            }
-        }
-        // 如果通过普通 PID 文件检测到服务运行
-        else if (pid && this.isProcessRunning(pid)) {
-            try {
-                process.kill(pid, 'SIGTERM');
-                // 等待一段时间后强制杀死
-                setTimeout(() => {
-                    if (this.isProcessRunning(pid)) {
-                        process.kill(pid, 'SIGKILL');
-                    }
-                }, 5000);
-            } catch (error) {
-                // 进程可能已经不存在
-            }
-        }
-        else {
-            throw new Error(`Service '${serviceName}' is not running.`);
-        }
-
-        // 删除普通 PID 文件
-        this.removePidFile(serviceName);
-        this.logger.info(`SSH service '${serviceName}' stopped.`);
-    }
-
-    /**
-     * 重启指定的 SSH 服务
-     */
-    public async restartService(serviceName: string, passwords?: { [keystoreId: string]: string }): Promise<void> {
-        const wasRunning = this.runningServices.has(serviceName);
-
-        if (wasRunning) {
-            await this.stopService(serviceName);
-        }
-
-        await this.startService(serviceName, passwords);
-    }
-
-    /**
-     * 获取所有运行中的服务
-     */
-    public getRunningServices(): string[] {
-        return Array.from(this.runningServices.keys());
-    }
-
-    /**
-     * 获取服务配置
-     */
-    public getServiceConfig(serviceName: string): SSHServiceConfig {
-        return this.configManager.loadServiceConfig(serviceName);
-    }
-
-    /**
-     * 获取服务状态
-     */
-    public getServiceStatus(serviceName: string): 'running' | 'stopped' | 'not_found' {
-        // 首先检查内存中的运行状态
-        if (this.runningServices.has(serviceName)) {
-            return 'running';
-        }
-
-        // 检查配置是否存在
-        try {
-            this.configManager.loadServiceConfig(serviceName);
-            
-            // 检查daemon模式的PID文件
-            const daemonPidFile = path.join(this.pidDir, `${serviceName}-daemon.pid`);
-            if (fs.existsSync(daemonPidFile)) {
-                const pidContent = fs.readFileSync(daemonPidFile, 'utf8').trim();
-                if (pidContent) {
-                    const pid = parseInt(pidContent);
-                    if (this.isProcessRunning(pid)) {
-                        return 'running';
-                    } else {
-                        // 进程不存在，清理PID文件
-                        fs.unlinkSync(daemonPidFile);
-                    }
-                }
-            }
-            
-            // 通过普通 PID 文件检查服务是否运行
-            const pid = this.readPidFile(serviceName);
-            if (pid && this.isProcessRunning(pid)) {
-                return 'running';
-            }
-            
-            // 如果 PID 文件存在但进程不存在，清理 PID 文件
-            if (pid) {
-                this.removePidFile(serviceName);
-            }
-            
-            return 'stopped';
-        } catch (error) {
-            return 'not_found';
-        }
-    }
-
-    /**
-     * 停止所有服务
-     */
-    public async stopAllServices(): Promise<void> {
-        const serviceNames = Array.from(this.runningServices.keys());
-
-        for (const serviceName of serviceNames) {
-            await this.stopService(serviceName);
-        }
-    }
-
-    /**
-     * 创建新的服务配置
-     */
-    public async createService(
-        serviceName: string,
-        port: number,
-        allowedKeystores: string[],
-        clientName?: string,
-        description?: string
-    ): Promise<SSHServiceConfig> {
-        return this.configManager.createServiceConfig(
-            serviceName,
-            port,
-            allowedKeystores,
-            clientName,
-            description
-        );
-    }
-
-    /**
-     * 删除服务配置
-     */
-    public async removeService(serviceName: string): Promise<void> {
-        // 如果服务正在运行，先停止它
-        if (this.runningServices.has(serviceName)) {
-            await this.stopService(serviceName);
-        }
-
-        console.log("serviceName:", serviceName);
-        this.configManager.removeServiceConfig(serviceName);
-        this.logger.info(`Service '${serviceName}' removed.`);
-    }
-
-    /**
-     * 列出所有服务配置
-     */
-    public listServices(): { name: string; status: string; port?: number; description?: string }[] {
-        const configNames = this.configManager.listServiceConfigs();
-
-        return configNames.map(name => {
-            const status = this.getServiceStatus(name);
-            let port: number | undefined;
-            let description: string | undefined;
-
-            try {
-                const config = this.configManager.loadServiceConfig(name);
-                port = config.ssh.port;
-                description = config.description;
-            } catch (error) {
-                // 忽略加载错误
-            }
-
-            return { name, status, port, description };
-        });
-    }
-
-    /**
-     * 更新服务配置中的 keystore 列表
-     */
-    public updateServiceKeystores(serviceName: string, keystores: string[]): void {
-        this.configManager.updateServiceConfig(serviceName, {
-            keystore: {
-                path: this.configManager.loadServiceConfig(serviceName).keystore.path,
-                allowed_keystores: keystores
-            }
-        });
-    }
-
-    /**
-     * 交互式输入密码（公共方法）
-     */
-    public async promptForPasswords(keystoreIds: string[]): Promise<{ [keystoreId: string]: string }> {
-        const passwords: { [keystoreId: string]: string } = {};
-
-        for (const keystoreId of keystoreIds) {
-            let password: string;
-            let isValidPassword = false;
-            let attempts = 0;
-            const maxAttempts = 3;
-
-            while (!isValidPassword && attempts < maxAttempts) {
-                password = await inputPasswordWithoutValidator(`Enter password for keystore [${keystoreId}]`);
-
-                // 使用 wative-core 验证密码
-                try {
-                    const keystorePath = this.configManager.getKeystorePath();
-                    const wativeCore = new WativeCore(keystorePath, [keystoreId]);
-                    isValidPassword = wativeCore.account.checkPassword(keystoreId, password);
-
-                    if (isValidPassword) {
-                        passwords[keystoreId] = password;
-                        break;
-                    } else {
-                        attempts++;
-                        if (attempts < maxAttempts) {
-                            console.log(`Invalid password for ${keystoreId}`);
-                        } else {
-                            throw new Error(`Failed to authenticate keystore [${keystoreId}] after ${maxAttempts} attempts.`);
-                        }
-                    }
-                } catch (error: any) {
-                    attempts++;
-                    if (attempts < maxAttempts) {
-                        console.log("Error validating password for keystore");
-                    } else {
-                        throw new Error(`Failed to authenticate keystore [${keystoreId}] after ${maxAttempts} attempts: ${error.message}`);
-                    }
-                }
-            }
-        }
-
-        return passwords;
-    }
-
-
-
-    /**
-     * 创建服务器实例
-     */
-    private createServerInstance(config: SSHServiceConfig, passwords: { [keystoreId: string]: string }): any {
-        const clients = config.clients;
-        if (clients.length === 0) {
-            throw new Error("No clients configured for service");
-        }
-
-        if (clients.length > 1) {
-            throw new Error("Only one client is supported for this service");
-        }
-
-        const client = JSON.parse(clients[0] as any);
-        const allowedAppIds = [client.name];
-        const allowedPublicKeyPaths = [client.public_key_path];
-        const allowedKeystoreIds = [client.allowed_keystores];
-
-        const keystoreIds = config.keystore.allowed_keystores;
-        if (keystoreIds.length === 0) {
-            throw new Error("No keystores configured for service");
-        }
-
-        let keystorePasswords: any = [];
-        for (const keystoreId of keystoreIds) {
-            keystorePasswords.push(passwords[keystoreId]);
-        }
-
-        return new WativeWielderServer(
-            config.server_keys.private_key_path,
-            config.server_keys.passphrase,
-            allowedAppIds,
-            allowedPublicKeyPaths,
-            allowedKeystoreIds,
-            config.keystore.path,
-            keystoreIds,
-            keystorePasswords
-        );
-    }
-
-    /**
-     * 显示日志
-     */
-    public async showLogs(serviceName?: string, lines: number = 50, follow: boolean = false): Promise<void> {
-        const logDir = process.env.HOME + '/.wative/logs';
-        let logFile: string;
-        
-        if (serviceName) {
-            logFile = path.join(logDir, `${serviceName}.log`);
-        } else {
-            logFile = path.join(logDir, 'service_manager.log');
-        }
-        
-        if (!fs.existsSync(logFile)) {
-            throw new Error(`Log file not found: ${logFile}`);
-        }
-        
-        const args = follow ? ['-f', `-n${lines}`, logFile] : [`-n${lines}`, logFile];
-        const tailProcess = spawn('tail', args, {
-            stdio: ['ignore', 'inherit', 'inherit']
-        });
-        
-        if (follow) {
-            // 如果是跟踪模式，等待用户中断
-            process.on('SIGINT', () => {
-                tailProcess.kill('SIGTERM');
-                process.exit(0);
-            });
-            
-            return new Promise((resolve, reject) => {
-                tailProcess.on('close', (code) => {
-                    if (code === 0) {
-                        resolve();
-                    } else {
-                        reject(new Error(`tail process exited with code ${code}`));
-                    }
-                });
-            });
-        } else {
-            return new Promise((resolve, reject) => {
-                tailProcess.on('close', (code) => {
-                    if (code === 0) {
-                        resolve();
-                    } else {
-                        reject(new Error(`tail process exited with code ${code}`));
-                    }
-                });
-            });
-        }
-    }
-
-    /**
-     * 设置日志记录器
-     */
-    private setupLogger(): void {
-        const logDir = process.env.HOME + '/.wative/logs';
-        if (!fs.existsSync(logDir)) {
-            fs.mkdirSync(logDir, { recursive: true });
-        }
-
-        log4js.configure({
-            appenders: {
-                file: {
-                    type: 'file',
-                    filename: path.join(logDir, 'service_manager.log'),
-                    maxLogSize: 10485760,
-                    backups: 3,
-                    compress: true,
-                    keepFileExt: true,
-                    layout: {
-                        type: 'pattern',
-                        pattern: '%d{yyyy-MM-dd hh:mm:ss.SSS} [%p] %c - %m'
-                    },
-                    encoding: 'utf-8'
-                },
-                console: { type: 'console' }
-            },
-            categories: {
-                default: { appenders: ['file', 'console'], level: 'info' }
-            }
-        });
-
-        this.logger = log4js.getLogger('service_manager');
-        this.logger.level = 'info';
-    }
-
-    /**
-     * 设置服务特定的日志记录器
-     */
-    private setupServiceLogger(serviceName: string): void {
-        const logDir = process.env.HOME + '/.wative/logs';
-        if (!fs.existsSync(logDir)) {
-            fs.mkdirSync(logDir, { recursive: true });
-        }
-
-        const serviceLogFile = path.join(logDir, `${serviceName}.log`);
-        
-        // 清理旧日志文件
-        this.cleanupOldLogs(logDir);
-        
-        log4js.configure({
-            appenders: {
-                file: {
-                    type: 'file',
-                    filename: path.join(logDir, 'service_manager.log'),
-                    maxLogSize: 10485760,
-                    backups: 3,
-                    compress: true,
-                    keepFileExt: true,
-                    layout: {
-                        type: 'pattern',
-                        pattern: '%d{yyyy-MM-dd hh:mm:ss.SSS} [%p] %c - %m'
-                    },
-                    encoding: 'utf-8'
-                },
-                console: { type: 'console' },
-                [`${serviceName}_file`]: {
-                    type: 'file',
-                    filename: serviceLogFile,
-                    maxLogSize: 10485760,
-                    backups: 3,
-                    compress: true,
-                    keepFileExt: true,
-                    layout: {
-                        type: 'pattern',
-                        pattern: '%d{yyyy-MM-dd hh:mm:ss.SSS} [%p] %c - %m'
-                    },
-                    encoding: 'utf-8'
-                }
-            },
-            categories: {
-                default: { appenders: ['file', 'console'], level: 'info' },
-                [serviceName]: { appenders: [`${serviceName}_file`], level: 'info' }
-            }
-        });
-    }
-
-    /**
-     * 清理超过3天的旧日志文件
-     */
-    private cleanupOldLogs(logDir: string): void {
-        try {
-            const files = fs.readdirSync(logDir);
-            const threeDaysAgo = new Date();
-            threeDaysAgo.setDate(threeDaysAgo.getDate() - 3);
-
-            files.forEach(file => {
-                const filePath = path.join(logDir, file);
-                const stats = fs.statSync(filePath);
-                
-                // 删除超过3天的日志文件
-                if (stats.mtime < threeDaysAgo && file.endsWith('.log')) {
-                    fs.unlinkSync(filePath);
-                    this.logger.info(`Deleted old log file: ${file}`);
-                }
-            });
-        } catch (error) {
-            this.logger.warn(`Failed to cleanup old logs: ${error}`);
-        }
-    }
-}