meminsight-test-demo 1.0.0

package/packages/meminsight/src/process/ArkGCProc.ts

@@ -0,0 +1,61 @@
+import { Command } from "commander";
+import { ILoggable, Log, DeviceShell } from "@meminsight/core";
+import { IProcess } from "./IProcess";
+import { Version } from "../Version";
+
+/**
+ * Ark GC Process
+ */
+export class ArkGCProc implements IProcess, ILoggable { 
+    public readonly DOMAIN: string = 'meminsight';
+    public readonly TAG: string = ArkGCProc.name;
+    public static readonly CMD: string = 'ark-gc';
+    public static readonly DESC: string = "ark force gc process.";
+    public static readonly VER: string = Version.ARK_GC.toString();
+    private static _instance: ArkGCProc;
+
+    private constructor() {}
+
+    /**
+     * get instance
+     * @returns instance
+     */
+    public static instance(): ArkGCProc {
+        if (!ArkGCProc._instance) {
+            ArkGCProc._instance = new ArkGCProc();
+        }
+        return ArkGCProc._instance;
+    }
+
+    public initialize(proc: Command, any: any) {
+        proc.command(ArkGCProc.CMD)
+            .description(ArkGCProc.DESC)
+            .option("-d, --device <target device id>", "target device id")
+            .option("-b, --bundle <bundle name>", "bundle name")
+            .option<number>("-p, --pid <target process pid>", "target process pid", parseInt)
+            .action(async (options) => {
+                await ArkGCProc.instance().process(new Map<string, any>([
+                    ["device", options.device],
+                    ["bundle", options.bundle || undefined],
+                    ["pid", options.pid || -1]
+                ]));
+            });
+    }
+
+    private async process(args: Map<string, any>): Promise<void> {
+        let device = args.get("device");
+
+        // 优先选择 pid 进行 GC
+        let pid : number = args.get('pid');
+        if (pid !== -1) {   
+            return await DeviceShell.getDeviceShell(device).forceGC(pid); 
+        } 
+
+        let bundleName = args.get("bundle");
+        if (bundleName) {
+            return await DeviceShell.getDeviceShell(device).forceGCByName(bundleName);
+        }
+        
+        Log.errorX(this, "Args: bundle name or pid is required");
+    }
+}

package/packages/meminsight/src/process/ArkLeakProc.ts

@@ -0,0 +1,47 @@
+import { Command } from "commander"
+import { ArkLeakAnalyzer, ILoggable } from "@meminsight/core";
+import { IProcess } from "./IProcess";
+import { Version } from "../Version";
+
+/**
+ * Ark Leak Process
+ */
+export class ArkLeakProc implements IProcess, ILoggable {
+    public readonly DOMAIN: string = 'meminsight';
+    public readonly TAG: string = ArkLeakProc.name;
+    public static readonly CMD: string = "ark-leak";
+    public static readonly DESC: string = "ark leaks analysis process.";
+    public static readonly VER: string = Version.ARK_LEAK.toString();
+    private static _instance: ArkLeakProc;
+
+    private _analyzer: ArkLeakAnalyzer;
+
+    /**
+     * get instance
+     * @returns instance
+     */
+    public static instance(): ArkLeakProc {
+        if (!ArkLeakProc._instance) {
+            ArkLeakProc._instance = new ArkLeakProc();
+        }
+        return ArkLeakProc._instance;
+    }
+
+    public initialize(proc: Command, any: any) {
+        this._analyzer = any as ArkLeakAnalyzer;
+        proc.command(ArkLeakProc.CMD)
+            .description(ArkLeakProc.DESC)
+            .option("-1, --from <from heapsnapshot>", "from-scenario heapsnapshot file")
+            .option("-2, --to <file>", "to-scenario heapsnapshot file")
+            .option("-3, --target <file>", "target heapsnapshot file")
+            .option("-o, --output <file>", "output file")
+            .option("-f, --output_file <file type>", "output file type, console | text | json | html.")
+            .action(async (options) => {
+                // TODO
+            });
+    }
+
+    private async process(args: Map<string, any>): Promise<void> {
+        // TODO:         
+    } 
+}

package/packages/meminsight/src/process/ArkStatProc.ts

