misakadb 0.1.1__py3-none-any.whl

misakadb/__init__.py

@@ -0,0 +1,13 @@
+"""Python client and MiQL query builder for MisakaDB."""
+
+from .apis.api import MisakaDBClient
+from .mql.MQ import MiQL
+from .network.command_send import commandSend
+from .network.sock import clientCore
+from .sdk import Connection, MisakaError, conn, getCurrent
+
+__version__ = "0.1.1"
+__all__ = [
+    "conn", "getCurrent", "Connection", "MisakaError",
+    "MisakaDBClient", "MiQL", "clientCore", "commandSend", "__version__",
+]

misakadb/__main__.py

@@ -0,0 +1,4 @@
+from .cli import main
+
+if __name__ == "__main__":
+    main()

misakadb/apis/__init__.py

@@ -0,0 +1 @@
+"""MisakaDB apis implementation."""

misakadb/apis/api.py

@@ -0,0 +1,394 @@
+import json
+import sys
+import threading
+import time
+from typing import Optional, Dict, Any, List, Union
+
+
+from ..network import sock
+
+
+class HeartbeatController:
+    def __init__(self, owner: "MisakaDBClient", interval: float) -> None:
+        self._owner = owner
+        self.interval = interval
+        self._enabled = threading.Event()
+        self._shutdown = threading.Event()
+        self._stats_lock = threading.Lock()
+        self._thread: Optional[threading.Thread] = None
+        self._attempt_count = 0
+        self._success_count = 0
+        self._failure_count = 0
+        self._last_error: Optional[str] = None
+        self._last_sent_at: Optional[float] = None
+
+    def _ensure_thread(self) -> None:
+        if self._thread is not None and self._thread.is_alive():
+            return
+
+        self._shutdown.clear()
+        self._thread = threading.Thread(
+            target=self._loop,
+            name=f"MisakaDBHeartbeat-{self._owner.host}:{self._owner.port}",
+            daemon=True,
+        )
+        self._thread.start()
+
+    def _loop(self) -> None:
+        while not self._shutdown.is_set():
+            if not self._enabled.is_set():
+                if self._shutdown.wait(0.1):
+                    return
+                continue
+
+            if self._owner.connected and self._owner.client is not None:
+                try:
+                    with self._owner._socket_lock:
+                        if self._owner.connected and self._owner.client is not None:
+                            self._owner.client.send_heartbeat()
+                            with self._stats_lock:
+                                self._attempt_count += 1
+                                self._success_count += 1
+                                self._last_error = None
+                                self._last_sent_at = time.time()
+                except Exception as e:
+                    with self._stats_lock:
+                        self._attempt_count += 1
+                        self._failure_count += 1
+                        self._last_error = str(e)
+                    print(f"心跳发送失败: {e}", file=sys.stderr)
+                    self._owner.connected = False
+
+            if self._shutdown.wait(self.interval):
+                return
+
+    @property
+    def running(self) -> bool:
+        return self._enabled.is_set()
+
+    @property
+    def count(self) -> int:
+        with self._stats_lock:
+            return self._attempt_count
+
+    @property
+    def success_count(self) -> int:
+        with self._stats_lock:
+            return self._success_count
+
+    @property
+    def failure_count(self) -> int:
+        with self._stats_lock:
+            return self._failure_count
+
+    @property
+    def loss_rate(self) -> float:
+        with self._stats_lock:
+            if self._attempt_count == 0:
+                return 0.0
+            return self._failure_count / self._attempt_count * 100.0
+
+    @property
+    def last_error(self) -> Optional[str]:
+        with self._stats_lock:
+            return self._last_error
+
+    @property
+    def last_sent_at(self) -> Optional[float]:
+        with self._stats_lock:
+            return self._last_sent_at
+
+    def stats(self) -> Dict[str, Any]:
+        with self._stats_lock:
+            loss_rate = (
+                self._failure_count / self._attempt_count * 100.0
+                if self._attempt_count > 0 else 0.0
+            )
+            return {
+                "running": self._enabled.is_set(),
+                "interval": self.interval,
+                "count": self._attempt_count,
+                "success_count": self._success_count,
+                "failure_count": self._failure_count,
+                # 当前协议没有心跳回包确认，这里按发送失败率统计。
+                "loss_rate": loss_rate,
+                "last_error": self._last_error,
+                "last_sent_at": self._last_sent_at,
+            }
+
+    def start(self) -> None:
+        self._ensure_thread()
+        self._enabled.set()
+
+    def stop(self) -> None:
+        self._enabled.clear()
+
+    def shutdown(self) -> None:
+        self._enabled.clear()
+        self._shutdown.set()
+
+
+class MisakaDBClient:
+    """MisakaDB客户端API"""
+
+    def __init__(
+        self,
+        host: str = "127.0.0.1",
+        port: int = 10032,
+        heartbeat_interval: float = 1
+    ):
+        self.host = host
+        self.port = port
+        self.client: Optional[sock.clientCore] = None
+        self.service_info: Optional[Dict[str, Any]] = None
+        self.connected = False
+        self.heartbeat_interval = heartbeat_interval
+        self._socket_lock = threading.Lock()
+        self.heart = HeartbeatController(self, heartbeat_interval)
+        self.heart.start()
+
+    def connect(self, retries: int = 3, retry_delay: float = 1.0) -> bool:
+        """连接到MisakaDB服务器
+
+        Args:
+            retries: 重试次数
+            retry_delay: 重试延迟（秒）
+
+        Returns:
+            bool: 连接是否成功
+        """
+        self.heart.start()
+
+        for attempt in range(retries):
+            try:
+                self.client = sock.clientCore(self.host, self.port)
+                connect_err = self.client.connect()
+
+                if connect_err is not None:
+                    if attempt < retries - 1:
+                        print(f"连接失败，第{attempt + 1}次重试... ({connect_err})", file=sys.stderr)
+                        time.sleep(retry_delay)
+                        continue
+                    else:
+                        print(f"连接失败: {connect_err}", file=sys.stderr)
+                        return False
+
+                self.connected = True
+                return True
+
+            except Exception as e:
+                if attempt < retries - 1:
+                    print(f"连接过程中发生错误，第{attempt + 1}次重试... ({e})", file=sys.stderr)
+                    time.sleep(retry_delay)
+                else:
+                    print(f"连接过程中发生错误: {e}", file=sys.stderr)
+                    return False
+        return False
+
+    def get_service_info(self) -> Optional[Dict[str, Any]]:
+        """获取服务器信息
+
+        Returns:
+            Optional[Dict[str, Any]]: 服务信息字典，如果失败返回None
+        """
+        if not self.connected or self.client is None:
+            print("未连接到服务器，请先调用connect()", file=sys.stderr)
+            return None
+
+        try:
+            with self._socket_lock:
+                if not self.connected or self.client is None:
+                    return None
+                response = self.client.send_command("get-service-info")
+            self.service_info = json.loads(response)
+            return self.service_info
+        except json.JSONDecodeError as e:
+            print(f"解析服务信息失败: {e}", file=sys.stderr)
+            return None
+        except Exception as e:
+            print(f"获取服务信息失败: {e}", file=sys.stderr)
+            return None
+
+    def execute_command(self, command: str) -> Optional[Union[str, Dict, List]]:
+        """执行自定义命令
+
+        Args:
+            command: 要执行的命令字符串
+
+        Returns:
+            Optional[Union[str, Dict, List]]: 命令执行结果
+        """
+        if not self.connected or self.client is None:
+            print("未连接到服务器，请先调用connect()", file=sys.stderr)
+            return None
+
+        try:
+            with self._socket_lock:
+                if not self.connected or self.client is None:
+                    return None
+                response = self.client.send_command(command)
+
+            # 尝试解析为JSON
+            try:
+                return json.loads(response)
+            except json.JSONDecodeError:
+                # 如果不是JSON，返回原始字符串
+                return response.decode('utf-8', errors='replace')
+
+        except Exception as e:
+            print(f"执行命令失败: {e}", file=sys.stderr)
+            return None
+
+    def ping(self) -> bool:
+        """检查服务器是否可达
+
+        Returns:
+            bool: 服务器是否可达
+        """
+        if not self.connected or self.client is None:
+            return False
+
+        try:
+            with self._socket_lock:
+                if not self.connected or self.client is None:
+                    return False
+                response = self.client.send_command("ping")
+            return response is not None
+        except:
+            return False
+
+    def get_server_version(self) -> Optional[str]:
+        """获取服务器版本
+
+        Returns:
+            Optional[str]: 服务器版本号
+        """
+        service_info = self.get_service_info()
+        if service_info:
+            return service_info.get('service', {}).get('version')
+        return None
+
+
+
+    def is_command_allowed(self, command: str) -> bool:
+        """检查命令是否被服务器允许
+
+        Args:
+            command: 要检查的命令
+
+        Returns:
+            bool: 命令是否被允许
+        """
+        allowed_commands = self.get_allowed_commands()
+        if allowed_commands:
+            return command in allowed_commands
+        return False
+
+    def get_network_config(self) -> Optional[Dict[str, Any]]:
+        """获取网络配置
+
+        Returns:
+            Optional[Dict[str, Any]]: 网络配置信息
+        """
+        service_info = self.get_service_info()
+        if service_info:
+            return service_info.get('network', {})
+        return None
+
+    def close(self) -> None:
+        """关闭连接"""
+        self.heart.shutdown()
+        with self._socket_lock:
+            if self.client is not None and self.client.s:
+                self.client.close()
+            self.client = None
+            self.service_info = None
+            self.connected = False
+        self.heart = HeartbeatController(self, self.heartbeat_interval)
+
+    def __enter__(self):
+        """上下文管理器入口"""
+        if not self.connect():
+            raise ConnectionError(f"无法连接到服务器 {self.host}:{self.port}")
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """上下文管理器退出"""
+        self.close()
+
+    def __repr__(self) -> str:
+        """对象表示"""
+        status = "已连接" if self.connected else "未连接"
+        return f"<MisakaDBClient {self.host}:{self.port} [{status}]>"
+
+
+# 兼容旧版本的函数接口
+def connect(host: str, port: int) -> Optional[MisakaDBClient]:
+    """连接到MisakaDB服务器（兼容旧版本接口）
+
+    Args:
+        host: 服务器地址
+        port: 服务器端口
+
+    Returns:
+        Optional[MisakaDBClient]: 客户端实例，如果连接失败返回None
+    """
+    client = MisakaDBClient(host, port)
+    if client.connect():
+        return client
+    return None
+
+
+# 示例使用
+if __name__ == "__main__":
+    # 使用上下文管理器（推荐）
+    print("=== 使用上下文管理器 ===")
+    try:
+        with MisakaDBClient("127.0.0.1", 10032) as client:
+            # 获取服务信息
+            service_info = client.get_service_info()
+            if service_info:
+                print("服务信息获取成功:")
+                print(json.dumps(service_info, indent=2, ensure_ascii=False))
+
+                # 获取特定信息
+                version = client.get_server_version()
+                allowed_commands = client.get_allowed_commands()
+                network_config = client.get_network_config()
+
+                print(f"\n服务器版本: {version}")
+                print(f"允许的命令: {allowed_commands}")
+                print(f"网络配置: {network_config}")
+
+                # 检查ping
+                if client.ping():
+                    print("服务器可达")
+                else:
+                    print("服务器不可达")
+
+                # 检查命令是否允许
+                test_command = "get-service-info"
+                if client.is_command_allowed(test_command):
+                    print(f"命令 '{test_command}' 被允许")
+                else:
+                    print(f"命令 '{test_command}' 不被允许")
+
+                # 执行自定义命令
+                result = client.execute_command("get-service-info")
+                print(f"\n执行命令结果: {result}")
+    except ConnectionError as e:
+        print(f"连接失败: {e}")
+
+    print("\n=== 使用传统方式 ===")
+    client = MisakaDBClient("127.0.0.1", 10032)
+    if client.connect():
+        try:
+            service_info = client.get_service_info()
+            if service_info:
+                print(f"服务版本: {service_info.get('service', {}).get('version', '未知')}")
+                print(f"监听地址: {service_info.get('network', {}).get('address', '未知')}")
+                print(f"监听端口: {service_info.get('network', {}).get('port', '未知')}")
+        finally:
+            client.close()
+    else:
+        print("连接失败")

