示例#1
0
class ServiceClient(IClientHandler):
    HTTP_HOST = 'http_host'
    VODS_HOST = 'vods_host'
    CODS_HOST = 'cods_host'
    SUBSCRIBERS_HOST = 'subscribers_host'
    BANDWIDTH_HOST = 'bandwidth_host'
    VERSION = 'version'
    OS = 'os'

    @staticmethod
    def get_log_service_path(host: str, port: int, sid: str):
        return constants.DEFAULT_SERVICE_LOG_PATH_TEMPLATE_3SIS.format(
            host, port, sid)

    @staticmethod
    def get_log_stream_path(host: str, port: int, stream_id: str):
        return constants.DEFAULT_STREAM_LOG_PATH_TEMPLATE_3SIS.format(
            host, port, stream_id)

    @staticmethod
    def get_pipeline_stream_path(host: str, port: int, stream_id: str):
        return constants.DEFAULT_STREAM_PIPELINE_PATH_TEMPLATE_3SIS.format(
            host, port, stream_id)

    def __init__(self, sid: ObjectId, host: str, port: int,
                 handler: IStreamHandler):
        self.id = sid
        self._request_id = 0
        self._handler = handler
        self._client = FastoCloudClient(host, port, self)
        self._set_runtime_fields()

    def connect(self):
        self._client.connect()

    def is_connected(self):
        return self._client.is_connected()

    def socket(self):
        return self._client.socket()

    def recv_data(self):
        data = self._client.read_command()
        self._client.process_commands(data)

    def status(self) -> ClientStatus:
        return self._client.status()

    def disconnect(self):
        self._client.disconnect()

    def activate(self, license_key: str):
        return self._client.activate(self._gen_request_id(), license_key)

    def ping_service(self):
        return self._client.ping_service(self._gen_request_id())

    def stop_service(self, delay: int):
        return self._client.stop_service(self._gen_request_id(), delay)

    def get_log_service(self, host: str, port: int):
        return self._client.get_log_service(
            self._gen_request_id(),
            ServiceClient.get_log_service_path(host, port, str(self.id)))

    def start_stream(self, config: dict):
        return self._client.start_stream(self._gen_request_id(), config)

    def stop_stream(self, stream_id: str):
        return self._client.stop_stream(self._gen_request_id(), stream_id)

    def restart_stream(self, stream_id: str):
        return self._client.restart_stream(self._gen_request_id(), stream_id)

    def get_log_stream(self, host: str, port: int, stream_id: str,
                       feedback_directory: str):
        return self._client.get_log_stream(
            self._gen_request_id(), stream_id, feedback_directory,
            ServiceClient.get_log_stream_path(host, port, stream_id))

    def get_pipeline_stream(self, host: str, port: int, stream_id: str,
                            feedback_directory: str):
        return self._client.get_pipeline_stream(
            self._gen_request_id(), stream_id, feedback_directory,
            ServiceClient.get_pipeline_stream_path(host, port, stream_id))

    def sync_service(self, settings):
        if not settings:
            return

        streams = []
        for stream in settings.streams:
            stream.set_server_settings(settings)
            streams.append(stream.config())

        subscribers = []
        for subs in settings.subscribers:
            conf = subs.to_service(settings)
            subscribers.append(conf)

        return self._client.sync_service(self._gen_request_id(), streams,
                                         subscribers)

    def prepare_service(self, settings):
        if not settings:
            return

        return self._client.prepare_service(
            self._gen_request_id(), settings.feedback_directory,
            settings.timeshifts_directory, settings.hls_directory,
            settings.playlists_directory, settings.dvb_directory,
            settings.capture_card_directory, settings.vods_in_directory,
            settings.vods_directory, settings.cods_directory)

    def get_http_host(self) -> str:
        return self._http_host

    def get_os(self) -> OperationSystem:
        return self._os

    def get_vods_host(self) -> str:
        return self._vods_host

    def get_cods_host(self) -> str:
        return self._cods_host

    def get_subscribers_host(self) -> str:
        return self._subscribers_host

    def get_bandwidth_host(self) -> str:
        return self._bandwidth_host

    def get_vods_in(self) -> list:
        return self._vods_in

    def get_version(self) -> str:
        return self._version

    # handler
    def process_response(self, req: Request, resp: Response):
        if not req:
            return

        if req.method == Commands.ACTIVATE_COMMAND and resp.is_message():
            if self._handler:
                result = resp.result
                subscribers_host = result.get(ServiceClient.SUBSCRIBERS_HOST,
                                              None)
                bandwidth_host = result.get(ServiceClient.BANDWIDTH_HOST, None)

                os = OperationSystem(**result[ServiceClient.OS])

                self._set_runtime_fields(result[ServiceClient.HTTP_HOST],
                                         result[ServiceClient.VODS_HOST],
                                         result[ServiceClient.CODS_HOST],
                                         subscribers_host, bandwidth_host,
                                         result[ServiceClient.VERSION], os)
                self._handler.on_service_statistic_received(result)

        if req.method == Commands.PREPARE_SERVICE_COMMAND and resp.is_message(
        ):
            for directory in resp.result:
                if Fields.VODS_IN_DIRECTORY in directory:
                    self._vods_in = directory[
                        Fields.VODS_IN_DIRECTORY]['content']
                    break

    def process_request(self, req: Request):
        if not req:
            return

        if not self._handler:
            return

        if req.method == Commands.STATISTIC_STREAM_COMMAND:
            self._handler.on_stream_statistic_received(req.params)
        elif req.method == Commands.CHANGED_STREAM_COMMAND:
            self._handler.on_stream_sources_changed(req.params)
        elif req.method == Commands.STATISTIC_SERVICE_COMMAND:
            self._handler.on_service_statistic_received(req.params)
        elif req.method == Commands.QUIT_STATUS_STREAM_COMMAND:
            self._handler.on_quit_status_stream(req.params)
        elif req.method == Commands.CLIENT_PING_COMMAND:
            self._handler.on_ping_received(req.params)

    def on_client_state_changed(self, status: ClientStatus):
        if status != ClientStatus.ACTIVE:
            self._set_runtime_fields()
        if self._handler:
            self._handler.on_client_state_changed(status)

    # private
    def _set_runtime_fields(self,
                            http_host=None,
                            vods_host=None,
                            cods_host=None,
                            subscribers_host=None,
                            bandwidth_host=None,
                            version=None,
                            os=None,
                            vods_in=None):
        self._http_host = http_host
        self._vods_host = vods_host
        self._cods_host = cods_host
        self._subscribers_host = subscribers_host
        self._bandwidth_host = bandwidth_host
        self._version = version
        self._os = os
        self._vods_in = vods_in

    def _gen_request_id(self) -> int:
        current_value = self._request_id
        self._request_id += 1
        return current_value
