# -*- coding: utf-8 -*-
import time,os
from os.path import join
from traceback import format_exc
import json
from cerberus import Validator

from common.Constant import ONLINE_START_SCHEMA, ONLINE_STOP_SCHEMA, OFFLINE_START_SCHEMA, OFFLINE_STOP_SCHEMA, \
    IMAGE_SCHEMA, RECORDING_START_SCHEMA, RECORDING_STOP_SCHEMA, PULL2PUSH_START_SCHEMA, PULL2PUSH_STOP_SCHEMA
from common.YmlConstant import service_yml_path, kafka_yml_path
from concurrency.FeedbackThread import FeedbackThread
from concurrency.uploadGPU import uploadGPUinfos
from concurrency.IntelligentRecognitionProcess2 import OnlineIntelligentRecognitionProcess2, \
    OfflineIntelligentRecognitionProcess2, PhotosIntelligentRecognitionProcess2
from concurrency.Pull2PushStreamProcess import PushStreamProcess
from entity.FeedBack import message_feedback, recording_feedback, pull_stream_feedback
from enums.AnalysisStatusEnum import AnalysisStatus
from enums.AnalysisTypeEnum import AnalysisType
from enums.ExceptionEnum import ExceptionType
from enums.ModelTypeEnum import ModelMethodTypeEnum, ModelType
from enums.RecordingStatusEnum import RecordingStatus
from enums.StatusEnum import PushStreamStatus, ExecuteStatus
from exception.CustomerException import ServiceException
from loguru import logger
from multiprocessing import Queue
from concurrency.IntelligentRecognitionProcess import OnlineIntelligentRecognitionProcess, \
    OfflineIntelligentRecognitionProcess, PhotosIntelligentRecognitionProcess, ScreenRecordingProcess
from util.CpuUtils import print_cpu_ex_status
from util.FileUtils import create_dir_not_exist
from util.GPUtils import get_first_gpu_name, print_gpu_ex_status, check_cude_is_available,select_best_server
from util.KafkaUtils import CustomerKafkaConsumer
from util.QueUtil import put_queue
from util.RWUtils import getConfigs
from kafka import KafkaProducer, KafkaConsumer
'''
   分发服务
'''


