dynapm 1.0.0

package/README.md

@@ -0,0 +1,42 @@
+# DynaPM
+
+[中文文档](./README_zh.md)
+
+This is a program management tool for dynamically starting and stopping programs, with some serverless-like features. The goal is to maintain a large number of low-frequency accessed programs while keeping a few high-frequency accessed programs running online, all while dealing with limited resources in a private deployment environment.
+
+Each time a user accesses one of these programs, if the program is offline, the gateway temporarily suspends the request and immediately starts the program. Once the program starts successfully, the gateway acts as a reverse proxy.
+
+When memory is insufficient or a program has been idle for a long time, the program is automatically shut down to free up server resources.
+
+Starting the simplest Node.js HTTP program using pm2 takes approximately 600ms.
+
+```log
+Starting [test]
+Starting [test] took 601 ms
+Stopping [test]
+Starting [test]
+Starting [test] took 592 ms
+Stopping [test]
+```
+
+## Introduction
+
+I often want to write programs that run continuously, and I hope to be able to access their websites or call their APIs at any time. However, these programs are not always working, so I also hope that when they are not working, they consume almost no CPU or RAM except for disk space. Previously, I looked into serverless solutions, but they were still quite麻烦 in terms of deployment and did not fully utilize my idle servers.
+
+Now I can use DynaPM to keep thousands of programs ready for immediate access as long as my disk space allows. Of course, the actual number of programs that can run simultaneously may be limited to dozens depending on the machine's capacity, but most of the programs I have written in the past do not have long service times, so this limitation should not be a problem.
+
+## Features
+
+- [x] Start programs using pm2 when a request arrives
+- [x] Shut down programs when they are idle
+- [ ] Support auto-scaling
+- [ ] Support persistent operation (only shut down programs when idle RAM is insufficient)
+- [ ] Support cron jobs
+- [ ] Support dynamically starting and stopping Docker containers
+- [ ] Support starting programs using spawn/fork
+
+## Performance
+
+### fastify + @fastify/reply-from
+
+After a cold start, testing performance with `autocannon http://127.0.0.1:83` yields an average of 3000 req/s.

package/dist/src/index.js