@@ -0,0 +1,320 @@
+import { Command } from "commander";
+import { IHeapNode } from "@memlab/core";
+import { 
+    ILoggable, Log, 
+    IAnalyzer, ArkStatAnalyzer, ArkStatCfg, defaultArkStatCfg, ArkSerializer, ArkNodeTracePath,
+    IOutput, OutputCfg, OutputFactory, OutputType,
+    JsonReader,
+    ArkNodesMap
+} from "@meminsight/core";
+import { IProcess } from "./IProcess";
+import { Version } from "../Version";
+
+/**
+ * Ark Statistics Process
+ */
+export class ArkStatProc implements IProcess, ILoggable { 
+    public static readonly CMD: string = 'ark-stat';
+    public static readonly DESC: string = "ark statistic analysis process.";
+    public static readonly VER: string = Version.ARK_STAT.toString();
+    private static _instance: ArkStatProc;
+
+    public readonly DOMAIN: string = 'meminsight';
+    public readonly TAG: string = ArkStatProc.name;
+    private analyzer: IAnalyzer = new ArkStatAnalyzer();
+
+    /**
+     * get instance
+     * @returns instance
+     */
+    public static instance(): ArkStatProc {
+        if (!ArkStatProc._instance) {
+            ArkStatProc._instance = new ArkStatProc();
+        }
+        return ArkStatProc._instance;
+    }
+
+    public initialize(proc: Command, any: any) {
+        proc.command(ArkStatProc.CMD)
+            .description(ArkStatProc.DESC)
+            .requiredOption("-t, --target <target heapsnapshot file>", "target heapsnapshot file")
+            .requiredOption(
+                "-m, --mode <mode type>", 
+                "\nmode type:\n" +
+                "\t1: get all detached nodes\n" + 
+                "\t2: get all gc roots\n" + 
+                "\t3: get node shortest path, node id is required\n" + 
+                "\t4: get node aggration paths by configuration\n" + 
+                "\t5: get node by configuration\n" + 
+                "\t6: get shared heap nodes\n")
+            .option("-i, --node_id <node id>", "node id")
+            .option("-c, --config <configuration file>", "configuration file")
+            .option("-o, --output <output folder path>", "output folder path", "./output")
+            .option("-f, --output_file <output file type>",
+                    "output file type, console | txt | json | html.",
+                    "console")
+            .action(async (options) => {
+                await ArkStatProc.instance().process(new Map<string, any>([
+                    ["target", options.target],
+                    ["mode", options.mode],
+                    ["node_id", options.node_id],
+                    ["config", options.config || undefined],
+                    ["output", options.output],
+                    ["output_file", options.output_file],
+                ]));
+            });
+    }
+
+    private async process(args: Map<string, string | undefined>): Promise<void> {
+        let target = args.get("target");
+        if (!target) {
+            Log.errorX(this, "Target filepath is required");
+            return;
+        }
+        let result = await this.analyzer.analyze([target]);
+        if (!result) {
+            Log.errorX(this, "Faled to analyze.");
+            return
+        }
+        Log.infoX(this, "Analyzed successfully.");
+
+        let cfgfile = args.get('config');
+        let setResult: boolean = false;
+        if (cfgfile) {
+            let cfg = await JsonReader.instance().readFromFile<ArkStatCfg>(cfgfile);
+            if (cfg) {
+                this.analyzer.setConfig(cfg);
+                setResult = true;
+            }
+        }
+        if (!setResult) {
+            Log.warnX(this, "No configuration found, use default config.");
+            this.analyzer.setConfig(defaultArkStatCfg());
+        }
+        console.log(this.analyzer.getConfig());
+        Log.infoX(this, "Set configuration successfully.");
+
+        let mode = args.get("mode") || '1';
+        let outputDir: string = args.get("output") || './output';
+        let outputFileType: string = args.get("output_file") || 'console';
+        let nodeId: number = parseInt(args.get("node_id") || '1');
+        Log.infoX(this, `mode:${mode}; output:${outputDir}; type:${outputFileType}`);
+
+        this.takeActionByMode(mode, outputDir, outputFileType, nodeId);
+    }
+
+    private getOutputCfg(
+        output: IOutput, 
+        outputDesc: any, 
+        outputDir: string, 
+        outputFile: string, 
+        enableNode: boolean = true) : OutputCfg { 
+        const analyzerCfg = this.analyzer.getConfig() as ArkStatCfg;
+        let cfg: OutputCfg = {
+            desc: outputDesc,
+            output: {
+                dir: outputDir,
+                filename: outputFile,
+                extension: output.type.toString(),
+            },  
+            node: enableNode ? {
+                enableId: analyzerCfg.Node.enableId,
+                enableType: analyzerCfg.Node.enableType,
+                enableName: analyzerCfg.Node.enableName,
+                enableSelfSize: analyzerCfg.Node.enableSelfSize,
+                enableRetainedSize: analyzerCfg.Node.enableRetainedSize,
+            } : undefined
+        }
+        return cfg;
+    }
+
+    private async outputNodes(
+        nodes: IHeapNode[], 
+        outputEntity: IOutput, 
+        outputCfg: OutputCfg): Promise<void> {
+        if (outputEntity?.type  === OutputType.CONSOLE) {
+            outputEntity?.output(ArkSerializer.getConsoleDataByNodes(true, nodes, outputCfg), outputCfg);
+        } else if (outputEntity?.type  === OutputType.TEXT) {
+            outputEntity?.output(ArkSerializer.getTextDataByNodes(nodes, outputCfg), outputCfg);
+        } else if (outputEntity?.type  === OutputType.JSON) {
+            outputEntity?.output(ArkSerializer.getJsonDataByNodes(nodes, outputCfg), outputCfg);
+        } else if (outputEntity?.type  === OutputType.HTML) {
+            // TODO
+            outputEntity?.output(ArkSerializer.getHtmlDataByNodes(nodes, outputCfg), outputCfg);
+        } else {
+            Log.errorX(this, 'Invalid output file type.');
+        }
+    }
+
+    private async outputArkNodeTracePath(
+        path: ArkNodeTracePath, 
+        outputEntity: IOutput, 
+        outputCfg: OutputCfg): Promise<void> {
+        if (outputEntity?.type  === OutputType.CONSOLE) {
+            let dataTmp: string = ArkSerializer.getNodeTracePathString(path.tracePathItem);
+            outputEntity?.output(dataTmp, outputCfg);
+        } else if (outputEntity?.type  === OutputType.TEXT) {
+            let dataTmp = {
+                desc: outputCfg.desc,
+                data: ArkSerializer.getNodeTracePathString(path.tracePathItem)
+            };
+            outputEntity?.output(dataTmp, outputCfg);
+        } else if (outputEntity?.type  === OutputType.JSON) {
+            let dataTmp = {
+                desc: outputCfg.desc,
+                data: ArkSerializer.getNodeTracePathString(path.tracePathItem)
+            };
+            outputEntity?.output(dataTmp, outputCfg);
+        } else if (outputEntity?.type  === OutputType.HTML) {
+            // TODO
+        } else {
+            Log.errorX(this, 'Invalid output file type.');
+        }
+    }
+
+    private async outputAggrationPath(
+        paths: ArkNodesMap, 
+        outputEntity: IOutput, 
+        outputCfg: OutputCfg) {
+        if (outputEntity?.type  === OutputType.CONSOLE) {
+            let dataTmp: string = ArkSerializer.getArkNodesMapString(paths);
+            outputEntity?.output(dataTmp, outputCfg);
+        } else if (outputEntity?.type  === OutputType.TEXT) {
+            // TODO
+        } else if (outputEntity?.type  === OutputType.JSON) {
+            // TODO
+        } else if (outputEntity?.type  === OutputType.HTML) {
+            // TODO
+        } else {
+            Log.errorX(this, 'Invalid output file type.');
+        }
+    }
+
+    private async takeActionByMode(mode: string, outputDir:string, type: string, nodeId?: number): Promise<void> {
+        const analyzer = this.analyzer as ArkStatAnalyzer;
+        let outputEntity: IOutput = OutputFactory.getOutput(type);
+        let outputCfg = this.getOutputCfg(outputEntity, undefined, outputDir, '');
+        switch (mode) {
+            // get detached nodes
+            case '1': 
+                {
+                    let nodes = await analyzer.getDetachedNodes();
+                    if (nodes.length === 0) {
+                        Log.errorX(this, `No detached nodes found.`);
+                        break;
+                    }
+                    outputCfg.desc = { 
+                        "Snapshot": analyzer.getSnapshotFilePath(), 
+                        "Action:": "Get Detached Nodes",
+                        "NodeLength": nodes.length,
+                        "Time": Date.now()
+                    };
+                    outputCfg.output.filename = `detached-nodes_${Date.now()}`;
+                    this.outputNodes(nodes, outputEntity, outputCfg);
+                    break;
+                }
+            // get gc roots
+            case '2':
+                {
+                    let nodes = await analyzer.getGCRoots();
+                    if (nodes.length === 0) {
+                        Log.errorX(this, "No gc roots found.");
+                        break;
+                    }
+                    outputCfg.desc = { 
+                        "FilePath": analyzer.getSnapshotFilePath(), 
+                        "Action:": "Get GC Roots",
+                        "NodeLength": nodes.length,
+                        "Time": Date.now()
+                    };
+                    outputCfg.output.filename = `gc-roots_${Date.now()}`;
+                    this.outputNodes(nodes, outputEntity, outputCfg);
+                    break;
+                }
+            // get shortest path to node
+            case '3':
+                {
+                    if (nodeId) {
+                        let shortestPath = await analyzer.getShortestPathToNode(nodeId);
+                        if  (!shortestPath) { 
+                            Log.errorX(this, `Failed to find shortest path to node ${nodeId}`);
+                            break;
+                        }
+                        let nodeTracePath = new ArkNodeTracePath(shortestPath, true);
+                        outputCfg.desc = { 
+                            "FilePath": analyzer.getSnapshotFilePath(), 
+                            "Action:": "Get Shortest Path to Node",
+                            "NodeID": nodeId,
+                            "ShortestPath": nodeTracePath.uid,
+                            "Time": Date.now()
+                        };  
+                        outputCfg.output.filename = `shortest-path-to-node${nodeId}_${Date.now()}`;
+                        this.outputArkNodeTracePath(nodeTracePath, outputEntity, outputCfg);
+                    } else {
+                        Log.errorX(this, 'Node id is required.')
+                    }           
+                    break;
+                }
+            // get ark nodes/paths
+            case '4':
+                {
+                    console.warn('Do not support this function.');
+                    break;
+                    // let arkNodesMap = await analyzer.getArkNodesMapByConfig();
+                    // if (!arkNodesMap) {
+                    //     Log.errorX(this, `Failed to find ark nodes map by configuration`);
+                    //     break;
+                    // }
+                    // outputCfg.desc = { 
+                    //     "FilePath": analyzer.getSnapshotFilePath(), 
+                    //     "Action:": "Get Aggration Paths",
+                    //     "Time": Date.now()
+                    // };
+                    // outputCfg.output.filename = `aggration-paths_${Date.now()}`;
+                    // this.outputAggrationPath(arkNodesMap, outputEntity, outputCfg);
+                    // break;
+                }
+            // get node by configuration
+            case '5':
+                {
+                    let nodes = await analyzer.getNodesByConfig();
+                    if (nodes.length === 0) {
+                        Log.errorX(this, `No nodes found by configuration.`);
+                        break;
+                    }
+                    outputCfg.desc = { 
+                        "FilePath": analyzer.getSnapshotFilePath(), 
+                        "Action:": "Get Nodes by Configuration",
+                        "NodeLength": nodes.length,
+                        "Time": Date.now()
+                    };
+                    this.outputNodes(nodes, outputEntity, outputCfg);
+                    break;
+                }
+            case '6':
+                {
+                    console.warn('Do not support this function.');
+                    break;
+                    // let map = await analyzer.getSharedHeapNodesMap();
+                    // if (map.size === 0) {
+                    //     Log.errorX(this, `No shared heap node found.`);
+                    //     break;
+                    // }
+                    // outputCfg.desc = { 
+                    //     "FilePath": analyzer.getSnapshotFilePath(), 
+                    //     "Action:": "Get Shared Heap Nodes Map",
+                    //     "NodesMapLength": map.size,
+                    //     "Time": Date.now()
+                    // };
+                    // outputCfg.output.filename = `shared-heap-nodes_${Date.now()}`;
+                    // map.forEach((nodes, key) => {
+                    //     this.outputNodes(nodes, outputEntity, outputCfg);
+                    // })
+                    // break;
+                }
+            default:
+                Log.warnX(this, `Unknown mode: ${mode}`);
+                break;
+        }
+    }
+}

