是否可以在不需要外部数据库的情况下为CLI应用程序实施共享状态管理？

Question

我想创建一个CLI应用程序，我认为这个问题不是关于特定技术的，而是为了复制目的，我将Node与命令line-commands （但我知道还有很多其他，例如=“ nofollow noreferrer”>指挥官）。

给定以下示例代码，

#!/usr/bin/env node

'use strict';

const commandLineArgs = require('command-line-args');
const commandLineCommands = require('command-line-commands');
const commandLineUsage = require('command-line-usage');

let isRunning = false; // global state

let commandResult;

try {
    commandResult = commandLineCommands([ 'start', 'info', 'help' ]);
} catch (error) {
    console.error('Invalid command.');
    process.exit(1);
}

if (commandResult.command === null || commandResult.command === 'help') {
    const commandInfo = commandLineUsage([
        { header: 'start', content: 'Sets the value to true' },
        { header: 'info', content: 'Gets the current value' },
    ]);

    console.log(commandInfo);
    process.exit(0);
}

let options;

try {
    options = commandLineArgs([], { argv: commandResult.argv });
} catch (error) {
    console.error('Invalid argument.');
    process.exit(1);
}

if (commandResult.command === 'start') {
    isRunning = true;
} else if (commandResult.command === 'info') {
    console.info({ isRunning });
}

布尔值isrunning表示共享状态。调用开始命令将其值设置为true。但是调用info命令显然启动了一个新的进程，并以其初始虚假值打印了新的变量iSrunning。

保持这种状态的最喜欢的技术是什么？ CLI是否必须使用外部数据库（例如本地文件系统），或者是否有一些方法可以将信息保存在存储器中直至关闭？

在系统上生成我自己的文件并将此变量存储到它对我来说就像是过度杀伤。

Answer 1

旧的跨平台黑客攻击是打开已知的TCP端口。能够打开端口的第一个过程将获得端口。试图打开端口的所有其他过程都将获得 eaddrinuse 错误：

const net = require('net');

const s = net.createServer();

s.on('error',() => {
    console.log('Program is already running!');

    // handle what to do here
});

s.listen(5123,'127.0.0.1',() => {
    console.log('OK');

    // run your main function here
});

这在任何OS上使用任何语言都起作用。您只需要注意一件事 - 使用您正在使用的端口，可能会意外地使用其他程序。

我最初在tcl wiki上遇到了这种技术： https：///wiki.tcl-lang .org/page/singleton+应用程序。

Answer 2

另一个旧的黑客是尝试创建一个符号链接。

创建符号链接通常是由大多数Unix和Unix型OS所保证的。因此，使用此技术的潜在种族条件没有问题（与创建常规文件不同）。我认为它也是Windows上的原子（根据Posix规格），但我不确定：

const fs = require('fs');

const scriptName = process.argv[1];
const lockFile = '/tmp/my-program.lock';

try {
    fs.symlinkSync(lockFile, scriptName);

    // run your main function here

    fs.unlinkSync(lockFile);
}
catch (err) {
    console.log('Program already running');

    // handle what to do here
}

注意：创建符号链接是原子链接，但在符号链接上的其他操作不能保证是原子质。特别要谨慎地假设更新符号是原子 - 它不是。更新Symlinks涉及两个操作：删除链接然后创建链接。在您的过程创建一个符号链接后，可以执行第二个进程的删除操作，从而导致两个进程认为它们是唯一运行的过程。在上面的示例中，我们删除链接 创建它，而不是之前。

Answer 3

一种方法是使用本地Web服务器。

index.js

const commandLineArgs = require('command-line-args');
const commandLineCommands = require('command-line-commands');
const commandLineUsage = require('command-line-usage');
var http = require('http');

let globalState = {
    isRunning: false
}

let commandResult;

try {
    commandResult = commandLineCommands([ 'start', 'info', 'help' ]);
} catch (error) {
    console.error('Invalid command.');
    process.exit(1);
}

if (commandResult.command === null || commandResult.command === 'help') {
    const commandInfo = commandLineUsage([
        { header: 'start', content: 'Sets the value to true' },
        { header: 'info', content: 'Gets the current value' },
    ]);

    console.log(commandInfo);
    process.exit(0);
}

let options;

try {
    options = commandLineArgs([], { argv: commandResult.argv });
} catch (error) {
    console.error('Invalid argument.');
    process.exit(1);
}

if (commandResult.command === 'start') {
    globalState.isRunning = true;
    http.createServer(function (req, res) {
        res.write(JSON.stringify(globalState));
        res.end();
    }).listen(9615);
} else if (commandResult.command === 'info') {
    console.info({ globalState });
}

index2.js

var http = require('http');

var req = http.request({ host: "localhost", port: 9615, path: "/" }, (response) => {
    var responseData = "";

    response.on("data", (chunk) => {
        responseData += chunk;
    });

    response.on("end", () => {
        console.log(JSON.parse(responseData));
    });
});

req.end();
req.on("error", (e) => {
    console.error(e);
});

这里index.js是一个持有“共享 /全局状态”并创建与之通信的Web服务器的程序。其他程序（例如Index2.js）可以提出HTTP请求并要求全球状态。您也可以让其他程序通过索引来改变状态。

这不必像这样的http来完成，您还可以使用 node-rpc 或“ nofollow noreferrer”> node-ipc 。我认为最简单的工作示例是使用本地的HTTP客户端和服务器进行操作。

无论哪种方式，我都认为您要寻找的单词是 nofollow noreferrer“> inter Process communication（ipc） a>或远程过程调用（rpc）。我不明白为什么一个人也无法使用 websockets 。即使您可以实施某种类型的亲子过程交流，儿童过程也可能无法在这里工作，因为只有主要过程产生的子进程才能使用。

编辑

更仔细地阅读您的问题后，我认为这只是“保持”启动命令后“保持”“控制台会话”并设置Isrunning变量的问题。

查看此内容：

const commandLineArgs = require('command-line-args');
const commandLineCommands = require('command-line-commands');
const commandLineUsage = require('command-line-usage');
const prompt = require('prompt-sync')();

let globalState = {
    isRunning: false
}

let commandResult;

try {
    commandResult = commandLineCommands([ 'start', 'info', 'help' ]);
} catch (error) {
    console.error('Invalid command.');
    process.exit(1);
}

if (commandResult.command === null || commandResult.command === 'help') {
    const commandInfo = commandLineUsage([
        { header: 'start', content: 'Sets the value to true' },
        { header: 'info', content: 'Gets the current value' },
    ]);

    console.log(commandInfo);
    process.exit(0);
}

let options;

try {
    options = commandLineArgs([], { argv: commandResult.argv });
} catch (error) {
    console.error('Invalid argument.');
    process.exit(1);
}

if (commandResult.command === 'start') {
    globalState.isRunning = true;

    while(globalState.isRunning)
    {
        let cmd = prompt(">");

        if(cmd === "exit")
            process.exit(0);
        if(cmd === "info")
            console.info({ globalState });
    }
   
} else if (commandResult.command === 'info') {
    console.info({ globalState });
}

在这里，我在循环中使用strips-sync库时，当程序与start> start命令调用时。无限期保留“控制台会话”，直到用户键入退出。我还添加了示例，以防用户类型info。

示例：