@@ -0,0 +1,154 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = function(module) {
+        var getter = module && module.__esModule ? function() {
+            return module['default'];
+        } : function() {
+            return module;
+        };
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = function(exports1, definition) {
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = function(obj, prop) {
+        return Object.prototype.hasOwnProperty.call(obj, prop);
+    };
+})();
+var __webpack_exports__ = {};
+const external_fastify_namespaceObject = require("fastify");
+var external_fastify_default = /*#__PURE__*/ __webpack_require__.n(external_fastify_namespaceObject);
+const reply_from_namespaceObject = require("@fastify/reply-from");
+var reply_from_default = /*#__PURE__*/ __webpack_require__.n(reply_from_namespaceObject);
+const external_pm2_namespaceObject = require("pm2");
+var external_pm2_default = /*#__PURE__*/ __webpack_require__.n(external_pm2_namespaceObject);
+function getBase200(base) {
+    return fetch(base).then((res)=>200 === res.status).catch(()=>false);
+}
+async function runCheck(config) {
+    const time1 = Date.now();
+    if ('getBase200' === config.runCheck) while(true){
+        if (Date.now() - time1 > config.maxAwaitLaunchTime) throw new Error(`等待启动的时间超过了配置的 maxAwaitLaunchTime :${config.maxAwaitLaunchTime}`);
+        if (await getBase200(config.base)) return true;
+    }
+    else {
+        config.runCheck;
+        throw new Error(`尚未支持的 config check : ${config.runCheck}`);
+    }
+}
+const pm2Map = {
+    '127.0.0.1': {
+        base: 'http://127.0.0.1:3001',
+        latestTime: Date.now(),
+        stopTime: 5000,
+        maxAwaitLaunchTime: 5000,
+        runCheck: 'getBase200',
+        runStatus: 'unknown',
+        pm2Options: {
+            name: 'test',
+            script: './dist/test/test.mjs',
+            interpreter: 'node'
+        }
+    }
+};
+setInterval(()=>{
+    Object.entries(pm2Map).forEach(([hostname, target])=>{
+        if ('running' === target.runStatus && Date.now() - target.latestTime > target.stopTime) external_pm2_default().stop(target.pm2Options.name, (err, proc)=>{
+            if (err) console.log('[stop失败]', err);
+            else {
+                target.runStatus = 'stop';
+                console.log(`停止 [${target.pm2Options.name}] `);
+            }
+        });
+    });
+}, 3000);
+const pm2Connect = new Promise((r)=>{
+    external_pm2_default().connect(()=>{
+        r(1);
+    });
+});
+const pm2Manage = {
+    async start (target) {
+        const time1 = Date.now();
+        await pm2Connect;
+        let status = await getProcessStatus(target.pm2Options.name);
+        async function skipLaunching() {
+            if ('launching' === status) while('launching' === status){
+                target.runStatus = 'launching';
+                status = await getProcessStatus(target.pm2Options.name);
+            }
+        }
+        await skipLaunching();
+        if ('online' !== status) {
+            await new Promise((resolve, reject)=>{
+                external_pm2_default().start(target.pm2Options, (err, proc)=>{
+                    console.log(`开始启动 [${target.pm2Options.name}]`);
+                    if (err) {
+                        console.log('启动程序失败', err);
+                        reject(err);
+                    } else {
+                        status = 'launching';
+                        resolve(1);
+                    }
+                });
+            });
+            await skipLaunching();
+        }
+        if ('online' !== status) {
+            console.log('[status]', status);
+            throw new Error('进程启动异常');
+        }
+        {
+            target.latestTime = Date.now();
+            target.runStatus = 'running';
+            await runCheck(target);
+            const time2 = Date.now();
+            console.log(`启动 [${target.pm2Options.name}] 耗时 ${time2 - time1} ms`);
+            return true;
+        }
+    }
+};
+async function getProcessStatus(processID) {
+    await pm2Connect;
+    return new Promise((r)=>{
+        external_pm2_default().describe(processID, (err, process)=>{
+            err ? r('error') : r(process[0]?.pm2_env?.status);
+        });
+    });
+}
+const proxyPort = 83;
+const proxy = external_fastify_default()();
+proxy.register(reply_from_default(), {});
+proxy.all('*', {}, async (request, reply)=>{
+    const target = pm2Map[request.hostname] || null;
+    if (!target) return reply.status(404).send('Not Found');
+    target.latestTime = Date.now();
+    if ('running' !== target.runStatus) await pm2Manage.start(target);
+    return reply.from(target.base + request.url);
+});
+proxy.listen({
+    port: proxyPort,
+    host: '127.0.0.1'
+}, (err)=>{
+    if (err) console.log('[err]', err);
+    else {
+        console.log('服务启动成功');
+        console.log(`[proxy] listening on port ${proxyPort}`);
+    }
+});
+var __webpack_export_target__ = exports;
+for(var __webpack_i__ in __webpack_exports__)__webpack_export_target__[__webpack_i__] = __webpack_exports__[__webpack_i__];
+if (__webpack_exports__.__esModule) Object.defineProperty(__webpack_export_target__, '__esModule', {
+    value: true
+});

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "dynapm",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "bin": {
+    "dynapm": "dist/src/index.js"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "build": "rslib build",
+    "publish2npm": "npm publish --registry=https://registry.npmjs.org",
+    "runTestServer": "pnpm tsx ./test/server1.ts"
+  },
+  "files": [
+    "dist/src/"
+  ],
+  "keywords": [
+    "serverless",
+    "pm2",
+    "self-host"
+  ],
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org"
+  },
+  "author": "崮生",
+  "license": "ISC",
+  "dependencies": {
+    "@fastify/reply-from": "^12.0.2",
+    "fastify": "^5.2.1",
+    "pm2": "^5.4.3"
+  },
+  "devDependencies": {
+    "@rslib/core": "^0.4.1",
+    "uWebSockets.js": "github:uNetworking/uWebSockets.js#v20.51.0",
+    "@types/node": "^22.13.4",
+    "tsx": "^4.19.3"
+  }
+}