package/packages/meminsight/src/process/ArkXProc.ts

@@ -0,0 +1,73 @@
+import fs from 'fs';
+import path from 'path';
+import { Command } from "commander";
+import { ILoggable, Log, IAnalyzer, ArkXAnalyzer } from "@meminsight/core";
+import { IProcess } from "./IProcess";
+import { Version } from "../Version";
+
+/**
+ * Ark X Process
+ */
+export class ArkXProc implements IProcess, ILoggable { 
+    public readonly DOMAIN: string = 'meminsight';
+    public readonly TAG: string = ArkXProc.name;
+    public static readonly CMD: string = 'ark-x';
+    public static readonly DESC: string = "ark-x analysis process.";
+    public static readonly VER: string = Version.ARK_GC.toString();
+    private static _instance: ArkXProc;
+    private analyzer: IAnalyzer = new ArkXAnalyzer();
+
+    private constructor() {}
+
+    /**
+     * get instance
+     * @returns instance
+     */
+    public static instance(): ArkXProc {
+        if (!ArkXProc._instance) {
+            ArkXProc._instance = new ArkXProc();
+        }
+        return ArkXProc._instance;
+    }
+
+    public initialize(proc: Command, any: any) {
+        proc.command(ArkXProc.CMD)
+            .description(ArkXProc.DESC)
+            .option("-f, --file <filepath>", "target filepath", '')
+            .option("-l, --list <list filepath>", "one list file which contains snapshot filepathes", '')
+            .option("-s, --sort <sort tyoe>", "sort type, 0 - by retained size | 1 - by count", parseInt, 0)
+            .option<number>("-T, --top <top number>", "top number, default is 10", parseInt, 10)
+            .option("-t, --tags <object tags>", "tobject tags, as tag1,tag2,tag3...", '')
+            .action(async (options) => {
+                await ArkXProc.instance().process(new Map<string, any>([
+                    ["file", options.file],
+                    ["list", options.list],
+                    ["top", options.top],
+                    ["sort", options.sort],
+                    ["tags", options.tags]
+                ]));
+            });
+    }
+
+    private async process(args: Map<string, any>): Promise<void> {
+        let file = args.get("file") as string;
+        let list = args.get("list") as string;
+        let topN = args.get("top") as number;
+        let sortType = args.get("sort") as number;
+        let tagStr = args.get("tags") as string;
+        // 读取 list file 中的快照文件路径
+        let fileList;
+        if (list != undefined && list !== '') {
+            fileList = fs.readFileSync(path.resolve(list), 'utf-8').replace(/\r/g, '').split('\n').filter(value => {
+                return value !== '';
+            });
+        }
+        let tags;
+        if (list != undefined && tagStr !== '') {
+            tags = tagStr.split(',').filter(value => {
+                return value !== '';
+            });
+        }
+        await this.analyzer.analyze([file, fileList, topN, sortType, tags]);
+    }
+}

