def __init__(self, config_file=None):
        self.stopped = False
        self.__lock = RLock()
        if config_file is None:
            config_file = path.dirname(path.dirname(
                path.abspath(__file__))) + '/config/tb_gateway.yaml'.replace(
                    '/', path.sep)
        with open(config_file) as general_config:
            config = safe_load(general_config)
        self._config_dir = path.dirname(path.abspath(config_file)) + path.sep
        logging_error = None
        try:
            logging.config.fileConfig(self._config_dir + "logs.conf",
                                      disable_existing_loggers=False)
        except Exception as e:
            logging_error = e
        global log
        log = logging.getLogger('service')
        log.info("Gateway starting...")
        self.__updater = TBUpdater()
        self.__updates_check_period_ms = 300000
        self.__updates_check_time = 0
        self.version = self.__updater.get_version()
        log.info("ThingsBoard IoT gateway version: %s",
                 self.version["current_version"])
        self.available_connectors = {}
        self.__connector_incoming_messages = {}
        self.__connected_devices = {}
        self.__saved_devices = {}
        self.__events = []
        self.name = ''.join(choice(ascii_lowercase) for _ in range(64))
        self.__rpc_register_queue = Queue(-1)
        self.__rpc_requests_in_progress = {}
        self.__connected_devices_file = "connected_devices.json"
        self.tb_client = TBClient(config["thingsboard"])
        self.tb_client.connect()
        self.subscribe_to_required_topics()
        self.__subscribed_to_rpc_topics = True
        if logging_error is not None:
            self.tb_client.client.send_telemetry({
                "ts": time() * 1000,
                "values": {
                    "LOGS":
                    "Logging loading exception, logs.conf is wrong: %s" %
                    (str(logging_error), )
                }
            })
            TBLoggerHandler.set_default_handler()
        self.counter = 0
        self.__rpc_reply_sent = False
        global main_handler
        self.main_handler = main_handler
        self.remote_handler = TBLoggerHandler(self)
        self.main_handler.setTarget(self.remote_handler)
        self._default_connectors = DEFAULT_CONNECTORS
        self._implemented_connectors = {}
        self._event_storage_types = {
            "memory": MemoryEventStorage,
            "file": FileEventStorage,
        }
        self.__gateway_rpc_methods = {
            "ping": self.__rpc_ping,
            "stats": self.__form_statistics,
            "devices": self.__rpc_devices,
            "update": self.__rpc_update,
        }
        self.__sheduled_rpc_calls = []
        self.__self_rpc_sheduled_methods_functions = {
            "restart": {
                "function": execv,
                "arguments":
                (executable, [executable.split(pathsep)[-1]] + argv)
            },
            "reboot": {
                "function": system,
                "arguments": ("reboot 0", )
            },
        }
        self._event_storage = self._event_storage_types[
            config["storage"]["type"]](config["storage"])
        self.connectors_configs = {}
        self._load_connectors(config)
        self._connect_with_connectors()
        self.__remote_configurator = None
        self.__request_config_after_connect = False
        if config["thingsboard"].get("remoteConfiguration"):
            try:
                self.__remote_configurator = RemoteConfigurator(self, config)
            except Exception as e:
                log.exception(e)
        if self.__remote_configurator is not None:
            self.__remote_configurator.send_current_configuration()
        self.__load_persistent_devices()
        self._published_events = Queue(-1)
        self._send_thread = Thread(target=self.__read_data_from_storage,
                                   daemon=True,
                                   name="Send data to Thingsboard Thread")
        self._send_thread.start()
        log.info("Gateway started.")

        try:
            gateway_statistic_send = 0
            while not self.stopped:
                cur_time = time() * 1000
                if not self.tb_client.is_connected(
                ) and self.__subscribed_to_rpc_topics:
                    self.__subscribed_to_rpc_topics = False
                if self.tb_client.is_connected(
                ) and not self.__subscribed_to_rpc_topics:
                    for device in self.__saved_devices:
                        self.add_device(
                            device, {
                                "connector":
                                self.__saved_devices[device]["connector"]
                            },
                            True,
                            device_type=self.__saved_devices[device]
                            ["device_type"])
                    self.subscribe_to_required_topics()
                    self.__subscribed_to_rpc_topics = True
                if self.__sheduled_rpc_calls:
                    for rpc_call_index in range(len(
                            self.__sheduled_rpc_calls)):
                        rpc_call = self.__sheduled_rpc_calls[rpc_call_index]
                        if cur_time > rpc_call[0]:
                            rpc_call = self.__sheduled_rpc_calls.pop(
                                rpc_call_index)
                            result = None
                            try:
                                result = rpc_call[1]["function"](
                                    *rpc_call[1]["arguments"])
                            except Exception as e:
                                log.exception(e)
                            if result == 256:
                                log.warning(
                                    "Error on RPC command: 256. Permission denied."
                                )
                if (self.__rpc_requests_in_progress
                        or not self.__rpc_register_queue.empty()
                    ) and self.tb_client.is_connected():
                    new_rpc_request_in_progress = {}
                    if self.__rpc_requests_in_progress:
                        for rpc_in_progress, data in self.__rpc_requests_in_progress.items(
                        ):
                            if cur_time >= data[1]:
                                data[2](rpc_in_progress)
                                self.cancel_rpc_request(rpc_in_progress)
                                self.__rpc_requests_in_progress[
                                    rpc_in_progress] = "del"
                        new_rpc_request_in_progress = {
                            key: value
                            for key, value in
                            self.__rpc_requests_in_progress.items()
                            if value != 'del'
                        }
                    if not self.__rpc_register_queue.empty():
                        rpc_request_from_queue = self.__rpc_register_queue.get(
                            False)
                        topic = rpc_request_from_queue["topic"]
                        data = rpc_request_from_queue["data"]
                        new_rpc_request_in_progress[topic] = data
                    self.__rpc_requests_in_progress = new_rpc_request_in_progress
                else:
                    try:
                        sleep(.1)
                    except Exception as e:
                        log.exception(e)
                        break
                if not self.__request_config_after_connect and self.tb_client.is_connected(
                ) and not self.tb_client.client.get_subscriptions_in_progress(
                ):
                    self.__request_config_after_connect = True
                    self.__check_shared_attributes()

                if cur_time - gateway_statistic_send > 5000.0 and self.tb_client.is_connected(
                ):
                    summary_messages = self.__form_statistics()
                    # with self.__lock:
                    self.tb_client.client.send_telemetry(summary_messages)
                    gateway_statistic_send = time() * 1000
                    # self.__check_shared_attributes()

                if cur_time - self.__updates_check_time >= self.__updates_check_period_ms:
                    self.__updates_check_time = time() * 1000
                    self.version = self.__updater.get_version()
        except KeyboardInterrupt:
            self.__stop_gateway()
        except Exception as e:
            log.exception(e)
            self.__close_connectors()
            log.info("The gateway has been stopped.")
            self.tb_client.stop()
