class MqttBridge(BaseBridge): def __init__(self): super(MqttBridge, self).__init__() self.client = MqttClient() self.client.on_message = self.onMqttMessage self.client.on_connect = self.onConnect def publishApiMessage(self, heat_pump_id, base_topic, topic, value): self.client.publish(base_topic + topic, value) # noinspection PyUnusedLocal def onConnect(self, client, userdata, flags, rc): # type: (MqttBridge, MqttClient, object, dict, object) -> None topics = [] for topic in self.binding.topics: topics.append((topic, 0)) if len(topics) == 0: return print "mqtt subscribing to topics: ", topics client.subscribe(topics) # noinspection PyUnusedLocal def onMqttMessage(self, client, userdata, msg): # type: (MqttBridge, MqttClient, object, MQTTMessage) -> None topic = str(msg.topic) self.binding.onApiMessage(topic, msg.payload) def start(self): print "mqtt connect to:", config.MQTT['host'] self.client.connect(config.MQTT['host']) self.client.loop_start() def stop(self): self.client.disconnect() self.client.loop_stop()
def main(): client = Client(protocol=MQTTv311) client.username_pw_set(USERNAME, password=PASSWORD) host1 = "98:07:2D:40:95:83" host2 = "98:07:2D:35:7B:00" print("Connecting to SensorTags") tag1 = SensorTag(host1) #tag2 = SensorTag(host2) sensor_enabler(tag1) #sensor_enabler(tag2) sleep(1.0) try: while True: data1 = read_sensor_data(tag1) #data2 = read_sensor_data(tag2) sleep(1.0) pprint({"SensorTag1": data1}) #pprint({"SensorTag2": data2}) client.connect(HOST, port=PORT, keepalive=60) client.publish(TOPIC1, payload=dumps(data1)) #client.publish(TOPIC2, payload=dumps(data2)) client.disconnect() sleep(30) except KeyboardInterrupt: print("Disconnected to SensorTags") tag1.disconnect()
class MqttController: def __init__(self): self.client = Client() self.client.on_connect = self.__on_connect self.client.on_message = self.__on_message self.evtCallback: Optional[EventCallback] = None def connect(self, connectCallback, host, port=1883, keepalive=60): log.info("Trying to connect MQTT client.") self.connectCallback = connectCallback self.client.connect(host, port, keepalive) self.client.loop_start() def disconnect(self): self.client.loop_stop() self.client.disconnect() def setCallback(self, callback: EventCallback): self.evtCallback = callback def delCallback(self): self.evtCallback = None def __on_connect(self, client, userdata, flags, rc): log.info("MQTT client connected, registering subscriptions.") self.client.subscribe("/baresip/event") self.connectCallback() def __on_message(self, client, userdata, msg: MQTTMessage): log.info("MQTT message received for path=%s.", msg.topic) log.debug("payload=%s", msg.payload) # parse message try: msgObj = json.loads(msg.payload) evtType = EventType[msgObj["type"]] # notify respective callback cb = self.evtCallback if cb is not None: log.debug("Calling event callback in a thread.") t = threading.Thread(target=lambda: cb(evtType, msgObj)) t.start() else: log.debug("No callback registered.") except JSONDecodeError: log.error("Received invalid JSON message.") except KeyError: log.warn("Received unhandled type code or type code is missing.") def send_command(self, msg): log.debug("Trying to send message %s to phone.", msg) info = self.client.publish("/baresip/command/", msg) log.debug("Waiting for publish") log.debug(info.rc) info.wait_for_publish() if info.rc != MQTT_ERR_SUCCESS: log.error("Failed to publish message") else: log.debug("Message sent successfully.")
class MQTT: client = None def __init__(self, client_id: str = 'raspberry005', clean_session: bool = True, auto_connect: bool = True, **kwargs): self.client = Client(client_id=client_id, clean_session=clean_session, **kwargs) self.client.on_message = self._on_message if auto_connect: self.connect(host='iot.eclipse.org') def connect(self, host: str, port: int = 1883, keepalive: int = 60, **kwargs): is_connected = self.client.connect(host=host, port=port, keepalive=keepalive, **kwargs) if is_connected in range(3): log.info('Successful connect') return True raise ConnectionError(f'MQTT connection error id {is_connected}') def _on_message(self, client, userdata, msg): log.info(f'{msg.topic} {msg.payload!s}') def pulish(self, topic: str, payload: str = None, retain: bool = False, **kwargs): message_info = self.client.publish(topic=topic, payload=payload, retain=retain, **kwargs) message_info.wait_for_publish() if message_info.is_published(): log.info(f'Successful published message "{payload}" to topic {topic}') return True log.info(f'Publishing error for message "{payload}" to topic {topic}') return False def __del__(self): self.client.disconnect()
class MQTTValuePub(object): ''' Use MQTT to send values on network pip install paho-mqtt ''' def __init__(self, name, broker="iot.eclipse.org"): from paho.mqtt.client import Client self.name = name self.message = None self.client = Client() print("connecting to broker", broker) self.client.connect(broker) self.client.loop_start() print("connected.") def run(self, values): packet = {"name": self.name, "val": values} p = pickle.dumps(packet) z = zlib.compress(p) self.client.publish(self.name, z) def shutdown(self): self.client.disconnect() self.client.loop_stop()
class MQTTClient(object): """Manages Paho MQTT client lifecycle and callbacks""" def __init__(self, config: dict, message_processor=None): self.config = config self.client = Client( client_id=config.mqtt_client, clean_session=config.mqtt_clean_session, userdata={"client": config.mqtt_client}, ) self.client.username_pw_set(config.mqtt_username, config.mqtt_password) if self.config.mqtt_debug: self.client.on_log = self._on_log self.client.on_connect = self._on_connect self.client.on_subscribe = self._on_subscribe self.client.on_message = self._on_message self.client.on_publish = self._on_publish self.client.on_disconnect = self._on_disconnect self.client.connect(config.mqtt_host, config.mqtt_port, 60) if message_processor: self.message_processor = message_processor def _on_log(self, client, userdata, level, buf): click.echo(f"{buf}, origin: {userdata['client']}") def _on_connect(self, client, userdata, flags, rc): click.echo(f"Connected {userdata['client']}, result code: {str(rc)} {str(flags)}") click.echo(f"Subscribing to all topics...") self.client.subscribe(self.config.mqtt_topics) def _on_subscribe(self, client, userdata, mid, granted_qos): click.echo(f"Subscribed {userdata['client']}, mid: {mid}, granted qos: {granted_qos}") click.echo(f"Listening for {userdata['client']} messages...") def _on_disconnect(self, client, userdata, rc): click.echo(f"Disconnected {userdata['client']}, result code: {str(rc)}") def _on_message(self, client, userdata, msg): if hasattr(self, "message_processor"): self.message_processor(client, userdata, msg) else: click.echo(f"Topic: {msg.topic}, Mid: {msg.mid}, Payload: {msg.payload.decode('utf-8')}") def _on_publish(self, client, userdata, mid): click.echo(f"Published by {userdata['client']}, mid: {mid}") def listen(self): try: self.client.loop_forever() except KeyboardInterrupt: click.echo(f"Received KeyboardInterrupt, disconnecting {self.config.mqtt_client}") self.client.disconnect()
def on_connect(client: mqtt_client.Client, userdata, flags, rc): if rc == 0: client.subscribe("+/devices/+/up", qos=2) elif rc == 3: # Server isn't available, retry later print("Server isn't available") else: # Error in config print("Error in config") client.disconnect()
def test_traffic_mqtt(): client = Client(client_id="test") client.on_connect = on_connect client.username_pw_set(username="******", password="******") client.connect(host="52.164.202.250", port=1883) client.loop_start() t.sleep(5) t.sleep(2) client.disconnect() t.sleep(2)
def send_to_mqtt(packet, db = "testcargo"): packet['database'] = db client = Client(client_id="test") client.on_connect = on_connect client.username_pw_set(username="******", password="******") client.connect(host="52.164.202.250", port=1883) client.loop_start() t.sleep(5) transmit(client) t.sleep(2) client.disconnect() t.sleep(2)
def on_connect(self, client: Client, userdata, flags, rc, properties=None): """ mqtt连接回调函数 """ status = ['连接成功', '协议版本错误', '客户端标识符无效', '服务器不可用', '用户名或密码错误', '未授权'] if rc != 0: self.publishStateChangedSignal.emit(status[rc]) return # 发布信息并发送消息给主界面 self.publishStateChangedSignal.emit('🙉 代理服务器连接成功!') client.publish(self.topic, self.message, 1) self.publishStateChangedSignal.emit('🙊 假数据包发送成功!') client.disconnect() self.publishStateChangedSignal.emit(f'🙊 已与代理服务器 {self.broker} 断开连接')
class Mqtt(object): def __init__(self, host): self.host = host self.client = Client() def send(self, topic, payload): try: self.client.connect(self.host) self.client.publish(topic, payload) self.client.disconnect() except: print("MQTT connection error with {}".format(self.host))
def _test_mqtt_connection(self): print("testing mqtt connection", flush=True) mqtt = Client() while True: try: mqtt.connect(mqtthost) break except: print("Waiting for mqtt...", flush=True) time.sleep(5) print("mqtt connected", flush=True) mqtt.disconnect()
class MqttClientConnector(): _host = None _port = None _brokerAddr = None _mqttClient = None #Allow user to use this constructor to pass custom callBack methods def __init__(self, host, port, on_connect, on_message, on_publish, on_subscribe): self._brokerAddr = host + ":" + str(port) self._host = host self._port = port self._mqttClient = Client() self._mqttClient.on_connect = on_connect self._mqttClient.on_message = on_message self._mqttClient.on_publish = on_publish self._mqttClient.on_subscribe = on_subscribe def connect(self): try: print("Connecting to broker:" + self._brokerAddr + ".....") self._mqttClient.connect(self._host, self._port, 60) self._mqttClient.loop_start() except Exception as e: print("Cloud not connect to broker " + self._brokerAddr + " " + str(e)) def disconnect(self): self._mqttClient.disconnect() self._mqttClient.loop_stop() def publishMessage(self, topic, message, qos): print("Publishing message:" + message + " to broker: " + self._brokerAddr + " Topic:" + topic) self._mqttClient.publish(topic, message, qos) def subscribeTopic(self, topic, qos): print("Subscribing to topic:" + topic + ".....") self._mqttClient.subscribe(topic, qos)
def main(): parser = argparse.ArgumentParser( description='Command line utility for quick MQTT publishes') parser.add_argument('--broker-port', type=int, default=1883) parser.add_argument('broker_address') parser.add_argument('topic') parser.add_argument('message', default='') args = parser.parse_args() client = Client() client.on_publish = print_publish_info client.connect(args.broker_address, args.broker_port) client.publish(args.topic, args.message) client.disconnect()
class MoodyBLEWrapper(Thread): def __init__(self, mac, host, ca_cert): Thread.__init__(self) self._mac = mac self._host = host self._ca_cert = ca_cert self._running = False self._mutex = Lock() self._client = Client(f"Moody{randint(100, 999)}") self._client.tls_set(ca_certs=ca_cert) # When receiving data with a delegate, you also receive a characteristic handle # This is a mapping of those characteristic for later usage self._handle_mappings = {} def run(self): self._running = True self._connect(host=self._host) with Peripheral(self._mac) as peripheral: for service in list(peripheral.getServices())[2:]: print(service, service.uuid.getCommonName()) char_uuids = [str(c.uuid) for c in service.getCharacteristics()] name_char = service.getCharacteristics(char_uuids[0])[0] value_char = service.getCharacteristics(char_uuids[1])[0] service_name = name_char.read().decode() self._handle_mappings[value_char.valHandle] = service_name mqtt_delegate = _MQTTDelegate(client=self._client, client_mutex=self._mutex, handle_map=self._handle_mappings) peripheral.withDelegate(mqtt_delegate) peripheral.writeCharacteristic(value_char.valHandle + 1, b"\x01\x00") while self._running: peripheral.waitForNotifications(1) peripheral.disconnect() def _connect(self, host, port=None): if not port: port = 8883 self._client.connect(host=host, port=port) self._client.loop_start() def stop(self): self._running = False self._client.loop_stop() self._client.disconnect()
def on_connect(client: Client, userdata, flags, rc, properties=None): """ mqtt连接回调函数 """ global isOk status = ['连接成功', '协议版本错误', '客户端标识符无效', '服务器不可用', '用户名或密码错误', '未授权'] if rc != 0: sys.exit(status[rc]) else: with open('captured_packet.json', encoding='utf-8') as f: packet_info = json.load(f) # 发布信息 print('🙉 代理服务器连接成功!') client.publish(packet_info['topic'], packet_info['msg'], 1) print('🙊 假数据包发送成功!') isOk = True client.disconnect()
def main(): client = Client(client_id="SHELL/UTILITY") client.connect(host=SERVICE_BROKER_PORT["ip"], port=SERVICE_BROKER_PORT["port"]) client.loop_start() chat_id = int( input_dialog( title='Chat ID', text='Please activate the bot on your phone:' ' https://t.me/SmartHome_IoTbot and type here your' ' telegram chat id .. to obtain it go to ' 'https://telegram.me/get_id_bot:').run() ) client.publish(topic=SERVICE_TOPIC, payload=json.dumps({"chat_id": chat_id})) client.loop_stop() client.disconnect()
class AzureIoT(IotProvider): def __init__(self, iot_provider_cfg): # 1. Set device_name. # 2. Set tls_version. # 3. Set MQTT Protocol version # 4. Call parent class' __init__ self.device_name = iot_provider_cfg["device_name"] self.tls_version = eval( f"ssl.PROTOCOL_TLSv1_{iot_provider_cfg['tls_version']}") self.mqtt_version = eval( f"mqtt.MQTTv{iot_provider_cfg['mqtt_version']}") super().__init__(iot_provider_cfg) def on_connect(self, client, userdata, flags, rc): # Event handler for connection event. Subscribe to topic(s) here. client.subscribe(self.subscribe_topic, qos=0) def on_disconnect(client, userdata, rc): print(f"Disconnected with code {rc}") def onmsg(self, client, userdata, msg): # Wraps core event handler for incoming messages msg_payload = msg.payload super().onmsg(msg_payload) def connect(self): # A connection to iot is established at the beginning and if publish fails self.azure_iot_comm = Client(client_id=self.device_name, protocol=self.mqtt_version) self.azure_iot_comm.on_connect = self.on_connect self.azure_iot_comm.on_disconnect = self.on_disconnect self.azure_iot_comm.on_message = self.onmsg self.azure_iot_comm.username_pw_set( username=f"{self.iot_broker}/{self.device_name}") self.azure_iot_comm.tls_set(self.iot_ca_cert_path, self.iot_client_cert_path, self.iot_client_key_path, tls_version=self.tls_version, cert_reqs=ssl.CERT_REQUIRED) self.azure_iot_comm.connect(self.iot_broker, self.iot_port) self.azure_iot_comm.loop_start() def disconnect(self): self.azure_iot_comm.disconnect() def publish(self, publish_topic, msg_str, qos): # Overriding qos to 0 because Azure doesn't seem to like any other qos self.azure_iot_comm.publish(publish_topic, msg_str, qos=0)
def mqtt_handler(): global mqtt_client Client.connected_flag = False mqtt_client = Client() mqtt_client.on_connect = on_connect mqtt_client.on_message = on_message mqtt_client.loop_start() mqtt_client.connect(host=MQTT_ADDR, port=MQTT_PRT) while not mqtt_client.connected_flag: # wait in loop print("In wait loop") time.sleep(1) # subscribe all rooms, using MQTT single layer wildcard mqtt_client.subscribe(topic='%s/+' % ORDER_STATUS) mqtt_client.loop_forever() mqtt_client.disconnect()
def on_connect(_client: mqtt.Client, _userdata: dict, _flags: dict, rc: int) -> None: """ Callback function when a MQTT client connects to the server Check if the connection is succeeded. Stop the loop regardless of whether the connection is succeeded or not. The rc argument is a connection result. """ _client.disconnect() _client.loop_stop() if rc != mqtt.MQTT_ERR_SUCCESS: demisto.info(mqtt.connack_string(rc)) raise paho.mqtt.MQTTException(mqtt.connack_string(rc)) else: demisto.info("connection was succeeded for test")
class MqttPlugin(plugins.SimplePlugin): """ Plugin that listens to MQTT topics and publishes the payload 'unmodified' to a channel on the CherryPy bus. The cherrypy channel name is the same as the MQTT topic Requires PAHO """ def __init__( self, bus: wspbus, broker: str, port: int, topic_list: Union[str, List[str]] ) -> None: """ Setup the plugin :param bus: Cherrypy internal Bus :param broker: Mqtt broker :param port: Port of the Mqtt broker :param topic_list: topic to subscribe """ # Cherrypy plugins.SimplePlugin doesn't accept the super().__init__() # Inside cherrypy's docs it's like this # https://docs.cherrypy.org/en/latest/extend.html#create-a-plugin plugins.SimplePlugin.__init__(self, bus) self.broker = broker self.port = port self.topic_list = topic_list self.client = Client(client_id=f"Catalog{randrange(1, 100000)}") self.client.on_message = Bus(bus).my_on_message def start(self): self.bus.log("Setup mqttcherrypy") self.client.connect(self.broker, self.port) self.bus.log(f"Connected to broker: {self.broker} port: {self.port})") self.client.loop_start() self.client.subscribe(self.topic_list) self.bus.log(f"Subscribed to {self.topic_list}") def stop(self): self.bus.log("Shut down mqttcherrypy") self.client.unsubscribe(self.topic_list) self.bus.log(f"Unsubscribed from {self.topic_list}") self.client.loop_stop(force=True) self.client.disconnect() self.bus.log(f"Disconnected from: {self.broker} port: {self.port}")
class MqttClientConnector(): _host = None _port = None _brokerAddr = None _mqttClient = None def __init__(self, host, port, on_connect, on_message, on_publish, on_subscribe): self._brokerAddr = host + ":" + str(port) self._host = host self._port = port self._mqttClient = Client() self._mqttClient.on_connect = on_connect self._mqttClient.on_message = on_message self._mqttClient.on_publish = on_publish self._mqttClient.on_subscribe = on_subscribe def connect(self): try: # make a connection with broker print("Connect to broker:" + self._brokerAddr + ".....") self._mqttClient.connect(self._host, self._port, 60) self._mqttClient.loop_start() except Exception as e: print("Broker error, Connected failed" + str(e)) def disconnect(self): # disconnect with broker self._mqttClient.disconnect() self._mqttClient.loop_stop() def publishMessage(self, topic, message, qos): # publish msg to remote boroker print("Start publishing message : " + message) self._mqttClient.publish(topic, message, qos) def subscribeTopic(self, topic, qos): # subscribe msg to remote boroker print("Start subscribing to topic: " + topic) self._mqttClient.subscribe(topic, qos)
class MQTT_PUBLISHER: def __init__(self): self.client = Client() def schedule(self, event_name, event_value, topic, host, port, value_name, value): if event_name == 'INIT': # connects to the broker self.client.connect(host, port) return [event_value, None] elif event_name == 'RUN': message_dict = {value_name: str(value)} message = json.dumps(message_dict) self.client.publish(topic, message) return [None, event_value] def __del__(self): self.client.disconnect()
def __init__(self, client: mqtt.Client, password: str): self.client = client self.client.username_pw_set("management/devicebootstrap", password) self.client.on_connect = self.on_connect self.client.on_message = self.on_message self.client.loop_start() self.client.tls_set() self.client.connect("ubirch.cumulocity.com", 8883) self.connected = False while not self.connected: time.sleep(10) self.authorized = False while not self.authorized: self.client.publish("s/ucr") time.sleep(10) client.disconnect() client.loop_stop()
class MqttClient: def __init__(self, name): self.client = None self.name = name self.connected = False self.client = Client(client_id=self.name) self.client.on_connect = self.on_connect self.client.connect(host='localhost', port=1883, keepalive=60) print("New MQTT client: " + str(self.name)) self.client.loop_start() def on_connect(self, client, userdata, flags, rc): self.connected = True print("MQTT Client(" + str(self.name) + ") Connected") def stop(self): self.client.loop_stop() self.client.disconnect() print("MQTT Client Stoped")
def mqtt_handler(): global mqtt_client Client.connected_flag = False mqtt_client = Client() # set mosquitto broker password and username mqtt_client.username_pw_set(username=USERNAME, password=PASSWORD) # set TLS cert for the client mqtt_client.tls_set(ca_certs=TLS_CERT) mqtt_client.tls_insecure_set(True) mqtt_client.on_connect = on_connect mqtt_client.on_message = on_message mqtt_client.loop_start() mqtt_client.connect(host=MQTT_ADDR, port=MQTT_PRT) while not mqtt_client.connected_flag: # wait in loop print("In wait loop") time.sleep(1) mqtt_client.subscribe(topic='%s/+' % ORDER_STATUS) mqtt_client.loop_forever() mqtt_client.disconnect()
class MQTTValueSub(object): ''' Use MQTT to recv values on network pip install paho-mqtt ''' def __init__(self, name, broker="iot.eclipse.org", def_value=None): from paho.mqtt.client import Client self.name = name self.data = None self.client = Client(clean_session=True) self.client.on_message = self.on_message print("(clean_session) connecting to broker", broker) self.client.connect(broker) self.client.loop_start() self.client.subscribe(self.name) self.def_value = def_value print("connected.") def on_message(self, client, userdata, message): self.data = message.payload def run(self): if self.data is None: return self.def_value p = zlib.decompress(self.data) obj = pickle.loads(p) if self.name == obj['name']: self.last = obj['val'] #print("steering, throttle", obj['val']) return obj['val'] return self.def_value def shutdown(self): self.client.disconnect() self.client.loop_stop()
class MosQuiTTo(IotProvider): """ Child class containing implementations of IotProvider specific to MosQuiTTo. """ def __init__(self, iot_provider_cfg): # 1. Set tls_version to correspond to mosquitto broker. # 2. Call parent class' __init__ self.tls_version = eval( f"ssl.PROTOCOL_TLSv1_{iot_provider_cfg['tls_version']}") super().__init__(iot_provider_cfg) def on_connect(self, client, userdata, flags, rc): # Event handler for connection event. Subscribe to topic(s) here. client.subscribe(self.subscribe_topic, qos=0) def onmsg(self, client, userdata, msg): # Wraps core event handler for incoming messages msg_payload = msg.payload super().onmsg(msg_payload) def connect(self): # A connection to iot is established at the beginning and if publish fails self.mosquitto_comm = Client() self.mosquitto_comm.on_connect = self.on_connect self.mosquitto_comm.on_message = self.onmsg self.mosquitto_comm.tls_set(self.iot_ca_cert_path, self.iot_client_cert_path, self.iot_client_key_path, tls_version=self.tls_version, cert_reqs=ssl.CERT_REQUIRED) self.mosquitto_comm.connect(self.iot_broker, self.iot_port) self.mosquitto_comm.loop_start() def disconnect(self): self.mosquitto_comm.disconnect() def publish(self, publish_topic, msg_str, qos): self.mosquitto_comm.publish(publish_topic, msg_str, qos=qos)
class Publisher: def __init__(self, server_address, location): self.client = Client() self.location = location self.address = server_address def publish(self, humidity, temperature): payload_humidity = self.__build_payload("humidity", humidity) payload_temperature = self.__build_payload("temperature", temperature) try: logging.debug("Connectint to MQTT...") self.client.connect(self.address) self.client.publish(TOPIC, payload_temperature) self.client.publish(TOPIC, payload_humidity) logging.info("Published values on " + TOPIC) self.client.disconnect() except Exception as ex: logging.error(ex) def __build_payload(self, prop, value): return '{{"timestamp":"{}", "place": "{}", "property":"{}", "value":{:.4f}}}'.format( datetime.now(), self.location, prop, value)
class MQTTClient: def __init__(self): h = Hosts() t = NetTools() self.client = Client(t.get_ip()) self.client.on_connect = self._on_connect self.client.on_message = self._on_message self.client.connect(host=h.get_ip_from_host(HOME_SERVER_HOSTNAME), port=1883, keepalive=60) self.connected = True self.subscribe = self.client.subscribe self.publish = self.client.publish @staticmethod def _on_connect(client: Client, userdata: Any, flags: Any, rc: int): """Set up a callback function to ensure the connection to Server was successful""" logger.info(f'Connected with result code {rc}.') # Subscribing in on_connect means that if we lose connection and reconnect # then subscriptions will be renewed client.subscribe('$SYS/#') @staticmethod def _on_message(client: Client, userdata: Any, msg: MQTTMessage): """Callback for when PUBLISH message is received from the server""" logger.debug(f'{msg.topic} {msg.payload}') def disconnect(self): """Disconnect from the broker""" self.client.disconnect() self.connected = False def __del__(self): """In case class is cleaned up before disconnecting""" if self.connected: self.disconnect()
class JMSClient(object): """Class JMSClient """ _mh = None _client = None _host = None _port = None _user = None _passw = None _verbose = None _is_connected = None _messages = [] def __init__(self, verbose=False): """Class constructor Called when the object is initialized Args: verbose (bool): verbose mode """ try: self._mh = MasterHead.get_head() self._client = Client() self._client.on_message = self._on_message self._verbose = verbose if (self._verbose): self._client.on_log = self._on_log except MQTTException as ex: self._mh.demsg('htk_on_error', ex, self._mh.fromhere()) @property def client(self): """ MQTT client property getter """ return self._client @property def host(self): """ server host property getter """ return self._host @property def port(self): """ server port property getter """ return self._port @property def user(self): """ username property getter """ return self._user @property def passw(self): """ user password property getter """ return self._passw @property def verbose(self): """ verbose property getter """ return self._verbose @property def is_connected(self): """ is_connected property getter """ return self._is_connected def _on_log(self, client, obj, level, string): """ Callback for on_log event """ print(string) def _on_message(self, client, obj, msg): """ Callback for on_message event """ self._messages.append(msg.payload.decode()) def connect(self, host, port=1883, user=None, passw=None, timeout=10): """Method connects to server Args: host (str): hostname port (str): port user (str): username passw (str): password timeout (int): timeout Returns: bool: result Raises: event: jms_before_connect event: jms_after_connected """ try: msg = 'host:{0}, port:{1}, user:{2}, passw:{3}, timeout:{4}'.format( host, port, user, passw, timeout) self._mh.demsg('htk_on_debug_info', self._mh._trn.msg( 'htk_jms_connecting', msg), self._mh.fromhere()) ev = event.Event( 'jms_before_connect', host, port, user, passw, timeout) if (self._mh.fire_event(ev) > 0): host = ev.argv(0) port = ev.argv(1) user = ev.argv(2) passw = ev.argv(3) timeout = ev.argv(4) self._host = host self._port = port self._user = user self._passw = passw if (ev.will_run_default()): if (self._user != None): self._client.username_pw_set(self._user, self._passw) setdefaulttimeout(timeout) self._client.connect(self._host, self._port) self._is_connected = True self._mh.demsg('htk_on_debug_info', self._mh._trn.msg( 'htk_jms_connected'), self._mh.fromhere()) ev = event.Event('jms_after_connect') self._mh.fire_event(ev) return True except (MQTTException, error, ValueError) as ex: self._mh.demsg('htk_on_error', ex, self._mh.fromhere()) return False def disconnect(self): """Method disconnects from server Args: none Returns: bool: result """ try: self._mh.demsg('htk_on_debug_info', self._mh._trn.msg( 'htk_jms_disconnecting'), self._mh.fromhere()) if (not self._is_connected): self._mh.demsg('htk_on_warning', self._mh._trn.msg( 'htk_jms_not_connected'), self._mh.fromhere()) return False else: self._client.disconnect() self._is_connected = False self._mh.demsg('htk_on_debug_info', self._mh._trn.msg( 'htk_jms_disconnected'), self._mh.fromhere()) return True except (MQTTException, error, ValueError) as ex: self._mh.demsg('htk_on_error', ex, self._mh.fromhere()) return False def send(self, destination_name, message): """Method sends message Args: destination_name (str): topic name message (str): message Returns: bool: result Raises: event: jms_before_send event: jms_after_send """ try: msg = 'destination_name:{0}, message:{1}'.format( destination_name, message) self._mh.demsg('htk_on_debug_info', self._mh._trn.msg( 'htk_jms_sending_msg', msg), self._mh.fromhere()) if (not self._is_connected): self._mh.demsg('htk_on_warning', self._mh._trn.msg( 'htk_jms_not_connected'), self._mh.fromhere()) return False ev = event.Event('jms_before_send', destination_name, message) if (self._mh.fire_event(ev) > 0): destination_name = ev.argv(0) message = ev.argv(1) if (ev.will_run_default()): res, id = self._client.publish(destination_name, message) if (res != 0): self._mh.demsg('htk_on_error', self._mh._trn.msg( 'htk_jms_sending_error'), self._mh.fromhere()) self._mh.demsg('htk_on_debug_info', self._mh._trn.msg( 'htk_jms_msg_sent'), self._mh.fromhere()) ev = event.Event('jms_after_send') self._mh.fire_event(ev) return True except (MQTTException, error, ValueError) as ex: self._mh.demsg('htk_on_error', ex, self._mh.fromhere()) return False def receive(self, destination_name, cnt=1, timeout=10): """Method receives messages Args: destination_name (str): queue name cnt (int): count of messages timeout (int): timeout to receive message Returns: list: messages Raises: event: jms_before_receive event: jms_after_receive """ try: msg = 'destination_name:{0}, count:{1}'.format( destination_name, cnt) self._mh.demsg('htk_on_debug_info', self._mh._trn.msg( 'htk_jms_receiving_msg', msg), self._mh.fromhere()) if (not self._is_connected): self._mh.demsg('htk_on_warning', self._mh._trn.msg( 'htk_jms_not_connected'), self._mh.fromhere()) return None ev = event.Event('jms_before_receive', destination_name, cnt) if (self._mh.fire_event(ev) > 0): destination_name = ev.argv(0) cnt = ev.argv(1) if (ev.will_run_default()): res, id = self._client.subscribe(destination_name) if (res != 0): self._mh.demsg('htk_on_error', self._mh._trn.msg( 'htk_jms_sending_error'), self._mh.fromhere()) return None res = 0 cnt_before = 0 start = time() while (res == 0): res = self._client.loop() cnt_after = len(self._messages) if (cnt_after > cnt_before and cnt_after < cnt): cnt_before = cnt_after elif (cnt_after == cnt or time() > start + timeout): res = -1 messages = self._messages self._client.unsubscribe(destination_name) self._messages = [] self._mh.demsg('htk_on_debug_info', self._mh._trn.msg( 'htk_jms_msg_received', len(messages)), self._mh.fromhere()) ev = event.Event('jms_after_receive') self._mh.fire_event(ev) return messages except (MQTTException, error, ValueError) as ex: self._mh.demsg('htk_on_error', ex, self._mh.fromhere()) return None
class Messenger(object): """ MQTT client for Herald transport. """ def __init__(self, peer): """ Initialize client :param peer: The peer behind the MQTT client. :return: """ self.__peer = peer self.__mqtt = MqttClient() self.__mqtt.on_connect = self._on_connect self.__mqtt.on_disconnect = self._on_disconnect self.__mqtt.on_message = self._on_message self.__callback_handler = None self.__WILL_TOPIC = "/".join( (TOPIC_PREFIX, peer.app_id, RIP_TOPIC)) def __make_uid_topic(self, subtopic): """ Constructs a complete UID topic. :param subtopic: The UID :return: Fully qualified topic :rtype : str """ return "/".join( (TOPIC_PREFIX, self.__peer.app_id, UID_TOPIC, subtopic)) def __make_group_topic(self, subtopic): """ Constructs a complete group topic. :param subtopic: The group name :return: Fully qualified topic :rtype : str """ return "/".join( (TOPIC_PREFIX, self.__peer.app_id, GROUP_TOPIC, subtopic)) def __handle_will(self, message): if self.__callback_handler and self.__callback_handler.on_peer_down: self.__callback_handler.on_peer_down( message.payload.decode('utf-8')) else: _log.debug("Missing callback for on_peer_down.") def _on_connect(self, *args, **kwargs): """ Handles a connection-established event. :param args: unnamed arguments :param kwargs: named arguments :return: """ _log.info("Connection established.") _log.debug("Subscribing for topic %s.", self.__make_uid_topic(self.__peer.uid)) self.__mqtt.subscribe(self.__make_uid_topic(self.__peer.uid)) self.__mqtt.subscribe(self.__make_group_topic("all")) self.__mqtt.subscribe(self.__WILL_TOPIC) for group in self.__peer.groups: _log.debug("Subscribing for topic %s.", self.__make_group_topic(group)) self.__mqtt.subscribe(self.__make_group_topic(group)) if self.__callback_handler and self.__callback_handler.on_connected: self.__callback_handler.on_connected() else: _log.warning("Missing callback for on_connect.") def _on_disconnect(self, *args, **kwargs): """ Handles a connection-lost event. :param args: unnamed arguments :param kwargs: named arguments :return: """ _log.info("Connection lost.") if self.__callback_handler and self.__callback_handler.on_disconnected: self.__callback_handler.on_disconnected() def _on_message(self, client, data, message): """ Handles an incoming message. :param client: the client instance for this callback :param data: the private user data :param message: an instance of MQTTMessage :type message: paho.mqtt.client.MQTTMessage :return: """ _log.info("Message received.") if message.topic == self.__WILL_TOPIC: self.__handle_will(message) return if self.__callback_handler and self.__callback_handler.on_message: self.__callback_handler.on_message(message.payload.decode('utf-8')) else: _log.warning("Missing callback for on_message.") def fire(self, peer_uid, message): """ Sends a message to another peer. :param peer_uid: Peer UID :param message: Message content :return: """ self.__mqtt.publish( self.__make_uid_topic(peer_uid), message, 1 ) def fire_group(self, group, message): """ Sends a message to a group of peers. :param group: Group's name :param message: Message content :return: """ self.__mqtt.publish( self.__make_group_topic(group), message, 1 ) def set_callback_listener(self, listener): """ Sets callback listener. :param listener: the listener :return: """ self.__callback_handler = listener def login(self, username, password): """ Set credentials for an MQTT broker. :param username: Username :param password: Password :return: """ self.__mqtt.username_pw_set(username, password) def connect(self, host, port): """ Connects to an MQTT broker. :param host: broker's host name :param port: broker's port number :return: """ _log.info("Connecting to MQTT broker at %s:%s ...", host, port) self.__mqtt.will_set(self.__WILL_TOPIC, self.__peer.uid, 1) self.__mqtt.connect(host, port) self.__mqtt.loop_start() def disconnect(self): """ Diconnects from an MQTT broker. :return: """ _log.info("Disconnecting from MQTT broker...") self.__mqtt.publish(self.__WILL_TOPIC, self.__peer.uid, 1) self.__mqtt.loop_stop() self.__mqtt.disconnect()