adp-operator 1.0.7__py3-none-any.whl

adp_operator/c2c/__init__.py

@@ -0,0 +1,6 @@
+from adp_operator.c2c.client import C2CClient
+from adp_operator.c2c.main import main
+
+
+__all__ = ["C2CClient", "main"]
+

adp_operator/c2c/__main__.py

@@ -0,0 +1,5 @@
+from adp_operator.c2c.main import main
+
+
+main()
+

adp_operator/c2c/client.py

@@ -0,0 +1,128 @@
+import hashlib
+import os
+import sys
+import tempfile
+import threading
+from pathlib import Path
+from typing import Optional
+
+from adp_operator.c2c.operator_executor import OperatorExecutor
+from adp_operator.c2c.runtime import Service
+from adp_operator.c2c.operator_loader import load_operator
+from adp_operator.c2c.operator import C2COperatorBase
+from adp_operator.c2c.operator_source import prepare_operator_source
+
+
+class C2CClient(Service):
+    """一个进程承载一个算子类，按 info/run 指令加载信息或执行算子。"""
+
+    def __init__(
+        self,
+        operator_config: dict,
+        node_id: Optional[str] = None,
+        network: Optional[str] = None,
+        max_concurrent_runs: Optional[int] = None,
+        join: Optional[tuple[str, int]] = None,
+    ):
+        self.operator_config = dict(operator_config)
+        self.operator_base = "PermanentOperator" if join is not None else "ADPOperator"
+        source = Path(operator_config["module_file"]).expanduser().resolve()
+        self._source_config = {**operator_config, "module_file": str(source)}
+        self._workspaces = {}
+        self._workspace_lock = threading.RLock()
+        identity = hashlib.sha256(
+            f"{node_id or operator_config['name']}:{operator_config['module_name']}".encode()
+        ).hexdigest()
+        self._namespace = Path(tempfile.gettempdir()).resolve() / "adp-operator-clients" / identity
+        self._namespace.mkdir(parents=True, exist_ok=True, mode=0o700)
+        self._temporary_directory = tempfile.TemporaryDirectory(prefix="session-", dir=self._namespace)
+        self.working_directory = Path(self._temporary_directory.name)
+        self._previous_directory = Path.cwd()
+        self._import_root = str(self._previous_directory)
+        self._added_import_root = self._import_root not in sys.path
+        try:
+            target = self.working_directory / source.name
+            prepare_operator_source(
+                source, target, operator_config["name"], self.operator_base
+            )
+            self.operator_config["module_file"] = str(target)
+            if self._added_import_root:
+                sys.path.insert(0, self._import_root)
+            os.chdir(self.working_directory)
+            self.operator_class = load_operator(self.operator_config)
+            if not issubclass(self.operator_class, C2COperatorBase):
+                raise TypeError(
+                    f"{self.operator_class.__name__} 必须继承 ADPOperator 或 PermanentOperator"
+                )
+            resolved_node_id = node_id or operator_config["name"]
+            if max_concurrent_runs is None:
+                max_concurrent_runs = max(1, (os.cpu_count() or 1) * 3)
+            executor = OperatorExecutor(
+                self.operator_class, resolved_node_id, max_concurrent_runs=max_concurrent_runs
+            )
+            executor.operator_config = self.operator_config
+            executor.working_directory = self.working_directory
+            executor.get_workspace = self.get_workspace
+            executor.close_workspace = self.close_workspace
+            super().__init__(resolved_node_id, network, executor, join=join)
+        except Exception:
+            self._cleanup_workspace()
+            raise
+
+    def _cleanup_workspace(self):
+        for session_id in list(self._workspaces):
+            self.close_workspace(session_id)
+        if Path.cwd() == self.working_directory:
+            os.chdir(self._previous_directory)
+        if self._added_import_root and self._import_root in sys.path:
+            sys.path.remove(self._import_root)
+        self._temporary_directory.cleanup()
+
+    def get_workspace(self, session_id):
+        """文件接收和算子运行使用同一个会话目录。"""
+        with self._workspace_lock:
+            if session_id not in self._workspaces:
+                if not self._workspaces and self.working_directory.exists():
+                    temporary = self._temporary_directory
+                else:
+                    temporary = tempfile.TemporaryDirectory(prefix="session-", dir=self._namespace)
+                directory = Path(temporary.name)
+                try:
+                    source = Path(self._source_config["module_file"])
+                    target = directory / source.name
+                    prepare_operator_source(
+                        source, target, self._source_config["name"], self.operator_base
+                    )
+                    config = {**self._source_config, "module_file": str(target)}
+                    self._workspaces[session_id] = (temporary, config)
+                except Exception:
+                    temporary.cleanup()
+                    raise
+            return self._workspaces[session_id][1]
+
+    def close_workspace(self, session_id):
+        with self._workspace_lock:
+            workspace = self._workspaces.get(session_id)
+            if workspace is None:
+                return
+            temporary, _ = workspace
+            if Path.cwd() == Path(temporary.name):
+                os.chdir(self._previous_directory)
+            temporary.cleanup()
+            del self._workspaces[session_id]
+
+    def start(self, blocking: bool = True) -> None:
+        try:
+            super().start(blocking=blocking)
+        except Exception:
+            if self._stopped:
+                self._cleanup_workspace()
+            raise
+
+    def stop(self) -> None:
+        super().stop()
+        self._cleanup_workspace()
+
+    def get_extra_info(self):
+        return self.executor.get_extra_info()
+

