Experiments#

I carried out three groups of experiments. Each group corresponds to one of Requires=, PartOf=, and BindsTo=.

In each group, a systemd unit a.service was kept the same. It served as the dependency of the second systemd unit, b.service. b.service depended on a.service using either Requires=, PartOf=, or BindsTo=.

Eight tests were done for each group. In other words, I ran a total of 24 tests. To keep the experiments in user space, a.service and b.service were saved in ~/.config/systemd/user/.

Here’s the content of a.service:

a.service

1
[Unit]
2
Description=Test service A
3

4
[Service]
5
Type=simple
6
ExecStart=sh -c 'while true; do echo A is alive; sleep 3; done'

The following are the contents of b.service in the three experiment groups:

1. Experiment group A: with Requires=

   b.service with Requires=a.service

1
[Unit]
2
Description=Test service B.
3
Requires=a.service
4

5
[Service]
6
Type=simple
7
ExecStart=sh -c 'while true; do echo B is alive; sleep 3; done'

2. Experiment group B: with PartOf=

   b.service with PartOf=a.service

1
[Unit]
2
Description=Test service B.
3
PartOf=a.service
4

5
[Service]
6
Type=simple
7
ExecStart=sh -c 'while true; do echo B is alive; sleep 3; done'

3. Experiment group C: with BindsTo=

   b.service with BindsTo=a.service

1
[Unit]
2
Description=Test service B.
3
BindsTo=a.service
4

5
[Service]
6
Type=simple
7
ExecStart=sh -c 'while true; do echo B is alive; sleep 3; done'

The following are the commands I ran in every experiment group, along with what I wanted to observe from the results:

1. Test 1 ``` $ systemctl —user start a.service

1
     *What I want to see*: if `b.service` also starts when `a.service` starts.
2
2. Test 2 ```
3
    $ systemctl --user start b.service

1
 *What I want to see*: if `a.service` also starts when `b.service` starts.

3. Test 3 ``` $systemctl --user start a.service b.service$ systemctl —user stop a.service

1
     *What I want to see*: if `b.service` also stops when `a.service` stops normally.
2
4. Test 4 ```
3
    $ systemctl --user start a.service b.service
4
    $ systemctl --user stop b.service

1
 *What I want to see*: if `a.service` also stops when `b.service` stops normally.

5. Test 5 ``` $systemctl --user start a.service b.service$ kill -9 $(systemctl —user show a.service | grep -oP ’(?<=ExecMainPID=)\d*’)

1
     *What I want to see*: if `b.service` stops when `a.service` stops abnormally (i.e., `a.service` is not stopped by `systemd`).
2
6. Test 6 ```
3
    $ systemctl --user start a.service b.service
4
    $ kill -9 $(systemctl --user show b.service | grep -oP '(?<=ExecMainPID=)\d*')

1
 *What I want to see*: if `a.service` stops when `b.service` stops abnormally (i.e., `b.service` is not stopped by `systemd`).

7. Test 7 ``` $systemctl --user start a.service b.service$ systemctl —user restart a.service

1
     *What I want to see*: if `b.service` also restarts when `a.service` restarts.
2
8. Test 8 ```
3
    $ systemctl --user start a.service b.service
4
    $ systemctl --user restart b.service

1
 *What I want to see*: if `a.service` also restarts when `b.service` restarts.

Results#

The following table shows the results. Each column represents an experiment group, and each row represents a test. Each result is either V/V, V/X, X/V, or X/X. They indicate whether a.service and b.service are running. For example, V/X means a.service is running while b.service has stopped.

From the results, we can ignore the tests in which we applied changes to the status of b.service (i.e., tests 4, 6, and 8), because changes to b.service were not propagated to a.service. This is expected behavior: b.service depended on a.service, but a.service did not depend on b.service.

One exception is when we started b.service (test 2). When we started b.service, a.service also started when using Requires and BindsTo. But when using PartOf, starting b.service had no effect on a.service.

Now let’s look at what happened to b.service when we changed the status of a.service (i.e., tests 1, 3, 5, and 7). In test 1, starting a.service did not trigger b.service to start. This is expected, because a.service did not know anything about b.service before b.service was loaded into systemd. So when a.service started, nothing happened to b.service.

Once both a.service and b.service were running, systemd knew about the existence of b.service and the dependency relationship. In test 3, when both services were running and then we stopped a.service, b.service also stopped no matter whether the dependency was Requires, PartOf, or BindsTo.

Now comes the interesting part, at least to me. In test 5, we simulated a situation in which a.service stopped unexpectedly. That is, a.service was not stopped by systemd or by any normal mechanism. It was killed with a SIGKILL signal to mimic a crash. In that case, b.service stopped only when using BindsTo. In other words, when using Requires and PartOf, b.service did not stop when a.service crashed unexpectedly.

Test 7 shows that when we restarted a.service, b.service also restarted regardless of whether the dependency was Requires, PartOf, or BindsTo.

Conclusion#

The last#

Finally, one thing to remember is that these tests do not consider the situation where we enable either service. If we use enable, an extra [Install] section is needed in the unit files. And in [Install], we have more options for configuring dependencies. Once we combine the dependency settings in [Unit] and [Install], things may become more complicated.