codosdk 1.0.54__tar.gz → 1.0.56__tar.gz

{codosdk-1.0.54 → codosdk-1.0.56}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codosdk
-Version: 1.0.54
+Version: 1.0.56
 Summary: CODO项目的Python SDK
 Home-page: https://github.com/ss1917/codo_sdk/
 Author: shenshuo

codosdk-1.0.56/README.md

@@ -0,0 +1,215 @@
+# CODO SDK
+
+[![Python](https://img.shields.io/badge/Python-%3E%3D3.9-blue)](https://www.python.org/)
+[![License](https://img.shields.io/badge/License-GPLv3-green)](https://www.gnu.org/licenses/gpl-3.0.html)
+[![Version](https://img.shields.io/badge/version-1.0.55-brightgreen)](https://pypi.org/project/codosdk/)
+
+CODO项目的官方Python SDK，提供企业级Web应用开发框架和运维工具集成。基于Tornado，集成数据库、缓存、消息队列、认证等核心组件。
+
+## 核心特性
+
+- **Tornado Web框架** - 异步请求处理，内置认证和权限管理
+- **数据库支持** - SQLAlchemy ORM，支持主从库配置
+- **Redis缓存** - 多连接池管理
+- **消息队列** - RabbitMQ集成
+- **多种认证** - JWT、LDAP、Session
+- **API集成** - 预定义CODO各平台API接口
+- **数据验证** - Pydantic模型验证
+- **工具支持** - 各类常用工具封装
+
+## 安装
+
+```bash
+# 从PyPI安装
+pip install codosdk
+
+# 从GitHub安装最新版
+pip install -U git+https://github.com/ss1917/ops_sdk.git
+```
+
+## 快速开始
+
+### 创建Web应用
+
+```python
+from websdk2.application import Application
+from websdk2.base_handler import BaseHandler
+
+class HelloHandler(BaseHandler):
+    def get(self):
+        self.write({'code': 0, 'msg': 'Hello CODO!'})
+
+handlers = [
+    (r'/api/hello/', HelloHandler, {'handle_name': '问候接口', 'method': ['GET']}),
+]
+
+app = Application(handlers)
+app.start_server()
+```
+
+### 使用数据库
+
+```python
+from websdk2.db_context import DBContextV2 as DBContext
+from sqlalchemy import Column, Integer, String
+from sqlalchemy.ext.declarative import declarative_base
+
+Base = declarative_base()
+
+class User(Base):
+    __tablename__ = 'users'
+    id = Column(Integer, primary_key=True)
+    username = Column(String(50), unique=True)
+
+# 查询
+with DBContext('r') as session:
+    user = session.query(User).filter(User.username == 'admin').first()
+
+# 创建/更新
+with DBContext('w') as session:
+    user = User(username='new_user')
+    session.add(user)
+```
+
+### 使用缓存
+
+```python
+from websdk2.cache_context import cache_conn
+
+redis_conn = cache_conn()
+redis_conn.set('key', 'value', ex=3600)
+value = redis_conn.get('key')
+```
+
+### JWT认证
+
+```python
+from websdk2.jwt_token import AuthToken
+
+auth = AuthToken()
+
+# 生成Token
+token = auth.encode_auth_token(
+    user_id='123',
+    username='admin',
+    exp_time=7  # 7天过期
+)
+
+# 验证Token
+user_info = auth.decode_auth_token(token)
+```
+
+### 消息队列
+
+```python
+from websdk2.mqhelper import MessageQueueBase
+import json
+
+# 发送消息（with语句自动管理连接）
+msg = json.dumps({'task_id': '123', 'status': 'running'})
+with MessageQueueBase('bpm_task_log', 'direct', 'the_log') as mq:
+    mq.publish_message(msg)
+
+# 消费消息（继承MessageQueueBase）
+class TaskConsumer(MessageQueueBase):
+    def __init__(self):
+        super().__init__(
+            exchange='bpm_task_log',
+            exchange_type='direct',
+            routing_key='the_log',
+            queue_name='task_queue'
+        )
+
+    def on_message(self, body):
+        """处理接收到的消息"""
+        print(f"收到消息: {body}")
+
+# 启动消费
+consumer = TaskConsumer()
+consumer.start_consuming()
+```
+
+## 配置示例
+
+### 数据库配置
+
+```python
+from websdk2.consts import const
+
+db_config = {
+    const.DB_CONFIG_ITEM: {
+        const.DEFAULT_DB_KEY: {
+            const.DBHOST_KEY: 'localhost',
+            const.DBPORT_KEY: 3306,
+            const.DBUSER_KEY: 'root',
+            const.DBPWD_KEY: 'password',
+            const.DBNAME_KEY: 'codo_db',
+        }
+    }
+}
+```
+
+### Redis配置
+
+```python
+from websdk2.consts import const
+redis_config = {
+    const.REDIS_CONFIG_ITEM: {
+        const.DEFAULT_RD_KEY: {
+            const.RD_HOST_KEY: 'localhost',
+            const.RD_PORT_KEY: 6379,
+            const.RD_DB_KEY: 0,
+            const.RD_PASSWORD_KEY: 'password',
+        }
+    }
+}
+```
+
+## 项目结构
+
+```
+ops_sdk/
+├── websdk2/                        # Web开发SDK（主模块）
+│   ├── apis/                       # CODO平台API集合
+│   │   ├── admin_apis.py          # 用户管理API
+│   │   ├── mgv4_apis.py           # 后台管理API
+│   │   ├── cmdb_apis.py           # CMDB配置API
+│   │   ├── agent_apis.py          # Agent代理API
+│   │   ├── task_apis.py           # 任务调度API
+│   │   ├── kerrigan_apis.py       # 配置文件管理API
+│   │   └── notice_apis.py         # 通知告警API
+│   │
+│   ├── cloud/                     # 云厂商SDK
+│   │
+│   ├── utils/                     # 工具集
+│   │   ├── pydantic_utils.py      # Pydantic数据验证
+│   │   ├── date_format.py         # 日期格式化
+│   │   └── cc_crypto.py           # 加密解密
+│   │
+│   ├── application.py              # Tornado应用定制
+│   ├── base_handler.py             # 请求处理基类（认证、授权）
+│   ├── db_context.py               # 数据库连接管理
+│   ├── cache.py / cache_context.py # Redis缓存管理
+│   ├── crud_utils.py               # CRUD工具（分页、验证）
+│   ├── sqlalchemy_pagination.py    # ORM分页组件
+│   ├── model_utils.py              # 模型转换工具
+│   ├── jwt_token.py                # JWT认证
+│   ├── mqhelper.py                 # RabbitMQ消息队列
+│   ├── client.py                   # API调用客户端
+│   ├── ldap.py                     # LDAP认证
+│   ├── configs.py                  # 配置管理
+│   ├── consts.py                   # 常量定义
+│   ├── error.py                    # 自定义异常
+│   ├── logger.py                   # 日志配置
+│   └── ...                         # 其他工具模块
+│
+├── opssdk/                         # 运维SDK（原始模块）
+│   └── utils/                      # 运维工具集
+│
+├── setup.py                        # 包配置
+└── pyproject.toml                  # 项目配置
+```
+
+## License
+
+Everything is [GPL v3.0](https://www.gnu.org/licenses/gpl-3.0.html).

{codosdk-1.0.54 → codosdk-1.0.56}/codosdk.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codosdk
-Version: 1.0.54
+Version: 1.0.56
 Summary: CODO项目的Python SDK
 Home-page: https://github.com/ss1917/codo_sdk/
 Author: shenshuo

{codosdk-1.0.54 → codosdk-1.0.56}/setup.py

@@ -9,7 +9,7 @@ desc   : CODO SDK
 import sys
 from setuptools import setup, find_packages
 
-VERSION = '1.0.54'
+VERSION = '1.0.56'
 
 if sys.version_info < (2, 7) or (3, 0) <= sys.version_info < (3, 6):
     print('This program requires at least Python 2.7 or 3.6 to run.')

{codosdk-1.0.54 → codosdk-1.0.56}/websdk2/apis/agent_apis.py

@@ -18,6 +18,7 @@ class AgentAPIS:
 
     sync_files_register_url_v2 = f"{route_prefix}/v1/manager/agent/share_filev2/register"
     sync_files_cancel_url_v2 = f"{route_prefix}/v1/manager/agent/share_filev2/cancel"
+    get_agent_task_result_url = f"{route_prefix}/v1/manager/agent/task/result'"
 
     get_agent_list = dict(method='GET',
                           url=agent_list_url,
@@ -77,3 +78,11 @@ class AgentAPIS:
                                  field_help={
                                  },
                                  description='云原生任务查询')
+
+    get_agent_task_result = dict(method='GET',
+                                 url=get_agent_task_result_url,
+                                 params={},
+                                 field_help={
+                                     'task_id': "提供任务ID"
+                                 },
+                                 description='云原生任务查询')

codosdk-1.0.56/websdk2/cache_context.py

@@ -0,0 +1,150 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+Contact : 191715030@qq.com
+Author  : shenshuo
+Date    : 2018/11/26
+Desc    : Redis连接
+"""
+import threading
+from typing import Dict, Optional
+
+import redis
+from .consts import const
+from .configs import configs
+
+_cache_conns: Dict[str, redis.Redis] = {}
+_init_lock = threading.Lock()
+
+# 固定默认值
+_MAX_CONNECTIONS: int = 200
+_POOL_TIMEOUT: float = 5.0
+_SOCKET_CONNECT_TIMEOUT: float = 2.0
+_SOCKET_TIMEOUT: float = 3.0
+_RETRY_ON_TIMEOUT: bool = True
+_HEALTH_CHECK_INTERVAL: int = 30
+
+
+def _validate_basic_types(key: Optional[str], db: Optional[int]) -> None:
+    if key is not None and not isinstance(key, str):
+        raise TypeError(f"key 必须为 str 或 None，当前类型为 {type(key).__name__}")
+    if db is not None and not isinstance(db, int):
+        raise TypeError(f"db 必须为 int 或 None，当前类型为 {type(db).__name__}")
+    # 可选：校验 db 合法范围（通常 0-15，取决于服务端配置）
+    if isinstance(db, int) and db < 0:
+        raise ValueError(f"db 不能为负数，当前值为 {db}")
+
+
+def _extract_and_validate_cfg(key: str, db: Optional[int]) -> tuple[str, int, Optional[str], bool, bool, int]:
+    # 读取配置字典并进行存在性校验
+    redis_configs = configs[const.REDIS_CONFIG_ITEM]
+    if key not in redis_configs:
+        raise ValueError(f"Redis配置键 '{key}' 不存在")
+    cfg = redis_configs[key]
+
+    # 逐项提取并校验类型
+    host = cfg[const.RD_HOST_KEY]
+    port = cfg[const.RD_PORT_KEY]
+    password = cfg.get(const.RD_PASSWORD_KEY)
+    auth = cfg.get(const.RD_AUTH_KEY, bool(password))
+    decode_responses = cfg.get(const.RD_DECODE_RESPONSES, False)
+    db_num = db if db is not None else cfg[const.RD_DB_KEY]
+
+    if not isinstance(host, str) or not host:
+        raise TypeError(f"RD_HOST 必须为非空字符串，当前: {host!r}")
+    if not isinstance(port, int) or port <= 0:
+        raise TypeError(f"RD_PORT 必须为正整数，当前: {port!r}")
+    if password is not None and not isinstance(password, str):
+        raise TypeError(f"RD_PASSWORD 必须为 str 或 None，当前: {type(password).__name__}")
+    if not isinstance(auth, bool):
+        raise TypeError(f"RD_AUTH 必须为 bool，当前: {type(auth).__name__}")
+    if not isinstance(decode_responses, bool):
+        raise TypeError(f"RD_DECODE_RESPONSES 必须为 bool，当前: {type(decode_responses).__name__}")
+    if not isinstance(db_num, int) or db_num < 0:
+        raise TypeError(f"RD_DB 必须为非负整数，当前: {db_num!r}")
+
+    return host, port, password, auth, decode_responses, db_num
+
+
+def _build_conn(
+    host: str,
+    port: int,
+    db_num: int,
+    password: Optional[str],
+    auth: bool,
+    decode_responses: bool,
+    cache_key: str,
+) -> redis.Redis:
+    # 快速路径（无锁）
+    conn = _cache_conns.get(cache_key)
+    if conn is not None:
+        return conn
+
+    # 慢路径：加锁 + 双重检查
+    with _init_lock:
+        conn = _cache_conns.get(cache_key)
+        if conn is not None:
+            return conn
+
+        # 认证处理
+        if isinstance(password, str) and password == "":
+            password = None
+        if not auth and password:
+            auth = True
+        if auth and not password:
+            raise ValueError("Redis要求认证但未提供有效密码")
+
+        # 阻塞连接池 + 固定默认值
+        pool = redis.BlockingConnectionPool(
+            host=host,
+            port=port,
+            db=db_num,
+            password=password if auth else None,
+            decode_responses=decode_responses,
+            max_connections=_MAX_CONNECTIONS,
+            timeout=_POOL_TIMEOUT,
+            socket_connect_timeout=_SOCKET_CONNECT_TIMEOUT,
+            socket_timeout=_SOCKET_TIMEOUT,
+            retry_on_timeout=_RETRY_ON_TIMEOUT,
+            health_check_interval=_HEALTH_CHECK_INTERVAL,
+        )
+
+        conn = redis.Redis(connection_pool=pool)
+        _cache_conns[cache_key] = conn
+        return conn
+
+
+def cache_conn(key: Optional[str] = None, db: Optional[int] = None) -> redis.Redis:
+    """
+    获取 Redis 客户端（遵循配置中的 RD_DECODE_RESPONSES）
+    - 老代码兼容：如果配置是 False，则返回 bytes；True 则返回 str
+    """
+    _validate_basic_types(key, db)
+
+    # 默认 key
+    if not key:
+        from .consts import const as _const
+        key = _const.DEFAULT_RD_KEY
+
+    host, port, password, auth, decode_responses, db_num = _extract_and_validate_cfg(key, db)
+    cache_key = f"{key}:{db_num}"
+    return _build_conn(host, port, db_num, password, auth, decode_responses, cache_key)
+
+
+def cache_conn_decode(key: Optional[str] = None, db: Optional[int] = None) -> redis.Redis:
+    """
+    获取 Redis 客户端（强制 decode_responses=True）
+    - 所有返回值为 str
+    - 与 cache_conn 共存，使用独立的缓存键后缀，避免类型混用
+    """
+    _validate_basic_types(key, db)
+
+    # 默认 key
+    if not key:
+        from .consts import const as _const
+        key = _const.DEFAULT_RD_KEY
+
+    host, port, password, auth, _decode_responses_cfg, db_num = _extract_and_validate_cfg(key, db)
+    cache_key = f"{key}:{db_num}:decode"
+    # 强制字符串返回
+    return _build_conn(host, port, db_num, password, auth, True, cache_key)

codosdk-1.0.56/websdk2/mqhelper.py

@@ -0,0 +1,435 @@
+# !/usr/bin/env python
+# -*-coding:utf-8-*-
+"""
+Author : ming
+date   : 2017/3/3 下午9:31
+role   : rabbitMQ 操作类
+"""
+
+import logging
+import traceback
+import pika
+import time
+import json
+from typing import Optional, Tuple, Union, List
+
+from pika.exceptions import AMQPConnectionError, ChannelClosedByBroker
+from .consts import const
+from .configs import configs
+from .error import ConfigError
+
+# 配置pika日志级别
+logger = logging.getLogger('pika')
+logger.setLevel(logging.ERROR)
+
+# 屏蔽pika诊断日志噪音
+pika_diagnostic_logger = logging.getLogger('pika.diagnostic_utils')
+pika_diagnostic_logger.setLevel(logging.CRITICAL)
+
+# 屏蔽pika适配器日志噪音
+pika_adapter_logger = logging.getLogger('pika.adapters')
+pika_adapter_logger.setLevel(logging.CRITICAL)
+JsonOrBytes = Union[bytes, bytearray, str, dict, list]
+
+
+class MessageQueueBase:
+    def __init__(self, exchange, exchange_type, routing_key="", routing_keys=None,
+                 queue_name="", no_ack=False, mq_key=const.DEFAULT_MQ_KEY):
+
+        mq_config = configs[const.MQ_CONFIG_ITEM].get(mq_key)
+        if not mq_config:
+            raise ConfigError(f"MQ config {mq_key} not found")
+
+        required_keys = [const.MQ_ADDR, const.MQ_PORT, const.MQ_VHOST, const.MQ_USER, const.MQ_PWD]
+        for k in required_keys:
+            if k not in mq_config:
+                raise ConfigError(k)
+
+        self.addr = mq_config[const.MQ_ADDR]
+        self.port = int(mq_config[const.MQ_PORT])
+        self.vhost = mq_config[const.MQ_VHOST]
+        self.user = mq_config[const.MQ_USER]
+        self.pwd = mq_config[const.MQ_PWD]
+
+        self.exchange = exchange
+        self.exchange_type = exchange_type
+        self.routing_key = routing_key
+        self.routing_keys = routing_keys or []
+        self.queue_name = queue_name
+        self.no_ack = no_ack
+
+        self.connection = None
+        self.channel = None
+
+    # ========== Context Manager ==========
+    def __enter__(self):
+        self.channel = self.create_channel()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.close()
+
+    # ========== Connection / Channel ==========
+    def create_channel(self):
+        credentials = pika.PlainCredentials(self.user, self.pwd)
+        self.connection = pika.BlockingConnection(
+            pika.ConnectionParameters(self.addr, self.port, self.vhost, credentials=credentials)
+        )
+        self.channel = self.connection.channel()
+        return self.channel
+
+    def close(self):
+        if self.connection and not self.connection.is_closed:
+            self.connection.close()
+
+    def new_channel(self):
+        self.channel = self.create_channel()
+        return self
+
+    # ========== Consume ==========
+    def start_consuming(self, exchange_durable=False):
+        ch = self.create_channel()
+        self._declare_exchange(ch, exchange_durable)
+        queue_name = self._declare_and_bind_queue(ch)
+
+        ch.basic_qos(prefetch_count=1)
+        ch.basic_consume(queue=queue_name, on_message_callback=self.call_back, auto_ack=self.no_ack)
+        logger.info(f"[*] Queue {queue_name} started.")
+        ch.start_consuming()
+
+    def call_back(self, ch, method, properties, body):
+        try:
+            logger.info("Received message")
+            self.on_message(body)
+            if not self.no_ack:
+                ch.basic_ack(delivery_tag=method.delivery_tag)
+        except Exception:
+            logger.error(traceback.format_exc())
+            if not self.no_ack:
+                ch.basic_nack(delivery_tag=method.delivery_tag, requeue=True)
+
+    def on_message(self, body):
+        """子类实现具体逻辑"""
+        raise NotImplementedError
+
+    # ========== Publish ==========
+    def publish_message(self, body, durable=True, exchange_durable=False):
+        if not self.channel:
+            self.create_channel()
+
+        self._declare_exchange(self.channel, exchange_durable)
+        queue_name = self._declare_and_bind_queue(self.channel)
+
+        props = pika.BasicProperties(delivery_mode=2) if durable else None
+        self.channel.basic_publish(
+            exchange=self.exchange,
+            routing_key=self.routing_key,
+            body=body,
+            properties=props,
+        )
+        logger.info(f"Publish message success: {body} -> queue {queue_name}")
+
+    # ========== Private Helpers ==========
+    def _declare_exchange(self, ch, exchange_durable):
+        ch.exchange_declare(exchange=self.exchange,
+                            exchange_type=self.exchange_type,
+                            durable=exchange_durable)
+
+    def _declare_and_bind_queue(self, ch):
+        if self.queue_name:
+            result = ch.queue_declare(queue=self.queue_name, durable=True)
+        else:
+            result = ch.queue_declare(queue="", exclusive=True, auto_delete=True)
+
+        queue_name = result.method.queue
+        if self.routing_keys:
+            for binding_key in self.routing_keys:
+                ch.queue_bind(exchange=self.exchange, queue=queue_name, routing_key=binding_key)
+        else:
+            ch.queue_bind(exchange=self.exchange, queue=queue_name, routing_key=self.routing_key)
+        return queue_name
+
+
+class MessageQueueBaseV2:
+    """
+    消息队列基类：集成消费者和生产者功能。
+    线程模型：推荐每个线程创建独立实例，不要跨线程共享（BlockingConnection 非线程安全）。
+    """
+
+    def __init__(self, exchange: str, exchange_type: str = "direct", routing_key: str = "",
+                 routing_keys: Optional[List[str]] = None, queue_name: str = "",
+                 no_ack: bool = False, mq_key: str = const.DEFAULT_MQ_KEY):
+
+        # 读取配置
+        mq_config = configs[const.MQ_CONFIG_ITEM].get(mq_key)
+        if not mq_config:
+            raise ConfigError(f"MQ config {mq_key} not found")
+
+        required_keys = [const.MQ_ADDR, const.MQ_PORT, const.MQ_VHOST, const.MQ_USER, const.MQ_PWD]
+        for k in required_keys:
+            if k not in mq_config:
+                raise ConfigError(k)
+
+        self.addr = mq_config[const.MQ_ADDR]
+        self.port = int(mq_config[const.MQ_PORT])
+        self.vhost = mq_config[const.MQ_VHOST]
+        self.user = mq_config[const.MQ_USER]
+        self.pwd = mq_config[const.MQ_PWD]
+
+        # 拓扑与消费参数
+        self.exchange = exchange
+        self.exchange_type = exchange_type
+        self.routing_key = routing_key
+        self.routing_keys = routing_keys or []
+        self.queue_name = queue_name
+        self.no_ack = no_ack
+
+        # 连接/通道
+        self.connection: Optional[pika.BlockingConnection] = None
+        self.channel: Optional[pika.adapters.blocking_connection.BlockingChannel] = None
+
+        # 状态
+        self._returned = []
+        self._callbacks_ready = False
+        self._blocked = False
+
+        # 统一的连接参数（避免重复创建）
+        self._conn_params = pika.ConnectionParameters(
+            host=self.addr,
+            port=self.port,
+            virtual_host=self.vhost,
+            credentials=pika.PlainCredentials(self.user, self.pwd),
+            heartbeat=30,
+            blocked_connection_timeout=300,
+            connection_attempts=3,
+            retry_delay=2.0,
+        )
+
+    # ========== Context Manager ==========
+    def __enter__(self):
+        self._ensure_conn_chan(need_confirm=False)
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.close()
+
+    # ========== 连接/通道管理 ==========
+    def _ensure_conn_chan(self, need_confirm: bool = False) -> None:
+        """
+        确保连接和通道可用，并按需注册回调和确认机制。
+
+        参数：
+        - need_confirm: 是否需要发布确认（消费时 False，生产时 True）
+        """
+        # 确保连接可用
+        if not (self.connection and self.connection.is_open):
+            self.connection = pika.BlockingConnection(self._conn_params)
+            self.connection.add_on_connection_blocked_callback(
+                lambda c, r: self._on_blocked(r)
+            )
+            self.connection.add_on_connection_unblocked_callback(
+                lambda c: self._on_unblocked()
+            )
+            self._callbacks_ready = False
+
+        # 确保通道可用
+        if not (self.channel and self.channel.is_open):
+            self.channel = self.connection.channel()
+            self._callbacks_ready = False
+
+        # 按需注册发布确认和 return 回调（仅注册一次）
+        if need_confirm and not self._callbacks_ready:
+            self.channel.confirm_delivery()
+            self._returned.clear()
+            self.channel.add_on_return_callback(
+                lambda ch, m, p, b: self._returned.append((m, p, b))
+            )
+            self._callbacks_ready = True
+
+    def _on_blocked(self, reason: str):
+        """broker 阻塞回调（内存/磁盘告警）"""
+        self._blocked = True
+        logger.warning(f"Connection blocked: {reason}")
+
+    def _on_unblocked(self):
+        """broker 解除阻塞回调"""
+        self._blocked = False
+        logger.info("Connection unblocked")
+
+    def _close_resources(self) -> None:
+        """关闭连接和通道（先关通道，再关连接）"""
+        # 关闭通道
+        if self.channel:
+            try:
+                if self.channel.is_open:
+                    self.channel.close()
+            except Exception:
+                pass
+            finally:
+                self.channel = None
+
+        # 关闭连接
+        if self.connection:
+            try:
+                if self.connection.is_open:
+                    self.connection.close()
+            except Exception:
+                pass
+            finally:
+                self.connection = None
+
+        # 重置状态
+        self._callbacks_ready = False
+        self._returned.clear()
+
+    def close(self):
+        """关闭连接和通道"""
+        self._close_resources()
+
+    def _reset_connection(self) -> None:
+        """异常时重置连接（同 close）"""
+        self._close_resources()
+
+    # ========== 消费 ==========
+    def start_consuming(self, exchange_durable: bool = False):
+        """开始消费消息"""
+        self._ensure_conn_chan(need_confirm=False)
+        self._declare_exchange(self.channel, exchange_durable)
+        queue_name = self._declare_and_bind_queue(self.channel)
+
+        self.channel.basic_qos(prefetch_count=1)
+        self.channel.basic_consume(queue=queue_name, on_message_callback=self._callback,
+                                   auto_ack=self.no_ack)
+        logger.info(f"[*] Queue {queue_name} started")
+        self.channel.start_consuming()
+
+    def _callback(self, ch, method, properties, body):
+        """消息回调处理"""
+        try:
+            self.on_message(body)
+            if not self.no_ack:
+                ch.basic_ack(delivery_tag=method.delivery_tag)
+        except Exception:
+            logger.error("on_message error:\n%s", traceback.format_exc())
+            if not self.no_ack:
+                ch.basic_nack(delivery_tag=method.delivery_tag, requeue=True)
+
+    def on_message(self, body: bytes):
+        """子类实现具体逻辑"""
+        raise NotImplementedError
+
+    # ========== 生产 ==========
+    @staticmethod
+    def _encode_body(body: JsonOrBytes, json_encode: bool) -> Tuple[bytes, str]:
+        """
+        编码消息体并推断 content_type。
+
+        返回：(payload, content_type)
+        """
+        if isinstance(body, (bytes, bytearray)):
+            return bytes(body), "application/octet-stream"
+        if isinstance(body, str):
+            return body.encode("utf-8"), "text/plain"
+        if json_encode:
+            return json.dumps(body, ensure_ascii=False).encode("utf-8"), "application/json"
+        raise TypeError(f"body type {type(body)} not supported")
+
+    def publish(self, exchange: str, routing_key: str, body: JsonOrBytes,
+                durable: bool = True, json_encode: bool = True, mandatory: bool = True,
+                max_retries: int = 6) -> None:
+        """
+        发送消息（可靠性：发布确认 + mandatory + return 机制）。
+
+        参数：
+        - exchange: 交换机名
+        - routing_key: 路由键
+        - body: 消息体 (str/bytes/dict/list)
+        - durable: 是否持久化（默认 True）
+        - json_encode: 是否 JSON 编码（默认 True）
+        - mandatory: 是否强制要求有接收方（默认 True，无队列绑定时返回）
+        - max_retries: 最大重试次数（默认 6）
+        """
+        # 检查 broker 是否阻塞
+        if self._blocked:
+            logger.warning("Broker is blocked, retrying may be needed")
+
+        # 编码消息
+        payload, actual_content_type = self._encode_body(body, json_encode)
+        props = pika.BasicProperties(
+            delivery_mode=2 if durable else 1,  # 2=持久化, 1=临时
+            content_type=actual_content_type,
+        )
+
+        last_err = None
+        for attempt in range(1, max_retries + 1):
+            try:
+                # 确保连接和通道可用（需要确认机制）
+                self._ensure_conn_chan(need_confirm=True)
+
+                # 清空返回列表
+                self._returned.clear()
+
+                # 发送消息
+                self.channel.basic_publish(
+                    exchange=exchange,
+                    routing_key=routing_key,
+                    body=payload,
+                    properties=props,
+                    mandatory=mandatory
+                )
+
+                # 检查消息是否被返回（无队列绑定）
+                if self._returned:
+                    raise RuntimeError(f"Message unroutable: no binding for routing_key={routing_key}")
+
+                # logger.info(f"Message published: {exchange}/{routing_key}")
+                return
+
+            except (AMQPConnectionError, ChannelClosedByBroker) as e:
+                # 网络错误 → 重试
+                last_err = e
+                logger.warning(f"Connection error on attempt {attempt}/{max_retries}: {e}")
+                self._reset_connection()
+                if attempt < max_retries:
+                    time.sleep(min(2 ** attempt, 5))  # 指数退避
+
+            except RuntimeError as e:
+                # 业务错误（不可路由等）→ 不重试
+                logger.error(f"Publish error: {e}")
+                raise
+
+            except Exception as e:
+                # 其他异常 → 重试
+                last_err = e
+                logger.error(f"Unexpected error on attempt {attempt}/{max_retries}: {e}")
+                self._reset_connection()
+                if attempt < max_retries:
+                    time.sleep(min(2 ** attempt, 5))
+
+        raise last_err or RuntimeError("Unknown publish error")
+
+    # ========== 私有辅助方法 ==========
+    def _declare_exchange(self, ch, exchange_durable: bool):
+        """声明交换机"""
+        ch.exchange_declare(exchange=self.exchange,
+                            exchange_type=self.exchange_type,
+                            durable=exchange_durable)
+
+    def _declare_and_bind_queue(self, ch):
+        """声明队列并绑定"""
+        # 声明队列
+        if self.queue_name:
+            result = ch.queue_declare(queue=self.queue_name, durable=True)
+        else:
+            result = ch.queue_declare(queue="", exclusive=True, auto_delete=True)
+
+        queue_name = result.method.queue
+
+        # 绑定队列
+        if self.routing_keys:
+            for rk in self.routing_keys:
+                ch.queue_bind(exchange=self.exchange, queue=queue_name, routing_key=rk)
+        else:
+            ch.queue_bind(exchange=self.exchange, queue=queue_name, routing_key=self.routing_key)
+
+        return queue_name

{codosdk-1.0.54 → codosdk-1.0.56}/websdk2/sqlalchemy_pagination.py

@@ -48,6 +48,7 @@ def paginate(query, order_by: str = None, **query_params):
     else:
         items = query.all() if page_size >= 200 else query.limit(page_size).offset((page - 1) * page_size).all()
 
-    total = query.count()
+    # 计算总数：去掉排序避免 filesort
+    total = query.order_by(None).count()
     if not items_not_to_list: items = queryset_to_list(items)
     return Page(items, page, page_size, total)

codosdk-1.0.54/README.md

@@ -1,58 +0,0 @@
-## 安装
-
-### python3安装
-
-[python链接](https://www.python.org/)
-
-##### python3.9以上
-
-##### SDK 安装
-
-```bash
-$ pip3 install -U git+https://github.com/ss1917/ops_sdk.git
-```
-
-## 结构
-
-```
-├── README.md    项目readme
-└── opssdk
-    ├── logs     日志模块
-    ├── install  安装模块
-    ├── get_info 配置获取
-    └── operate  运维操作
-        ├── check           系统参数检查和获取
-        ├── mysql           mysql 操作
-        ├── mail            发送邮件
-        └── centralization  集中化管理工具 salt
-    ├── websdk2      web开发使用
-    ├── application.py           tornado application
-    ├── base_handler.py          tornado  基类
-    ├── cache.py                 处理redis缓存
-    ├── configs.py               配置文件管理
-    ├── consts.py                常量
-    ├── db_context.py            MySQL 处理类
-    ├── error.py                 异常
-    ├── crud_utils.py            API CRUD类
-    ├── model_utils.py           数据库模型处理类 sqlalchemy_pagination
-    ├── sqlalchemy_pagination.py 分页
-    ├── fetch_coroutine.py      
-    ├── jwt_token.py             JWT处理
-    ├── mqhelper.py              MQ 处理类
-    ├── program.py              
-    ├── salt_api.py              salt 处理类 可以移到工具类
-    ├── ldap.py                  LDAP 处理
-    ├── sms.py                   发送短信     可以移到工具类
-    ├── tools.py                 工具类
-    ├── clent.py                 API调用客户端封装
-    └── apis                     API集合
-        ├── mgv4_apis       后台API集合
-        ├── cmdb_apis       配置平台API
-        ├── agent_apis      Agent
-        ├── kerrigan_apis   配置文件管理
-        └── notice_apis       待补充
-```
-
-## License
-
-Everything is [GPL v3.0](https://www.gnu.org/licenses/gpl-3.0.html).

codosdk-1.0.54/websdk2/cache_context.py

@@ -1,38 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-"""
-Contact : 191715030@qq.com
-Author  : shenshuo
-Date    : 2018/11/26
-Desc    : 
-"""
-import redis
-from .consts import const
-from .configs import configs
-
-cache_conns = {}
-
-def cache_conn(key=None, db=None):
-    redis_configs = configs[const.REDIS_CONFIG_ITEM]
-    if not key:
-        key = const.DEFAULT_RD_KEY
-    for config_key, redis_config in redis_configs.items():
-        auth = redis_config[const.RD_AUTH_KEY]
-        host = redis_config[const.RD_HOST_KEY]
-        port = redis_config[const.RD_PORT_KEY]
-        password = redis_config[const.RD_PASSWORD_KEY]
-        if db:
-            db = db
-        else:
-            db = redis_config[const.RD_DB_KEY]
-        return_utf8 = False
-        if const.RD_DECODE_RESPONSES in redis_config:
-            return_utf8 = redis_config[const.RD_DECODE_RESPONSES]
-
-        if auth:
-            redis_pool = redis.ConnectionPool(host=host, port=port, db=db, password=password,
-                                              decode_responses=return_utf8)
-        else:
-            redis_pool = redis.ConnectionPool(host=host, port=port, db=db, decode_responses=return_utf8)
-        cache_conns[config_key] = redis.StrictRedis(connection_pool=redis_pool)
-    return cache_conns[key]

codosdk-1.0.54/websdk2/mqhelper.py

@@ -1,144 +0,0 @@
-# !/usr/bin/env python
-# -*-coding:utf-8-*-
-"""
-Author : ming
-date   : 2017/3/3 下午9:31
-role   : rabbitMQ 操作类
-"""
-
-import logging
-import traceback
-import pika
-from .consts import const
-from .configs import configs
-from .error import ConfigError
-
-# 配置pika日志级别
-logger = logging.getLogger('pika')
-logger.setLevel(logging.ERROR)
-
-# 屏蔽pika诊断日志噪音
-pika_diagnostic_logger = logging.getLogger('pika.diagnostic_utils')
-pika_diagnostic_logger.setLevel(logging.CRITICAL)
-
-# 屏蔽pika适配器日志噪音
-pika_adapter_logger = logging.getLogger('pika.adapters')
-pika_adapter_logger.setLevel(logging.CRITICAL)
-
-
-class MessageQueueBase:
-    def __init__(self, exchange, exchange_type, routing_key="", routing_keys=None,
-                 queue_name="", no_ack=False, mq_key=const.DEFAULT_MQ_KEY):
-
-        mq_config = configs[const.MQ_CONFIG_ITEM].get(mq_key)
-        if not mq_config:
-            raise ConfigError(f"MQ config {mq_key} not found")
-
-        required_keys = [const.MQ_ADDR, const.MQ_PORT, const.MQ_VHOST, const.MQ_USER, const.MQ_PWD]
-        for k in required_keys:
-            if k not in mq_config:
-                raise ConfigError(k)
-
-        self.addr = mq_config[const.MQ_ADDR]
-        self.port = int(mq_config[const.MQ_PORT])
-        self.vhost = mq_config[const.MQ_VHOST]
-        self.user = mq_config[const.MQ_USER]
-        self.pwd = mq_config[const.MQ_PWD]
-
-        self.exchange = exchange
-        self.exchange_type = exchange_type
-        self.routing_key = routing_key
-        self.routing_keys = routing_keys or []
-        self.queue_name = queue_name
-        self.no_ack = no_ack
-
-        self.connection = None
-        self.channel = None
-
-    # ========== Context Manager ==========
-    def __enter__(self):
-        self.channel = self.create_channel()
-        return self
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        self.close()
-
-    # ========== Connection / Channel ==========
-    def create_channel(self):
-        credentials = pika.PlainCredentials(self.user, self.pwd)
-        self.connection = pika.BlockingConnection(
-            pika.ConnectionParameters(self.addr, self.port, self.vhost, credentials=credentials)
-        )
-        self.channel = self.connection.channel()
-        return self.channel
-
-    def close(self):
-        if self.connection and not self.connection.is_closed:
-            self.connection.close()
-
-    def new_channel(self):
-        self.channel = self.create_channel()
-        return self
-
-    # ========== Consume ==========
-    def start_consuming(self, exchange_durable=False):
-        ch = self.create_channel()
-        self._declare_exchange(ch, exchange_durable)
-        queue_name = self._declare_and_bind_queue(ch)
-
-        ch.basic_qos(prefetch_count=1)
-        ch.basic_consume(queue=queue_name, on_message_callback=self.call_back, auto_ack=self.no_ack)
-        logger.info(f"[*] Queue {queue_name} started.")
-        ch.start_consuming()
-
-    def call_back(self, ch, method, properties, body):
-        try:
-            logger.info("Received message")
-            self.on_message(body)
-            if not self.no_ack:
-                ch.basic_ack(delivery_tag=method.delivery_tag)
-        except Exception:
-            logger.error(traceback.format_exc())
-            if not self.no_ack:
-                ch.basic_nack(delivery_tag=method.delivery_tag, requeue=True)
-
-    def on_message(self, body):
-        """子类实现具体逻辑"""
-        raise NotImplementedError
-
-    # ========== Publish ==========
-    def publish_message(self, body, durable=True, exchange_durable=False):
-        if not self.channel:
-            self.create_channel()
-
-        self._declare_exchange(self.channel, exchange_durable)
-        queue_name = self._declare_and_bind_queue(self.channel)
-
-        props = pika.BasicProperties(delivery_mode=2) if durable else None
-        self.channel.basic_publish(
-            exchange=self.exchange,
-            routing_key=self.routing_key,
-            body=body,
-            properties=props,
-        )
-        logger.info(f"Publish message success: {body} -> queue {queue_name}")
-
-    # ========== Private Helpers ==========
-    def _declare_exchange(self, ch, exchange_durable):
-        ch.exchange_declare(exchange=self.exchange,
-                            exchange_type=self.exchange_type,
-                            durable=exchange_durable)
-
-    def _declare_and_bind_queue(self, ch):
-        if self.queue_name:
-            result = ch.queue_declare(queue=self.queue_name, durable=True)
-        else:
-            result = ch.queue_declare(queue="", exclusive=True, auto_delete=True)
-
-        queue_name = result.method.queue
-        if self.routing_keys:
-            for binding_key in self.routing_keys:
-                ch.queue_bind(exchange=self.exchange, queue=queue_name, routing_key=binding_key)
-        else:
-            ch.queue_bind(exchange=self.exchange, queue=queue_name, routing_key=self.routing_key)
-        return queue_name