feat: add archive client foundation

2026-07-22 14:55:02 +00:00
commit c11a7b5b5b
39 changed files with 2985 additions and 0 deletions
@@ -0,0 +1,112 @@
+import asyncio
+import os
+import tempfile
+import unittest
+from pathlib import Path, PurePosixPath
+from uuid import uuid4
+
+from websockets.asyncio.server import serve
+
+from archive_clients.config import ClientConfig, ConnectionConfig, ServiceConfig
+from archive_clients.daemon import ArchiveClientDaemon
+from archive_clients.probes import FilesystemProbe
+from archive_clients.protocol import decode, encode, new_envelope
+from archive_control.v1 import client_pb2, common_pb2, control_pb2
+
+
+class DaemonTransportTests(unittest.IsolatedAsyncioTestCase):
+    async def test_registration_heartbeat_and_duplicate_command(self):
+        observed = {}
+
+        async def control(websocket):
+            registration = decode(await websocket.recv())
+            observed["token"] = registration.register_request.shared_token
+            observed["root_names"] = [
+                item.root_name
+                for item in registration.register_request.capabilities.filesystems
+            ]
+            observed["addresses"] = list(
+                registration.register_request.capabilities
+                .syncthing_advertised_addresses
+            )
+            response = new_envelope()
+            response.correlation_id = registration.message_id
+            response.register_response.status = client_pb2.REGISTRATION_STATUS_ACCEPTED
+            response.register_response.negotiated_version.major = 1
+            await websocket.send(encode(response))
+            heartbeat = new_envelope()
+            heartbeat.heartbeat.sequence = 7
+            await websocket.send(encode(heartbeat))
+            observed["heartbeat"] = decode(await websocket.recv()).heartbeat_ack.sequence
+            command_id = str(uuid4())
+            command = new_envelope()
+            command.command.command_id = command_id
+            command.command.created_at.CopyFrom(command.sent_at)
+            command.command.request_job_snapshot.job_ids.append(str(uuid4()))
+            await websocket.send(encode(command))
+            observed["first"] = decode(await websocket.recv()).command_ack.status
+            observed["snapshot"] = (
+                decode(await websocket.recv()).WhichOneof("payload")
+            )
+            duplicate = new_envelope()
+            duplicate.command.CopyFrom(command.command)
+            await websocket.send(encode(duplicate))
+            observed["second"] = decode(await websocket.recv()).command_ack.status
+            unsupported = new_envelope()
+            unsupported.command.command_id = str(uuid4())
+            unsupported.command.created_at.CopyFrom(unsupported.sent_at)
+            unsupported.command.assign_job.SetInParent()
+            await websocket.send(encode(unsupported))
+            rejected = decode(await websocket.recv()).command_ack
+            observed["rejected"] = (rejected.status, rejected.error.code)
+            unsupported_duplicate = new_envelope()
+            unsupported_duplicate.command.CopyFrom(unsupported.command)
+            await websocket.send(encode(unsupported_duplicate))
+            observed["rejected_duplicate"] = (
+                decode(await websocket.recv()).command_ack.status
+            )
+
+        with tempfile.TemporaryDirectory() as directory:
+            root = Path(directory)
+            token = root / "token"
+            token.write_text("shared-secret", encoding="utf-8")
+            os.chmod(token, 0o600)
+            async with serve(control, "127.0.0.1", 0, ping_interval=None) as server:
+                port = server.sockets[0].getsockname()[1]
+                service = ServiceConfig(
+                    "http://local", PurePosixPath("/api"), root,
+                    advertised_addresses=("dynamic",),
+                )
+                config = ClientConfig(
+                    "cache-1", "Cache 1", "cache",
+                    f"ws://127.0.0.1:{port}", token,
+                    root / "state.db", root / "backups", service, service,
+                    ConnectionConfig(registration_timeout=2),
+                )
+                probe = FilesystemProbe(root, True, True, True, True)
+                daemon = ArchiveClientDaemon(config, [probe, probe])
+                await asyncio.to_thread(daemon.store.initialize)
+                await daemon._connection()
+
+        self.assertEqual(observed["token"], "shared-secret")
+        self.assertEqual(observed["root_names"], ["qbittorrent", "syncthing"])
+        self.assertEqual(observed["addresses"], ["dynamic"])
+        self.assertEqual(observed["heartbeat"], 7)
+        self.assertEqual(observed["first"], control_pb2.COMMAND_ACK_STATUS_ACCEPTED)
+        self.assertEqual(observed["second"], control_pb2.COMMAND_ACK_STATUS_DUPLICATE)
+        self.assertEqual(observed["snapshot"], "client_state_snapshot")
+        self.assertEqual(
+            observed["rejected"],
+            (
+                control_pb2.COMMAND_ACK_STATUS_REJECTED,
+                common_pb2.ERROR_CODE_UNSUPPORTED,
+            ),
+        )
+        self.assertEqual(
+            observed["rejected_duplicate"],
+            control_pb2.COMMAND_ACK_STATUS_REJECTED,
+        )
+
+
+if __name__ == "__main__":
+    unittest.main()