shaba/systemd
1
0
Fork 0
mirror of https://github.com/systemd/systemd.git synced 2024-12-23 21:35:11 +03:00
Code
6eb151e989
systemd/test/units/testsuite-23.start-stop-no-reload.sh

94 lines
2.9 KiB
Bash
Raw Normal View History

core: reload cache if it's dirty when starting a UNIT_NOT_FOUND unit The time-based cache allows starting a new unit without an expensive daemon-reload, unless there was already a reference to it because of a dependency or ordering from another unit. If the cache is out of date, check again if we can load the fragment.
2020-05-08 01:26:53 +03:00
#!/usr/bin/env bash
tests: add spdx headers to scripts and Makefiles
2021-10-17 19:13:06 +03:00
# SPDX-License-Identifier: LGPL-2.1-or-later
core: reload cache if it's dirty when starting a UNIT_NOT_FOUND unit The time-based cache allows starting a new unit without an expensive daemon-reload, unless there was already a reference to it because of a dependency or ordering from another unit. If the cache is out of date, check again if we can load the fragment.
2020-05-08 01:26:53 +03:00
# -*- mode: shell-script; indent-tabs-mode: nil; sh-basic-offset: 4; -*-
# ex: ts=8 sw=4 sts=4 et filetype=sh
test: use set -eux and set -o pipefail everywhere This should make the scripts more robust.
2021-04-09 20:39:41 +03:00
set -eux
test: merge TEST-48-START-STOP-NO-RELOAD into TEST-23-UNIT-FILE
2023-05-16 21:41:35 +03:00
set -o pipefail
core: reload cache if it's dirty when starting a UNIT_NOT_FOUND unit The time-based cache allows starting a new unit without an expensive daemon-reload, unless there was already a reference to it because of a dependency or ordering from another unit. If the cache is out of date, check again if we can load the fragment.
2020-05-08 01:26:53 +03:00
test: merge TEST-48-START-STOP-NO-RELOAD into TEST-23-UNIT-FILE
2023-05-16 21:41:35 +03:00
# Test start & stop operations without daemon-reload
at_exit() {
set +e
rm -f /run/systemd/system/testsuite-23-no-reload.{service,target}
}
trap at_exit EXIT
cat >/run/systemd/system/testsuite-23-no-reload.target <<EOF
core: reload cache if it's dirty when starting a UNIT_NOT_FOUND unit The time-based cache allows starting a new unit without an expensive daemon-reload, unless there was already a reference to it because of a dependency or ordering from another unit. If the cache is out of date, check again if we can load the fragment.
2020-05-08 01:26:53 +03:00
[Unit]
test: merge TEST-48-START-STOP-NO-RELOAD into TEST-23-UNIT-FILE
2023-05-16 21:41:35 +03:00
Wants=testsuite-23-no-reload.service
core: reload cache if it's dirty when starting a UNIT_NOT_FOUND unit The time-based cache allows starting a new unit without an expensive daemon-reload, unless there was already a reference to it because of a dependency or ordering from another unit. If the cache is out of date, check again if we can load the fragment.
2020-05-08 01:26:53 +03:00
EOF
systemctl daemon-reload
test: merge TEST-48-START-STOP-NO-RELOAD into TEST-23-UNIT-FILE
2023-05-16 21:41:35 +03:00
systemctl start testsuite-23-no-reload.target
core: reload cache if it's dirty when starting a UNIT_NOT_FOUND unit The time-based cache allows starting a new unit without an expensive daemon-reload, unless there was already a reference to it because of a dependency or ordering from another unit. If the cache is out of date, check again if we can load the fragment.
2020-05-08 01:26:53 +03:00
# The filesystem on the test image, despite being ext4, seems to have a mtime
# granularity of one second, which means the manager's unit cache won't be
# marked as dirty when writing the unit file, unless we wait at least a full
# second after the previous daemon-reload.
tests: use "H" as the hostname "systemd-testsuite" gets in the way when grepping for "testsuite-*.sh". Also, the name doesn't matter for anything, so let's just use something very short to save space.
2021-05-04 14:54:33 +03:00
# May 07 23:12:20 H testsuite-48.sh[30]: + cat
test: merge TEST-48-START-STOP-NO-RELOAD into TEST-23-UNIT-FILE
2023-05-16 21:41:35 +03:00
# May 07 23:12:20 H testsuite-48.sh[30]: + ls -l --full-time /etc/systemd/system/testsuite-23-no-reload.service
tests: use "H" as the hostname "systemd-testsuite" gets in the way when grepping for "testsuite-*.sh". Also, the name doesn't matter for anything, so let's just use something very short to save space.
2021-05-04 14:54:33 +03:00
# May 07 23:12:20 H testsuite-48.sh[52]: -rw-r--r-- 1 root root 50 2020-05-07 23:12:20.000000000 +0100 /
test: merge TEST-48-START-STOP-NO-RELOAD into TEST-23-UNIT-FILE
2023-05-16 21:41:35 +03:00
# May 07 23:12:20 H testsuite-48.sh[30]: + stat -f --format=%t /etc/systemd/system/testsuite-23-no-reload.servic
tests: use "H" as the hostname "systemd-testsuite" gets in the way when grepping for "testsuite-*.sh". Also, the name doesn't matter for anything, so let's just use something very short to save space.
2021-05-04 14:54:33 +03:00
# May 07 23:12:20 H testsuite-48.sh[53]: ef53
core: store timestamps of unit load attempts When the system is under heavy load, it can happen that the unit cache is refreshed for an unrelated reason (in the test I simulate this by attempting to start a non-existing unit). The new unit is found and accounted for in the cache, but it's ignored since we are loading something else. When we actually look for it, by attempting to start it, the cache is up to date so no refresh happens, and starting fails although we have it loaded in the cache. When the unit state is set to UNIT_NOT_FOUND, mark the timestamp in u->fragment_loadtime. Then when attempting to load again we can check both if the cache itself needs a refresh, OR if it was refreshed AFTER the last failed attempt that resulted in the state being UNIT_NOT_FOUND. Update the test so that this issue reproduces more often.
2020-06-16 20:46:55 +03:00
sleep 3.1
core: reload cache if it's dirty when starting a UNIT_NOT_FOUND unit The time-based cache allows starting a new unit without an expensive daemon-reload, unless there was already a reference to it because of a dependency or ordering from another unit. If the cache is out of date, check again if we can load the fragment.
2020-05-08 01:26:53 +03:00
test: merge TEST-48-START-STOP-NO-RELOAD into TEST-23-UNIT-FILE
2023-05-16 21:41:35 +03:00
cat >/run/systemd/system/testsuite-23-no-reload.service <<EOF
core: reload cache if it's dirty when starting a UNIT_NOT_FOUND unit The time-based cache allows starting a new unit without an expensive daemon-reload, unless there was already a reference to it because of a dependency or ordering from another unit. If the cache is out of date, check again if we can load the fragment.
2020-05-08 01:26:53 +03:00
[Service]
ExecStart=/bin/sleep infinity
EOF
test: merge TEST-48-START-STOP-NO-RELOAD into TEST-23-UNIT-FILE
2023-05-16 21:41:35 +03:00
systemctl start testsuite-23-no-reload.service
core: reload cache if it's dirty when starting a UNIT_NOT_FOUND unit The time-based cache allows starting a new unit without an expensive daemon-reload, unless there was already a reference to it because of a dependency or ordering from another unit. If the cache is out of date, check again if we can load the fragment.
2020-05-08 01:26:53 +03:00
test: merge TEST-48-START-STOP-NO-RELOAD into TEST-23-UNIT-FILE
2023-05-16 21:41:35 +03:00
systemctl is-active testsuite-23-no-reload.service
core: reload cache if it's dirty when starting a UNIT_NOT_FOUND unit The time-based cache allows starting a new unit without an expensive daemon-reload, unless there was already a reference to it because of a dependency or ordering from another unit. If the cache is out of date, check again if we can load the fragment.
2020-05-08 01:26:53 +03:00
core: store timestamps of unit load attempts When the system is under heavy load, it can happen that the unit cache is refreshed for an unrelated reason (in the test I simulate this by attempting to start a non-existing unit). The new unit is found and accounted for in the cache, but it's ignored since we are loading something else. When we actually look for it, by attempting to start it, the cache is up to date so no refresh happens, and starting fails although we have it loaded in the cache. When the unit state is set to UNIT_NOT_FOUND, mark the timestamp in u->fragment_loadtime. Then when attempting to load again we can check both if the cache itself needs a refresh, OR if it was refreshed AFTER the last failed attempt that resulted in the state being UNIT_NOT_FOUND. Update the test so that this issue reproduces more often.
2020-06-16 20:46:55 +03:00
# Stop and remove, and try again to exercise https://github.com/systemd/systemd/issues/15992
test: merge TEST-48-START-STOP-NO-RELOAD into TEST-23-UNIT-FILE
2023-05-16 21:41:35 +03:00
systemctl stop testsuite-23-no-reload.service
rm -f /run/systemd/system/testsuite-23-no-reload.service
core: store timestamps of unit load attempts When the system is under heavy load, it can happen that the unit cache is refreshed for an unrelated reason (in the test I simulate this by attempting to start a non-existing unit). The new unit is found and accounted for in the cache, but it's ignored since we are loading something else. When we actually look for it, by attempting to start it, the cache is up to date so no refresh happens, and starting fails although we have it loaded in the cache. When the unit state is set to UNIT_NOT_FOUND, mark the timestamp in u->fragment_loadtime. Then when attempting to load again we can check both if the cache itself needs a refresh, OR if it was refreshed AFTER the last failed attempt that resulted in the state being UNIT_NOT_FOUND. Update the test so that this issue reproduces more often.
2020-06-16 20:46:55 +03:00
systemctl daemon-reload
sleep 3.1
test: merge TEST-48-START-STOP-NO-RELOAD into TEST-23-UNIT-FILE
2023-05-16 21:41:35 +03:00
cat >/run/systemd/system/testsuite-23-no-reload.service <<EOF
core: store timestamps of unit load attempts When the system is under heavy load, it can happen that the unit cache is refreshed for an unrelated reason (in the test I simulate this by attempting to start a non-existing unit). The new unit is found and accounted for in the cache, but it's ignored since we are loading something else. When we actually look for it, by attempting to start it, the cache is up to date so no refresh happens, and starting fails although we have it loaded in the cache. When the unit state is set to UNIT_NOT_FOUND, mark the timestamp in u->fragment_loadtime. Then when attempting to load again we can check both if the cache itself needs a refresh, OR if it was refreshed AFTER the last failed attempt that resulted in the state being UNIT_NOT_FOUND. Update the test so that this issue reproduces more often.
2020-06-16 20:46:55 +03:00
[Service]
ExecStart=/bin/sleep infinity
EOF
# Start a non-existing unit first, so that the cache is reloaded for an unrelated
# reason. Starting the existing unit later should still work thanks to the check
# for the last load attempt vs cache timestamp.
test: merge TEST-48-START-STOP-NO-RELOAD into TEST-23-UNIT-FILE
2023-05-16 21:41:35 +03:00
systemctl start testsuite-23-no-reload-nonexistent.service || true
core: store timestamps of unit load attempts When the system is under heavy load, it can happen that the unit cache is refreshed for an unrelated reason (in the test I simulate this by attempting to start a non-existing unit). The new unit is found and accounted for in the cache, but it's ignored since we are loading something else. When we actually look for it, by attempting to start it, the cache is up to date so no refresh happens, and starting fails although we have it loaded in the cache. When the unit state is set to UNIT_NOT_FOUND, mark the timestamp in u->fragment_loadtime. Then when attempting to load again we can check both if the cache itself needs a refresh, OR if it was refreshed AFTER the last failed attempt that resulted in the state being UNIT_NOT_FOUND. Update the test so that this issue reproduces more often.
2020-06-16 20:46:55 +03:00
test: merge TEST-48-START-STOP-NO-RELOAD into TEST-23-UNIT-FILE
2023-05-16 21:41:35 +03:00
systemctl start testsuite-23-no-reload.service
core: store timestamps of unit load attempts When the system is under heavy load, it can happen that the unit cache is refreshed for an unrelated reason (in the test I simulate this by attempting to start a non-existing unit). The new unit is found and accounted for in the cache, but it's ignored since we are loading something else. When we actually look for it, by attempting to start it, the cache is up to date so no refresh happens, and starting fails although we have it loaded in the cache. When the unit state is set to UNIT_NOT_FOUND, mark the timestamp in u->fragment_loadtime. Then when attempting to load again we can check both if the cache itself needs a refresh, OR if it was refreshed AFTER the last failed attempt that resulted in the state being UNIT_NOT_FOUND. Update the test so that this issue reproduces more often.
2020-06-16 20:46:55 +03:00
test: merge TEST-48-START-STOP-NO-RELOAD into TEST-23-UNIT-FILE
2023-05-16 21:41:35 +03:00
systemctl is-active testsuite-23-no-reload.service
core: store timestamps of unit load attempts When the system is under heavy load, it can happen that the unit cache is refreshed for an unrelated reason (in the test I simulate this by attempting to start a non-existing unit). The new unit is found and accounted for in the cache, but it's ignored since we are loading something else. When we actually look for it, by attempting to start it, the cache is up to date so no refresh happens, and starting fails although we have it loaded in the cache. When the unit state is set to UNIT_NOT_FOUND, mark the timestamp in u->fragment_loadtime. Then when attempting to load again we can check both if the cache itself needs a refresh, OR if it was refreshed AFTER the last failed attempt that resulted in the state being UNIT_NOT_FOUND. Update the test so that this issue reproduces more often.
2020-06-16 20:46:55 +03:00
core: refresh unit cache when building a transaction if UNIT_NOT_FOUND When a command asks to load a unit directly and it is in state UNIT_NOT_FOUND, and the cache is outdated, we refresh it and attempto to load again. Use the same logic when building up a transaction and a dependency in UNIT_NOT_FOUND state is encountered. Update the unit test to exercise this code path.
2020-07-03 20:45:19 +03:00
# Stop and remove, and try again to exercise the transaction setup code path by
# having the target pull in the unloaded but available unit
test: merge TEST-48-START-STOP-NO-RELOAD into TEST-23-UNIT-FILE
2023-05-16 21:41:35 +03:00
systemctl stop testsuite-23-no-reload.service testsuite-23-no-reload.target
rm -f /run/systemd/system/testsuite-23-no-reload.service /run/systemd/system/testsuite-23-no-reload.target
core: refresh unit cache when building a transaction if UNIT_NOT_FOUND When a command asks to load a unit directly and it is in state UNIT_NOT_FOUND, and the cache is outdated, we refresh it and attempto to load again. Use the same logic when building up a transaction and a dependency in UNIT_NOT_FOUND state is encountered. Update the unit test to exercise this code path.
2020-07-03 20:45:19 +03:00
systemctl daemon-reload
sleep 3.1
test: merge TEST-48-START-STOP-NO-RELOAD into TEST-23-UNIT-FILE
2023-05-16 21:41:35 +03:00
cat >/run/systemd/system/testsuite-23-no-reload.target <<EOF
core: refresh unit cache when building a transaction if UNIT_NOT_FOUND When a command asks to load a unit directly and it is in state UNIT_NOT_FOUND, and the cache is outdated, we refresh it and attempto to load again. Use the same logic when building up a transaction and a dependency in UNIT_NOT_FOUND state is encountered. Update the unit test to exercise this code path.
2020-07-03 20:45:19 +03:00
[Unit]
Conflicts=shutdown.target
test: merge TEST-48-START-STOP-NO-RELOAD into TEST-23-UNIT-FILE
2023-05-16 21:41:35 +03:00
Wants=testsuite-23-no-reload.service
core: refresh unit cache when building a transaction if UNIT_NOT_FOUND When a command asks to load a unit directly and it is in state UNIT_NOT_FOUND, and the cache is outdated, we refresh it and attempto to load again. Use the same logic when building up a transaction and a dependency in UNIT_NOT_FOUND state is encountered. Update the unit test to exercise this code path.
2020-07-03 20:45:19 +03:00
EOF
systemctl daemon-reload
test: merge TEST-48-START-STOP-NO-RELOAD into TEST-23-UNIT-FILE
2023-05-16 21:41:35 +03:00
systemctl start testsuite-23-no-reload.target
core: refresh unit cache when building a transaction if UNIT_NOT_FOUND When a command asks to load a unit directly and it is in state UNIT_NOT_FOUND, and the cache is outdated, we refresh it and attempto to load again. Use the same logic when building up a transaction and a dependency in UNIT_NOT_FOUND state is encountered. Update the unit test to exercise this code path.
2020-07-03 20:45:19 +03:00
test: merge TEST-48-START-STOP-NO-RELOAD into TEST-23-UNIT-FILE
2023-05-16 21:41:35 +03:00
cat >/run/systemd/system/testsuite-23-no-reload.service <<EOF
core: refresh unit cache when building a transaction if UNIT_NOT_FOUND When a command asks to load a unit directly and it is in state UNIT_NOT_FOUND, and the cache is outdated, we refresh it and attempto to load again. Use the same logic when building up a transaction and a dependency in UNIT_NOT_FOUND state is encountered. Update the unit test to exercise this code path.
2020-07-03 20:45:19 +03:00
[Service]
ExecStart=/bin/sleep infinity
EOF
test: merge TEST-48-START-STOP-NO-RELOAD into TEST-23-UNIT-FILE
2023-05-16 21:41:35 +03:00
systemctl restart testsuite-23-no-reload.target
core: reload cache if it's dirty when starting a UNIT_NOT_FOUND unit The time-based cache allows starting a new unit without an expensive daemon-reload, unless there was already a reference to it because of a dependency or ordering from another unit. If the cache is out of date, check again if we can load the fragment.
2020-05-08 01:26:53 +03:00
test: merge TEST-48-START-STOP-NO-RELOAD into TEST-23-UNIT-FILE
2023-05-16 21:41:35 +03:00
systemctl is-active testsuite-23-no-reload.service
Copy Permalink