Implementing Service Synchronization with notify:pid

[justbaominh]

Hi Finit users and Happy new year all,

I am quite new to Finit and am currently learning how to implement Service Synchronization using notify:pid among other available options. I have two processes: A and B, where B should start only after A has started. My goal is to ensure that process_B starts only after process_A has successfully started. Unfortunately, it hasn't worked as expected.

I am using Finit v4.6. Both are compiled C programs. In process A, I write its PID into /var/run/process_A.pid. Below is my configuration file:

service [S123456789] log:console notify:pid /data/finit/tp/process_A -n pid -- Test Process A
service [S123456789] log:console <pid/process_A/ready> /data/finit/tp/process_B -- Test Process B

When I checked the status with initctl, I got:

/ # initctl
PID IDENT STATUS RUNLEVELS DESCRIPTION
9 process_A running [S-123456789] Test Process A
0 process_B waiting [S-123456789] Test Process B

I've also verified that the PID file has been correctly saved into /var/run/process_A.pid:

/ # cat /var/run/process_A.pid
9

I'm not sure what's messing up here, so I'd really appreciate any help or tips on where I might have gone wrong with my setup.

[troglobit]

The syntax for declaring process B should be:

service [S123456789] log:console <pid/process_A> /data/finit/tp/process_B -- Test Process B

Please note, the synchronization is actually a dependency, so if process A stops the condition will no longer be satisfied and B will also be stopped. If A is stopped and restarted, so will B.

[justbaominh]

Thanks for your comment but no luck so far 😞 However, I know the correct syntax for my .conf file 😄 . It could be something else that's broken. Here is what process A looks like:

#define BUF_SIZE 100 

void createPidFile(const char *pidFile) {
    int fd;
    char buf[BUF_SIZE];

    // Open or create the PID file
    fd = open(pidFile, O_RDWR | O_CREAT, S_IRUSR | S_IWUSR);
    if (fd == -1) {
        fprintf(stderr, "Could not open PID file %s: %s\n", pidFile, strerror(errno));
        exit(EXIT_FAILURE);
    }

    // Truncate the file
    if (ftruncate(fd, 0) == -1) {
        fprintf(stderr, "Could not truncate PID file %s: %s\n", pidFile, strerror(errno));
        close(fd);
        exit(EXIT_FAILURE);
    }

    // Write PID to the file
    snprintf(buf, BUF_SIZE, "%ld\n", (long) getpid());
    if (write(fd, buf, strlen(buf)) != strlen(buf)) {
        fprintf(stderr, "Writing to PID file %s failed: %s\n", pidFile, strerror(errno));
        close(fd);
        exit(EXIT_FAILURE);
    }
    close(fd);
}

int main (int argc, char *argv[]) {
    const char *pidFile = "/var/run/process_A.pid";
    createPidFile(pidFile);

    printf("Process A is running\n");

    while(1) {
        sleep(1);
    }
    return 0;
}

Do you have any ideas to debug? 🤔

[troglobit]

Well, I don't know how you've built and installed Finit, but it needs the pidfile.so plugin to be installed for PID conditions to work.

You can check the status of conditions with the initctl tool. See the cond family of commands.

Btw, that was a very complicated createPidFile() function. I'd recommend using just fopen + fprintf + fclose to handle all of that ...

[justbaominh]

Oh nice. It seems like I am missing that plugin. I know that createPidFile() is complicated. I copied it from here, just want to make sure that I don't make any mistakes. I will investigate more. Thank you so much 😃

[troglobit]

I really recommend installing Finit using make install, or make install-strip. This is documented in the README file. There are other plugins you'll need too -- the name "plugin" is a bit deceiving unfortunately. Optional plugins are selected using the configure script.

[justbaominh]

Hi,

I believe my question is still relevant, so I've posted it here instead of starting a new topic 😄.

I've managed to run synchronization with PID and systemd. However, during my testing, I noticed an issue with the dependency management. Specifically, processes dependent on notify:pid did not stop when their parent process was killed.

Here is my configuration

# Test systemd notify
service name:test1_systemd [2345] restart:0 notify:systemd ready:/data/finit/script/ready.sh finit_test -n DEP1 --systemd -d 2 -- Systemd proc
service name:test2 [2345] <service/test1_systemd/ready> finit_test -n DEP2 -- Dependency test 1

#Test pid notify
service name:test3_pid [2345] notify:pid <service/test1_systemd/ready> ready:/data/finit/script/ready.sh finit_test -n DEP3 -d 2 -p -- Dependency test 1
service name:test4 [2345] <service/test3_pid/ready> finit_test -n DEP4 -- Dependency test 3

In this setup, test3_pid depends on test1_systemd. When I terminate test1_systemd, both test2 and test3 stop, but test4 continues running. Here are the logs:

0    test1_systemd  restart  [---2345----] Systemd proc
0    test2          waiting  [---2345----] Dependency test 1
0    test3_pid      waiting  [---2345----] Dependency test 1
170  test4          running  [---2345----] Dependency test 3

I'm curious as to why this happens. Is it a bug or a feature? I also tested with systemd and observed that test4 stops running when test1 is killed.

[troglobit]

Well, what does initctl cond and initctl cond dump say? If the condition for test4 is still satisfied it will continue running. Does your processes clean up their PID file when they exit?

[justbaominh]

Yes pid file was removed whey they exit. Here is my initctl cond and initctl cond dump

   PID  IDENT          STATUS  CONDITION (+ ON, ~ FLUX, - OFF)                                                                                                                    
   0    test2          off     <-service/test1_systemd/ready>
   0    test3_pid      off     <-service/test1_systemd/ready>
   170  test4          on      <+service/test3_pid/ready>

PID  IDENT          STATUS  CONDITION                                                                                                                                          
    13   syslogd        on      <pid/syslogd>
    1    init           on      <int/bootstrap>
    1    init           on      <int/container>
    1    static         on      <hook/mount/root>
    1    static         on      <hook/mount/all>
    1    static         on      <hook/svc/up>
    1    static         on      <hook/svc/plugin>
    1    static         on      <hook/net/up>
    1    static         on      <hook/sys/up>
    1    static         on      <hook/sys/banner>
    1    init           on      <service/syslogd/ready>
    1    init           on      <service/syslogd/running>
    1    init           on      <service/test1_systemd/restart>
    1    init           on      <service/test4/running>
    1    init           on      <service/mdev/ready>
    1    init           on      <service/mdev/running>
    1    init           on      <service/test3_pid/ready>

[troglobit]

That does indeed look like a bug.

My guess is a regression introduced in the v4.6 release cycle, there were some changes made to the service/{ready,running} code.

[justbaominh]

Ya. Thank you for your clarification 😄

[troglobit]

Would you mind summarizing the above in a bug report (issue)? I'd like to set up a regression test and start working on fixing this one asap

[troglobit]

Bug reported in #392 and fixed as of Finit v4.7, closing.