cubething_psync 0.2.1.dev2__tar.gz → 0.4.0__tar.gz

{cubething_psync-0.2.1.dev2/src/cubething_psync.egg-info → cubething_psync-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cubething_psync
-Version: 0.2.1.dev2
+Version: 0.4.0
 Summary: Simple project synchronization tool.
 Author-email: ada mandala <ada@cubething.dev>
 License-Expression: MIT

{cubething_psync-0.2.1.dev2 → cubething_psync-0.4.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cubething_psync"
-version = "0.2.1.dev2"
+version = "0.4.0"
 description = "Simple project synchronization tool."
 authors = [{name = "ada mandala", email="ada@cubething.dev"}]
 readme = "README.md"
@@ -26,6 +26,23 @@ build-backend = "setuptools.build_meta"
 [tool.setuptools.packages.find]
 where= ["src"]
 
+[dependency-groups]
+dev = [
+    "basedpyright>=1.35.0",
+    "pytest>=9.0.1",
+    "ruff>=0.14.7",
+    "testcontainers>=4.13.3",
+]
+
 [project.scripts]
 psync-server = "server.main:main"
 psync-client = "client.main:main"
+
+[pytest]
+testpaths="test"
+addopts = ["--import-mode=importlib"]
+
+[tool.basedpyright]
+ignore=["**/__pycache__", "build", "dist"]
+include=["src", "test"]
+failOnWarnings=false

cubething_psync-0.4.0/src/client/args.py

@@ -0,0 +1,207 @@
+import argparse
+from dataclasses import dataclass, field
+import hashlib
+import logging
+import os
+from os.path import basename
+from pathlib import Path
+import shlex
+from common.data import deserialize_env
+from typing import TYPE_CHECKING, Any
+if TYPE_CHECKING:
+    from _typeshed import SupportsWrite
+    Logfile = SupportsWrite[str] | Path | None
+else:
+    Logfile = Any
+
+
+@dataclass
+class Args:
+    """
+    Client arguments.
+    """
+
+    target_path: str
+    """
+    ``--path -p <target_path>``
+
+    **Required.** Path to the target executable.
+    """
+
+    assets: list[str] = field(default_factory=list)
+    """
+    ``--assets -A <env>``
+
+    Extra files or directories to be synced to the destination path.
+    """
+
+    env: dict[str, str] = field(default_factory=dict)
+    """
+    ``--env -e <env>``
+
+    Space separated list of environment variables which will be passed to the executable.
+    """
+
+    args: list[str] = field(default_factory=list)
+    """
+    ``--args -a <args>``
+
+    Arguments passed to the executable.
+    """
+
+    server_ip: str = os.environ.get("PSYNC_SERVER_IP", "127.0.0.1")
+    """
+    environ: ``PSYNC_SERVER_IP``
+
+    Server IP address.
+    """
+
+    server_port: int = int(os.environ.get("PSYNC_SERVER_PORT", "5000"))
+    """
+    environ: ``PSYNC_SERVER_PORT``
+
+    Server port.
+    """
+
+    server_ssh_port: int = int(os.environ.get("PSYNC_SSH_PORT", "5022"))
+    """
+    environ: ``PSYNC_SSH_PORT``
+
+    SSH port on the server host. Client must be authenticated with a shared public key.
+    """
+
+    ssh_args: str = os.environ.get("PSYNC_SSH_ARGS", "-l psync")
+    """
+    environ: ``PSYNC_SSH_ARGS``
+
+    Arguments passed to SSH. Under the hood, psync runs
+    ``rsync -e "/usr/bin/ssh {PSYNC_SSH_ARGS} -p {PSYNC_SSH_PORT}"``
+    """
+
+    server_dest: str = os.environ.get("PSYNC_SERVER_DEST", "/home/psync")
+    """
+    environ: ``PSYNC_SERVER_DEST``
+
+    Base path on the server where the files should be synced.
+    """
+
+    ssl_cert_path: str = os.environ.get(
+        "PSYNC_CERT_PATH", "~/.local/share/psync/cert.pem"
+    )
+    """
+    environ: ``PSYNC_CERT_PATH``
+
+    Public SSL certificate used to trust the psync server.
+    """
+
+    client_origin: str = os.environ.get("PSYNC_CLIENT_ORIGIN", "127.0.0.1")
+    """
+    environ: ``PSYNC_CLIENT_ORIGIN``
+
+    Domain name. Should match the origins set in the server's ``PSYNC_ORIGINS``
+    variable.
+    """
+
+    logfile: Logfile = None
+    """
+    environ: ``PSYNC_LOG_FILE``
+
+    Optional file where the executable's logs will be output.
+    """
+
+    def project_hash(self) -> str:
+        """
+        Hash value generated from the target path. Used as the directory name for the project.
+        """
+        return hashlib.blake2s(self.target_path.encode(), digest_size=8).hexdigest()
+
+    def rsync_url(self) -> str:
+        """
+        {server_ip}:{server_dest}/{project_hash}
+        """
+        return f"{self.server_ip}:{self.server_dest}/{self.project_hash()}/"
+
+    def destination_path(self) -> Path:
+        """
+        {server_dest}/{project_hash}/{basename(target_path)}
+        """
+        return Path(self.server_dest) / self.project_hash() / basename(self.target_path)
+
+
+parser = argparse.ArgumentParser(
+    prog="psync-client",
+    usage="""\
+Client for the psync server.
+
+In addition to the options below, the client is configurable through environment
+variables.
+
+Variable            | Default
+--------------------+-------------------------------
+PSYNC_SERVER_IP     | 127.0.0.1
+PSYNC_SERVER_PORT   | 5000
+PSYNC_SSH_PORT      | 5022
+PSYNC_SERVER_DEST   | /home/psync/
+PSYNC_SSH_ARGS      | -l psync
+PSYNC_CERT_PATH     | ~/.local/share/psync/cert.pem
+PSYNC_CLIENT_ORIGIN | 127.0.0.1
+PSYNC_LOG_FILE      | None (stdout)
+
+SSH arguments will be append with "-p {PSYNC_SSH_PORT}"
+
+For more info, please read the docs:
+    https://psync.readthedocs.io/
+""",
+)
+_action = parser.add_argument(
+    "--path",
+    "-p",
+    required=True,
+    help="Path to the target exectuable.",
+)
+_action = parser.add_argument(
+    "--assets",
+    "-A",
+    nargs="+",
+    help="Extra files or directories to be synced to the destination path.",
+)
+_action = parser.add_argument(
+    "--env",
+    "-e",
+    help="Environment variables to set in the remote execution environment. Variables must be space-sepated or double-quoted.",
+)
+_action = parser.add_argument(
+    "--args", "-a", help="Arguments passed to the executable."
+)
+
+
+def parse_args() -> Args:
+    args = vars(parser.parse_args())
+
+    target_path = str(args.get("path"))
+    target_path = Path(target_path)
+    if not target_path.is_file():
+        logging.error(f"Could not file at {target_path}")
+        exit(1)
+
+    extra: list[str] = []
+    extra_raw = args.get("extra")
+    if extra_raw is not None:
+        extra = extra_raw  # pyright: ignore[reportAny]
+
+    client_args: list[str] = []
+    raw_args = args.get("args")
+    if raw_args is not None:
+        client_args = shlex.split(str(raw_args))  # pyright: ignore[reportAny]
+
+    env: dict[str, str] = dict()
+    raw_env = args.get("env")
+    if raw_env is not None:
+        env = deserialize_env(f"env='{raw_env}'")
+
+    return Args(
+        target_path=str(target_path),
+        assets=extra or [],
+        env=env,
+        args=client_args,
+    )

{cubething_psync-0.2.1.dev2 → cubething_psync-0.4.0}/src/client/main.py

@@ -2,14 +2,16 @@
 psync client
 """
 
+from io import TextIOWrapper
+import sys
 import asyncio
-import hashlib
 import os
-import pathlib
+from pathlib import Path
 import signal
 import ssl
 import subprocess
 import websockets
+from websockets.typing import Origin
 from common.data import (
     ErrorResp,
     ExitResp,
@@ -17,90 +19,92 @@ from common.data import (
     LogResp,
     OkayResp,
     OpenReq,
+    SetPidResp,
     deserialize,
     serialize,
 )
 import logging
 from common.log import InterceptHandler
 from client.args import (
-    SERVER_IP,
-    SERVER_PORT,
-    SERVER_SSH_PORT,
-    USER,
-    SSL_CERT_PATH,
-    SERVER_DEST,
     Args,
     parse_args,
 )
 
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from _typeshed import SupportsWrite
+    Logfile = SupportsWrite[str]
+else:
+    Logfile = Any
+
 
 class PsyncClient:
     """
     The primary interface for psync. The client CLI allows users to sync files with
     rsync, then execute them remotely while receiving the logs.
-
-    CLI arguments: ::
-          -h, --help            show this help message and exit
-          --path, -p PATH       Path to the target exectuable.
-          --extra, -E EXTRA [EXTRA ...]
-                                Extra files or directories to be synced to the destination path.
-          --env, -e ENV         Environment variables to set in the remote execution environment. Variables
-                                must be space-sepated or double-quoted.
-          --args, -a ARGS       Arguments with which to run the remote executable.
-
-    Environment configuration:
-        PSYNC_SERVER_IP: The IP address of the server instance.
-            Default: 127.0.0.1
-        PSYNC_SERVER_PORT: The port of the server instance.
-            Default: 5000
-        PSYNC_SSH_PORT: The server instance's SSH port.
-            Default: 5022
-        PSYNC_SSH_USER: The server instance's SSH user.
-            Default: psync
-        PSYNC_CERT_PATH: Path to the SSL certificate. Used to trust self-signed certs. Should
-            match the server's certificate.
-            Default: ~/.local/share/psync/cert.pem
     """
 
-    __args: list[str]
-    __env: dict[str, str]
-    __path: pathlib.Path
-    __quit: bool = False
+    args: Args
+    pid: int | None = None
+    """ID of the current connection."""
     __force_exit: bool = False
+    __outfile: Logfile
+
+    def __init__(self, args: Args):
+        self.args = args
+        if isinstance(self.args.logfile, Path):
+            self.__outfile = open(self.args.logfile, "w")
+        elif self.args.logfile is not None:
+            self.__outfile = self.args.logfile
+        else:
+            self.__outfile = sys.stdout
 
-    def __init__(self, args: list[str], env: dict[str, str], path: pathlib.Path):
-        self.__args = args
-        self.__env = env
-        self.__path = path
+    def __enter__(self):
+        return self
+
+    def __exit__(self):
+        if isinstance(self.__outfile, TextIOWrapper):
+            self.__outfile.close()
 
     def __mk_handler(self, ws: websockets.ClientConnection):
         async def inner():
             if not self.__force_exit:
                 logging.info("Gracefully shutting down...")
                 self.__force_exit = True
-                await ws.send(serialize(KillReq()))
+                if self.pid is not None:
+                    await ws.send(serialize(KillReq(pid=self.pid)))
                 await ws.close()
                 asyncio.get_event_loop().stop()
+                raise SystemExit(130)
             else:
                 logging.warning("Got second SIGINT, shutting down")
                 asyncio.get_event_loop().stop()
-                raise Exception("Forced shutdown")
+                raise SystemExit(1)
 
         return lambda: asyncio.create_task(inner())
 
     async def run(self):
         """Run the client instance."""
         ssl_ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
-        ssl_ctx.load_verify_locations(pathlib.Path(SSL_CERT_PATH).expanduser())
+        ssl_ctx.load_verify_locations(Path(self.args.ssl_cert_path).expanduser())
         ssl_ctx.check_hostname = False  # not ideal
         async with websockets.connect(
-            f"wss://{SERVER_IP}:{SERVER_PORT}", ssl=ssl_ctx
+            f"wss://{self.args.server_ip}:{self.args.server_port}",
+            ssl=ssl_ctx,
+            origin=Origin(f"wss://{self.args.client_origin}"),
         ) as ws:
             asyncio.get_event_loop().add_signal_handler(
                 signal.SIGINT, self.__mk_handler(ws)
             )
             await ws.send(
-                serialize(OpenReq(path=self.__path, env=self.__env, args=self.__args))
+                serialize(
+                    OpenReq(
+                        path=self.args.destination_path(),
+                        env=self.args.env,
+                        args=self.args.args,
+                    )
+                )
             )
             async for data in ws:
                 if isinstance(data, bytes):
@@ -115,47 +119,50 @@ class PsyncClient:
                         f"Failed to deserialize message '{msg}' with error '{e}'"
                     )
                     await ws.close()
-                    exit(1)
+                    raise Exception(e)
 
                 match resp:
                     case LogResp():
-                        print(resp.msg, end="")
+                        print(resp.msg, end="", file=self.__outfile)
                     case ErrorResp():
                         logging.error(f"Received server error: {resp.msg}")
                         await ws.close()
-                        exit(1)
+                        raise Exception(resp.msg)
                     case ExitResp():
                         logging.info(f"Exiting with code {resp.exit_code}")
                         await ws.close()
-                        exit(resp.exit_code)
+                        raise SystemExit(resp.exit_code)
+                    case SetPidResp():
+                        logging.info(f"Remote PID = {resp.pid}")
+                        self.pid = resp.pid
                     case OkayResp():
-                        logging.info("Running exectuable...")
+                        logging.info("OK.")
                     case _:
                         logging.warning(f"Got unknown request {resp}")
 
 
-def __rsync(project_hash: str, args: Args):
+def __rsync(args: Args):
     """Runs rsync."""
-    url = f"{SERVER_IP}:{SERVER_DEST}/{project_hash}/"
     rsync_args = [
         "rsync",
         "-avzr",
         "-e",
-        f"/usr/bin/ssh -l {USER} -p {str(SERVER_SSH_PORT)}",
+        f"/usr/bin/ssh {args.ssh_args} -p {str(args.server_ssh_port)}",
         "--progress",
         "--mkpath",
         args.target_path,
-        *args.extra,
-        url,
+        *args.assets,
+        args.rsync_url(),
     ]
     logging.info(" ".join(rsync_args))
     p = subprocess.run(rsync_args)
     if p.returncode != 0:
-        logging.error(f"Rsync failed with exit code {p.returncode}")
-        exit(1)
+        msg = f"Rsync failed with exit code {p.returncode}"
+        logging.error(msg)
+        raise Exception(msg)
 
 
-def main():
+def main(args: Args | None = None):
     """
     The main executable.
     Sync project files with rsync, then run the client.
@@ -163,15 +170,15 @@ def main():
     log_level = os.environ.get("PSYNC_LOG", "INFO").upper()
     logging.basicConfig(handlers=[InterceptHandler()], level=log_level, force=True)
 
-    project_hash = hashlib.blake2s(os.getcwd().encode(), digest_size=8).hexdigest()
-    args = parse_args()
-    __rsync(project_hash, args)
+    args = parse_args() if args is None else args
+    __rsync(args)
 
-    dest_path = pathlib.Path(
-        f"{SERVER_DEST}/{project_hash}/{os.path.basename(args.target_path)}"
-    )
-    client = PsyncClient(args=args.args, env=args.env, path=dest_path)
-    asyncio.run(client.run())
+    try:
+        asyncio.run(PsyncClient(args).run())
+    except SystemExit as e:
+        exit(e.code)
+    except Exception:
+        exit(1)
 
 
 if __name__ == "__main__":

{cubething_psync-0.2.1.dev2 → cubething_psync-0.4.0}/src/common/data.py

@@ -1,4 +1,3 @@
-from collections.abc import Mapping
 from dataclasses import dataclass
 import logging
 from pathlib import Path
@@ -15,6 +14,7 @@ class Mode(Enum):
 class ReqKind(Enum):
     Open = "open"
     Kill = "kill"
+    HealthCheck = "hc"
 
 
 class RespKind(Enum):
@@ -22,18 +22,20 @@ class RespKind(Enum):
     Error = "error"
     Exit = "exit"
     Okay = "ok"
+    SetPid = "set_pid"
 
 
 @dataclass
 class OpenReq:
     path: Path
     args: list[str]
-    env: Mapping[str, str]
+    env: dict[str,str]
     kind: ReqKind = ReqKind.Open
 
 
 @dataclass
 class KillReq:
+    pid: int
     kind: ReqKind = ReqKind.Kill
 
 
@@ -60,28 +62,44 @@ class OkayResp:
     kind: RespKind = RespKind.Okay
 
 
-Req = OpenReq | KillReq
-Resp = LogResp | ExitResp | ErrorResp | OkayResp
+@dataclass
+class HealthCheckReq:
+    kind: ReqKind = ReqKind.HealthCheck
+
+
+@dataclass
+class SetPidResp:
+    pid: int
+    kind: RespKind = RespKind.SetPid
+
+
+Req = OpenReq | KillReq | HealthCheckReq
+Resp = LogResp | ExitResp | ErrorResp | OkayResp | SetPidResp
 
 
 def serialize(msg: Req | Resp) -> str:
+    value = msg.kind.value
     match msg:
         case OpenReq():
             args = " ".join(msg.args)
             env: list[str] = []
-            for key, value in msg.env.items():
-                env.append(f'{key}="{value}"')
-            return f"open path='{msg.path}' args='{args}' env='{' '.join(env)}'"
+            for k, v in msg.env.items():
+                env.append(f'{k}="{v}"')
+            return f"{value} path='{msg.path}' args='{args}' env='{' '.join(env)}'"
         case KillReq():
-            return "kill"
+            return f"{value} {msg.pid}"
+        case SetPidResp():
+            return f"{value} {msg.pid}"
         case LogResp():
-            return f"log {msg.msg}"
+            return f"{value} {msg.msg}"
         case ExitResp():
-            return f"exit {msg.exit_code}"
+            return f"{value} {msg.exit_code}"
         case ErrorResp():
-            return f"error {msg.msg}"
+            return f"{value} {msg.msg}"
         case OkayResp():
-            return "okay"
+            return f"{value}"
+        case HealthCheckReq():
+            return f"{value}"
 
 
 path_expr = re.compile(r"path='([^']+)'")
@@ -106,13 +124,9 @@ def deserialize(msg: str) -> Req | Resp:
     logging.debug(f"Got message {msg}")
     try:
         [kind, rest] = msg.split(" ", 1)
-    except Exception as e:
-        if msg == "okay":
-            return OkayResp()
-        elif msg == "kill":
-            return KillReq()
-        else:
-            raise e
+    except Exception:
+        kind = msg.strip()
+        rest = ""
 
     match kind:
         case ReqKind.Open.value:
@@ -134,12 +148,20 @@ def deserialize(msg: str) -> Req | Resp:
 
             return OpenReq(path=Path(path), args=args, env=env)
 
+        case ReqKind.Kill.value:
+            return KillReq(int(rest))
         case RespKind.Log.value:
-            return LogResp(msg=rest)
+            return LogResp(rest)
         case RespKind.Exit.value:
-            return ExitResp(exit_code=rest)
+            return ExitResp(rest)
         case RespKind.Error.value:
-            return ErrorResp(msg=rest)
+            return ErrorResp(rest)
+        case RespKind.Okay.value:
+            return OkayResp()
+        case ReqKind.HealthCheck.value:
+            return HealthCheckReq()
+        case RespKind.SetPid.value:
+            return SetPidResp(int(rest))
 
         case _:
             raise ValueError("Could not match kind for message", msg)

{cubething_psync-0.2.1.dev2 → cubething_psync-0.4.0/src/cubething_psync.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cubething_psync
-Version: 0.2.1.dev2
+Version: 0.4.0
 Summary: Simple project synchronization tool.
 Author-email: ada mandala <ada@cubething.dev>
 License-Expression: MIT

{cubething_psync-0.2.1.dev2 → cubething_psync-0.4.0}/src/cubething_psync.egg-info/SOURCES.txt

@@ -17,4 +17,5 @@ src/cubething_psync.egg-info/top_level.txt
 src/server/__init__.py
 src/server/__main__.py
 src/server/args.py
-src/server/main.py
+src/server/main.py
+test/test_integration.py