adp_operator/c2c/commands.py

@@ -0,0 +1,181 @@
+"""与网络入口无关的 C2C 指令实现。"""
+
+import base64
+import logging
+import uuid
+from pathlib import Path
+
+
+def output_event(event, prefix=""):
+    text = event.get("message", event)
+    lines = str(text).splitlines() or [""]
+    if event.get("type") == "log":
+        logger = logging.getLogger(event.get("logger") or __name__)
+        level = getattr(logging, str(event.get("level", "INFO")).upper(), logging.INFO)
+        if not isinstance(level, int):
+            level = logging.INFO
+        logger.disabled = False
+        if logger.getEffectiveLevel() > level:
+            logger.setLevel(level)
+        if not logger.hasHandlers():
+            handler = logging.StreamHandler()
+            handler.setFormatter(logging.Formatter("%(asctime)s - %(levelname)s - %(message)s"))
+            logger.addHandler(handler)
+            logger.propagate = False
+        logger.log(level, "\n".join(f"{prefix}{line}" for line in lines))
+        return
+    print("\n".join(f"{prefix}{line}" for line in lines), flush=True)
+
+
+class C2CCommands:
+    """统一实现 C2C 的运行、调用和文件指令。"""
+
+    def __init__(self, transport, session_id: str | None = None) -> None:
+        self.transport = transport
+        self.session_id = session_id or uuid.uuid4().hex
+        self._operators: set[str] = set()
+        self._closed = False
+
+    def can_reach(self, operator_name: str) -> bool:
+        return self.transport.can_reach(operator_name, self.session_id)
+
+    def call(self, operator_name: str, method: str, *args, **kwargs):
+        if not self.can_reach(operator_name):
+            return None
+        result = None
+        result_received = False
+        for event in self._request(operator_name, {
+            "type": "call",
+            "operator_name": operator_name,
+            "method": method,
+            "args": list(args),
+            "kwargs": kwargs,
+        }, {"call_end", "call_error"}):
+            if event.get("type") == "call_error":
+                raise RuntimeError(event.get("error", "C2C 方法调用失败"))
+            if event.get("type") == "call_result":
+                result = event.get("result")
+                result_received = True
+            if event.get("type") == "call_end":
+                if not result_received:
+                    raise RuntimeError(f"方法 {operator_name}.{method} 未返回结果")
+                return result
+        raise RuntimeError(f"方法 {operator_name}.{method} 的事件流异常结束")
+
+    def run(self, message: dict, on_event=None):
+        operator_name = message["operator_name"]
+        result = None
+        for event in self._request(
+            operator_name, message, {"run_end", "run_error"}
+        ):
+            event_type = event.get("type")
+            if event_type == "log":
+                continue
+            if event_type == "run_end" and result is None:
+                event = {
+                    "type": "run_error",
+                    "status": "error",
+                    "operator_name": operator_name,
+                    "pipeline_id": message.get("pipeline_id"),
+                    "error": f"算子 {operator_name} 运行失败，未返回结果",
+                }
+                event_type = "run_error"
+            if event_type in ("run_result", "run_error"):
+                result = event
+            if on_event is None:
+                output_event(event)
+            else:
+                on_event(event)
+            if event_type == "run_error":
+                return result
+            if event_type == "run_end":
+                return result
+        raise RuntimeError(f"算子 {operator_name} 的事件流异常结束")
+
+    def transfer_file(self, operator_name: str, path, filename: str) -> str:
+        offset = 0
+        response = None
+        with Path(path).open("rb") as source:
+            for chunk in iter(lambda: source.read(512 * 1024), b""):
+                response = self._single(operator_name, {
+                    "type": "receive_file",
+                    "operator_name": operator_name,
+                    "filename": filename,
+                    "offset": offset,
+                    "content": base64.b64encode(chunk).decode("ascii"),
+                }, "receive_file_ack")
+                offset += len(chunk)
+                if response.get("size") != offset:
+                    raise RuntimeError("文件接收确认不一致")
+        if response is None:
+            response = self._single(operator_name, {
+                "type": "receive_file",
+                "operator_name": operator_name,
+                "filename": filename,
+                "offset": 0,
+                "content": "",
+            }, "receive_file_ack")
+            if response.get("size") != 0:
+                raise RuntimeError("空文件接收确认不一致")
+        return response["path"]
+
+    def sync_files(self, operator_name: str, targets: list[str]) -> dict:
+        targets = list(dict.fromkeys(targets))
+        if not targets:
+            return {}
+        self._operators.update(targets)
+        response = self._single(operator_name, {
+            "type": "sync_files",
+            "operator_name": operator_name,
+            "targets": targets,
+        }, "sync_files_ack")
+        return response["synchronized"]
+
+    def close(self) -> None:
+        if self._closed:
+            return
+        error = None
+        try:
+            for operator_name in self._operators:
+                try:
+                    self._single(operator_name, {
+                        "type": "close_session",
+                        "operator_name": operator_name,
+                    }, "close_session_ack")
+                except Exception as exc:
+                    error = error or exc
+        finally:
+            self._closed = True
+            self.transport.close()
+        if error is not None:
+            raise error
+
+    def _single(self, operator_name: str, message: dict, response_type: str) -> dict:
+        response = None
+        for event in self._request(operator_name, message, {response_type}):
+            response = event
+        if response is None or response.get("type") != response_type:
+            raise RuntimeError(f"{message['type']} 响应无效")
+        if response.get("status") == "error":
+            raise RuntimeError(response.get("error", "C2C 请求失败"))
+        return response
+
+    def _request(
+        self,
+        operator_name: str,
+        message: dict,
+        terminal_types: set[str],
+    ):
+        self._operators.add(operator_name)
+        yield from self.transport.request(
+            operator_name,
+            message,
+            self.session_id,
+            terminal_types,
+        )
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        self.close()

