268 lines
9.2 KiB
Python
268 lines
9.2 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)
|
|
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
|
|
|
|
# 初始化计算服务
|
|
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
|