package/packages/meminsight/src/process/HMemXProc.ts

@@ -0,0 +1,50 @@
+import { program, Command } from "commander";
+import { IProcess } from "./IProcess";
+import { Version } from "../Version";
+import { ArkLeakProc } from "./ArkLeakProc";
+import { ArkGCProc } from "./ArkGCProc";
+import { ArkCompareProc } from "./ArkCompareProc";
+import { ArkStatProc } from "./ArkStatProc";
+import { ArkXProc } from "./ArkXProc";
+
+/**
+ * MemInsight Process
+ */
+export class MemInsight implements IProcess {
+    public readonly CMD : string = "meminsight";
+    public readonly DESC : string = "meminsight binary is a command tool for memory analysis.";
+    public readonly VER : string;
+    
+    public constructor(ver: string, processes: IProcess[]) {
+        this.VER = ver;
+        this.initialize(new Command(), processes);
+    }
+
+    public initialize(proc: Command, any?: any) : void{
+        program.name(this.CMD);
+        program.description(this.DESC);
+        program.version(this.VER, "-v, --version", "meminsight version");
+        let processes = any as IProcess[];
+        if (processes) {
+            processes.forEach(process => process.initialize(program));
+        }
+    }
+
+    /**
+     * work
+     */
+    public work() : void{ 
+        program.parse();
+    }
+}
+
+export const meminsight: MemInsight = new MemInsight(
+    Version.HMEMX.toString(),
+    [ 
+        ArkStatProc.instance(),
+        ArkCompareProc.instance(),
+        ArkLeakProc.instance(),
+        ArkGCProc.instance(),
+        ArkXProc.instance(),
+    ]
+);

