code-server-sync 0.0.0-stage → 0.1.0

package/cs_sync/server.py

@@ -0,0 +1,360 @@
+from __future__ import annotations
+
+import errno
+import hmac
+import json
+import os
+import signal
+import subprocess
+import threading
+import time
+import urllib.parse
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+
+from cs_sync.files import FileIndex, remove_file, safe_destination, write_file
+from cs_sync.git import StageError, collect_changes, stage_changes
+from cs_sync.protocol import (
+    DEFAULT_PORT,
+    MAX_BYTES,
+    ROUTE_CHANGES,
+    ROUTE_DELETE,
+    ROUTE_FILE,
+    ROUTE_HEALTH,
+    ROUTE_IGNORE,
+    ROUTE_MANIFEST,
+    ROUTE_PULL,
+    ROUTE_STAGE,
+    eprint,
+    route_of,
+)
+
+def make_handler(root: str, token: str, index: FileIndex):
+    class Handler(BaseHTTPRequestHandler):
+        protocol_version = "HTTP/1.1"
+
+        def log_message(self, fmt: str, *args) -> None:
+            return
+
+        def _send(self, status: int, body: bytes, content_type: str = "text/plain; charset=utf-8") -> None:
+            self.send_response(status)
+            self.send_header("Content-Type", content_type)
+            self.send_header("Content-Length", str(len(body)))
+            self.send_header("Cache-Control", "no-store")
+            self.end_headers()
+            self.wfile.write(body)
+
+        def _authorized(self) -> bool:
+            given = self.headers.get("X-Sync-Token", "")
+            if not token or len(given) != len(token):
+                return False
+            return hmac.compare_digest(given, token)
+
+        def _rel_path(self) -> str:
+            raw = self.headers.get("X-Rel-Path", "")
+            if not raw:
+                raise ValueError("缺少 X-Rel-Path")
+            return urllib.parse.unquote(raw)
+
+        def _read_body(self) -> bytes:
+            length_raw = self.headers.get("Content-Length")
+            if length_raw is None:
+                raise ValueError("缺少 Content-Length")
+            length = int(length_raw)
+            if length < 0 or length > MAX_BYTES:
+                raise ValueError("文件过大")
+            payload = self.rfile.read(length) if length else b""
+            if len(payload) != length:
+                raise ValueError("请求体不完整")
+            return payload
+
+        def do_GET(self) -> None:  # noqa: N802
+            route = route_of(self.path)
+            if route == ROUTE_HEALTH:
+                self._send(200, b"ok\n")
+                return
+            if not self._authorized():
+                self._send(403, b"bad token\n")
+                return
+            if route == ROUTE_MANIFEST:
+                body = json.dumps({"files": index.manifest()}).encode("utf-8")
+                self._send(200, body, "application/json")
+                return
+            if route == ROUTE_PULL:
+                try:
+                    rel = self._rel_path()
+                    dest = safe_destination(root, rel)
+                    if not os.path.isfile(dest) or os.path.islink(dest):
+                        self._send(404, b"missing\n")
+                        return
+                    if os.path.getsize(dest) > MAX_BYTES:
+                        self._send(400, ("文件过大\n").encode("utf-8"))
+                        return
+                    with open(dest, "rb") as handle:
+                        payload = handle.read(MAX_BYTES + 1)
+                    if len(payload) > MAX_BYTES:
+                        self._send(400, ("文件过大\n").encode("utf-8"))
+                        return
+                    mode = "755" if os.stat(dest).st_mode & 0o111 else "644"
+                except (ValueError, OSError) as exc:
+                    self._send(400, (str(exc) + "\n").encode("utf-8"))
+                    return
+                self.send_response(200)
+                self.send_header("Content-Type", "application/octet-stream")
+                self.send_header("Content-Length", str(len(payload)))
+                self.send_header("X-File-Mode", mode)
+                self.send_header("Cache-Control", "no-store")
+                self.end_headers()
+                self.wfile.write(payload)
+                return
+            self._send(404, b"not found\n")
+
+        def do_POST(self) -> None:  # noqa: N802
+            route = route_of(self.path)
+            if route not in (ROUTE_FILE, ROUTE_DELETE, ROUTE_IGNORE, ROUTE_STAGE, ROUTE_CHANGES):
+                self._send(404, b"not found\n")
+                return
+            if not self._authorized():
+                self._send(403, b"bad token\n")
+                return
+            try:
+                if route == ROUTE_STAGE:
+                    if self.headers.get("Content-Length") not in (None, "0"):
+                        self._read_body()
+                    try:
+                        staged, repo_count = stage_changes(root, set(index.ignore))
+                    except StageError as exc:
+                        self._send(500, (str(exc) + "\n").encode("utf-8"))
+                        return
+                    body = json.dumps({"staged": staged, "repos": repo_count}).encode("utf-8")
+                    self._send(200, body, "application/json")
+                    return
+                if route == ROUTE_CHANGES:
+                    if self.headers.get("Content-Length") not in (None, "0"):
+                        self._read_body()
+                    try:
+                        changes, repo_count = collect_changes(root, set(index.ignore))
+                    except StageError as exc:
+                        self._send(500, (str(exc) + "\n").encode("utf-8"))
+                        return
+                    body = json.dumps({"changes": changes, "repos": repo_count}).encode("utf-8")
+                    self._send(200, body, "application/json")
+                    return
+                if route == ROUTE_IGNORE:
+                    payload = self._read_body()
+                    names = json.loads(payload.decode("utf-8")).get("dirs") or []
+                    index.set_ignore(names)
+                    index.scan()
+                    self._send(200, b"ok\n")
+                    return
+                rel = self._rel_path()
+                if route == ROUTE_FILE:
+                    payload = self._read_body()
+                    mode = 0o644
+                    mode_raw = self.headers.get("X-File-Mode", "644")
+                    if mode_raw == "755":
+                        mode = 0o755
+                    write_file(root, rel, payload, mode)
+                    index.note_write(rel, payload)
+                    print("云端写入 %s (%d 字节)" % (rel, len(payload)), flush=True)
+                else:
+                    if self.headers.get("Content-Length") not in (None, "0"):
+                        self._read_body()
+                    remove_file(root, rel)
+                    index.note_delete(rel)
+                    print("云端写入（删除） %s" % rel, flush=True)
+            except ValueError as exc:
+                self._send(400, (str(exc) + "\n").encode("utf-8"))
+                return
+            except OSError as exc:
+                self._send(500, (str(exc) + "\n").encode("utf-8"))
+                return
+            self._send(200, b"ok\n")
+
+    return Handler
+
+
+class PortProbeError(Exception):
+    pass
+
+
+def listening_pids_linux(port: int) -> list:
+    hexport = "%04X" % port
+    inodes = set()
+    for path in ("/proc/net/tcp", "/proc/net/tcp6"):
+        try:
+            lines = open(path).read().splitlines()[1:]
+        except OSError:
+            continue
+        for line in lines:
+            parts = line.split()
+            if len(parts) < 10:
+                continue
+            local, state, inode = parts[1], parts[3], parts[9]
+            if local.rsplit(":", 1)[-1].upper() == hexport and state == "0A":
+                inodes.add(inode)
+    pids = []
+    try:
+        proc_names = os.listdir("/proc")
+    except OSError:
+        return pids
+    for name in proc_names:
+        if not name.isdigit():
+            continue
+        fd_dir = "/proc/%s/fd" % name
+        try:
+            fds = os.listdir(fd_dir)
+        except OSError:
+            continue
+        for fd in fds:
+            try:
+                target = os.readlink("%s/%s" % (fd_dir, fd))
+            except OSError:
+                continue
+            if target.startswith("socket:[") and target[8:-1] in inodes:
+                pids.append(int(name))
+                break
+    return pids
+
+
+def listening_pids_lsof(port: int) -> list:
+    try:
+        result = subprocess.run(
+            ["lsof", "-nP", "-t", "-iTCP:%d" % port, "-sTCP:LISTEN"],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            check=False,
+        )
+    except OSError as exc:
+        raise PortProbeError("无法执行 lsof：%s" % exc)
+    # lsof 在没有匹配时退出码为 1
+    if result.returncode not in (0, 1):
+        detail = result.stderr.decode("utf-8", errors="replace").strip()
+        raise PortProbeError(detail or ("lsof 失败，退出码 %d" % result.returncode))
+    pids = []
+    for line in result.stdout.decode("utf-8", errors="replace").splitlines():
+        text = line.strip()
+        if text.isdigit():
+            pids.append(int(text))
+    return pids
+
+
+def listening_pids(port: int) -> list:
+    if os.path.isdir("/proc") and os.path.exists("/proc/net/tcp"):
+        return listening_pids_linux(port)
+    return listening_pids_lsof(port)
+
+
+def process_command_line(pid: int) -> str:
+    try:
+        return open("/proc/%d/cmdline" % pid, "rb").read().replace(b"\0", b" ").decode()
+    except OSError:
+        pass
+    try:
+        result = subprocess.run(
+            ["ps", "-p", str(pid), "-o", "command="],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            check=False,
+        )
+    except OSError:
+        return ""
+    if result.returncode != 0:
+        return ""
+    return result.stdout.decode("utf-8", errors="replace").strip()
+
+
+def is_our_recv(command: str) -> bool:
+    text = command or ""
+    if "cs-sync.py" in text:
+        return True
+    return "cs_sync" in text and "recv" in text
+
+
+def release_sync_port(port: int) -> None:
+    try:
+        found = listening_pids(port)
+    except PortProbeError as exc:
+        raise SystemExit(
+            "端口 %d 被占用，但无法列出监听进程：%s\n"
+            "请手动检查并结束后再启动：lsof -nP -iTCP:%d -sTCP:LISTEN"
+            % (port, exc, port)
+        )
+    pids = [pid for pid in found if pid != os.getpid()]
+    if not pids:
+        raise SystemExit(
+            "端口 %d 被占用，但未找到可停止的监听进程。\n"
+            "请手动检查：lsof -nP -iTCP:%d -sTCP:LISTEN"
+            % (port, port)
+        )
+    for pid in pids:
+        command = process_command_line(pid)
+        if not is_our_recv(command):
+            raise SystemExit("端口 %d 被其他程序占用：%s %s" % (port, pid, command))
+        print("停掉已在端口 %d 上运行的接收程序 %d" % (port, pid), flush=True)
+        os.kill(pid, signal.SIGTERM)
+    for _ in range(50):
+        try:
+            remaining = listening_pids(port)
+        except PortProbeError:
+            break
+        if not [pid for pid in remaining if pid != os.getpid()]:
+            return
+        time.sleep(0.1)
+    try:
+        remaining = listening_pids(port)
+    except PortProbeError as exc:
+        eprint("端口 %d 仍可能被占用，且无法再次列出进程：%s" % (port, exc))
+        return
+    for pid in remaining:
+        if pid == os.getpid():
+            continue
+        try:
+            os.kill(pid, signal.SIGKILL)
+        except OSError:
+            pass
+    time.sleep(0.2)
+
+
+class ReuseHTTPServer(ThreadingHTTPServer):
+    allow_reuse_address = True
+
+
+def serve(root: str, token: str, port: int) -> None:
+    if not os.path.isabs(root):
+        raise SystemExit("云端项目路径必须是绝对路径")
+    if len(token) < 16:
+        raise SystemExit("令牌太短")
+    os.makedirs(root, exist_ok=True)
+    index = FileIndex(root)
+    index.scan()
+
+    def refresh() -> None:
+        while True:
+            time.sleep(1)
+            try:
+                index.scan(announce=True)
+            except OSError as exc:
+                eprint("扫描云端目录失败: %s" % exc)
+
+    threading.Thread(target=refresh, daemon=True).start()
+    try:
+        server = ReuseHTTPServer(("0.0.0.0", port), make_handler(root, token, index))
+    except OSError as exc:
+        if getattr(exc, "errno", None) not in (errno.EADDRINUSE, 98):
+            raise
+        release_sync_port(port)
+        try:
+            server = ReuseHTTPServer(("0.0.0.0", port), make_handler(root, token, index))
+        except OSError as again:
+            if getattr(again, "errno", None) in (errno.EADDRINUSE, 98):
+                raise SystemExit("端口 %d 仍被占用。先停掉旧的 cs-sync recv，再启动。" % port)
+            raise
+    server.daemon_threads = True
+    print("接收程序已听在 0.0.0.0:%d" % port, flush=True)
+    print("项目目录: %s" % root, flush=True)
+    print("本机经 code-server 访问时使用 /proxy/%d/" % port, flush=True)
+    try:
+        server.serve_forever()
+    except KeyboardInterrupt:
+        print("\n已停止", flush=True)
+        server.server_close()