class TBGatewayService:
    def __init__(self, config_file=None):
        self.stopped = False
        self.__lock = RLock()
        if config_file is None:
            config_file = path.dirname(path.dirname(
                path.abspath(__file__))) + '/config/tb_gateway.yaml'.replace(
                    '/', path.sep)
        with open(config_file) as general_config:
            config = safe_load(general_config)
        self._config_dir = path.dirname(path.abspath(config_file)) + path.sep
        logging_error = None
        try:
            logging.config.fileConfig(self._config_dir + "logs.conf",
                                      disable_existing_loggers=False)
        except Exception as e:
            logging_error = e
        global log
        log = logging.getLogger('service')
        log.info("Gateway starting...")
        self.__updater = TBUpdater()
        self.__updates_check_period_ms = 300000
        self.__updates_check_time = 0
        self.version = self.__updater.get_version()
        log.info("ThingsBoard IoT gateway version: %s",
                 self.version["current_version"])
        self.available_connectors = {}
        self.__connector_incoming_messages = {}
        self.__connected_devices = {}
        self.__saved_devices = {}
        self.__events = []
        self.name = ''.join(choice(ascii_lowercase) for _ in range(64))
        self.__rpc_register_queue = Queue(-1)
        self.__rpc_requests_in_progress = {}
        self.__connected_devices_file = "connected_devices.json"
        self.tb_client = TBClient(config["thingsboard"])
        self.tb_client.connect()
        self.subscribe_to_required_topics()
        self.__subscribed_to_rpc_topics = True
        if logging_error is not None:
            self.tb_client.client.send_telemetry({
                "ts": time() * 1000,
                "values": {
                    "LOGS":
                    "Logging loading exception, logs.conf is wrong: %s" %
                    (str(logging_error), )
                }
            })
            TBLoggerHandler.set_default_handler()
        self.counter = 0
        self.__rpc_reply_sent = False
        global main_handler
        self.main_handler = main_handler
        self.remote_handler = TBLoggerHandler(self)
        self.main_handler.setTarget(self.remote_handler)
        self._default_connectors = DEFAULT_CONNECTORS
        self._implemented_connectors = {}
        self._event_storage_types = {
            "memory": MemoryEventStorage,
            "file": FileEventStorage,
        }
        self.__gateway_rpc_methods = {
            "ping": self.__rpc_ping,
            "stats": self.__form_statistics,
            "devices": self.__rpc_devices,
            "update": self.__rpc_update,
        }
        self.__sheduled_rpc_calls = []
        self.__self_rpc_sheduled_methods_functions = {
            "restart": {
                "function": execv,
                "arguments":
                (executable, [executable.split(pathsep)[-1]] + argv)
            },
            "reboot": {
                "function": system,
                "arguments": ("reboot 0", )
            },
        }
        self._event_storage = self._event_storage_types[
            config["storage"]["type"]](config["storage"])
        self.connectors_configs = {}
        self._load_connectors(config)
        self._connect_with_connectors()
        self.__remote_configurator = None
        self.__request_config_after_connect = False
        if config["thingsboard"].get("remoteConfiguration"):
            try:
                self.__remote_configurator = RemoteConfigurator(self, config)
            except Exception as e:
                log.exception(e)
        if self.__remote_configurator is not None:
            self.__remote_configurator.send_current_configuration()
        self.__load_persistent_devices()
        self._published_events = Queue(-1)
        self._send_thread = Thread(target=self.__read_data_from_storage,
                                   daemon=True,
                                   name="Send data to Thingsboard Thread")
        self._send_thread.start()
        log.info("Gateway started.")

        try:
            gateway_statistic_send = 0
            while not self.stopped:
                cur_time = time() * 1000
                if not self.tb_client.is_connected(
                ) and self.__subscribed_to_rpc_topics:
                    self.__subscribed_to_rpc_topics = False
                if self.tb_client.is_connected(
                ) and not self.__subscribed_to_rpc_topics:
                    for device in self.__saved_devices:
                        self.add_device(
                            device, {
                                "connector":
                                self.__saved_devices[device]["connector"]
                            },
                            True,
                            device_type=self.__saved_devices[device]
                            ["device_type"])
                    self.subscribe_to_required_topics()
                    self.__subscribed_to_rpc_topics = True
                if self.__sheduled_rpc_calls:
                    for rpc_call_index in range(len(
                            self.__sheduled_rpc_calls)):
                        rpc_call = self.__sheduled_rpc_calls[rpc_call_index]
                        if cur_time > rpc_call[0]:
                            rpc_call = self.__sheduled_rpc_calls.pop(
                                rpc_call_index)
                            result = None
                            try:
                                result = rpc_call[1]["function"](
                                    *rpc_call[1]["arguments"])
                            except Exception as e:
                                log.exception(e)
                            if result == 256:
                                log.warning(
                                    "Error on RPC command: 256. Permission denied."
                                )
                if (self.__rpc_requests_in_progress
                        or not self.__rpc_register_queue.empty()
                    ) and self.tb_client.is_connected():
                    new_rpc_request_in_progress = {}
                    if self.__rpc_requests_in_progress:
                        for rpc_in_progress, data in self.__rpc_requests_in_progress.items(
                        ):
                            if cur_time >= data[1]:
                                data[2](rpc_in_progress)
                                self.cancel_rpc_request(rpc_in_progress)
                                self.__rpc_requests_in_progress[
                                    rpc_in_progress] = "del"
                        new_rpc_request_in_progress = {
                            key: value
                            for key, value in
                            self.__rpc_requests_in_progress.items()
                            if value != 'del'
                        }
                    if not self.__rpc_register_queue.empty():
                        rpc_request_from_queue = self.__rpc_register_queue.get(
                            False)
                        topic = rpc_request_from_queue["topic"]
                        data = rpc_request_from_queue["data"]
                        new_rpc_request_in_progress[topic] = data
                    self.__rpc_requests_in_progress = new_rpc_request_in_progress
                else:
                    try:
                        sleep(.1)
                    except Exception as e:
                        log.exception(e)
                        break
                if not self.__request_config_after_connect and self.tb_client.is_connected(
                ) and not self.tb_client.client.get_subscriptions_in_progress(
                ):
                    self.__request_config_after_connect = True
                    self.__check_shared_attributes()

                if cur_time - gateway_statistic_send > 5000.0 and self.tb_client.is_connected(
                ):
                    summary_messages = self.__form_statistics()
                    # with self.__lock:
                    self.tb_client.client.send_telemetry(summary_messages)
                    gateway_statistic_send = time() * 1000
                    # self.__check_shared_attributes()

                if cur_time - self.__updates_check_time >= self.__updates_check_period_ms:
                    self.__updates_check_time = time() * 1000
                    self.version = self.__updater.get_version()
        except KeyboardInterrupt:
            self.__stop_gateway()
        except Exception as e:
            log.exception(e)
            self.__close_connectors()
            log.info("The gateway has been stopped.")
            self.tb_client.stop()

    def __close_connectors(self):
        for current_connector in self.available_connectors:
            try:
                self.available_connectors[current_connector].close()
                log.debug("Connector %s closed connection.", current_connector)
            except Exception as e:
                log.exception(e)

    def __stop_gateway(self):
        self.stopped = True
        self.__updater.stop()
        log.info("Stopping...")
        self.__close_connectors()
        log.info("The gateway has been stopped.")
        self.tb_client.stop()

    def _attributes_parse(self, content, *args):
        try:
            log.debug("Received data: %s", content)
            log.debug(args)
            if content is not None:
                shared_attributes = content.get("shared")
                client_attributes = content.get("client")
                new_configuration = shared_attributes.get(
                    "configuration"
                ) if shared_attributes is not None and shared_attributes.get(
                    "configuration") is not None else content.get(
                        "configuration")
                if new_configuration is not None and self.__remote_configurator is not None:
                    try:
                        confirmed = self.__remote_configurator.process_configuration(
                            new_configuration)
                        # if confirmed:
                        # self._send_thread = Thread(target=self.__read_data_from_storage, daemon=True,
                        #                            name="Send data to Thingsboard Thread")
                        # self._send_thread.start()
                        self.__remote_configurator.send_current_configuration()
                    except Exception as e:
                        log.exception(e)
                remote_logging_level = shared_attributes.get(
                    'RemoteLoggingLevel'
                ) if shared_attributes is not None else content.get(
                    "RemoteLoggingLevel")
                if remote_logging_level == 'NONE':
                    self.remote_handler.deactivate()
                    log.info('Remote logging has being deactivated.')
                elif remote_logging_level is not None:
                    if self.remote_handler.current_log_level != remote_logging_level or not self.remote_handler.activated:
                        self.main_handler.setLevel(remote_logging_level)
                        self.remote_handler.activate(remote_logging_level)
                        log.info(
                            'Remote logging has being updated. Current logging level is: %s ',
                            remote_logging_level)
                if shared_attributes is not None:
                    log.debug(
                        "Shared attributes received (%s).",
                        ", ".join([attr for attr in shared_attributes.keys()]))
                if client_attributes is not None:
                    log.debug(
                        "Client attributes received (%s).",
                        ", ".join([attr for attr in client_attributes.keys()]))
        except Exception as e:
            log.exception(e)

    def get_config_path(self):
        return self._config_dir

    def subscribe_to_required_topics(self):
        self.tb_client.client.gw_set_server_side_rpc_request_handler(
            self._rpc_request_handler)
        self.tb_client.client.set_server_side_rpc_request_handler(
            self._rpc_request_handler)
        self.tb_client.client.subscribe_to_all_attributes(
            self._attribute_update_callback)
        self.tb_client.client.gw_subscribe_to_all_attributes(
            self._attribute_update_callback)

    def __check_shared_attributes(self):
        self.tb_client.client.request_attributes(
            callback=self._attributes_parse)

    def _load_connectors(self, main_config):
        self.connectors_configs = {}
        if main_config.get("connectors"):
            for connector in main_config['connectors']:
                try:
                    connector_class = TBUtility.check_and_import(
                        connector["type"],
                        self._default_connectors.get(connector["type"],
                                                     connector.get("class")))
                    self._implemented_connectors[
                        connector["type"]] = connector_class
                    with open(self._config_dir + connector['configuration'],
                              'r',
                              encoding="UTF-8") as conf_file:
                        connector_conf = load(conf_file)
                        if not self.connectors_configs.get(connector['type']):
                            self.connectors_configs[connector['type']] = []
                        connector_conf["name"] = connector["name"]
                        self.connectors_configs[connector['type']].append({
                            "name":
                            connector["name"],
                            "config": {
                                connector['configuration']: connector_conf
                            }
                        })
                except Exception as e:
                    log.error("Error on loading connector:")
                    log.exception(e)
        else:
            log.error("Connectors - not found! Check your configuration!")
            main_config["remoteConfiguration"] = True
            log.info("Remote configuration is enabled forcibly!")

    def _connect_with_connectors(self):
        for connector_type in self.connectors_configs:
            for connector_config in self.connectors_configs[connector_type]:
                for config in connector_config["config"]:
                    connector = None
                    try:
                        if connector_config["config"][config] is not None:
                            connector = self._implemented_connectors[
                                connector_type](
                                    self, connector_config["config"][config],
                                    connector_type)
                            connector.setName(connector_config["name"])
                            self.available_connectors[
                                connector.get_name()] = connector
                            connector.open()
                        else:
                            log.info("Config not found for %s", connector_type)
                    except Exception as e:
                        log.exception(e)
                        if connector is not None:
                            connector.close()

    def send_to_storage(self, connector_name, data):
        if not connector_name == self.name:
            if not TBUtility.validate_converted_data(data):
                log.error("Data from %s connector is invalid.", connector_name)
                return None
            if data["deviceName"] not in self.get_devices():
                self.add_device(
                    data["deviceName"],
                    {"connector": self.available_connectors[connector_name]},
                    wait_for_publish=True,
                    device_type=data["deviceType"])
            if not self.__connector_incoming_messages.get(connector_name):
                self.__connector_incoming_messages[connector_name] = 0
            else:
                self.__connector_incoming_messages[connector_name] += 1
        else:
            data["deviceName"] = "currentThingsBoardGateway"

        telemetry = {}
        telemetry_with_ts = []
        for item in data["telemetry"]:
            if item.get("ts") is None:
                telemetry = {**telemetry, **item}
            else:
                telemetry_with_ts.append({
                    "ts": item["ts"],
                    "values": {
                        **item["values"]
                    }
                })
        if telemetry_with_ts:
            data["telemetry"] = telemetry_with_ts
        else:
            data["telemetry"] = {"ts": int(time() * 1000), "values": telemetry}

        json_data = dumps(data)
        save_result = self._event_storage.put(json_data)
        if not save_result:
            log.error(
                'Data from the device "%s" cannot be saved, connector name is %s.',
                data["deviceName"], connector_name)

    def check_size(self, size, devices_data_in_event_pack):
        if size >= 48000:
            self.__send_data(devices_data_in_event_pack)
            size = 0
        return size

    def __read_data_from_storage(self):
        devices_data_in_event_pack = {}
        log.debug("Send data Thread has been started successfully.")
        while True:
            try:
                if self.tb_client.is_connected():
                    size = getsizeof(devices_data_in_event_pack)
                    events = []
                    if self.__remote_configurator is None or not self.__remote_configurator.in_process:
                        events = self._event_storage.get_event_pack()
                    if events:
                        for event in events:
                            self.counter += 1
                            try:
                                current_event = loads(event)
                            except Exception as e:
                                log.exception(e)
                                continue
                            if not devices_data_in_event_pack.get(
                                    current_event["deviceName"]):
                                devices_data_in_event_pack[
                                    current_event["deviceName"]] = {
                                        "telemetry": [],
                                        "attributes": {}
                                    }
                            if current_event.get("telemetry"):
                                if isinstance(current_event["telemetry"],
                                              list):
                                    for item in current_event["telemetry"]:
                                        size += getsizeof(item)
                                        size = self.check_size(
                                            size, devices_data_in_event_pack)
                                        devices_data_in_event_pack[
                                            current_event["deviceName"]][
                                                "telemetry"].append(item)
                                else:
                                    size += getsizeof(
                                        current_event["telemetry"])
                                    size = self.check_size(
                                        size, devices_data_in_event_pack)
                                    devices_data_in_event_pack[current_event[
                                        "deviceName"]]["telemetry"].append(
                                            current_event["telemetry"])
                            if current_event.get("attributes"):
                                if isinstance(current_event["attributes"],
                                              list):
                                    for item in current_event["attributes"]:
                                        size += getsizeof(item)
                                        size = self.check_size(
                                            size, devices_data_in_event_pack)
                                        devices_data_in_event_pack[
                                            current_event["deviceName"]][
                                                "attributes"].update(
                                                    item.items())
                                else:
                                    size += getsizeof(
                                        current_event["attributes"].items())
                                    size = self.check_size(
                                        size, devices_data_in_event_pack)
                                    devices_data_in_event_pack[current_event[
                                        "deviceName"]]["attributes"].update(
                                            current_event["attributes"].items(
                                            ))
                        if devices_data_in_event_pack:
                            if not self.tb_client.is_connected():
                                continue
                            while self.__rpc_reply_sent:
                                sleep(.01)
                            self.__send_data(devices_data_in_event_pack)
                        if self.tb_client.is_connected() and (
                                self.__remote_configurator is None
                                or not self.__remote_configurator.in_process):
                            success = True
                            while not self._published_events.empty():
                                if (self.__remote_configurator is not None and self.__remote_configurator.in_process) or \
                                        not self.tb_client.is_connected() or \
                                        self._published_events.empty() or \
                                        self.__rpc_reply_sent:
                                    success = False
                                    break
                                event = self._published_events.get(False, 10)
                                try:
                                    if self.tb_client.is_connected() and (
                                            self.__remote_configurator is None
                                            or not self.__remote_configurator.
                                            in_process):
                                        success = event.get(
                                        ) == event.TB_ERR_SUCCESS
                                    else:
                                        break
                                except Exception as e:
                                    log.exception(e)
                                    success = False
                                sleep(.01)
                            if success:
                                self._event_storage.event_pack_processing_done(
                                )
                                del devices_data_in_event_pack
                                devices_data_in_event_pack = {}
                        else:
                            continue
                    else:
                        sleep(.01)
                else:
                    sleep(.1)
            except Exception as e:
                log.exception(e)
                sleep(1)

    def __send_data(self, devices_data_in_event_pack):
        try:
            for device in devices_data_in_event_pack:
                if devices_data_in_event_pack[device].get("attributes"):
                    if device == self.name or device == "currentThingsBoardGateway":
                        self._published_events.put(
                            self.tb_client.client.send_attributes(
                                devices_data_in_event_pack[device]
                                ["attributes"]))
                    else:
                        self._published_events.put(
                            self.tb_client.client.gw_send_attributes(
                                device, devices_data_in_event_pack[device]
                                ["attributes"]))
                if devices_data_in_event_pack[device].get("telemetry"):
                    if device == self.name or device == "currentThingsBoardGateway":
                        self._published_events.put(
                            self.tb_client.client.send_telemetry(
                                devices_data_in_event_pack[device]
                                ["telemetry"]))
                    else:
                        self._published_events.put(
                            self.tb_client.client.gw_send_telemetry(
                                device, devices_data_in_event_pack[device]
                                ["telemetry"]))
                devices_data_in_event_pack[device] = {
                    "telemetry": [],
                    "attributes": {}
                }
        except Exception as e:
            log.exception(e)

    def _rpc_request_handler(self, request_id, content):
        try:
            device = content.get("device")
            if device is not None:
                connector_name = self.get_devices()[device].get("connector")
                if connector_name is not None:
                    connector_name.server_side_rpc_handler(content)
                else:
                    log.error(
                        "Received RPC request but connector for the device %s not found. Request data: \n %s",
                        content["device"], dumps(content))
            else:
                try:
                    method_split = content["method"].split('_')
                    module = None
                    if len(method_split) > 0:
                        module = method_split[0]
                    if module is not None:
                        result = None
                        if self.connectors_configs.get(module):
                            log.debug(
                                "Connector \"%s\" for RPC request \"%s\" found",
                                module, content["method"])
                            for connector_name in self.available_connectors:
                                if self.available_connectors[
                                        connector_name]._connector_type == module:
                                    log.debug(
                                        "Sending command RPC %s to connector %s",
                                        content["method"], connector_name)
                                    result = self.available_connectors[
                                        connector_name].server_side_rpc_handler(
                                            content)
                        elif module == 'gateway':
                            result = self.__rpc_gateway_processing(
                                request_id, content)
                        else:
                            log.error("Connector \"%s\" not found", module)
                            result = {
                                "error":
                                "%s - connector not found in available connectors."
                                % module,
                                "code":
                                404
                            }
                        if result is None:
                            self.send_rpc_reply(None,
                                                request_id,
                                                success_sent=False)
                        else:
                            self.send_rpc_reply(None, request_id,
                                                dumps(result))
                except Exception as e:
                    self.send_rpc_reply(
                        None, request_id,
                        "{\"error\":\"%s\", \"code\": 500}" % str(e))
                    log.exception(e)
        except Exception as e:
            log.exception(e)

    def __rpc_gateway_processing(self, request_id, content):
        log.info("Received RPC request to the gateway, id: %s, method: %s",
                 str(request_id), content["method"])
        arguments = content.get('params')
        method_to_call = content["method"].replace("gateway_", "")
        result = None
        if isinstance(arguments, list):
            result = self.__gateway_rpc_methods[method_to_call](*arguments)
        elif method_to_call in self.__self_rpc_sheduled_methods_functions:
            seconds_to_restart = arguments * 1000 if arguments and arguments != '{}' else 0
            self.__sheduled_rpc_calls.append([
                time() * 1000 + seconds_to_restart,
                self.__self_rpc_sheduled_methods_functions[method_to_call]
            ])
            log.info("Gateway %s sheduled in %i seconds", method_to_call,
                     seconds_to_restart / 1000)
            result = {"success": True}
        elif arguments is not None:
            result = self.__gateway_rpc_methods[method_to_call](arguments)
        else:
            result = self.__gateway_rpc_methods[method_to_call]()
        log.debug(result)
        return result

    def __rpc_ping(self, *args):
        return {"code": 200, "resp": "pong"}

    def __rpc_devices(self, *args):
        data_to_send = {}
        for device in self.__connected_devices:
            if self.__connected_devices[device]["connector"] is not None:
                data_to_send[device] = self.__connected_devices[device][
                    "connector"].get_name()
        return {"code": 200, "resp": data_to_send}

    def __rpc_update(self, *args):
        try:
            result = {
                "resp": self.__updater.update(),
                "code": 200,
            }
        except Exception as e:
            result = {"error": str(e), "code": 500}
        return result

    def rpc_with_reply_processing(self, topic, content):
        req_id = self.__rpc_requests_in_progress[topic][0]["data"]["id"]
        device = self.__rpc_requests_in_progress[topic][0]["device"]
        self.send_rpc_reply(device, req_id, content)
        self.cancel_rpc_request(topic)

    def send_rpc_reply(self,
                       device=None,
                       req_id=None,
                       content=None,
                       success_sent=None,
                       wait_for_publish=None,
                       quality_of_service=0):
        try:
            self.__rpc_reply_sent = True
            rpc_response = {"success": False}
            if success_sent is not None:
                if success_sent:
                    rpc_response["success"] = True
            if device is not None and success_sent is not None:
                self.tb_client.client.gw_send_rpc_reply(
                    device,
                    req_id,
                    dumps(rpc_response),
                    quality_of_service=quality_of_service)
            elif device is not None and req_id is not None and content is not None:
                self.tb_client.client.gw_send_rpc_reply(
                    device,
                    req_id,
                    content,
                    quality_of_service=quality_of_service)
            elif device is None and success_sent is not None:
                self.tb_client.client.send_rpc_reply(
                    req_id,
                    dumps(rpc_response),
                    quality_of_service=quality_of_service,
                    wait_for_publish=wait_for_publish)
            elif device is None and content is not None:
                self.tb_client.client.send_rpc_reply(
                    req_id,
                    content,
                    quality_of_service=quality_of_service,
                    wait_for_publish=wait_for_publish)
            self.__rpc_reply_sent = False
        except Exception as e:
            log.exception(e)

    def register_rpc_request_timeout(self, content, timeout, topic,
                                     cancel_method):
        self.__rpc_register_queue.put(
            {
                "topic": topic,
                "data": (content, timeout, cancel_method)
            }, False)
        # self.__rpc_requests_in_progress[topic] = (content, timeout, cancel_method)

    def cancel_rpc_request(self, rpc_request):
        content = self.__rpc_requests_in_progress[rpc_request][0]
        self.send_rpc_reply(device=content["device"],
                            req_id=content["data"]["id"],
                            success_sent=False)

    def _attribute_update_callback(self, content, *args):
        log.debug("Attribute request received with content: \"%s\"", content)
        log.debug(args)
        if content.get('device') is not None:
            try:
                self.__connected_devices[content["device"]][
                    "connector"].on_attributes_update(content)
            except Exception as e:
                log.exception(e)
        else:
            self._attributes_parse(content)

    def __form_statistics(self):
        summary_messages = {"eventsProduced": 0, "eventsSent": 0}
        telemetry = {}
        for connector in self.available_connectors:
            connector_camel_case = connector.lower().replace(' ', '')
            telemetry[(connector_camel_case + ' EventsProduced').replace(' ', '')] = \
                self.available_connectors[connector].statistics['MessagesReceived']
            self.available_connectors[connector].statistics[
                'MessagesReceived'] = 0
            telemetry[(connector_camel_case + ' EventsSent').replace(' ', '')] = \
                self.available_connectors[connector].statistics['MessagesSent']
            self.available_connectors[connector].statistics['MessagesSent'] = 0
            summary_messages['eventsProduced'] += telemetry[str(
                connector_camel_case + ' EventsProduced').replace(' ', '')]
            summary_messages['eventsSent'] += telemetry[str(
                connector_camel_case + ' EventsSent').replace(' ', '')]
            summary_messages.update(**telemetry)
        return summary_messages

    def add_device(self,
                   device_name,
                   content,
                   wait_for_publish=False,
                   device_type=None):
        if device_name not in self.__saved_devices:
            device_type = device_type if device_type is not None else 'default'
            self.__connected_devices[device_name] = {
                **content, "device_type": device_type
            }
            self.__saved_devices[device_name] = {
                **content, "device_type": device_type
            }
            self.__save_persistent_devices()
        if wait_for_publish:
            self.tb_client.client.gw_connect_device(
                device_name, device_type).wait_for_publish()
        else:
            self.tb_client.client.gw_connect_device(device_name, device_type)

    def update_device(self, device_name, event, content):
        if event == 'connector' and self.__connected_devices[device_name].get(
                event) != content:
            self.__save_persistent_devices()
        self.__connected_devices[device_name][event] = content

    def del_device(self, device_name):
        del self.__connected_devices[device_name]
        del self.__saved_devices[device_name]
        self.tb_client.client.gw_disconnect_device(device_name)
        self.__save_persistent_devices()

    def get_devices(self):
        return self.__connected_devices

    def __load_persistent_devices(self):
        devices = {}
        if self.__connected_devices_file in listdir(self._config_dir) and \
                path.getsize(self._config_dir + self.__connected_devices_file) > 0:
            try:
                with open(self._config_dir +
                          self.__connected_devices_file) as devices_file:
                    devices = load(devices_file)
            except Exception as e:
                log.exception(e)
        else:
            connected_devices_file = open(
                self._config_dir + self.__connected_devices_file, 'w')
            connected_devices_file.close()

        if devices is not None:
            log.debug("Loaded devices:\n %s", devices)
            for device_name in devices:
                try:
                    if self.available_connectors.get(devices[device_name]):
                        self.__connected_devices[device_name] = {
                            "connector":
                            self.available_connectors[devices[device_name]]
                        }
                    else:
                        log.info(
                            "Pair device %s - connector %s from persistent device storage - not found.",
                            device_name, devices[device_name])
                except Exception as e:
                    log.exception(e)
                    continue
        else:
            log.debug("No device found in connected device file.")
            self.__connected_devices = {} if self.__connected_devices is None else self.__connected_devices

    def __save_persistent_devices(self):
        with open(self._config_dir + self.__connected_devices_file,
                  'w') as config_file:
            try:
                data_to_save = {}
                for device in self.__connected_devices:
                    if self.__connected_devices[device][
                            "connector"] is not None:
                        data_to_save[device] = self.__connected_devices[
                            device]["connector"].get_name()
                config_file.write(dumps(data_to_save, indent=2,
                                        sort_keys=True))
            except Exception as e:
                log.exception(e)
        log.debug("Saved connected devices.")