cubething_psync 0.3.0__tar.gz → 0.4.0__tar.gz

{cubething_psync-0.3.0/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.3.0
+Version: 0.4.0
 Summary: Simple project synchronization tool.
 Author-email: ada mandala <ada@cubething.dev>
 License-Expression: MIT

{cubething_psync-0.3.0 → cubething_psync-0.4.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cubething_psync"
-version = "0.3.0"
+version = "0.4.0"
 description = "Simple project synchronization tool."
 authors = [{name = "ada mandala", email="ada@cubething.dev"}]
 readme = "README.md"
@@ -41,3 +41,8 @@ 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.3.0 → cubething_psync-0.4.0}/src/client/args.py

@@ -7,6 +7,12 @@ 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
@@ -96,6 +102,13 @@ class Args:
     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.
@@ -132,8 +145,12 @@ 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(

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

@@ -2,6 +2,8 @@
 psync client
 """
 
+from io import TextIOWrapper
+import sys
 import asyncio
 import os
 from pathlib import Path
@@ -28,6 +30,14 @@ from client.args import (
     parse_args,
 )
 
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from _typeshed import SupportsWrite
+    Logfile = SupportsWrite[str]
+else:
+    Logfile = Any
+
 
 class PsyncClient:
     """
@@ -39,9 +49,23 @@ class PsyncClient:
     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 __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():
@@ -99,7 +123,7 @@ class PsyncClient:
 
                 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()

{cubething_psync-0.3.0 → 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
@@ -30,7 +29,7 @@ class RespKind(Enum):
 class OpenReq:
     path: Path
     args: list[str]
-    env: Mapping[str, str]
+    env: dict[str,str]
     kind: ReqKind = ReqKind.Open
 
 
@@ -84,8 +83,8 @@ def serialize(msg: Req | Resp) -> str:
         case OpenReq():
             args = " ".join(msg.args)
             env: list[str] = []
-            for key, value in msg.env.items():
-                env.append(f'{key}="{value}"')
+            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 f"{value} {msg.pid}"
@@ -127,6 +126,7 @@ def deserialize(msg: str) -> Req | Resp:
         [kind, rest] = msg.split(" ", 1)
     except Exception:
         kind = msg.strip()
+        rest = ""
 
     match kind:
         case ReqKind.Open.value:

{cubething_psync-0.3.0 → 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.3.0
+Version: 0.4.0
 Summary: Simple project synchronization tool.
 Author-email: ada mandala <ada@cubething.dev>
 License-Expression: MIT

{cubething_psync-0.3.0 → cubething_psync-0.4.0}/src/server/main.py

@@ -9,7 +9,6 @@ import asyncio
 from asyncio.tasks import Task
 from asyncio.subprocess import Process
 from collections.abc import Awaitable
-from os.path import basename
 import pathlib
 import signal
 import ssl
@@ -166,10 +165,18 @@ class PsyncServer:
     async def __open(self, req: OpenReq, ws: ServerConnection):
         host = self.__get_host(ws)
         path = pathlib.Path.expanduser(req.path).resolve()
-        args = [str(path), *req.args]
-        env = req.env if not self.args.use_base_env else {**environ, **req.env}
-
-        info_log = f"Running `[...]/{basename(args[0])} {' '.join(args[1:])}`..."
+        base_env = environ.copy() if self.args.use_base_env else {}
+        if not self.args.use_base_env:
+            # still get path and etc
+            for var in ['PATH','HOME','USER','SHELL']:
+                if var in environ:
+                    base_env[var] = environ[var]
+            if 'VIRTUAL_ENV' in environ:
+                base_env['VIRUTAL_ENV'] = environ['VIRTUAL_ENV']
+                base_env["PATH"] = f"{environ['VIRTUAL_ENV']}/bin:{base_env["PATH"]}"
+        env = base_env | req.env
+
+        info_log = f"Running `{path} {' '.join(req.args)}`"
         if env != {}:
             info_log += f"\n... with env {pprint(env)}"
         if self.args.user is not None:
@@ -179,7 +186,8 @@ class PsyncServer:
 
         try:
             p = await asyncio.create_subprocess_exec(
-                *args,
+                path,
+                *req.args,
                 env=env,
                 stdout=asyncio.subprocess.PIPE,
                 stderr=asyncio.subprocess.STDOUT,
@@ -196,7 +204,7 @@ class PsyncServer:
             await ws.send(serialize(resp))
 
         except Exception as e:
-            logging.error(f"Failed to start process `{args[0]}` with error {e}")
+            logging.error(f"Failed to start process `{path}` with error {e}")
             resp = ErrorResp(f"Server error: {e}")
             await ws.send(serialize(resp))
 

cubething_psync-0.4.0/test/test_integration.py

@@ -0,0 +1,153 @@
+import asyncio
+import multiprocessing
+import os
+from os.path import basename
+import re
+import sys
+from signal import Signals
+from io import StringIO
+from dataclasses import dataclass
+
+from testcontainers.core.generic import DockerContainer  # pyright: ignore[reportMissingTypeStubs]
+
+from client.args import Args as ClientArgs
+from client.main import PsyncClient
+from client.main import __rsync as rsync  # pyright: ignore[reportPrivateUsage]
+from test.conftest import assets_path
+
+OUTFILE = StringIO()
+
+
+@dataclass
+class Logs:
+    stdout: str
+    stderr: str
+
+
+def get_logs(server: DockerContainer) -> Logs:
+    slogs = server.get_logs()
+    return Logs(stdout=slogs[0].decode(), stderr=slogs[1].decode())
+
+
+def template(args: ClientArgs, server: DockerContainer, kill: bool = False):
+    try:
+        rsync(args)
+
+        def find(path: str):
+            exec_result = server.exec(["ls", str(path)])
+            ok = exec_result.output.decode().__contains__(basename(args.target_path))
+            if not ok:
+                print(f"Could not find path {path}")
+                assert False
+
+        find(str(args.destination_path()))
+        for file in args.assets:
+            find(args.target_path + "/" + file)
+
+        client = PsyncClient(args)
+
+        def run(code: int):
+            try:
+                asyncio.run(client.run())
+            except SystemExit as e:
+                assert str(e.code) == str(code)
+
+        if not kill:
+            run(0)
+        else:
+            p = multiprocessing.Process(target=run, args=[130])
+            p.start()
+            while p.pid is None:
+                pass
+            asyncio.run(asyncio.sleep(1))
+            os.kill(p.pid, Signals.SIGINT)
+            p.join(3)
+
+        # check that the pid closed
+        logs = get_logs(server)
+
+        pat = re.compile(r"Running process with PID (\d+)")
+        res = pat.search(logs.stderr)
+        if res is None:
+            raise Exception("Could not get PID from stdout!")
+        pid = res.group(1)
+
+        client_logs = OUTFILE.getvalue()
+
+        if args.args != []:
+            pat = re.compile(r"argv1=\w+")
+            res = pat.search(client_logs)
+            if res is None:
+                raise Exception("Did not find argv1 value!")
+
+        if args.env.get("TEST") is not None:
+            pat = re.compile(r"'TEST':\s*'TEST'")
+            res = pat.search(client_logs)
+            if res is None:
+                raise Exception("Env value TEST was not set!")
+
+        exec_result = server.exec(
+            ["sh", "-c", f"ps -p {pid} > /dev/null; echo $?"],
+        )
+        assert exec_result.output.decode().strip() == "1"
+
+    except Exception as e:
+        print(f"Got exception:\n {e}", file=sys.stderr)
+        logs = get_logs(server)
+        print(
+            f"Server logs:\n--- stdout ---\n{logs.stdout}\n--- stderr ---\n{logs.stderr}",
+            file=sys.stderr,
+        )
+        print(
+            f"OUTFILE:\n--- stdout ---\n{OUTFILE.getvalue()}",
+            file=sys.stderr,
+        )
+        assert False
+
+
+def get_test_args(file: str, server: DockerContainer):
+    return ClientArgs(
+        target_path=assets_path.joinpath(file).__str__(),
+        ssh_args=f"-i {(assets_path / 'ssh-key').resolve()} -l psync -o StrictHostKeyChecking=no",
+        ssl_cert_path=(assets_path / "cert.pem").resolve().__str__(),
+        server_ip="127.0.0.1",
+        server_port=server.get_exposed_port(5000),
+        server_ssh_port=server.get_exposed_port(5022),
+        logfile=OUTFILE,
+    )
+
+
+def test_basic(server: DockerContainer):
+    args = get_test_args("example_basic.py", server)
+    template(args, server)
+
+
+def test_sigint(server: DockerContainer):
+    args = get_test_args("example.py", server)
+    template(args, server, True)
+
+
+def test_env(server: DockerContainer):
+    args = get_test_args("example_basic.py", server)
+    args.env = {"PYTHONUNBUFERED": "1", "TEST": "TEST"}
+    template(args, server)
+
+
+def test_assets(server: DockerContainer):
+    args = get_test_args("example_basic.py", server)
+    args.assets = ["./test/assets/wizard.png", "./test/assets/test-dir"]
+    template(args, server)
+
+
+def test_args(server: DockerContainer):
+    args = get_test_args("example_basic.py", server)
+    args.args = ["test"]
+    template(args, server)
+
+
+def test_full(server: DockerContainer):
+    args = get_test_args("example_basic.py", server)
+    args.args = ["test"]
+    args.assets = ["./test/assets/wizard.png", "./test/assets/test-dir"]
+    args.env = {"PYTHONUNBUFERED": "1", "TEST": "TEST"}
+    template(args, server)

cubething_psync-0.3.0/test/test_integration.py

@@ -1,83 +0,0 @@
-import asyncio
-import multiprocessing
-import os
-from os.path import basename
-import re
-import sys
-from signal import Signals
-
-from testcontainers.core.generic import DockerContainer  # pyright: ignore[reportMissingTypeStubs]
-
-from client.args import Args as ClientArgs
-from client.main import PsyncClient
-from client.main import __rsync as rsync  # pyright: ignore[reportPrivateUsage]
-from test.conftest import assets_path
-
-
-def template(args: ClientArgs, server: DockerContainer, kill: bool = False):
-    try:
-        rsync(args)
-        exec_result = server.exec(["ls", str(args.destination_path())])
-        print(f"ls {args.destination_path()}\n --- \n {exec_result.output}")
-        assert exec_result.output.decode().__contains__(basename(args.target_path))
-        client = PsyncClient(args)
-
-        def run(code: int):
-            try:
-                asyncio.run(client.run())
-            except SystemExit as e:
-                assert str(e.code) == str(code)
-
-        if not kill:
-            run(0)
-        else:
-            p = multiprocessing.Process(target=run, args=[130])
-            p.start()
-            while p.pid is None:
-                pass
-            asyncio.run(asyncio.sleep(1))
-            os.kill(p.pid, Signals.SIGINT)
-            p.join(3)
-
-        # check that the pid closed
-        stdout, stderr = server.get_logs()
-        pat = re.compile(r"Running process with PID (\d+)")
-        res = pat.search(stderr.decode())
-        if res is None:
-            raise Exception("Could not get PID from stdout!")
-        pid = res.group(1)
-
-        exec_result = server.exec(
-            ["sh", "-c", f"ps -p {pid} > /dev/null; echo $?"],
-        )
-        assert exec_result.output.decode().strip() == "1"
-
-    except Exception as e:
-        print(f"Got exception:\n {e}", file=sys.stderr)
-        stdout, stderr = server.get_logs()
-        print(
-            f"Server logs:\n--- stdout ---\n{stdout.decode()}\n--- stderr ---\n{stderr.decode()}",
-            file=sys.stderr,
-        )
-        assert False
-
-
-def get_test_args(file: str, server: DockerContainer):
-    return ClientArgs(
-        target_path=assets_path.joinpath(file).__str__(),
-        ssh_args=f"-i {(assets_path / 'ssh-key').resolve()} -l psync -o StrictHostKeyChecking=no",
-        ssl_cert_path=(assets_path / "cert.pem").resolve().__str__(),
-        server_ip="127.0.0.1",
-        server_port=server.get_exposed_port(5000),
-        server_ssh_port=server.get_exposed_port(5022),
-    )
-
-
-def test_basic(server: DockerContainer):
-    args = get_test_args("example_basic.py", server)
-    template(args, server)
-
-
-def test_sigint(server: DockerContainer):
-    args = get_test_args("example.py", server)
-    template(args, server, True)