Files
CPY_AlgorithmGateway/cpy_server.py
T
2026-07-07 18:19:14 +08:00

274 lines
9.6 KiB
Python

import logging
import json
import base64
from mqtt_client import MqttClient
from file_handler import FileHandler
from compute_service import ComputeService
from version import get_version
from config import config_manager
logger = logging.getLogger(__name__)
class CpyServer:
def __init__(self):
# 服务器状态
self.running = False
# 初始化各个模块
self._init_modules()
def _init_modules(self):
"""初始化各个功能模块"""
try:
# 初始化MQTT客户端
if config_manager.get('mqtt.enable', False):
self.mqtt_client = MqttClient()
self.mqtt_client.set_callbacks(on_message = self.mqtt_msg_handler)
else:
self.mqtt_client = None
# 初始化文件处理器
file_root = config_manager.get("file_root", r"C:\\CPY\\Data")
self.file_handler = FileHandler(file_root)
# 初始化计算服务
self.compute_services = {}
for dev_id in config_manager.get('udp_map', {}).keys():
try:
compute_service = ComputeService(dev_id)
logger.info(f"ComputeService initialized for dev_id: {dev_id}, udp port {compute_service.udp_handler.port}")
if compute_service.udp_handler.port != config_manager.get(f'udp_map.{dev_id}', 0):
config_manager.set(f'udp_map.{dev_id}', compute_service.udp_handler.port)
self.compute_services[dev_id] = compute_service
except Exception as e:
logger.error(f"Failed to initialize ComputeService for dev_id {dev_id}: {e}")
logger.info("All modules initialized successfully")
except Exception as e:
logger.error(f"Failed to initialize modules: {e}")
raise
def mqtt_ack(self, cmd, dev_id, result, error = 200, uuid = None):
topic = f"v1/cpy/{dev_id}"
rsp = {
'ack' : cmd,
'error' : error,
'result' : result
}
if uuid:
rsp['uuid'] = uuid
self.mqtt_client.publish(topic, rsp, 1)
def mqtt_msg_handler(self, client, userdata, msg):
try:
payload = json.loads(msg.payload.decode())
logger.info(f"Received message on topic {msg.topic}: ")
cmd = payload.get("cmd", None)
if not cmd:
return
if cmd == 'status':
self.get_status(payload)
elif cmd == 'register':
self.register_device(payload)
elif cmd == 'calculate':
self.handle_data(payload)
except json.JSONDecodeError:
logger.error(f"Failed to decode JSON from message on topic {msg.topic}")
def handle_data(self, metadata):
"""处理数据上传请求"""
try:
dev_id = metadata.get('dev_id', None)
msg_uuid = metadata.get('uuid', None)
file_name = metadata.get('file_name', None)
file_content = metadata.get('data', None)
scanner = metadata.get('scanner', None)
if file_name is None or \
file_content is None or\
dev_id is None or\
msg_uuid is None:
return
try:
file_content = base64.b64decode(file_content)
except:
self.mqtt_ack('calculate', dev_id, "failed to decode data", 400, msg_uuid)
return
# 处理文件上传
processed_filename = self.file_handler.process_file_upload(
file_name, file_content, metadata
)
if not processed_filename:
self.mqtt_ack('calculate', dev_id, 'Failed to process file', 400, msg_uuid)
return
# 获取计算参数
init = int(metadata.get('init', 0))
# 执行计算
file_path = processed_filename
compute_service = self.compute_services.get(dev_id)
if not compute_service:
self.mqtt_ack('calculate', dev_id, f'ComputeService not initialized for dev_id {dev_id}', 400, msg_uuid)
return
try:
result_json = compute_service.compute_file(file_path, init, metadata)
except Exception as e:
self.mqtt_ack('calculate', dev_id, f'ComputeService error: {e}', 400, msg_uuid)
return
# 返回结果
try:
rsp = json.loads(result_json)
except:
rsp = result_json
self.mqtt_ack('calculate', dev_id, rsp, uuid = msg_uuid)
except Exception as e:
logger.error(f"Error handling data request: {e}")
return json.dumps({'error': str(e)})
def get_status(self, data):
"""获取服务器状态"""
try:
# 获取MQTT连接状态
mqtt_connected = self.mqtt_client.is_connected() if self.mqtt_client else False
# 获取版本号
version = get_version()
#检查是否传入dev_id
dev_id = data.get('dev_id', None)
if not dev_id:
rsp = json.dumps({
'running': 'true' if self.running else 'false',
'mqtt_connected': mqtt_connected,
'version': version
})
return
try:
compute_status = self.compute_services.get(dev_id).is_available()
except:
compute_status = False
rsp = {
'running': self.running,
'mqtt_connected': mqtt_connected,
'compute_status': compute_status,
'version': version
}
self.mqtt_ack('status', dev_id, rsp)
except Exception as e:
logger.error(f"Error getting status: {e}")
return json.dumps({'error': str(e)})
def register_device(self, data):
"""注册设备"""
try:
dev_id = data.get('dev_id')
print('register msg from', dev_id)
if not dev_id:
return json.dumps({'error': 'dev_id is required'})
if dev_id in self.compute_services:
try:
if self.compute_services[dev_id].is_available():
self.mqtt_ack('register', \
dev_id, \
{'message': 'Device registered successfully'},\
200)
return
except:
pass
try:
self.compute_services[dev_id].close()
del self.compute_services[dev_id]
except:
pass
# 检查是否开启自动注册
if not config_manager.get('dev_auto_register', False):
if not dev_id in config_manager.get('udp_map', {}).keys():
logger.error(f"Device {dev_id} not registered in udp_map")
self.mqtt_ack('register', dev_id, {'error': f"Device {dev_id} not registered in config"}, 400)
return
# 初始化计算服务
try:
compute_service = ComputeService(dev_id)
except Exception as e:
logger.error(f"Failed to initialize ComputeService for dev_id {dev_id}: {e}")
self.mqtt_ack('register', dev_id, {'error': f'Failed to initialize ComputeService: {e}'}, 500)
return
self.compute_services[dev_id] = compute_service
if compute_service.udp_handler.port != config_manager.get(f'udp_map.{dev_id}', 0):
config_manager.set(f'udp_map.{dev_id}', compute_service.udp_handler.port)
self.mqtt_ack('register', dev_id, {'message': 'Device registered successfully'})
except Exception as e:
logger.error(f"Error registering device: {e}")
return json.dumps({'error': str(e)})
def start(self):
"""启动服务"""
if self.running:
logger.warning("Server is already running")
return
self.running = True
# 启动MQTT客户端
if self.mqtt_client:
self.mqtt_client.connect()
logger.info("Server started")
def stop(self):
"""停止服务"""
if not self.running:
logger.warning("Server is not running")
return
self.running = False
logger.info("Stopping server")
# 断开MQTT连接
if self.mqtt_client:
self.mqtt_client.disconnect()
# 关闭所有计算服务
for dev_id in list(self.compute_services.keys()):
try:
self.compute_services[dev_id].close()
except:
pass
try:
del self.compute_services[dev_id]
except:
pass
logger.info("Server stopped")
def is_running(self) -> bool:
"""检查服务器是否在运行"""
return self.running