# E:\AI_System\web_ui\server.py (完整可运行版)
import sys
import os
import time
import logging
import json
import traceback
import threading
import platform
import psutil
import datetime
from pathlib import Path
from functools import wraps
from concurrent.futures import ThreadPoolExecutor
import logging.handlers
# ========== 关键修复1: 最先执行eventlet猴子补丁 ==========
try:
import eventlet
eventlet.monkey_patch() # 必须在所有导入之前执行
print("✅ Eventlet monkey patch applied at startup")
except ImportError:
print("⚠️ Eventlet not installed, using threading mode")
pass
# 修复1：更新依赖包列表
REQUIRED_PACKAGES = [
'flask',
'flask_socketio',
'flask_limiter',
'psutil',
'waitress'
]
def check_dependencies():
"""增强依赖检查功能"""
missing = []
for package in REQUIRED_PACKAGES:
try:
__import__(package)
except ImportError:
missing.append(package)
if missing:
print(f"❌ 缺少必要的依赖包: {', '.join(missing)}")
print("请运行以下命令安装依赖:")
print(f"pip install {' '.join(missing)}")
sys.exit(1)
if __name__ == '__main__':
check_dependencies() # 在启动前检查依赖
# 现在导入其他模块
from flask import Flask, jsonify, request, render_template, send_from_directory
from flask_socketio import SocketIO, emit
from flask_limiter import Limiter
from flask_limiter.util import get_
remote_address
# ========== 配置系统 ==========
class SystemConfig:
def __init__(self):
self.BASE_DIR = Path(__file__).resolve().parent.parent
self.HOST = '0.0.0.0'
self.PORT = 5000
self.LOG_LEVEL = 'DEBUG'
self.SECRET_KEY = os.getenv('SECRET_KEY', 'your_secret_key_here')
self.DEBUG = True
self.USE_GPU = False
self.DEFAULT_MODEL = 'gpt-3.5-turbo'
self.MAX_WORKERS = 4
# 目录配置
self.LOG_DIR = self.BASE_DIR / 'logs'
self.LOG_DIR.mkdir(parents=True, exist_ok=True)
self.CONFIG_DIR = self.BASE_DIR / 'config'
self.CONFIG_DIR.mkdir(parents=True, exist_ok=True)
self.AGENT_PATH = self.BASE_DIR / 'agent'
self.MODEL_CACHE_DIR = self.BASE_DIR / 'model_cache'
self.MODEL_CACHE_DIR.mkdir(parents=True, exist_ok=True)
self.TEMPLATE_DIR = self.BASE_DIR / 'web_ui' / 'templates'
self.STATIC_DIR = self.BASE_DIR / 'web_ui' / 'static'
def __str__(self):
return f"SystemConfig(HOST={self.HOST}, PORT={self.PORT})"
config = SystemConfig()
# ========== 全局协调器 ==========
coordinator = None
executor = ThreadPoolExecutor(max_workers=config.MAX_WORKERS)
def register_coordinator(coord):
global coordinator
coordinator = coord
if coordinator and hasattr(coordinator, 'connect_to_ui'):
coordinator.connect_to_ui(update_ui)
def update_ui(event):
if 'socketio' in globals():
socketio.emit('system_event', event)
# ========== 线程安全装饰器 ==========
def synchronized(lock):
def decorator(func):
@wraps(func)
def wrapper(*args, **kwargs):
with lock:
return func(*args, **kwargs)
return wrapper
return decorator
# ========== 日志系统 ==========
def setup_logger():
"""优化日志配置"""
logger = logging.getLogger('WebServer')
logger.setLevel(getattr(logging, config.LOG_LEVEL.upper(), logging.DEBUG))
# 清除所有现有处理器
for handler in logger.handlers[:]:
logger.removeHandler(handler)
# 日志格式
log_formatter = logging.Formatter(
'%(asctime)s [%(levelname)s] %(name)s: %(message)s',
datefmt='%Y-%m-%d %H:%M:%S'
)
# 文件日志处理器 (每天轮换，保留30天)
file_handler = logging.handlers.TimedRotatingFileHandler(
config.LOG_DIR / 'web_server.log',
when='midnight',
backupCount=30,
encoding='utf-8'
)
file_handler.setFormatter(log_formatter)
logger.addHandler(file_handler)
# 控制台日志处理器
console_handler = logging.StreamHandler()
console_handler.setFormatter(log_formatter)
logger.addHandler(console_handler)
# 设置Flask和SocketIO日志
flask_logger = logging.getLogger('werkzeug')
flask_logger.setLevel(logging.WARNING)
socketio_logger = logging.getLogger('engineio')
socketio_logger.setLevel(logging.WARNING)
return logger
logger = setup_logger()
# ========== 环境管理器 ==========
class EnvironmentManager:
"""独立的环境管理器类"""
def __init__(self, config):
self.config = config
self.state = {
'temperature': 22.5,
'humidity': 45.0,
'light_level': 75,
'objects': [],
'last_updated': datetime.datetime.now().isoformat()
}
self.healthy = True
self.lock = threading.Lock()
@synchronized(threading.Lock())
def start(self):
logger.info("环境管理器已启动")
@synchronized(threading.Lock())
def get_state(self):
# 更新模拟数据
self.state['temperature'] = round(20 + 5 * (time.time() %
10) /
10, 1)
self.state['humidity'] = round(40 +
10 * (time.time() %
10) /
10, 1)
self.state['light_level'] = round(70 +
10 * (time.time() %
10) /
10, 1)
self.state['last_updated'] = datetime.datetime.now().isoformat()
return self.state
@synchronized(threading.Lock())
def execute_action(self, action, params):
logger.info(f"执行环境动作: {action} 参数: {params}")
if action == "adjust_temperature":
self.state['temperature'] = params.get('value', 22.0)
return True
elif action == "adjust_light":
self.state['light_level'] = params.get('level', 70)
return True
return False
def is_healthy(self):
return self.healthy
# ========== 系统初始化 ==========
class SystemInitializer:
def __init__(self):
self.base_dir = Path(__file__).resolve().parent.parent
self.ai_core = None
self.hardware_manager = None
self.life_scheduler = None
self.ai_agent = None
self.start_time = time.time()
self.environment_manager = None
self.life_lock = threading.Lock()
def initialize_system_paths(self):
sys.path.insert(0, str(self.base_dir))
logger.info(f"项目根目录: {self.base_dir}")
sub_dirs = ['agent', 'core', 'utils', 'config', 'cognitive_arch', 'environment']
for sub_dir in sub_dirs:
full_path = self.base_dir / sub_dir
if full_path.exists():
sys.path.insert(0, str(full_path))
logger.info(f"添加路径: {full_path}")
else:
logger.warning(f"目录不存在: {full_path} - 已跳过")
def initialize_environment_manager(self):
try:
env_config = {'update_interval': 1.0, 'spatial': {'grid_size': 1.0}}
self.environment_manager = EnvironmentManager(env_config)
self.environment_manager.start()
logger.info("✅ 环境管理器初始化成功")
return self.environment_manager
except Exception as e:
logger.error(f"❌ 环境管理器初始化失败: {str(e)}")
logger.warning("⚠️ 环境交互功能将不可用")
return None
def initialize_ai_core(self):
logger.info("✅ 模拟AI核心初始化")
self.ai_core = type('AICore', (), {
'status': 'running',
'get_state': lambda: {"status": "running", "model": "gpt-3.5-turbo"}
})()
def initialize_hardware_manager(self):
logger.info("✅ 模拟硬件管理器初始化")
self.hardware_manager = type('HardwareManager', (), {
'get_status': lambda: {
"cpu_usage": psutil.cpu_percent(),
"memory_usage": psutil.virtual_memory().percent,
"gpu_usage": 0
}
})()
@synchronized(lock=threading.Lock())
def initialize_life_scheduler(self):
logger.info("✅ 模拟生活调度器初始化")
self.life_scheduler = type('LifeScheduler', (), {
'get_status': lambda: {
"current_activity": "thinking",
"next_activity": "learning",
"energy": 85
}
})()
@synchronized(lock=threading.Lock())
def initialize_ai_agent(self):
logger.info("✅ 模拟AI智能体初始化")
self.ai_agent = type('AIAgent', (), {
'process_input': lambda self, input, user_id: f"你好{user_id}，我收到了你的消息: '{input}'"
})()
def start_evolution_monitor(self):
logger.info("✅ 模拟进化监视器启动")
def initialize_all(self):
logger.info("=" * 50)
logger.info("🚀 开始初始化AI系统")
logger.info("=" * 50)
self.initialize_system_paths()
self.initialize_ai_core()
self.initialize_hardware_manager()
self.initialize_life_scheduler()
self.initialize_ai_agent()
self.initialize_environment_manager()
self.start_evolution_monitor()
logger.info("✅ 所有系统组件初始化完成")
return {
"ai_core": self.ai_core,
"hardware_manager": self.hardware_manager,
"life_scheduler": self.life_scheduler,
"ai_agent": self.ai_agent,
"environment_manager": self.environment_manager
}
# ========== 环境交互路由 ==========
def register_environment_routes(app):
@app.route('/environment')
def environment_view():
return render_template('environment_view.html')
@app.route('/api/environment/state', methods=['GET'])
@app.config['LIMITER'].limit("
10 per minute")
def get_environment_state():
env_manager = app.config['SYSTEM_COMPONENTS'].get('environment_manager')
if not env_manager:
return jsonify({"success": False, "error": "环境管理器未初始化"}), 503
try:
state = env_manager.get_state()
return jsonify(state)
except Exception as e:
app.logger.error(f"获取环境状态失败: {traceback.format_exc()}")
return jsonify({"success": False, "error": str(e)}), 500
@app.route('/api/environment/action', methods=['POST'])
@app.config['LIMITER'].limit("5 per minute")
def execute_environment_action():
env_manager = app.config['SYSTEM_COMPONENTS'].get('environment_manager')
if not env_manager:
return jsonify({"success": False, "error": "环境管理器未初始化"}), 503
try:
data = request.json
action = data.get('action')
params = data.get('params', {})
if not action:
return jsonify({"success": False, "error": "缺少动作参数"}), 400
success = env_manager.execute_action(action, params)
return jsonify({"success": success, "action": action})
except Exception as e:
app.logger.error(f"执行环境动作失败: {traceback.format_exc()}")
return jsonify({"success": False, "error": str(e)}), 500
# ========== 路由注册 ==========
def register_routes(app):
# 添加根路由 - 关键修复
@app.route('/')
def home():
"""根路由显示欢迎页面"""
current_time = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
return f"""
<!DOCTYPE html>
<html>
<head>
<title>AI系统控制中心</title>
<style>
body {{
font-family: Arial, sans-serif;
margin: 40px;
background-color: #f5f8fa;
}}
.container {{
max-width: 800px;
margin: 0 auto;
padding: 20px;
background: white;
border-radius: 8px;
box-shadow: 0 2px
10px rgba(0,0,0,0.1);
}}
h1 {{
color: #2c3e50;
text-align: center;
margin-bottom: 30px;
}}
.status {{
background: #f8f9fa;
padding: 20px;
border-radius: 8px;
margin-top: 30px;
border-left: 4px solid #3498db;
}}
.links {{
margin-top: 20px;
display: flex;
justify-content: center;
flex-wrap: wrap;
gap: 15px;
}}
.links a {{
display: inline-block;
padding: 12px 25px;
background: #3498db;
color: white;
text-decoration: none;
border-radius: 4px;
transition: all 0.3s ease;
text-align: center;
min-width: 150px;
}}
.links a:hover {{
background: #2980b9;
transform: translateY(-2px);
box-shadow: 0 4px 8px rgba(0,0,0,0.1);
}}
.footer {{
text-align: center;
margin-top: 30px;
color: #7f8c8d;
font-size: 0.9em;
}}
</style>
</head>
<body>
<div class="container">
<h1>🤖 AI系统控制中心</h1>
<p>欢迎访问AI系统控制面板，请选择以下功能：</p>
<div class="links">
<a href="/environment">🌍 环境监控</a>
<a href="/life/dashboard">📅 生活调度</a>
<a href="/status">📊 系统状态</a>
<a href="/health">🩺 健康检查</a>
<a href="/chat">💬 聊天交互</a>
</div>
<div class="status">
<h3>系统状态</h3>
<p>✅ 服务器已启动，运行正常</p>
<p>🕒 启动时间: {current_time}</p>
<p>📍 服务器地址: http://{request.host}</p>
</div>
<div class="footer">
<p>AI系统控制中心 v1.0 | 技术支持: support@ai-system.com</p>
</div>
</div>
</body>
</html>
"""
register_environment_routes(app)
# 静态文件路由
@app.route('/static/<path:filename>')
def static_files(filename):
return send_from_directory(app.static_folder, filename)
# 健康检查路由
@app.route('/health')
def health_check():
return jsonify({"status": "healthy", "timestamp": datetime.datetime.now().isoformat()})
# 系统状态路由
@app.route('/status')
@app.config['LIMITER'].exempt
def status():
components = app.config['SYSTEM_COMPONENTS']
system_info = {
"uptime": time.time() - app.config['START_TIME'],
"ai_core_status": components['ai_core'].status if components['ai_core'] else "uninitialized",
"hardware_status": components['hardware_manager'].get_status() if components[
'hardware_manager'] else "uninitialized",
"life_scheduler_status": components['life_scheduler'].get_status() if components[
'life_scheduler'] else "uninitialized",
"environment_status": components['environment_manager'].is_healthy() if components[
'environment_manager'] else "uninitialized",
"platform": platform.platform(),
"python_version": sys.version,
"memory_usage": psutil.virtual_memory().percent,
"cpu_usage": psutil.cpu_percent(),
"thread_count": threading.active_count(),
"process_id": os.getpid()
}
return jsonify(system_info)
# 核心系统路由
@app.route('/api/core/state')
@app.config['LIMITER'].limit("
10 per minute")
def get_core_state():
ai_core = app.config['SYSTEM_COMPONENTS'].get('ai_core')
if not ai_core:
return jsonify({"error": "AI核心未初始化"}), 503
return jsonify(ai_core.get_state())
# 生活系统路由
@app.route('/life/dashboard')
def life_dashboard():
return render_template('life_dashboard.html')
@app.route('/api/life/status')
@app.config['LIMITER'].limit("
10 per minute")
def get_life_status():
life_scheduler = app.config['SYSTEM_COMPONENTS'].get('life_scheduler')
if not life_scheduler:
return jsonify({"error": "生活调度器未初始化"}), 503
status = life_scheduler.get_status()
return jsonify(status)
# 聊天路由
@app.route('/chat', methods=['GET'])
def chat_interface():
"""聊天界面"""
return render_template('chat.html')
@app.route('/api/chat', methods=['POST'])
@app.config['LIMITER'].limit("30 per minute")
def chat_handler():
"""处理聊天请求的API端点"""
components = app.config['SYSTEM_COMPONENTS']
if not components['ai_agent']:
return jsonify({"error": "Agent未初始化"}), 503
try:
data = request.get_json()
user_input = data.get('message', '')
user_id = data.get('user_id', 'default')
if not user_input:
return jsonify({"error": "消息内容不能为空"}), 400
app.logger.info(f"聊天请求: 用户={user_id}, 内容长度={len(user_input)}")
# 使用线程池异步处理
future = executor.submit(components['ai_agent'].process_input, user_input, user_id)
response = future.result(timeout=
10) #
10秒超时
return jsonify({"response": response})
except TimeoutError:
return jsonify({"error": "处理超时"}), 504
except Exception as e:
app.logger.error(f"聊天处理失败: {traceback.format_exc()}")
return jsonify({"error": "聊天处理失败", "details": str(e)}), 500
# 404处理
@app.route('/<path:path>')
def catch_all(path):
return jsonify({"error": "路由不存在", "path": path}), 404
def register_error_handlers(app):
@app.errorhandler(404)
def not_found_error(error):
return jsonify({"error": "资源未找到", "message": str(error)}), 404
@app.errorhandler(500)
def internal_error(error):
app.logger.error(f"服务器内部错误: {str(error)}")
return jsonify({"error": "服务器内部错误", "message": "请查看日志获取详细信息"}), 500
# ========== WebSocket处理 ==========
def setup_websocket_handlers(socketio):
@socketio.on('connect')
def handle_connect():
logger.info('客户端已连接')
socketio.emit('system_status', {'status': 'ready'})
@socketio.on('disconnect')
def handle_disconnect():
logger.info('客户端已断开连接')
@socketio.on('user_message')
def handle_user_message(data):
user_id = data.get('user_id', 'guest')
message = data.get('message', '')
logger.info(f"收到来自 {user_id} 的消息: {message}")
# 使用线程池处理消息
def process_message():
try:
global coordinator
if coordinator:
return coordinator.process_message(message)
else:
return f"已收到您的消息: {message}"
except Exception as e:
logger.error(f"消息处理失败: {str(e)}")
return "处理消息时出错"
future = executor.submit(process_message)
try:
response = future.result(timeout=
10)
socketio.emit('agent_response', {
'user_id': user_id,
'response': response
})
except TimeoutError:
socketio.emit('agent_response', {
'user_id': user_id,
'response': "处理超时，请重试"
})
# ========== 生产环境启动器 ==========
def run_production_server(app):
try:
from waitress import serve
logger.info(f"🚀 生产服务器启动: http://{config.HOST}:{config.PORT}")
logger.warning("⚠️ 当前运行在生产模式 (Waitress WSGI服务器)")
serve(app, host=config.HOST, port=config.PORT, threads=8)
except ImportError:
logger.error("❌ 缺少生产环境依赖: waitress")
logger.info("请运行: pip install waitress")
sys.exit(1)
# ========== Flask应用工厂 ==========
def create_app():
app = Flask(
__name__,
template_folder=str(config.TEMPLATE_DIR),
static_folder=str(config.STATIC_DIR),
static_url_path='/static'
)
app.secret_key = config.SECRET_KEY
# 初始化限流器
limiter = Limiter(
get_
remote_address,
app=app,
default_limits=["200 per
day", "50 per hour"],
storage_uri="memory://"
)
app.config['LIMITER'] = limiter
system_initializer = SystemInitializer()
components = system_initializer.initialize_all()
app.config['SYSTEM_COMPONENTS'] = components
app.config['START_TIME'] = system_initializer.start_time
app.config['BASE_DIR'] = system_initializer.base_dir
# 配置SocketIO
async_mode = 'threading'
try:
import eventlet
async_mode = 'eventlet'
logger.info("✅ 使用eventlet异步模式")
except ImportError:
logger.warning("⚠️ eventlet未安装，使用threading模式")
pass
# 注册路由和错误处理
register_routes(app)
register_error_handlers(app)
# 创建SocketIO实例
socketio = SocketIO(app, async_mode=async_mode, logger=False, engineio_logger=False)
setup_websocket_handlers(socketio)
app.config['SOCKETIO'] = socketio
return app, socketio
# ========== 主程序入口 ==========
if __name__ == '__main__':
app, socketio = create_app()
# 启动服务器
if os.environ.get('ENV') == 'production':
run_production_server(app)
else:
logger.info(f"🚀 开发服务器启动: http://{config.HOST}:{config.PORT}")
socketio.run(
app,
host=config.HOST,
port=config.PORT,
debug=config.DEBUG,
use_reloader=False
)
# E:\AI_System\agent\autonomous_agent.py
import os
import sys
import time
import logging
import importlib
import traceback
import psutil
import platform
import threading
import json
from pathlib import Path
from dotenv import load_dotenv
from typing import Dict, Any, Optional, List, Callable
from concurrent.futures import ThreadPoolExecutor
from ..core.config import system_config
# 使用绝对导入 - 确保路径正确
sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
from core.config import system_config
from core.exceptions import DependencyError, SubsystemFailure
from core.dependency_manager import DependencyManager
from core.metrics import PerformanceMetrics, MetricsCollector
# 全局线程池
executor = ThreadPoolExecutor(max_workers=4)
class AutonomousAgent:
def __init__(self):
"""自主智能体核心类，负责协调所有子系统"""
self.logger = self._setup_logger()
self.logger.info("🔁 初始化自主智能体核心模块...")
self._running = False # 运行状态标志
self._background_thread = None # 后台线程
# 初始化状态跟踪
self.initialization_steps = []
self._last_env_check = 0
self._initialization_time = time.time()
self.subsystem_status = {} # 子系统熔断状态
self.metrics = MetricsCollector() # 性能监控
self._status_lock = threading.Lock() # 状态锁
# 依赖管理器
self.dependency_manager = DependencyManager()
try:
# 记录初始化步骤
self._record_step("加载环境变量")
load_dotenv()
self._record_step("验证环境")
self.verify_environment()
self._record_step("初始化核心组件")
self._initialize_core_components()
self._record_step("初始化子系统")
self._initialize_subsystems()
self.logger.info(f"✅ 自主智能体初始化完成 (耗时: {time.time() - self._initialization_time:.2f}秒)")
self.logger.info(f"初始化步骤: {', '.join(self.initialization_steps)}")
# 启动后台任务线程
self._start_background_tasks()
except Exception as e:
self.logger.exception(f"❌ 智能体初始化失败: {str(e)}")
self.logger.error(f"堆栈跟踪:\n{traceback.format_exc()}")
raise RuntimeError(f"智能体初始化失败: {str(e)}") from e
def _start_background_tasks(self):
"""启动后台任务线程"""
if self._running:
self.logger.warning("后台任务已在运行")
return
self._running = True
self._background_thread = threading.Thread(
target=self._background_task_loop,
daemon=True,
name="AutonomousAgentBackgroundTasks"
)
self._background_thread.start()
self.logger.info("✅ 后台任务线程已启动")
def _background_task_loop(self):
"""后台任务循环"""
while self._running:
try:
start_time = time.time()
self.run_periodic_tasks()
# 动态调整睡眠时间
task_time = time.time() - start_time
sleep_time = max(0.1,
10 - task_time) # 确保至少
10秒间隔
time.sleep(sleep_time)
except Exception as e:
self.logger.error(f"后台任务错误: {str(e)}")
self.metrics.record_error('background_task')
time.sleep(30)
def _record_step(self, step_name: str):
"""记录初始化步骤"""
self.initialization_steps.append(step_name)
self.logger.info(f"⏳ 步骤 {len(self.initialization_steps)}: {step_name}")
def verify_environment(self):
"""验证运行环境是否满足要求"""
missing = []
warnings = []
# 检查必需模块
required_modules = [
'os', 'sys', 'logging', 'dotenv', 'flask', 'werkzeug',
'numpy', 'transformers', 'torch', 'psutil'
]
for mod in required_modules:
try:
importlib.import_module(mod)
except ImportError:
missing.append(mod)
# 检查配置文件
if not hasattr(system_config, 'CONFIG_PATH') or not os.path.exists(system_config.CONFIG_PATH):
self.logger.error(f"❌ 配置文件缺失: {system_config.CONFIG_PATH}")
warnings.append(f"配置文件缺失: {system_config.CONFIG_PATH}")
# 检查模型目录 - 如果不存在则创建
model_dir = Path(system_config.MODEL_CACHE_DIR)
if not model_dir.exists():
model_dir.mkdir(parents=True, exist_ok=True)
self.logger.warning(f"⚠️ 创建模型缓存目录: {model_dir}")
# 检查日志目录 - 如果不存在则创建
log_dir = Path(system_config.LOG_DIR)
if not log_dir.exists():
log_dir.mkdir(parents=True, exist_ok=True)
self.logger.warning(f"⚠️ 创建日志目录: {log_dir}")
# 处理警告
for warning in warnings:
self.logger.warning(warning)
# 处理缺失项
if missing:
error_msg = f"环境验证失败，缺失: {', '.join(missing)}"
self.logger.error(error_msg)
self.dependency_manager.record_missing_dependencies(missing)
raise DependencyError(error_msg)
self.logger.info("✅ 环境验证通过")
def _setup_logger(self) -> logging.Logger:
"""配置日志记录器"""
logger = logging.getLogger('AutonomousAgent')
logger.setLevel(system_config.LOG_LEVEL)
# 创建控制台处理器
console_handler = logging.StreamHandler()
console_handler.setLevel(system_config.LOG_LEVEL)
# 创建文件处理器
log_file = Path(system_config.LOG_DIR) / 'autonomous_agent.log'
file_handler = logging.FileHandler(log_file, encoding='utf-8')
file_handler.setLevel(system_config.LOG_LEVEL)
# 创建格式化器
formatter = logging.Formatter(
'%(asctime)s - %(name)s - %(levelname)s - %(message)s',
datefmt='%Y-%m-%d %H:%M:%S'
)
console_handler.setFormatter(formatter)
file_handler.setFormatter(formatter)
# 添加处理器
logger.addHandler(console_handler)
logger.addHandler(file_handler)
logger.propagate = False
return logger
def _initialize_core_components(self):
"""初始化不依赖其他组件的核心组件"""
# 获取项目根目录
base_dir = Path(__file__).resolve().parent.parent
# 环境相关组件 - 使用回退实现
self.environment = self._create_fallback_environment(base_dir)
self.logger.info("✅ 环境接口初始化完成")
# 记录环境状态
self._log_environment_status()
# 初始化状态持久化
self._load_subsystem_status()
def _create_fallback_environment(self, base_dir: Path):
"""创建回退的环境实现"""
class FallbackEnvironment:
def __init__(self, base_dir):
self.base_dir = base_dir
self.status_file = base_dir / 'environment_status.json'
def get_system_info(self):
try:
# 尝试从文件加载状态
if self.status_file.exists():
with open(self.status_file, 'r') as f:
return json.load(f)
except:
pass
# 创建新状态
status = {
"os": platform.system(),
"os_version": platform.version(),
"cpu": platform.processor(),
"cpu_cores": psutil.cpu_count(logical=False),
"memory_total": round(psutil.virtual_memory().total / (
1024 ** 3), 1),
"memory_used": round(psutil.virtual_memory().used / (
1024 ** 3), 1),
"disk_total": round(psutil.disk_usage('/').total / (
1024 ** 3), 1),
"disk_used": round(psutil.disk_usage('/').used / (
1024 ** 3), 1),
"timestamp": time.time()
}
# 保存状态
try:
with open(self.status_file, 'w') as f:
json.dump(status, f)
except:
pass
return status
return FallbackEnvironment(base_dir)
def _log_environment_status(self):
"""记录环境状态信息"""
try:
env_status = self.environment.get_system_info() or {}
self.logger.info(
f"📊 系统状态: OS={env_status.get('os', '未知')} {env_status.get('os_version', '')}, "
f"CPU={env_status.get('cpu', '未知')} ({env_status.get('cpu_cores', 0)}核), "
f"内存={env_status.get('memory_used', 0)}/{env_status.get('memory_total', 0)}GB, "
f"磁盘={env_status.get('disk_used', 0)}/{env_status.get('disk_total', 0)}GB"
)
except Exception as e:
self.logger.error(f"环境状态获取失败: {str(e)}")
self.metrics.record_error('environment_status')
def _initialize_subsystems(self):
"""初始化所有子系统 - 使用动态导入并添加详细错误处理"""
# 定义子系统初始化顺序 - 使用更简单的回退实现
subsystems = [
('健康系统', self._create_fallback_health_system, {}),
('模型管理器', self._create_fallback_model_manager, {}),
('记忆系统', self._create_fallback_memory_system, {}),
('情感系统', self._create_fallback_affective_system, {}),
('认知架构', self._create_fallback_cognitive_architecture, {}),
('通信系统', self._create_fallback_
communication_system, {})
]
# 注册子系统依赖关系
self.dependency_manager.register_dependency('通信系统', ['认知架构'])
self.dependency_manager.register_dependency('情感系统', ['健康系统', '记忆系统'])
self.dependency_manager.register_dependency('认知架构', ['记忆系统'])
# 初始化子系统
for name, creator_func, kwargs in subsystems:
try:
# 检查依赖是否满足
missing_deps = self.dependency_manager.check_dependencies(name)
if missing_deps:
self.logger.warning(f"⚠️ 子系统 {name} 缺少依赖: {', '.join(missing_deps)}")
# 尝试自动安装缺失依赖
self.dependency_manager.install_missing_dependencies(missing_deps)
# 创建实例
instance = creator_func(**kwargs)
setattr(self, name.lower().replace(' ', '_'), instance)
self.logger.info(f"✅ {name}初始化完成")
# 标记子系统为活跃状态
with self._status_lock:
self.subsystem_status[name] = {
'active': True,
'error_count': 0,
'last_active': time.time(),
'last_recovery_attempt': 0
}
except Exception as e:
self.logger.error(f"❌ {name}初始化失败: {str(e)}")
with self._status_lock:
self.subsystem_status[name] = {
'active': False,
'error': str(e),
'error_count': 1,
'last_error': time.time()
}
# 记录指标
self.metrics.record_error(f'subsystem_init_{name.lower()}')
# 保存子系统状态
self._save_subsystem_status()
# 各子系统回退实现保持不变...
def process_input(self, user_input: str, user_id: str = "default") -> Dict[str, Any]:
"""处理用户输入（通过通信系统）"""
# 检查通信系统是否活跃
with self._status_lock:
comm_status = self.subsystem_status.get('通信系统', {})
active =
comm_status.get('active', False)
if not active:
self.logger.error("通信系统未激活，使用回退处理")
self.metrics.record_error('
communication_system_inactive')
return {"response": "系统正在维护中，请稍后再试"}
try:
# 使用性能监控
with PerformanceMetrics() as pm:
# 使用线程池异步处理
future = executor.submit(
self.
communication_system.process_input,
user_input,
user_id
)
response = future.result(timeout=
10) #
10秒超时
# 记录性能指标
self.metrics.record_latency('process_input', pm.duration)
self.metrics.record_success('process_input')
self.logger.info(f"📥 处理输入: '{user_input[:30]}...' → 耗时: {pm.duration:.2f}秒")
return response
except TimeoutError:
self.logger.warning("处理输入超时")
self.metrics.record_timeout('process_input')
return {"error": "处理超时，请重试"}
except Exception as e:
# 更新错误计数
with self._status_lock:
comm_status = self.subsystem_status.get('通信系统', {})
comm_status['error_count'] =
comm_status.get('error_count', 0) + 1
comm_status['last_error'] = time.time()
# 检查熔断条件
if
comm_status['error_count'] >= 5: # 临时阈值
comm_status['active'] = False
self.logger.critical(f"🚨 通信系统因连续错误被熔断！")
self.metrics.record_event('circuit_breaker', '通信系统')
self.logger.error(f"处理输入失败: {str(e)}")
self.metrics.record_error('process_input')
return {"error": "处理失败，请稍后再试"}
def run_periodic_tasks(self):
"""运行周期性任务"""
task_start = time.time()
tasks_executed = 0
tasks_failed = 0
# 定义任务列表
tasks = [
('健康系统更新', lambda: self.health_system.update()),
('情感系统更新', lambda: self.affective_system.grow()),
('记忆系统维护', lambda: self.memory_system.consolidate_memories()),
('环境监控', self._monitor_environment),
('子系统心跳检查', self._check_subsystem_heartbeats),
('子系统恢复', self._recover_failed_subsystems)
]
# 执行任务
for name, task_func in tasks:
try:
if name == '环境监控' or self._is_subsystem_active(name.split()[0]):
task_func()
tasks_executed += 1
except Exception as e:
tasks_failed += 1
subsystem_name = name.split()[0]
self.logger.error(f"{name}失败: {str(e)}", exc_info=True)
self._handle_subsystem_error(subsystem_name, e)
self.metrics.record_error(f'periodic_{subsystem_name.lower()}')
# 记录任务执行情况
if tasks_executed > 0:
task_time = time.time() - task_start
self.logger.debug(f"⏱️ 执行 {tasks_executed} 项周期性任务 ({tasks_failed}失败), 耗时: {task_time:.3f}秒")
self.metrics.record_latency('periodic_tasks', task_time)
self.metrics.record_value('periodic_tasks_count', tasks_executed)
self.metrics.record_value('periodic_tasks_failed', tasks_failed)
def _is_subsystem_active(self, name: str) -> bool:
"""检查子系统是否活跃"""
with self._status_lock:
status = self.subsystem_status.get(name, {})
return status.get('active', False)
def _handle_subsystem_error(self, name: str, error: Exception):
"""处理子系统错误"""
with self._status_lock:
status = self.subsystem_status.get(name, {})
status['error_count'] = status.get('error_count', 0) + 1
status['last_error'] = time.time()
# 检查熔断条件
if status['error_count'] >= 5: # 临时阈值
status['active'] = False
self.logger.critical(f"🚨 子系统 {name} 因连续错误被熔断！")
self.metrics.record_event('circuit_breaker', name)
def _check_subsystem_heartbeats(self):
"""检查子系统心跳"""
for name in list(self.subsystem_status.keys()):
with self._status_lock:
status = self.subsystem_status.get(name, {})
if not status.get('active', False):
continue # 跳过已熔断的
subsystem = getattr(self, name.lower().replace(' ', '_'), None)
if subsystem and hasattr(subsystem, 'check_heartbeat'):
try:
if not subsystem.check_heartbeat():
self.logger.warning(f"⚠️ 子系统 {name} 心跳检测失败")
self._handle_subsystem_error(name, RuntimeError("心跳检测失败"))
else:
# 更新最后活跃时间
with self._status_lock:
status['last_active'] = time.time()
except Exception as e:
self.logger.error(f"子系统 {name} 心跳检查异常: {str(e)}")
self._handle_subsystem_error(name, e)
self.metrics.record_error(f'heartbeat_{name.lower()}')
def _recover_failed_subsystems(self):
"""尝试恢复失败的子系统"""
for name in list(self.subsystem_status.keys()):
with self._status_lock:
status = self.subsystem_status.get(name, {})
if status.get('active', False):
continue # 跳过活跃的
# 检查恢复条件：错误后至少等待5分钟
last_error = status.get('last_error', 0)
if time.time() - last_error < 300:
continue
# 检查上次恢复尝试时间
last_attempt = status.get('last_recovery_attempt', 0)
if time.time() - last_attempt < 600: # 每
10分钟尝试一次
continue
self.logger.info(f"🔄 尝试恢复子系统: {name}")
status['last_recovery_attempt'] = time.time()
try:
# 尝试重新初始化子系统
# 这里需要根据子系统名称调用相应的初始化方法
# 简化实现：直接重置状态
subsystem = self._reinitialize_subsystem(name)
setattr(self, name.lower().replace(' ', '_'), subsystem)
with self._status_lock:
status['active'] = True
status['error_count'] = 0
status['last_error'] = 0
self.logger.info(f"✅ 子系统 {name} 恢复成功")
self.metrics.record_event('subsystem_recovered', name)
except Exception as e:
with self._status_lock:
status['active'] = False
status['error_count'] += 1
status['last_error'] = time.time()
self.logger.error(f"子系统 {name} 恢复失败: {str(e)}")
self.metrics.record_error(f'recovery_{name.lower()}')
def _reinitialize_subsystem(self, name: str) -> Any:
"""重新初始化子系统"""
# 根据名称选择初始化方法
creators = {
'健康系统': self._create_fallback_health_system,
'模型管理器': self._create_fallback_model_manager,
'记忆系统': self._create_fallback_memory_system,
'情感系统': self._create_fallback_affective_system,
'认知架构': self._create_fallback_cognitive_architecture,
'通信系统': self._create_fallback_
communication_system
}
if name in creators:
return creators[name]()
else:
raise SubsystemFailure(f"未知子系统: {name}")
def _monitor_environment(self):
"""监控环境状态"""
try:
self.logger.info("🔍 开始环境监控...")
env_status = self.environment.get_system_info() or {}
# 获取CPU和内存使用情况
env_status['cpu_usage'] = psutil.cpu_percent()
env_status['memory_usage'] = psutil.virtual_memory().percent
env_status['disk_usage'] = psutil.disk_usage('/').percent
# 记录到日志
self.logger.info(
f"📊 环境监控: CPU={env_status['cpu_usage']}%, "
f"内存={env_status['memory_usage']}%, "
f"磁盘={env_status['disk_usage']}%"
)
# 记录到健康系统
if hasattr(self, 'health_system'):
self.health_system.record_environment_status(env_status)
# 记录指标
self.metrics.record_value('cpu_usage', env_status['cpu_usage'])
self.metrics.record_value('memory_usage', env_status['memory_usage'])
self.metrics.record_value('disk_usage', env_status['disk_usage'])
except Exception as e:
self.logger.error(f"环境监控失败: {str(e)}", exc_info=True)
self.metrics.record_error('environment_monitoring')
def _save_subsystem_status(self):
"""保存子系统状态到文件"""
status_file = Path(system_config.CONFIG_DIR) / 'subsystem_status.json'
try:
with self._status_lock:
data = {
'timestamp': time.time(),
'status': self.subsystem_status
}
with open(status_file, 'w') as f:
json.dump(data, f, indent=2)
except Exception as e:
self.logger.error(f"保存子系统状态失败: {str(e)}")
def _load_subsystem_status(self):
"""从文件加载子系统状态"""
status_file = Path(system_config.CONFIG_DIR) / 'subsystem_status.json'
if status_file.exists():
try:
with open(status_file, 'r') as f:
data = json.load(f)
# 只加载24小时内的状态
if time.time() - data.get('timestamp', 0) < 86400:
with self._status_lock:
self.subsystem_status = data.get('status', {})
self.logger.info("加载子系统状态缓存")
except Exception as e:
self.logger.error(f"加载子系统状态失败: {str(e)}")
def get_status(self) -> Dict[str, Any]:
"""获取智能体状态报告"""
with self._status_lock:
status_data = {
"uptime": time.time() - self._initialization_time,
"subsystems": {
name: info.get('active', False)
for name, info in self.subsystem_status.items()
},
"circuit_breaker": {
name: {
"active": info.get('active', False),
"error_count": info.get('error_count', 0),
"last_error": info.get('last_error', 0)
}
for name, info in self.subsystem_status.items()
},
"metrics": self.metrics.get_metrics(),
"environment": self.environment.get_system_info() if hasattr(self, 'environment') else {}
}
# 添加子系统状态
for name in ['健康系统', '情感系统', '记忆系统', '模型管理器', '认知架构', '通信系统']:
attr_name = name.lower().replace(' ', '_')
if hasattr(self, attr_name) and hasattr(getattr(self, attr_name), 'get_status'):
status_data[name] = getattr(self, attr_name).get_status()
return status_data
def shutdown(self):
"""关闭智能体"""
self.logger.info("🛑 正在关闭智能体...")
self._running = False
# 停止线程池
executor.shutdown(wait=False)
# 保存状态
self._save_subsystem_status()
# 等待后台线程
if self._background_thread and self._background_thread.is_alive():
self._background_thread.join(timeout=5.0)
if self._background_thread.is_alive():
self.logger.warning("后台线程未正常退出")
self.logger.info("✅ 智能体已关闭")
你看看怎么修改 主要是哪个模块没启动 哪里有问题 我需要知道 你理解吗？
本文介绍了一个使用Python编写的脚本，该脚本能够通过SSH连接到多个远程主机并执行指定的命令。它利用了paramiko库来实现SSH连接，并采用了多线程方式提高效率。
扫一扫
1409
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
