Bash 脚本和 C++ 之间的持久 IPC；

Question

问题： 有一个 C 应用程序，每次事件发生时都会调用 Bash 脚本。还有一个C++ 应用程序需要跟踪这些事件。 C++ 应用程序 由 select() 事件循环驱动。在 Bash 脚本 和 C++ 应用程序 之间实现的最简单的 IPC 是什么？

C Application ---Each time calls Bash script---> Bash application ---???---> C++ Application

我想到的解决方案很少：

1. 使用 TCP 网络套接字，但这意味着 select 必须处理侦听套接字和实际套接字的事件
2. 使用命名管道，但一旦 bash 脚本终止，管道的另一端就是也已关闭

有没有更简单的方法可以让我在 select() 中仅使用一个文件描述符？

Answer 1

您可以使用轻量级消息队列，例如 ZeroMQ。我认为你会使用它的推拉机制。您的 C 程序或 bash 脚本推送事件，而 C++ 应用程序拉取事件。 ZeroMQ 是用 C 语言编写的，但除了许多其他语言之外，还存在 C++ 和 Python 绑定。有关推拉示例，请参阅此处。

Answer 2

Unix 数据报 或 UDP 套接字即可。 bash 脚本只会向该套接字发送一个数据报（您可能需要一个在该套接字上执行 sendmsg() 或 sendto() 的帮助程序，例如 socat 或 netcat/nc）。接收方不需要接受数据报套接字的连接，一旦准备好读取，就必须有一个数据报在等待。受数据报长度限制。

Answer 3

我会使用未命名的 pipe() 来完成此操作。请记住：在 UNIX 中，文件描述符在两个进程中的 fork() 和 execve() 之后保持打开状态！因此，您可以使用 pipe() 获取一对文件描述符，然后使用 bash 的 echo >&FD 写入 fd，其中 FD 是文件描述符编号。

这非常简单、简单，并且比我想象的任何其他方法都使用更少的资源。使用 select() 没有问题，只是不要在 read() 上阻塞，这是我在示例中所做的，但在 select() 上pfds[0]。

示例程序（生成 10 个 bash 进程，这些进程发送“hello work，我的 pid：XXX”，在生成进程之间等待 1 秒。该示例仅对所有子进程使用一个管道。我这样更改了它，因为作者询问了这一点。在实践中，我不推荐它（参见示例下面的注释））：

#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#include <stdlib.h>

#include <stdio.h>
#include <assert.h>

int main(int argc, char **argv) {
    int pfds[2];
    pid_t p;

    assert(0 == pipe(pfds));

    p = fork();
    if (p == 0) {
        unsigned int i;
        char str_fd[3];            char *env[] = {NULL};
        char *args[] = { "/bin/bash", "-c", "echo >&$1 hello world, my pid: $"
                       , "-s", str_fd, NULL};
        snprintf(str_fd, 3, "%d", pfds[1]);
        str_fd[2] = 0;

        for (i = 0; i < 10; i++) {
            p = fork();
            if(0 == p) {
                assert(0 ==
                       execve( "/bin/bash", (char *const*)args
                             , (char *const*)env));
            } else if (0 > p) {
                perror("fork");
                exit(1);
            } else {
                wait(NULL);
            }   
            sleep(1);
        }   
    } else if(p > 0) {
        char *buf = malloc(100);
        ssize_t sz; 
        printf("fd is %d, <hit Ctrl+C to exit>\n", pfds[1]);
        while(0 < ( sz = read(pfds[0], buf, 100))) {
            buf[99] = 0;
            printf("received: '%s'\n", buf);
        }   
        free(buf);
        if (0 == sz) {
            fprintf(stderr, "EOF!");
        } else {
            perror("read from bash failed");
        }   
        wait(NULL);
    } else {
        perror("fork failed");
        exit(1);
    }   
    return 0;
}   

示例程序输出：

$ gcc test.c && ./a.out 
fd is 4, <hit Ctrl+C to exit>
received: 'hello world, my pid: 779
'
received: 'hello world, my pid: 780
'
received: 'hello world, my pid: 781
'
received: 'hello world, my pid: 782
'
received: 'hello world, my pid: 783
'
received: 'hello world, my pid: 784
'
received: 'hello world, my pid: 785
'
received: 'hello world, my pid: 786
'
received: 'hello world, my pid: 787
'
received: 'hello world, my pid: 788
'

有效，bashs使用一个管道向父进程发送“hello world，我的pid：XXX \ n” :-)。

尽管如此，这似乎可以像演示程序所示那样工作（使用 POSIX 语义应该没问题，并且在 Linux 和 MacOS X 下进行了测试），我建议每个子进程使用一个 pipe() 。这将减少问题，并且一次运行多个子进程也是可能的。 select() 或 epoll() （如果你有很多子进程）是你的朋友。

由于 pipe() 非常便宜，特别是与 bash! 相比，我绝对不会为多个子级使用同一个管道（正如我更新的示例现在所做的那样）。