Bound daemon startup and shutdown and exit with a useful code

start_daemon and stop_daemon polled "while True" with no bound, and no
seaf-cli exit code was checked. A daemon that failed to start left the
container spinning forever with nothing pointing at the cause, and there was
no signal handling, so "docker stop" waited the full 10 second grace period
and then SIGKILLed the process with the daemon still running.

Readiness polling is now bounded by DAEMON_START_TIMEOUT and
DAEMON_STOP_TIMEOUT. The stop timeout is 8 seconds so a graceful shutdown
fits inside the docker stop grace period, and a test asserts that relation.

SIGTERM and SIGINT raise GracefulShutdown, and the lifecycle moved into
start.run(), which always stops the daemon on the way out and returns the
process exit code: 0 on a clean finish or a stop signal, 1 on a daemon or
configuration failure.

seaf-cli exit codes are checked. A failed sync is reported per library and
does not stop the remaining libraries, since one bad library should not take
the container down.

Verified in the built image: "docker stop" now returns in 0s with exit code 0
and the daemon stopped, against 10s and exit 137 before. A daemon that cannot
start exits 1 with the failing command and its exit code in the log.

Also bumps actions/setup-python to v7, which clears the last Node 20
deprecation warning; v7 only drops the unused pip-install input.

start.py

@@ -3,15 +3,78 @@
 import argparse
 import logging
 import os
+import signal
 import sys
 
 from dsc import SeafileClient, const
+from dsc.errors import DscError, GracefulShutdown
 from dsc.misc import setup_uid, create_dir
 from dsc.paths import plan_lib_dirs
 
 _lg = logging.getLogger('dsc')
 
 
+def handle_signal(signum, frame):
+    """Turn a stop signal into an exception so the daemon is stopped on the
+    way out instead of the container being killed with the daemon running."""
+    raise GracefulShutdown(signal.Signals(signum).name)
+
+
+def install_signal_handlers():
+    for signum in (signal.SIGTERM, signal.SIGINT):
+        signal.signal(signum, handle_signal)
+
+
+def resolve_libraries(client, requested: str, server: str) -> set:
+    """Map the requested names or IDs to library IDs that are not synced yet."""
+    libs_to_sync = set()
+    for arg_lib in requested.split(sep=":"):
+        lib_id = client.get_library_id(arg_lib)
+        if lib_id:
+            libs_to_sync.add(lib_id)
+        else:
+            _lg.warning("Library %s is not found on server %s", arg_lib, server)
+
+    # don't start to sync libraries already in sync
+    return libs_to_sync - client.get_local_libraries()
+
+
+def run(client, args, libs_dir: str) -> int:
+    """
+    Run the client lifecycle and return the process exit code. The daemon is
+    always stopped on the way out, including on a failure or a stop signal.
+    """
+    rc = 0
+    try:
+        client.init_config()
+        client.start_daemon()
+        client.configure(args, check_for_daemon=False)
+
+        libs_to_sync = resolve_libraries(client, args.libraries, args.server)
+
+        # Library names come from the server, so the directory for each one is
+        # resolved and checked before anything is created or written.
+        lib_dirs = plan_lib_dirs(
+            {lib_id: client.remote_libraries[lib_id] for lib_id in libs_to_sync},
+            libs_dir,
+        )
+        for lib_id, lib_dir in lib_dirs.items():
+            client.sync_lib(lib_id, lib_dir)
+        client.watch_status()
+    except GracefulShutdown as err:
+        _lg.info("Received %s, shutting down", err)
+    except DscError as err:
+        _lg.error("%s", err)
+        rc = 1
+
+    try:
+        client.stop_daemon()
+    except DscError as err:
+        _lg.error("Could not stop seafile daemon cleanly: %s", err)
+        rc = 1
+    return rc
+
+
 def main():
     logging.basicConfig(format="%(asctime)s %(message)s", level=logging.INFO)
 
@@ -49,24 +112,12 @@ def main():
     if not args.libraries:
         parser.error("library is not specified")
 
+    install_signal_handlers()
+
     setup_uid(args.uid, args.gid)
     create_dir(const.DEFAULT_APP_DIR)
 
     client = SeafileClient(args.server, args.username, args.password, const.DEFAULT_APP_DIR)
-    client.init_config()
-    client.start_daemon()
-    client.configure(args, check_for_daemon=False)
-
-    libs_to_sync = set()
-    for arg_lib in args.libraries.split(sep=":"):
-        lib_id = client.get_library_id(arg_lib)
-        if lib_id:
-            libs_to_sync.add(lib_id)
-        else:
-            _lg.warning("Library %s is not found on server %s", arg_lib, args.server)
-
-    # don't start to sync libraries already in sync
-    libs_to_sync -= client.get_local_libraries()
 
     # check for deprecated /data directory
     if os.path.isdir(const.DEPRECATED_LIBS_DIR):
@@ -77,18 +128,7 @@ def main():
     else:
         libs_dir = const.DEFAULT_LIBS_DIR
 
-    # Library names come from the server, so the directory for each one is
-    # resolved and checked before anything is created or written.
-    lib_dirs = plan_lib_dirs(
-        {lib_id: client.remote_libraries[lib_id] for lib_id in libs_to_sync},
-        libs_dir,
-    )
-    for lib_id, lib_dir in lib_dirs.items():
-        client.sync_lib(lib_id, lib_dir)
-    client.watch_status()
-
-    client.stop_daemon()
-    return 0
+    return run(client, args, libs_dir)
 
 
 if __name__ == "__main__":