示例#2
0
class ServiceClient(IClientHandler):
    HTTP_HOST = 'http_host'
    VODS_HOST = 'vods_host'
    CODS_HOST = 'cods_host'
    PROJECT = 'project'
    VERSION = 'version'
    EXP_TIME = 'expiration_time'
    OS = 'os'

    @staticmethod
    def get_log_service_path(host: str, port: int, sid: str):
        return constants.DEFAULT_SERVICE_LOG_PATH_TEMPLATE_3SIS.format(
            host, port, sid)

    @staticmethod
    def get_log_stream_path(host: str, port: int, stream_id: str):
        return constants.DEFAULT_STREAM_LOG_PATH_TEMPLATE_3SIS.format(
            host, port, stream_id)

    @staticmethod
    def get_pipeline_stream_path(host: str, port: int, stream_id: str):
        return constants.DEFAULT_STREAM_PIPELINE_PATH_TEMPLATE_3SIS.format(
            host, port, stream_id)

    def __init__(self, sid: ObjectId, host: str, port: int,
                 handler: IStreamHandler):
        self.id = sid
        self._request_id = 0
        self._handler = handler
        self._client = FastoCloudClient(host, port, self, gsocket)
        self._set_runtime_fields()

    def connect(self):
        self._client.connect()

    def is_connected(self):
        return self._client.is_connected()

    def socket(self):
        return self._client.socket()

    def recv_data(self) -> bool:
        data = self._client.read_command()
        if not data:
            return False

        self._client.process_commands(data)
        return True

    def status(self) -> ClientStatus:
        return self._client.status()

    def disconnect(self):
        self._client.disconnect()

    def activate(self, license_key: str) -> RequestReturn:
        return self._client.activate(self._gen_request_id(), license_key)

    def ping_service(self) -> RequestReturn:
        return self._client.ping(self._gen_request_id())

    def stop_service(self, delay: int) -> RequestReturn:
        return self._client.stop_service(self._gen_request_id(), delay)

    def get_log_service(self, host: str, port: int) -> RequestReturn:
        return self._client.get_log_service(
            self._gen_request_id(),
            ServiceClient.get_log_service_path(host, port, str(self.id)))

    def start_stream(self, config: dict) -> RequestReturn:
        return self._client.start_stream(self._gen_request_id(), config)

    def stop_stream(self, stream_id: str) -> RequestReturn:
        return self._client.stop_stream(self._gen_request_id(), stream_id)

    def restart_stream(self, stream_id: str) -> RequestReturn:
        return self._client.restart_stream(self._gen_request_id(), stream_id)

    def get_log_stream(self, host: str, port: int, stream_id: str,
                       feedback_directory: str) -> RequestReturn:
        return self._client.get_log_stream(
            self._gen_request_id(), stream_id, feedback_directory,
            ServiceClient.get_log_stream_path(host, port, stream_id))

    def get_pipeline_stream(self, host: str, port: int, stream_id: str,
                            feedback_directory: str) -> RequestReturn:
        return self._client.get_pipeline_stream(
            self._gen_request_id(), stream_id, feedback_directory,
            ServiceClient.get_pipeline_stream_path(host, port, stream_id))

    def sync_service(self, streams_objects) -> RequestReturn:
        streams = []
        for streams_object in streams_objects:
            config = streams_object.config()
            streams.append(config)

        return self._client.sync_service(self._gen_request_id(), streams)

    def prepare_service(self, settings) -> RequestReturn:
        if not settings:
            return False, None

        return self._client.prepare_service(
            self._gen_request_id(), settings.feedback_directory,
            settings.timeshifts_directory, settings.hls_directory,
            settings.vods_directory, settings.cods_directory,
            settings.proxy_directory)

    @property
    def http_host(self) -> str:
        return self._http_host

    @property
    def os(self) -> OperationSystem:
        return self._os

    @property
    def vods_host(self) -> str:
        return self._vods_host

    @property
    def cods_host(self) -> str:
        return self._cods_host

    @property
    def project(self) -> str:
        return self._project

    @property
    def version(self) -> str:
        return self._version

    @property
    def exp_time(self):
        return self._exp_time

    # handler
    def process_response(self, client, req: Request, resp: Response):
        if not req:
            return

        if req.method == Commands.ACTIVATE_COMMAND and resp.is_message():
            if self._handler:
                result = resp.result

                os = OperationSystem(**result[ServiceClient.OS])

                self._set_runtime_fields(result[ServiceClient.HTTP_HOST],
                                         result[ServiceClient.VODS_HOST],
                                         result[ServiceClient.CODS_HOST],
                                         result[ServiceClient.PROJECT],
                                         result[ServiceClient.VERSION], os,
                                         result[ServiceClient.EXP_TIME])
                self._handler.on_service_statistic_received(result)

        if req.method == Commands.PREPARE_SERVICE_COMMAND and resp.is_message(
        ):
            pass

    def process_request(self, client, req: Request):
        if not req:
            return

        if not self._handler:
            return

        if req.method == Commands.STATISTIC_STREAM_COMMAND:
            assert req.is_notification()
            self._handler.on_stream_statistic_received(req.params)
        elif req.method == Commands.CHANGED_STREAM_COMMAND:
            assert req.is_notification()
            self._handler.on_stream_sources_changed(req.params)
        elif req.method == Commands.ML_NOTIFICATION_STREAM_COMMAND:
            assert req.is_notification()
            self._handler.on_stream_ml_notification(req.params)
        elif req.method == Commands.STATISTIC_SERVICE_COMMAND:
            assert req.is_notification()
            self._handler.on_service_statistic_received(req.params)
        elif req.method == Commands.QUIT_STATUS_STREAM_COMMAND:
            assert req.is_notification()
            self._handler.on_quit_status_stream(req.params)
        elif req.method == Commands.CLIENT_PING_COMMAND:
            self._handler.on_ping_received(req.params)

    def on_client_state_changed(self, client, status: ClientStatus):
        if status != ClientStatus.ACTIVE:
            self._set_runtime_fields()
        if self._handler:
            self._handler.on_client_state_changed(status)

    # private
    def _set_runtime_fields(self,
                            http_host=None,
                            vods_host=None,
                            cods_host=None,
                            project=None,
                            version=None,
                            os=None,
                            exp_time=None):
        self._http_host = http_host
        self._vods_host = vods_host
        self._cods_host = cods_host
        self._project = project
        self._version = version
        self._exp_time = exp_time
        self._os = os

    def _gen_request_id(self) -> int:
        current_value = self._request_id
        self._request_id += 1
        return current_value