adp_operator/c2c/config.py

@@ -0,0 +1,11 @@
+BROADCAST_BASE_PORT = 50000
+BROADCAST_PORT_RANGE = 1000
+SERVICE_BASE_PORT = 60000
+SERVICE_PORT_RANGE = 1000
+WEBSOCKET_BASE_PORT = 61000
+WEBSOCKET_PORT_RANGE = 1000
+BROADCAST_INTERVAL = 3
+PEER_SYNC_INTERVAL = 3
+PEER_TTL = 300
+MAX_REQUEST_SIZE = 1024 * 1024
+

adp_operator/c2c/discovery.py

@@ -0,0 +1,314 @@
+import ipaddress
+import json
+import logging
+import socket
+import threading
+import time
+from typing import Optional
+
+from adp_operator.c2c.operator_executor import OperatorExecutor
+
+from adp_operator.c2c.config import (
+    BROADCAST_BASE_PORT,
+    BROADCAST_INTERVAL,
+    BROADCAST_PORT_RANGE,
+    PEER_SYNC_INTERVAL,
+)
+from adp_operator.c2c.peer_registry import PeerRegistry
+from adp_operator.c2c.protocol import read_json_response, send_json
+from adp_operator.c2c.state import RuntimeState
+
+
+
+def broadcast_announce(
+    node_id: str,
+    instance_id: str,
+    network: Optional[str],
+    send_socket: socket.socket,
+    stop_event: threading.Event,
+    operator_name: Optional[str],
+    state: RuntimeState,
+    executor: Optional[OperatorExecutor],
+    registry: PeerRegistry,
+) -> None:
+    if network and network.startswith("127."):
+        targets = [
+            ("127.0.0.1", BROADCAST_BASE_PORT + offset)
+            for offset in range(BROADCAST_PORT_RANGE)
+        ]
+        logging.info(
+            "[广播] 同机模式 → 127.0.0.1:%s~%s",
+            BROADCAST_BASE_PORT,
+            BROADCAST_BASE_PORT + BROADCAST_PORT_RANGE - 1,
+        )
+    else:
+        broadcast_address = (
+            str(ipaddress.IPv4Network(network, strict=False).broadcast_address)
+            if network
+            else "<broadcast>"
+        )
+        targets = [
+            (broadcast_address, BROADCAST_BASE_PORT + offset)
+            for offset in range(BROADCAST_PORT_RANGE)
+        ]
+        logging.info("[广播] 网络模式 → %s", broadcast_address)
+
+    node_id, instance_id = state.identity()
+    deadline = time.monotonic() + BROADCAST_INTERVAL * 2
+    while not stop_event.is_set():
+        existing = registry.get(node_id)
+        identifier = None
+        takeover_via = None
+        if existing is not None and existing.get("instance_id") != instance_id:
+            existing_instance_id = existing.get("instance_id")
+            identifier = existing_instance_id or node_id
+            takeover_via = node_id
+        else:
+            for source_id in registry.active():
+                try:
+                    with registry.open_connection(source_id, timeout=2) as connection:
+                        connection.settimeout(2)
+                        send_json(connection, {
+                            "type": "discover",
+                            "identifier": source_id,
+                            "node_id": instance_id,
+                        })
+                        response = read_json_response(connection, limit=1024 * 1024)
+                    if response.get("type") != "discover_ack":
+                        continue
+                    advertised = response.get("peers", {}).get(node_id)
+                    if not isinstance(advertised, dict):
+                        continue
+                    existing_instance_id = advertised.get("instance_id")
+                    if (
+                        isinstance(existing_instance_id, str)
+                        and existing_instance_id
+                        and existing_instance_id != instance_id
+                    ):
+                        identifier = existing_instance_id
+                        takeover_via = source_id
+                        break
+                except (ConnectionError, OSError, RuntimeError, TimeoutError, ValueError):
+                    continue
+        if identifier is not None and takeover_via is not None:
+            try:
+                with registry.open_connection(takeover_via, timeout=2) as connection:
+                    connection.settimeout(2)
+                    send_json(connection, {
+                        "type": "takeover",
+                        "identifier": identifier,
+                        "instance_id": instance_id,
+                    })
+                    acknowledgement = read_json_response(connection, limit=64 * 1024)
+                if (
+                    acknowledgement.get("type") != "takeover_ack"
+                    or acknowledgement.get("status") != "ok"
+                ):
+                    raise RuntimeError(
+                        acknowledgement.get("error", "takeover 响应无效")
+                    )
+                logging.info(
+                    "[接管] 已通过 C2C 接管旧实例: %s (instance_id=%s)",
+                    node_id,
+                    identifier,
+                )
+            except (ConnectionError, OSError, RuntimeError, TimeoutError, ValueError):
+                pass
+            break
+        remaining = deadline - time.monotonic()
+        if remaining <= 0:
+            break
+        stop_event.wait(min(0.1, remaining))
+    _do_broadcast(send_socket, targets, operator_name, state, executor)
+    next_broadcast = time.monotonic() + BROADCAST_INTERVAL
+    while not stop_event.is_set():
+        timeout = max(0, next_broadcast - time.monotonic())
+        state.identity_changed.wait(min(timeout, 0.5))
+        if stop_event.is_set():
+            break
+        rename = state.take_pending_rename()
+        if rename is not None:
+            _send_datagram(send_socket, targets, rename)
+            logging.info(
+                "[改名] 已通知其他节点: %s -> %s (instance_id=%s)",
+                rename["old_node_id"], rename["node_id"], rename["instance_id"],
+            )
+        if rename is not None or time.monotonic() >= next_broadcast:
+            _do_broadcast(send_socket, targets, operator_name, state, executor)
+            next_broadcast = time.monotonic() + BROADCAST_INTERVAL
+
+
+def _do_broadcast(
+    send_socket: socket.socket,
+    targets: list[tuple[str, int]],
+    operator_name: Optional[str],
+    state: RuntimeState,
+    executor: Optional[OperatorExecutor],
+) -> None:
+    node_id, instance_id = state.identity()
+    message = {
+            "type": "announce",
+            "node_id": node_id,
+            "instance_id": instance_id,
+            "operator_name": operator_name,
+            "service_port": state.service_port,
+            "broadcast_port": state.broadcast_port,
+            "websocket_port": state.websocket_port,
+            "started_at": state.started_at,
+            "timestamp": time.time(),
+        }
+    if executor is not None:
+        message.update(executor.get_runtime_info())
+    _send_datagram(send_socket, targets, message)
+
+
+def _send_datagram(send_socket, targets, message) -> None:
+    message = json.dumps(message).encode("utf-8")
+    for target in targets:
+        try:
+            send_socket.sendto(message, target)
+        except OSError:
+            pass
+
+
+def listen_broadcast(
+    node_id: str,
+    instance_id: str,
+    receive_socket: socket.socket,
+    registry: PeerRegistry,
+    state: RuntimeState,
+    stop_event: threading.Event,
+    executor: Optional[OperatorExecutor],
+    event_bus,
+) -> None:
+    logging.info("[监听] 监听端口 %s", state.broadcast_port)
+    receive_socket.settimeout(1.0)
+    while not stop_event.is_set():
+        try:
+            data, address = receive_socket.recvfrom(4096)
+            message = json.loads(data.decode("utf-8"))
+            if message.get("type") not in ("announce", "leave", "renamed"):
+                continue
+
+            if message["type"] == "renamed":
+                renamed_instance_id = message.get("instance_id")
+                old_node_id = message.get("old_node_id")
+                renamed_node_id = message.get("node_id")
+                if not all(
+                    isinstance(value, str) and value
+                    for value in (renamed_instance_id, old_node_id, renamed_node_id)
+                ):
+                    continue
+                if registry.rename_instance(
+                    renamed_instance_id, old_node_id, renamed_node_id
+                ):
+                    logging.info(
+                        "[改名] %s -> %s (instance_id=%s)",
+                        old_node_id, renamed_node_id, renamed_instance_id,
+                    )
+                continue
+
+            node_id, instance_id = state.identity()
+            peer_id = message["node_id"]
+            peer_instance_id = message.get("instance_id")
+            if peer_id == node_id and peer_instance_id == instance_id:
+                continue
+            peer_ip = address[0]
+            if message["type"] == "leave":
+                if registry.remove(peer_id, peer_ip, message.get("broadcast_port")):
+                    logging.info("[离线] 移除节点: %s", peer_id)
+                continue
+
+            peer = {
+                "ip": peer_ip,
+                "port": message.get("service_port"),
+                "broadcast_port": message.get("broadcast_port"),
+                "websocket_port": message.get("websocket_port"),
+                "operator_name": message.get("operator_name"),
+                "instance_id": peer_instance_id,
+                "started_at": message.get("started_at"),
+                "last_seen": time.time(),
+            }
+            if "last_active_at" in message:
+                peer["last_active_at"] = message["last_active_at"]
+            if "channels" in message:
+                peer["channels"] = message["channels"]
+
+            previous = registry.update_direct(peer_id, peer)
+            if previous is None:
+                logging.info("[发现] %s @ %s:%s", peer_id, peer_ip, peer["port"])
+            elif (
+                previous["ip"], previous["port"], previous["broadcast_port"]
+            ) != (peer_ip, peer["port"], peer["broadcast_port"]):
+                logging.info("[刷新] %s @ %s:%s", peer_id, peer_ip, peer["port"])
+        except socket.timeout:
+            continue
+        except OSError:
+            if stop_event.is_set():
+                break
+            raise
+        except json.JSONDecodeError:
+            continue
+        except Exception as error:
+            logging.info("[监听] 错误: %s", error)
+            time.sleep(0.1)
+
+
+def expire_peers(registry: PeerRegistry, stop_event: threading.Event) -> None:
+    while not stop_event.wait(5):
+        expired = registry.expire()
+        if expired:
+            logging.info("[清理] 移除过期节点: %s", expired)
+
+
+def sync_discovered_peers(
+    node_id: str,
+    instance_id: str,
+    registry: PeerRegistry,
+    stop_event: threading.Event,
+    state: RuntimeState,
+) -> None:
+    while not stop_event.wait(PEER_SYNC_INTERVAL):
+        node_id, instance_id = state.identity()
+        for source_id, source in registry.direct_peers().items():
+            try:
+                with registry.open_connection(source_id, timeout=5) as connection:
+                    send_json(connection, {
+                        "type": "discover", "node_id": node_id,
+                        "instance_id": instance_id,
+                        "identifier": source_id,
+                    })
+                    response = read_json_response(connection)
+                if response.get("type") != "discover_ack":
+                    registry.discard_if_unchanged(source_id, source)
+                    continue
+                discovered = response.get("peers", {})
+                if not isinstance(discovered, dict):
+                    continue
+                merged = registry.merge_discovered(node_id, source_id, discovered)
+                if merged:
+                    logging.info("[同步] 通过 %s 发现节点: %s", source_id, merged)
+            except (OSError, ValueError, TypeError, UnicodeDecodeError, json.JSONDecodeError):
+                registry.discard_if_unchanged(source_id, source)
+                continue
+
+
+def announce_leave(
+    node_id: str,
+    send_socket: socket.socket,
+    registry: PeerRegistry,
+    state: RuntimeState,
+) -> None:
+    message = json.dumps(
+        {
+            "type": "leave",
+            "node_id": node_id,
+            "broadcast_port": state.broadcast_port,
+        }
+    ).encode("utf-8")
+    for target in registry.leave_targets():
+        try:
+            send_socket.sendto(message, target)
+        except OSError:
+            pass
+