misakadb/cli.py

@@ -0,0 +1,124 @@
+import argparse
+import getpass
+import os
+import sys
+import time
+
+# 在类 Unix 终端中启用 input() 的行编辑和历史能力。
+try:
+    import readline
+    readline.parse_and_bind("tab: complete")
+except ImportError:
+    readline = None
+
+from .interface.status import StatusSocket
+from . import __version__
+from .mql.MQ import MiQL
+from .network.command_send import commandSend
+from .network import sock
+
+
+def main(argv=None):
+    parser = argparse.ArgumentParser(description=f"MisakaDB CLI {__version__}")
+    parser.add_argument("--version", action="version", version=f"misakadb {__version__}")
+    parser.add_argument("--address", type=str, default="127.0.0.1", help="服务地址, 默认本地")
+    parser.add_argument("--port", type=int, default=10032, help="服务端口, 默认10032")
+    parser.add_argument("--mode", type=str, default="shell", help="运行模式: shell[cli调试模式]、onlyConn[仅连接]")
+    parser.add_argument("--username", type=str, default="", help="[可选]用户名")
+    parser.add_argument("--password", type=str, default="", help="[可选]密码")
+
+
+    args = parser.parse_args(argv)
+
+    address = args.address
+    port = args.port
+    mode = args.mode
+    username = args.username
+    password = args.password
+
+
+    cli = sock.clientCore(address, port)
+    connect_err = cli.connect()
+    if connect_err is not None:
+        print(f"连接失败: {connect_err}", file=sys.stderr)
+        cli.close()
+        sys.exit(1)
+
+    try:
+        command_send = commandSend(cli)
+        server_recv = command_send.init_command()
+
+        if mode in ["shell", "sh", "s"]:
+            retry = False
+            while username == "" or password == "":
+                if retry:
+                    print("\n登录失败, 请重新输入用户名和密码:\n")
+                else:
+                    retry = True
+                username = input("请输入用户名: ")
+                password = getpass.getpass("请输入密码: ")
+
+
+
+            while not command_send.login(username, password):
+                print("登录失败, 请重新输入用户名和密码:\n")
+                username = input("请输入用户名: ")
+                password = getpass.getpass("请输入密码: ")
+
+            cli.status = StatusSocket.Connected
+
+
+            mq = MiQL(cli)
+            while True:
+                commands = ""
+
+
+                user_input = "\\"
+                row = 0
+                while user_input.endswith("\\"):
+                    selection = ""
+                    if cli.session.database:
+                        selection = f" db={cli.session.database}"
+                        if cli.session.table:
+                            selection += f" table={cli.session.table}"
+                    user_input = input(f"[{address}:{port} {cli.status.value}{selection}]{row if row > 0 else ''} >")
+                    commands += (user_input[:-1] if user_input.endswith("\\") else user_input) + "\n"
+                    row += 1
+
+                commands = commands.strip()
+                if commands.startswith("mq."):
+                    try:
+                        start_time = time.time()
+                        res = mq.shot(commands)
+                        end_time = time.time()
+                        elapsed_ms = (end_time - start_time) * 1000.0
+
+                        if isinstance(res, bytes):
+                            res_str = res.decode("utf-8", errors="replace")
+                            command_send.handle_response(res_str, elapsed_ms, is_init=False)
+                        elif res is not None:
+                            print(res)
+                    except Exception as e:
+                        print(f"MiQL 执行失败: {e}", file=sys.stderr)
+                    continue
+
+                elif commands in ["exit", 'e', 'q']:
+                    cli.close()
+                    print("bye~")
+                    sys.exit(0)
+                elif commands:
+                    start_time = time.time()
+                    res = cli.send_command(commands)
+                    end_time = time.time()
+                    elapsed_ms = (end_time - start_time) * 1000.0
+
+                    res_str = res.decode('utf-8', errors='replace')
+                    command_send.handle_response(res_str, elapsed_ms, is_init=False)
+    except (EOFError, KeyboardInterrupt):
+        print("\nbye~")
+    finally:
+        cli.close()
+
+
+if __name__ == "__main__":
+    main()

misakadb/interface/__init__.py

@@ -0,0 +1 @@
+"""MisakaDB interface implementation."""

misakadb/interface/status.py

@@ -0,0 +1,7 @@
+from enum import Enum
+
+
+class StatusSocket(Enum):
+    Disconnected = "Disconnected"
+    ConnectedNoAuth = "Connected(NoAuth)"
+    Connected = "Connected(Auth)"