class DispatcherService:
    __slots__ = ('__context', '__feedbackThread', '__listeningProcesses', '__fbQueue', '__topics','__taskType', '__task_type',
                 '__kafka_config', '__recordingProcesses', '__pull2PushProcesses','__topicsPort','__gpuTopic','__role','__uploadGPUThread','__gpuDics','__producer')

    def __init__(self, base_dir, env):
        # 检测cuda是否活动
        check_cude_is_available()
        # 获取全局上下文配置
        self.__context = getConfigs(join(base_dir, service_yml_path % env))
        # 创建任务执行, 视频保存路径
        create_dir_not_exist(join(base_dir, self.__context["video"]["file_path"]))
        # 将根路径和环境设置到上下文中
        self.__context["base_dir"], self.__context["env"] = base_dir, env

        # 问题反馈线程
        self.__feedbackThread,self.__uploadGPUThread, self.__fbQueue = None,None, Queue()
        # 实时、离线、图片任务进程字典
        self.__listeningProcesses = {}
        # 录屏任务进程字典
        self.__recordingProcesses = {}
        # 转推流任务进程字典
        self.__pull2PushProcesses = {}
        self.__kafka_config = getConfigs(join(base_dir, kafka_yml_path % env))
        
        self.__producer = KafkaProducer(
            bootstrap_servers=self.__kafka_config['bootstrap_servers'],#tencent yun
            value_serializer=lambda v: v.encode('utf-8'))

        self.__gpuDics = { }#用于存储gpu信息的字典
        self.__role = self.__context["role"]
        self.__topics = [
                self.__kafka_config["topic"]["dsp-alg-online-tasks-topic"],  # 实时监听topic
                self.__kafka_config["topic"]["dsp-alg-offline-tasks-topic"],  # 离线监听topic
                self.__kafka_config["topic"]["dsp-alg-image-tasks-topic"],  # 图片监听topic
                self.__kafka_config["topic"]["dsp-recording-task-topic"],  # 录屏监听topic
                self.__kafka_config["topic"]["dsp-push-stream-task-topic"]  # 推流监听topic
            ]
            
        self.__topicsPort = [
                self.__kafka_config["topicPort"]["dsp-alg-online-tasks-topic"],  # 实时监听topic
                self.__kafka_config["topicPort"]["dsp-alg-offline-tasks-topic"],  # 离线监听topic
                self.__kafka_config["topicPort"]["dsp-alg-image-tasks-topic"],  # 图片监听topic
                self.__kafka_config["topicPort"]["dsp-recording-task-topic"],  # 录屏监听topic
                self.__kafka_config["topicPort"]["dsp-push-stream-task-topic"]  # 推流监听topic
            ]  
        self.__gpuTopic = [self.__kafka_config["topicGPU"]]
        
        if self.__role==1:
            self.__topics = self.__topics +  self.__topicsPort + self.__gpuTopic
   
            
        # 对应topic的各个lambda表达式
        self.__task_type = {
            self.__topics[0]: (AnalysisType.ONLINE.value, lambda x, y: self.online(x, y),
                               lambda x, y, z: self.identify_method(x, y, z)),
            self.__topics[1]: (AnalysisType.OFFLINE.value, lambda x, y: self.offline(x, y),
                               lambda x, y, z: self.identify_method(x, y, z)),
            self.__topics[2]: (AnalysisType.IMAGE.value, lambda x, y: self.image(x, y),
                               lambda x, y, z: self.identify_method(x, y, z)),
            self.__topics[3]: (AnalysisType.RECORDING.value, lambda x, y: self.recording(x, y),
                               lambda x, y, z: self.recording_method(x, y, z)),
            self.__topics[4]: (AnalysisType.PULLTOPUSH.value, lambda x, y: self.pullStream(x, y),
                               lambda x, y, z: self.push_stream_method(x, y, z))
                               
        }
        self.__taskType={
            self.__kafka_config["topic"]["dsp-alg-online-tasks-topic"]:0,  # 实时监听topic
            self.__kafka_config["topic"]["dsp-alg-offline-tasks-topic"]:1,  # 离线监听topic
            self.__kafka_config["topic"]["dsp-alg-image-tasks-topic"]:2,  # 图片监听topic
            self.__kafka_config["topic"]["dsp-recording-task-topic"]:3,  # 录屏监听topic
            self.__kafka_config["topic"]["dsp-push-stream-task-topic"]:4  # 推流监听topic
        }  
        gpu_name_array = get_first_gpu_name()
        gpu_array = [g for g in ('3090', '2080', '4090', 'A10') if g in gpu_name_array]
        gpu_name = '2080Ti'
        if len(gpu_array) > 0:
            if gpu_array[0] != '2080':
                gpu_name = gpu_array[0]
        else:
            raise Exception("GPU资源不在提供的模型所支持的范围内！请先提供对应的GPU模型！")
        logger.info("当前服务环境为: {}, 服务器GPU使用型号: {}", env, gpu_name)
        self.__context["gpu_name"] = gpu_name
        self.start_service()

    # 服务调用启动方法
    def start_service(self):
        # 初始化kafka监听者
        customerKafkaConsumer = CustomerKafkaConsumer(self.__kafka_config, topics=self.__topics)
        ####增加一个线程，用于试试监控和发送gpu状态####
        ####
        logger.info("(♥◠‿◠)ﾉﾞ  DSP【算法调度服务】启动成功   服务器IP:{}".format(self.__kafka_config['bootstrap_servers']  ))
        while True:
            try:
                # 检查任务进程运行情况，去除结束的任务
                self.check_process_task()
                # 启动反馈线程
                self.start_feedback_thread()
                self.start_uploadGPU_thread()
                msg = customerKafkaConsumer.poll()
                if msg is not None and len(msg) > 0:
                    for k, v in msg.items():
                        for m in v:
                            message = m.value
                            #如果收到的信息是gpu状态的话，收到信息后，更新自己的gpu服务器状态，下面不再执行
                            if m.topic in self.__gpuTopic:
                                customerKafkaConsumer.commit_offset(m,'x'*16,False)
                                #更新机器资源现状
                                ip = message['System']['Local IP Address']
                                self.__gpuDics[ip]=message 
                                continue
                            #如果收到的信息是门户消息，收到信息后，要根据Gpu状态，转发到对应的机器。
                            elif m.topic in self.__topicsPort:
                                customerKafkaConsumer.commit_offset(m, 'y'*16)
                                #状态分析
                                #recondGpu={'hostname':'thsw2','IP':'192.168.10.66','gpuId':0}
                                recondGpu= select_best_server(self.__gpuDics)
                                if recondGpu is None:
                                    print(  'recondGpu：',recondGpu, '  self.__gpuDics: ',self.__gpuDics,' topic:',m.topic, ' message:',message )
                                    continue
                                #转发消息
                                message['transmit_topic'] = m.topic + '-' + recondGpu['IP']
                                transmitMsg={'transmit':message}
                                msg_json = json.dumps( message )
                                future =  self.__producer.send( message['transmit_topic']  ,msg_json)
                                try:
                                     future.get(timeout=2)
                                     logger.info( "转发消息成功，消息topic:{},消息内容:{}",message['transmit_topic'],message   )
                                except kafka_errors as e:
                                     print('------transmitted error:',e)
                                     logger.info("转发消息失败")
                                     traceback.format_exc()
                            else:
                                requestId = message.get("request_id")
                                if requestId is None:
                                    logger.error("请求参数格式错误, 请检查请求体格式是否正确！message:%s"%(message))
                                    continue
                                customerKafkaConsumer.commit_offset(m, requestId)
                                logger.info("当前拉取到的消息, topic:{}, offset:{}, partition: {}, body: {}, requestId:{}",
                                            m.topic, m.offset, m.partition, message, requestId)
      
                                message['taskType']=self.__taskType[m.topic]               
                                topic_method = self.__task_type[m.topic]
                                topic_method[2](topic_method[1], message, topic_method[0])
                else:
                    print_gpu_ex_status()
                    print_cpu_ex_status(self.__context["base_dir"])
                    time.sleep(1)
            except Exception:
                logger.error("主线程异常：{}", format_exc())

    def identify_method(self, handle_method, message, analysisType):
        try:
            check_cude_is_available()
            handle_method(message, analysisType)
        except ServiceException as s:
            logger.error("消息监听异常：{}, requestId: {}", s.msg, message["request_id"])
            put_queue(self.__fbQueue, message_feedback(message["request_id"], AnalysisStatus.FAILED.value, analysisType,
                                                       s.code, s.msg), timeout=1)
        except Exception:
            logger.error("消息监听异常：{}, requestId: {}", format_exc(), message["request_id"])
            put_queue(self.__fbQueue, message_feedback(message["request_id"], AnalysisStatus.FAILED.value, analysisType,
                                                       ExceptionType.SERVICE_INNER_EXCEPTION.value[0],
                                                       ExceptionType.SERVICE_INNER_EXCEPTION.value[1]), timeout=1)
        finally:
            del message

    def push_stream_method(self, handle_method, message, analysisType):
        try:
            check_cude_is_available()
            handle_method(message, analysisType)
        except ServiceException as s:
            logger.error("消息监听异常：{}, requestId: {}", s.msg, message['request_id'])
            videoInfo = [{"id": url.get("id"), "status": PushStreamStatus.FAILED.value[0]} for url in
                         message.get("video_urls", []) if url.get("id") is not None]
            put_queue(self.__fbQueue, pull_stream_feedback(message['request_id'], ExecuteStatus.FAILED.value[0],
                                                           s.code, s.msg, videoInfo), timeout=1)
        except Exception:
            logger.error("消息监听异常：{}, requestId: {}", format_exc(), message['request_id'])
            videoInfo = [{"id": url.get("id"), "status": PushStreamStatus.FAILED.value[0]} for url in
                         message.get("video_urls", []) if url.get("id") is not None]
            put_queue(self.__fbQueue, pull_stream_feedback(message.get("request_id"), ExecuteStatus.FAILED.value[0],
                                                           ExceptionType.SERVICE_INNER_EXCEPTION.value[0],
                                                           ExceptionType.SERVICE_INNER_EXCEPTION.value[1], videoInfo),
                      timeout=1)
        finally:
            del message

    def recording_method(self, handle_method, message, analysisType):
        try:
            check_cude_is_available()
            handle_method(message, analysisType)
        except ServiceException as s:
            logger.error("消息监听异常：{}, requestId: {}", s.msg, message["request_id"])
            put_queue(self.__fbQueue,
                      recording_feedback(message["request_id"], RecordingStatus.RECORDING_FAILED.value[0],
                                         error_code=s.code, error_msg=s.msg), timeout=1)
        except Exception:
            logger.error("消息监听异常：{}, requestId: {}", format_exc(), message["request_id"])
            put_queue(self.__fbQueue,
                      recording_feedback(message["request_id"], RecordingStatus.RECORDING_FAILED.value[0],
                                         ExceptionType.SERVICE_INNER_EXCEPTION.value[0],
                                         ExceptionType.SERVICE_INNER_EXCEPTION.value[1]), timeout=1)
        finally:
            del message

    # 开启实时进程
    def startOnlineProcess(self, msg, analysisType):
        if self.__listeningProcesses.get(msg["request_id"]):
            logger.warning("实时重复任务，请稍后再试！requestId:{}", msg["request_id"])
            return
        model_type = self.__context["service"]["model"]["model_type"]
        codes = [model.get("code") for model in msg["models"] if model.get("code")]
        if ModelMethodTypeEnum.NORMAL.value == model_type or ModelType.ILLPARKING_MODEL.value[1] in codes:
            coir = OnlineIntelligentRecognitionProcess(self.__fbQueue, msg, analysisType, self.__context)
        else:
            coir = OnlineIntelligentRecognitionProcess2(self.__fbQueue, msg, analysisType, self.__context)
        coir.start()
        logger.info("开始实时进程！requestId:{},pid:{}, ppid:{}",  msg["request_id"],os.getpid(),os.getppid())
        self.__listeningProcesses[msg["request_id"]] = coir

    # 结束实时进程
    def stopOnlineProcess(self, msg):
        ps = self.__listeningProcesses.get(msg["request_id"])
        if ps is None:
            logger.warning("未查询到该任务，无法停止任务！requestId:{}", msg["request_id"])
            return
        ps.sendEvent({"command": "stop"})
        
    # 新增该函数用于，向子任务发送命令（algStart，algStop）
    def sendCmdToChildProcess(self, msg,cmd="algStart"):
        ps = self.__listeningProcesses.get(msg["request_id"])
        if ps is None:
            logger.warning("未查询到该任务，无法停止任务！requestId:{}", msg["request_id"])
            return
        ps.sendEvent({"command": cmd})    

    @staticmethod
    def check_process(listeningProcess):
        for requestId in list(listeningProcess.keys()):
            if not listeningProcess[requestId].is_alive():
                del listeningProcess[requestId]

    def check_process_task(self):
        self.check_process(self.__listeningProcesses)
        self.check_process(self.__recordingProcesses)
        self.check_process(self.__pull2PushProcesses)

    # 开启离线进程
    def startOfflineProcess(self, msg, analysisType):
        if self.__listeningProcesses.get(msg["request_id"]):
            logger.warning("离线重复任务，请稍后再试！requestId:{}", msg["request_id"])
            return
        model_type = self.__context["service"]["model"]["model_type"]
        codes = [model.get("code") for model in msg["models"] if model.get("code")]
        if ModelMethodTypeEnum.NORMAL.value == model_type:
            first = OfflineIntelligentRecognitionProcess(self.__fbQueue, msg, analysisType, self.__context)
        else:
            first = OfflineIntelligentRecognitionProcess2(self.__fbQueue, msg, analysisType, self.__context)
        first.start()
        self.__listeningProcesses[msg["request_id"]] = first

    # 结束离线进程
    def stopOfflineProcess(self, msg):
        ps = self.__listeningProcesses.get(msg["request_id"])
        if ps is None:
            logger.warning("未查询到该任务，无法停止任务！requestId:{}", msg["request_id"])
            return
        ps.sendEvent({"command": "stop"})

    # 开启图片分析进程
    def startImageProcess(self, msg, analysisType):
        pp = self.__listeningProcesses.get(msg["request_id"])
        if pp is not None:
            logger.warning("重复任务，请稍后再试！requestId:{}", msg["request_id"])
            return
        model_type = self.__context["service"]["model"]["model_type"]
        codes = [model.get("code") for model in msg["models"] if model.get("code")]
        if ModelMethodTypeEnum.NORMAL.value == model_type or ModelType.ILLPARKING_MODEL.value[1] in codes:
            imaged = PhotosIntelligentRecognitionProcess(self.__fbQueue, msg, analysisType, self.__context)
        else:
            imaged = PhotosIntelligentRecognitionProcess2(self.__fbQueue, msg, analysisType, self.__context)
        # 创建在线识别进程并启动
        imaged.start()
        self.__listeningProcesses[msg["request_id"]] = imaged

    '''
        校验kafka消息
    '''

    @staticmethod
    def check_msg(msg, schema):
        try:
            v = Validator(schema, allow_unknown=True)
            result = v.validate(msg)
            if not result:
                logger.error("参数校验异常: {}, requestId: {}", v.errors, msg["request_id"])
                raise ServiceException(ExceptionType.ILLEGAL_PARAMETER_FORMAT.value[0],
                                       ExceptionType.ILLEGAL_PARAMETER_FORMAT.value[1])
        except ServiceException as s:
            raise s
        except Exception:
            logger.error("参数校验异常: {}, requestId: {}", format_exc(), msg["request_id"])
            raise ServiceException(ExceptionType.ILLEGAL_PARAMETER_FORMAT.value[0],
                                   ExceptionType.ILLEGAL_PARAMETER_FORMAT.value[1])

    '''
        开启反馈线程，用于发送消息
    '''

    def start_feedback_thread(self):
        if self.__feedbackThread is None:
            self.__feedbackThread = FeedbackThread(self.__fbQueue, self.__kafka_config)
            self.__feedbackThread.setDaemon(True)
            self.__feedbackThread.start()
            time.sleep(1)
        if self.__feedbackThread and not self.__feedbackThread.is_alive():
            logger.error("反馈线程异常停止, 开始重新启动反馈线程！！！！！")
            self.__feedbackThread = FeedbackThread(self.__fbQueue, self.__kafka_config)
            self.__feedbackThread.setDaemon(True)
            self.__feedbackThread.start()
            time.sleep(1)

    def start_uploadGPU_thread(self):
        if self.__uploadGPUThread is None:
            self.__uploadGPUThread = uploadGPUinfos(self.__context, self.__kafka_config)
            self.__uploadGPUThread.setDaemon(True)
            self.__uploadGPUThread.start()
            time.sleep(1)
        if self.__uploadGPUThread and not self.__uploadGPUThread.is_alive():
            logger.error("反馈线程异常停止, 开始重新启动反馈线程！！！！！")
            self.__uploadGPUThread = uploadGPUinfos(self.__context, self.__kafka_config)
            self.__uploadGPUThread.setDaemon(True)
            self.__uploadGPUThread.start()
            time.sleep(1)
    
    '''
    在线分析逻辑
    '''

    def online0(self, message, analysisType):
        if "start" == message.get("command"):
            self.check_msg(message, ONLINE_START_SCHEMA)
            if len(self.__listeningProcesses) >= int(self.__context['service']["task"]["limit"]):
                raise ServiceException(ExceptionType.NO_RESOURCES.value[0],
                                       ExceptionType.NO_RESOURCES.value[1])
            self.startOnlineProcess(message, analysisType)
        elif  message.get("command") in ["algStart","algStop"]: 
            self.sendCmdToChildProcess(message,cmd=message.get("command"))
        elif "stop" == message.get("command"):
            self.check_msg(message, ONLINE_STOP_SCHEMA)
            self.stopOnlineProcess(message)
        else:
            raise ServiceException(ExceptionType.ILLEGAL_PARAMETER_FORMAT.value[0],
                                   ExceptionType.ILLEGAL_PARAMETER_FORMAT.value[1])


    def online(self, message, analysisType):
        if "start" == message.get("command"):
            self.check_msg(message, ONLINE_START_SCHEMA)
            if len(self.__listeningProcesses) >= int(self.__context['service']["task"]["limit"]):
                raise ServiceException(ExceptionType.NO_RESOURCES.value[0],
                                       ExceptionType.NO_RESOURCES.value[1])
            self.startOnlineProcess(message, analysisType)
            
        elif  message.get("command") in ["algStart","algStop"]: 
            
            if message.get("defaultEnabled",True):
                self.sendCmdToChildProcess(message,cmd=message.get("command"))  
                
              
        elif "stop" == message.get("command"):
            self.check_msg(message, ONLINE_STOP_SCHEMA)
            self.stopOnlineProcess(message)
        else:
            raise ServiceException(ExceptionType.ILLEGAL_PARAMETER_FORMAT.value[0],
                                   ExceptionType.ILLEGAL_PARAMETER_FORMAT.value[1])




    def offline(self, message, analysisType):
        if "start" == message.get("command"):
            self.check_msg(message, OFFLINE_START_SCHEMA)
            if len(self.__listeningProcesses) >= int(self.__context['service']["task"]["limit"]):
                raise ServiceException(ExceptionType.NO_RESOURCES.value[0],
                                       ExceptionType.NO_RESOURCES.value[1])
            self.startOfflineProcess(message, analysisType)
        elif  message.get("command") in ["algStart","algStop"]: 
            self.sendCmdToChildProcess( message,cmd=message.get("command"))    
        elif "stop" == message.get("command"):
            self.check_msg(message, OFFLINE_STOP_SCHEMA)
            self.stopOfflineProcess(message)
        else:
            raise ServiceException(ExceptionType.ILLEGAL_PARAMETER_FORMAT.value[0],
                                   ExceptionType.ILLEGAL_PARAMETER_FORMAT.value[1])

    def image(self, message, analysisType):
        if "start" == message.get("command"):
            self.check_msg(message, IMAGE_SCHEMA)
            if len(self.__listeningProcesses) >= int(self.__context['service']["task"]["image"]["limit"]):
                raise ServiceException(ExceptionType.NO_RESOURCES.value[0],
                                       ExceptionType.NO_RESOURCES.value[1])
            self.startImageProcess(message, analysisType)
        else:
            raise ServiceException(ExceptionType.ILLEGAL_PARAMETER_FORMAT.value[0],
                                   ExceptionType.ILLEGAL_PARAMETER_FORMAT.value[1])

    def recording(self, message, analysisType):
        if "start" == message.get("command"):
            self.check_msg(message, RECORDING_START_SCHEMA)
            if len(self.__recordingProcesses) >= int(self.__context['service']["task"]["limit"]):
                raise ServiceException(ExceptionType.NO_RESOURCES.value[0],
                                       ExceptionType.NO_RESOURCES.value[1])
            self.startRecordingProcess(message, analysisType)
        elif "stop" == message.get("command"):
            self.check_msg(message, RECORDING_STOP_SCHEMA)
            self.stopRecordingProcess(message)
        else:
            raise ServiceException(ExceptionType.ILLEGAL_PARAMETER_FORMAT.value[0],
                                   ExceptionType.ILLEGAL_PARAMETER_FORMAT.value[1])

    # 开启录屏进程
    def startRecordingProcess(self, msg, analysisType):
        if self.__listeningProcesses.get(msg["request_id"]):
            logger.warning("重复任务，请稍后再试！requestId:{}", msg["request_id"])
            return
        srp = ScreenRecordingProcess(self.__fbQueue, self.__context, msg, analysisType)
        srp.start()
        self.__recordingProcesses[msg["request_id"]] = srp

    # 结束录屏进程
    def stopRecordingProcess(self, msg):
        rdp = self.__recordingProcesses.get(msg["request_id"])
        if rdp is None:
            logger.warning("未查询到该任务，无法停止任务！requestId:{}", msg["request_id"])
            return
        rdp.sendEvent({"command": "stop"})

    def pullStream(self, message, analysisType):
        if "start" == message.get("command"):
            self.check_msg(message, PULL2PUSH_START_SCHEMA)
            if len(self.__pull2PushProcesses) >= int(self.__context['service']["task"]["limit"]):
                raise ServiceException(ExceptionType.NO_RESOURCES.value[0],
                                       ExceptionType.NO_RESOURCES.value[1])

            self.startPushStreamProcess(message, analysisType)
        elif "stop" == message.get("command"):
            self.check_msg(message, PULL2PUSH_STOP_SCHEMA)
            self.stopPushStreamProcess(message)
        else:
            raise ServiceException(ExceptionType.ILLEGAL_PARAMETER_FORMAT.value[0],
                                   ExceptionType.ILLEGAL_PARAMETER_FORMAT.value[1])

    def startPushStreamProcess(self, msg, analysisType):
        if self.__pull2PushProcesses.get(msg["request_id"]):
            logger.warning("重复任务，请稍后再试！requestId:{}", msg["request_id"])
            return
        srp = PushStreamProcess(self.__fbQueue, self.__context, msg, analysisType)
        srp.start()
        self.__pull2PushProcesses[msg["request_id"]] = srp

    # 结束录屏进程
    def stopPushStreamProcess(self, msg):
        srp = self.__pull2PushProcesses.get(msg["request_id"])
        if srp is None:
            logger.warning("未查询到该任务，无法停止任务！requestId:{}", msg["request_id"])
            return
        srp.sendEvent({"command": "stop", "videoIds": msg.get("video_ids", [])})
