scbc_repos/ssat_sdk/service/service_manager.py

# -*- coding:utf-8 -*-
import os
import sys
import time
from multiprocessing import Process
import thread
from multiprocessing.connection import Listener, Client

from ssat_sdk.core.ibinder_listener import *
from ccard_service import *
from tg39_service import *
from chroma_22293_service import *
from redrat_service import *
from sound_service import *
from TC_UB530_service import *
from ssat_sdk.utils import string_util
import subprocess

serviceConfig = ServiceConfig()


class ServiceManager():
    def __init__(self):
        self.ccardService = None
        self.tg39Service = None
        self.c22293Service = None
        self.redratService = None
        self.soundService = None
        self.ub530Service = None
        self.errMsg = ""

    def initService(self, service_name):
        print u"启动Service:", service_name
        if CCardService.Service_Name == service_name:
            self.ccardService = CCardService()
            staus, msg = self.ccardService.initCCard()
            if staus == 0:
                self.errMsg = msg
        elif TG39Service.Service_Name == service_name:
            self.tg39Service = TG39Service()
            staus, msg = self.tg39Service.initTG39()
            if staus == 0:
                self.errMsg = msg
        elif C22293Service.Service_Name == service_name:
            self.c22293Service = C22293Service()
            staus, msg = self.c22293Service.initC22293()
            if staus == 0:
                self.errMsg = msg
        elif RedRatService.Service_Name == service_name:
            self.redratService = RedRatService()
            staus, msg = self.redratService.initRedRat()
            if staus == 0:
                self.errMsg = msg
        elif SoundCollectionService.Service_Name == service_name:
            self.soundService = SoundCollectionService()
            staus, msg = self.soundService.initSoundCollection()
            if staus == 0:
                self.errMsg = msg
        elif string_util.strcmp(TC_UB530Service.Service_Name, service_name):
            baseDir = os.path.dirname(__file__)
            exe = os.path.join(baseDir, "TC_UB530_service.py")
            cmd = "python " + exe + " " + str(os.getpid())
            self.ub530Service = subprocess.Popen(cmd)
            # self.ub530Service = TC_UB530Service()
            # self.ub530Service.startService()

        print u"退出Service:", service_name

    def startSDKServer(self):
        print u"启动SDK服务"
        self.onOff = True
        self.service_process = Process(target=self.startBGServer, args=())
        self.service_process.start()

    def startSDKServer2(self):
        print u"启动SDK服务"
        self.onOff = True
        self.startServerTerminal()

    def startServerTerminal(self):
        print u"启动Server控制台"
        inline = ""
        while inline <> "exit":
            print u"输入命令:"
            inline = raw_input()
            if inline.__len__() < 1:
                continue
            self.parseCmd(inline)

    def startBGServer(self):
        print u"已启动后台服务进程"
        # 采用listener监听服务指令
        while (True):
            binder = ListenerBinder(port=30500)
            self.listener, port = binder.createListener()
            serviceConfig.setSDKListenerPort(port)
            conn = self.listener.accept()
            cmd = conn.recv()
            self.parseCmd(cmdLine=cmd)
            # print u"服务指令：",cmd
            conn.send(u"指令完成")

    def parseCmd(self, cmdLine):
        print u"SDK服务接受指令：", cmdLine
        cmdParam = self.rmNULFrom(cmdLine.split(" "))
        if (cmdParam.__len__() < 2):
            print u"请输入正确命令"
            return False
        command = cmdParam[0]
        param = cmdParam[1]
        self.excuteCmd(command, param)

    def excuteCmd(self, command, param):
        if (command == "start"):
            self.startServiceThread(param)

    def startServiceThread(self, service_name):
        if (service_name == CCardService.Service_Name):
            if (self.ccardService == None) or (self.ccardService.getStatus() == 0):
                thread.start_new_thread(
                    self.initService, (CCardService.Service_Name,))
            else:
                print u"视频采集卡已经启动"

        elif (service_name == TG39Service.Service_Name):
            if self.tg39Service == None or (self.tg39Service.status == 0):
                thread.start_new_thread(
                    self.initService, (TG39Service.Service_Name,))
            else:
                print u"TG39已经启动"

        elif (service_name == C22293Service.Service_Name):
            if self.c22293Service == None or (self.c22293Service.status == 0):
                thread.start_new_thread(
                    self.initService, (C22293Service.Service_Name,))
            else:
                print u"c22293已经启动"
        elif (service_name == "all"):
            if self.ccardService == None or (self.ccardService.status == 0):
                thread.start_new_thread(
                    self.initService, (CCardService.Service_Name,))
            else:
                print u"视频采集卡已经启动"
            if self.tg39Service == None or (self.tg39Service.status == 0):
                thread.start_new_thread(
                    self.initService, (TG39Service.Service_Name,))
            else:
                print u"TG39已经启动"
        elif (service_name == RedRatService.Service_Name):
            if self.redratService == None or (self.redratService.status == 0):
                thread.start_new_thread(
                    self.initService, (RedRatService.Service_Name,))
            else:
                print u"红老鼠已经启动"
        elif (service_name == SoundCollectionService.Service_Name):
            if self.soundService == None or (self.soundService.status == 0):
                thread.start_new_thread(
                    self.initService, (SoundCollectionService.Service_Name,))
            else:
                print u"声音采集器已经启动"
        elif (service_name == TC_UB530Service.Service_Name):
            # self.initService(TC_UB530Service.Service_Name)
            if self.ub530Service is None:
                thread.start_new_thread(
                    self.initService, (TC_UB530Service.Service_Name,))
            else:
                print u"UB530视频采集器已经启动"

    '''
    return:0代表设备服务不可用，1代表设备服务正常运行；-1 代表没有此类设备。
    '''

    def getServiceStatus(self, service_name):
        if TG39Service.Service_Name == service_name:
            if self.tg39Service == None or (self.tg39Service.status == 0):
                return 0
            else:
                return 1
        elif CCardService.Service_Name == service_name:
            if self.ccardService == None or self.ccardService.status == 0:
                return 0
            else:
                return 1
        elif C22293Service.Service_Name == service_name:
            if self.c22293Service == None or self.c22293Service.status == 0:
                return 0
            else:
                return 1
        elif RedRatService.Service_Name == service_name:
            if self.redratService == None or self.redratService.status == 0:
                return 0
            else:
                return 1
        elif (service_name == TC_UB530Service.Service_Name):
            # self.initService(TC_UB530Service.Service_Name)
            if self.ub530Service is None and self.ub530Service.poll() is None:
                return 0
            else:
                return 1
        return -1

    def rmNULFrom(self, strArr):
        destArr = []
        for i in range(strArr.__len__()):
            item = strArr[i]
            if (item <> ''):
                destArr.append(item)
        return destArr


class ServiceClient():
    def __init__(self):
        print u"初始化Server控制台"
        self.port = serviceConfig.getSDKListenerPort()

    def startTerminal(self):
        print u"启动Server控制台"
        inline = ""
        while inline <> "exit":
            print u"输入命令:"
            inline = raw_input()
            if inline.__len__() < 1:
                continue
            self.executeCommand(inline)

    def executeCommand(self, inline):
        # print u"执行命令：", inline
        conn = Client(("localhost", self.port), authkey="sat")
        conn.send(inline)
        result = conn.recv()
        print u"执行结果：", result
        conn.close()


if __name__ == "__main__":
    # if (sys.argv.__len__() > 1) and ("server" == sys.argv[1]):
    #     sManager = ServiceManager()
    #     sManager.startSDKServer()
    # elif (sys.argv.__len__() > 1) and ("client" == sys.argv[1]):
    #     sClient = ServiceClient()
    #     sClient.startTerminal()
    # else:
    #     sManager = ServiceManager()
    #     sManager.startSDKServer2()
    sManager = ServiceManager()
    sManager.startServiceThread("ub530")

    while 1:
        pass