package/packages/meminsight/src/process/IProcess.ts

@@ -0,0 +1,12 @@
+import { Command } from "commander"
+
+/**
+ * Process Interface
+ */
+export interface IProcess {
+    /**
+     * initialize command program
+     * @param proc command
+     */
+    initialize(proc: Command, any?: any) : void;
+}

package/packages/meminsight/tsconfig.json

@@ -0,0 +1,15 @@
+{
+    "extends": "../../tsconfig.base.json",
+    "compilerOptions": {
+        "outDir": "./dist",
+        "rootDir": "./src",
+    },
+    "include": [
+        "src/**/*"
+    ],
+    "references": [
+        {
+            "path": "../core"
+        }
+    ]
+}

package/packages/stack/README.md

@@ -0,0 +1,31 @@
+## Steps
+
+1. 进入 stack 目录
+
+2. install npm, package.json 中的依赖
+
+   ```JSON
+    "hstack_lib": "file:libs/hstack_lib-1.0.1.tgz",
+   ```
+
+3. 替换 src/Index.js 中的需要反混淆解析的字符串
+
+   ```JS
+   // input one line
+   const line = '';
+   // input multi lines
+   const lines = [];
+   ```
+
+4. 将 sourcemap 文件、namecache 文件、so文件放置到对应的目录中，在 src/Index.js 中配置对应目录
+
+   ```JS
+   const sourcemapFolder = ...;
+   const namecacheFolder = ...;
+   const libFolder = ...;
+   ```
+
+5. 运行 index.js "node index.js"
+
+6. 测试等待结果
+

