4l_capital_central_control_client/src/utils/file.js

const fs = require('fs');
const path = require('path');
const {logger} = require("./logger");
const {rustConfig} = require("../config");
const http = require("./http");
const readline = require('readline');


// 检查目录是否存在，不存在新建
function checkPathSync(filePath) {
    // 将相对路径转换为绝对路径
    const directoryPath = path.resolve(filePath);
    // 同步检查目录是否存在
    if (!fs.existsSync(directoryPath)) {
        // 目录不存在，需要创建它
        logger.info('目录不存在，正在创建...');
        try {
            // 同步创建目录
            fs.mkdirSync(directoryPath, {recursive: true});
            logger.info('目录已成功创建');
        } catch (error) {
            // 创建目录失败
            logger.error('创建目录失败:', error);
            return false
        }
    } else {
        // 目录已存在
        logger.info('目录已存在');
    }
    return true
}

// 检查文件是否存在
function checkFilePath(filePath) {
    // 同步检查文件是否存在
    const directoryPath = path.resolve(filePath);
    if (fs.existsSync(directoryPath)) {
        logger.info('文件存在:' + filePath);
        return true
    } else {
        logger.error('文件不存在:' + filePath);
        return false
    }
}

// 创建文件
function writeFile(filePath, text, breakFun) {
    fs.writeFile(filePath, text, (err) => {
        if (err) {
            logger.error('写入文件时发生错误:', err);
            breakFun(err)
        } else {
            logger.log('文件已成功写入!');
            breakFun(null, true)
        }
    });
}

// 同步复制
function copyFileSync(source, destination) {
    try {
        // 同步复制文件
        fs.copyFileSync(source, destination);
        // logger.info("成功");
        return true;
    } catch (err) {
        return false;
        // logger.info("失败");
    }
}

// // 读取日志（倒叙）指定行数
// function readLastNLines(filePath, n) {
//     const content = fs.readFileSync(filePath, 'utf8');
//     const lines = content.trim().split('\n');
//     const lastNLines = lines.slice(-n).join('\n');
//
//     // 此处处理或输出最后n行的内容
//     // console.log(lastNLines);
//     return lastNLines.split("\n").reverse();
// }


// 下载文件
function dowFile(url, fileName, dowPath, headers) {
    return http.dowFile(url, fileName, dowPath, headers)
}

// 删除文件
function delFile() {
}

/***********************************/
function getLastFile(dirPath, number, callback) {
    fs.readdir(dirPath, async (err, files) => {
        if (err) {
            logger.error(`无法列出目录。`, err);
            // process.exit(1);
        } else {
            let fileList = [];
            //提示日志默认是根据日志生成的，拿到的files 也是 按照生成日志排序的，所以
            // 按照倒叙获取，如果一个文件内容满足num,就不在继续查询，如果不够，继续获取文件
            // logger.info("文件:",files)
            for (file of files) {
                const filePath = path.join(dirPath, file);
                const stats = await fs.promises.stat(filePath);
                if (stats.isFile()) {
                    fileList.push({name: file, time: stats.birthtime.getTime()});
                    // logger.info("文件:" + filePath + "时间：" + stats.birthtime.getTime())
                }
            }

            fileList.sort((a, b) => b.time - a.time);
            // for (a of fileList) {
            //     logger.info("文件cccccccc22222222:" + a.name + "\ttime:" + a.time)
            // }
            lastFileList = fileList.slice(0, number != -1 ? number : fileList.length);
            lastFileNameList = lastFileList.map((item) => item.name);

            callback(lastFileNameList.reverse(), lastFileList.reverse());
        }
    });
}

// 读取日志（倒叙）指定行数
async function readLastNLines(dirPath, filePathList, n) {
    try {
        // for (var i = 0; i < filePathList.length; i++) {
        //     var item = filePathList[i];
        //     logger.info("日志文件2222222:" + item)
        // }

        const fileList = [];
        var count = 0;
        for (var i = filePathList.length - 1; i >= 0; i--) {
            var item = filePathList[i];
            const filepath = `${dirPath}/${item}`;
            logger.info("日志文件:" + filepath)

            //老版本 加载整个文件
            // const content = fs.readFileSync(`${filepath}`, "utf8");
            // let lines = content.trim().split("\n");

            //新版本：流式读取和逐行处理
            const lines = await readLines(filepath, n - count);
            // logger.info("日:" + lines)
            fileList.push({
                filePath: item,
                lines: lines,
            })
            count += lines.length;
            if (count > n) {
                break
            }
        }
        fileList.reverse();

        // const allFile = [].concat(...fileList.map((item) => item.lines));
        // let lastNLines = allFile.slice(-n).join("\n");
        // return lastNLines.split("\n").reverse();

        const allFile = [].concat(...fileList.map((item) => item.lines));
        const lastNLines = allFile.slice(-n).reverse();
        return lastNLines;
    } catch (e) {
        logger.info('获取日志异常了~~1111111111111111', e);
    }
}

 async function readLines(filePath, maxLines) {
     const fileStream = fs.createReadStream(filePath);
     const rl = readline.createInterface({
         input: fileStream,
         crlfDelay: Infinity
     });

     const lines = [];
     for await   (const line of rl) {
         lines.push(line);
         if (lines.length >= maxLines) {
             break;
         }
     }

     rl.close();
     fileStream.close();
     return lines;
 }


module.exports = {
    dowFile,
    checkFilePath,
    checkPathSync,
    writeFile,
    copyFileSync,
    readLastNLines,
    getLastFile
}