package/packages/stack/libs/lib_list.json

@@ -0,0 +1,34 @@
+{
+    "list": [
+	    {
+            "name": "hstack_lib-1.0.4.tgz",
+            "version": "1.0.4",
+            "type": "commonjs",
+            "API": [
+                "init",
+                "parseLine",
+                "stop"
+            ]
+        },
+        {
+            "name": "hstack_lib-1.0.1.tgz",
+            "version": "1.0.1",
+            "type": "commonjs",
+            "API": [
+                "init",
+                "parseLine",
+                "stop"
+            ]
+        },
+		{
+            "name": "hstack_lib-1.0.0.tgz",
+            "version": "1.0.0",
+            "type": "module",
+            "API": [
+                "init",
+                "parseLine",
+                "stop"
+            ]
+        }
+    ]
+}

package/packages/stack/package.json

@@ -0,0 +1,27 @@
+{
+  "dependencies": {
+    "@types/jest": "^29.1.1",
+    "@types/node": "^22.14.1",
+    "ansi": "^0.3.1",
+    "babar": "^0.2.0",
+    "chalk": "^5.4.1",
+    "fs-extra": "^11.2.0",
+    "hstack_lib": "file:libs/hstack_lib-1.0.4.tgz",
+    "jest": "^29.1.1",
+    "minimist": "^1.2.8",
+    "node-xlsx": "^0.24.0",
+    "string-width": "^7.2.0",
+    "typescript": "^5.3.3",
+    "util.promisify": "^1.1.1"
+  },
+  "devDependencies": {
+    "@types/fs-extra": "^11.0.4",
+    "@types/jest": "^29.1.1",
+    "@types/minimist": "^1.2.2",
+    "@types/node": "^22.14.1",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.1.1",
+    "ts-node": "^10.9.1",
+    "typescript": "^5.3.3"
+  }
+}