def mqtt(self): if not hasattr(self, '_mqtt_client'): self.responses = {} self.ready = False client = MQTTClient() client.username_pw_set(self.apikey) client.on_connect = self._on_connect client.on_message = self._on_message client.on_subscribe = self._on_subscribe client.connect(self.client.endpoint.replace('mqtt://', '')) self._mqtt_client = client # Start the loop and wait for the connection to be ready self._mqtt_client.loop_start() while not self.ready: time.sleep(.1) return self._mqtt_client
class MqttClient(TransportClient): def __init__(self, host_name: str, settings: MqttSettings): self.host_name = host_name self.settings = settings self.sub_topic_root = f"label_servers/print/{host_name}" self._callback: Optional[Callable[[PrintRequest], Any]] = None # Configure the client self.client = Client(self.host_name) # TLS settings if we have them if self.settings.tls_cafile is not None and self.settings.tls_cafile.strip( ): self.client.tls_set(self.settings.tls_cafile) self.client.connect(settings.mqtt_broker_host, settings.mqtt_broker_port, 60) self.client.on_connect = self._on_connect self.client.on_message = self._on_message def _on_connect(self, client: Client, user_data, flags, reason_code, properties=None): logger.info(f"Connected with reason code {reason_code}") sub_topic = f"{self.sub_topic_root}/#" logger.info(f"Subscribing to: {sub_topic}") client.subscribe(sub_topic) client.will_set(f"label_servers/status/{self.host_name}", json.dumps({"online": False})) def _on_message(self, client: Client, user_data, message: MQTTMessage): logger.info(f"Received Message: {message.topic}") try: # Remove topic root stripped = message.topic.replace(self.sub_topic_root, "").strip("/") # Print requests should be of the form "<printer_serial>/<mode>" parts = stripped.split("/") if len(parts) >= 2: serial, mode, *_ = parts request = PrintRequest(serial, RequestMode.parse(mode), message.payload) if self._callback: self._callback(request) except Exception as e: logger.error("Error processing received message", exc_info=e) def publish(self, status: HostStatus): self.client.publish(f"label_servers/status/{self.host_name}", json.dumps(status.as_dict())) def start(self, on_message: Callable[[PrintRequest], None]): self._callback = on_message self.client.loop_start()
def main(): global args, write_api parser = ArgumentParser(description=__doc__) parser.add_argument("--host", default='localhost', help='hostname of mqtt broker') parser.add_argument( "-t", action='append', default=['velogen/raw'], help='MQTT topic to subscribe to. Can be put multiple times.') parser.add_argument("-d", action='store_true', help='enable debug output') parser.add_argument("--user", default=None, help="username") parser.add_argument("--pw", default=None, help="password") args = parser.parse_args() client = Client() client.on_connect = on_connect client.on_disconnect = on_disconnect client.on_message = on_message if args.user is not None and args.pw is not None: client.username_pw_set(args.user, args.pw) client.connect(args.host) # For influxdb2 only db = InfluxDBClient(url='http://localhost:8086', token=token, debug=args.d) write_api = db.write_api(write_options=SYNCHRONOUS) while True: client.loop(timeout=1.0)
def setMqttClient(client: Client): client.on_message = on_message client.on_connect = on_connect client.connect(server, port) client.loop_start() self.client = client
class MqttSubscriber(BaseSubscriber): def __init__(self, *args, **kwargs): self.client = None self.message = None self.f = open("time_taken_mqtt.txt", "a+") def connect(self, host="localhost", port=5000, topic="test"): print("Connected") self.client = Client() self.client.connect(host=host) self.client.on_message = self.recv_message self.client.on_subscribe = self.on_subscribe self.client.subscribe(topic) self.client.loop_forever() def on_subscribe(self, *args, **kwargs): print("Subscribed") def recv_message(self, client, userdata, message): print(message.payload) message = json.loads(message.payload) latency = time() - message["sentAt"] msg_size = len(message["message"].encode('utf-8')) self.f.write("{} : {}\n".format(msg_size, latency)) print("Message received : {} size is {} in {}".format( message, msg_size, str(latency))) def close(self): pass
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.")
def test_mqtt_telemetry(): # Create receiver sub = Client(clean_session=True) # def on_message(client, userdata, message): # data = message.payload # print(message) on_message_mock = mock.Mock() sub.on_message = on_message_mock sub.connect(cfg.TELEMETRY_MQTT_BROKER_HOST) sub.loop_start() name = "donkey/%s/telemetry" % cfg.TELEMETRY_DONKEY_NAME sub.subscribe(name) t = MqttTelemetry(cfg, default_inputs=['angle'], default_types=['float']) t.publish() timestamp = t.report({'speed': 16, 'voltage': 12}) t.run(33.3) assert t.qsize == 2 time.sleep(1.5) t.publish() assert t.qsize == 0 time.sleep(0.5) res = str.encode( '[{"ts": %s, "values": {"speed": 16, "voltage": 12, "angle": 33.3}}]' % timestamp) assert on_message_mock.call_args_list[0][0][2].payload == res
def _run(self): ''' The main function of this task. ''' # join function input buffer, it's a shared memory join_in_buf = [None] * len(self.idf_confs) def on_connect(client, userdata, rc): log.info('ESM connect to mqtt broker with return code %s', rc) # create odf publish partial function for conf in self.odf_confs: conf['pub'] = partial(client.publish, conf['topic']) for idx, idf in enumerate(self.idf_confs): topic = idf['topic'] client.subscribe(topic) client.message_callback_add( topic, self._msg_callback( idf.get('func'), self.join_func.get('func'), self.odf_confs, join_in_buf, idx)) mqtt_conn = Client() mqtt_conn.on_connect = on_connect mqtt_conn.connect(config.mqtt_conf['host'], port=config.mqtt_conf['port']) mqtt_conn.loop_forever()
def create_client(self, host, port, username, password, clientid, cafile=None): """Creating an MQTT Client Object""" client = MqttClient(clientid) if username and password: client.username_pw_set(username=username, password=password) else: self.logger.warn("Proceeding without username and password") if cafile: client.tls_set(ca_certs=cafile) else: self.logger.warn("Proceeding without certificate file") try: client.on_connect = self.on_connect client.on_message = self.on_message client.connect(host=host, port=port) except OSError as error: self.logger.error(error) return client
class PahoClient(MQTTClientBase): def __init__(self, host: str, port: int, keepalive: int): self._client = Client() self._host = host self._port = port self._keepalive = keepalive self._on_message, self._on_connect, self._subscription_topics = None, None, [] def connect(self, subscription_topics: List[str], on_connect=None, on_message=None): self._client.on_connect = self.__connected self._client.on_message = self.__message_received self._on_message, self._on_connect, self._subscription_topics = on_message, on_connect, subscription_topics self._client.connect(self._host, self._port, self._keepalive) def __connected(self): for topic in self._subscription_topics: self._client.subscribe(topic) if self._on_connect: self._on_connect() def __message_received(self, client: Client, userdata, msg): if self._on_message: self._on_message(msg) def loop_background(self): self._client.loop_start()
def main(broker, port, interface): """Scan for all MiPlant devicesself. Send via MQTT if broker is provided. Print to console otherwise. """ sensors = discover_and_scan(interface) if broker: client = Client() client.connect(broker, port) client.loop_start() for sensor in sensors: payload = json.dumps({ 'battery': sensor.battery, 'temperature': sensor.temperature, 'light': sensor.light, 'moisture': sensor.moisture, 'conductivity': sensor.conductivity }) channel = "sensors/plantsensors/{addr}".format(addr=sensor.address) client.publish(channel, json.dumps(payload)) client.loop_stop() else: for sensor in sensors: print('--------------------------') print('Address: {addr}'.format(addr=sensor.address)) print('Battery level: {bat}'.format(bat=sensor.battery)) print('Temperature: {temp} °C'.format(temp=sensor.temperature)) print('Light: {light} lx'.format(light=sensor.light)) print('Moisture: {moist}'.format(moist=sensor.moisture)) print( 'Conductivity: {cond} µS/cm'.format(cond=sensor.conductivity))
class BugfixClient(PAHO_MQTT_Client): def connect(self): homie.mqtt.mqtt_base.MQTT_Base.connect(self) #self.mqtt_client = MQTTClientWrapper(client_id=self.mqtt_settings['MQTT_CLIENT_ID']) self.mqtt_client = Client(client_id=self.mqtt_settings['MQTT_CLIENT_ID']) self.mqtt_client.on_connect = self._on_connect self.mqtt_client.on_message = self._on_message #self.mqtt_client.on_publish = self._on_publish self.mqtt_client.on_disconnect = self._on_disconnect self.mqtt_client.enable_logger(homie.mqtt.paho_mqtt_client.mqtt_logger) self.mqtt_client.enable_logger() if self.mqtt_settings ['MQTT_USERNAME']: self.mqtt_client.username_pw_set( self.mqtt_settings ['MQTT_USERNAME'], password=self.mqtt_settings ['MQTT_PASSWORD'] ) try: self.mqtt_client.connect( self.mqtt_settings ['MQTT_BROKER'], port=self.mqtt_settings ['MQTT_PORT'], keepalive=self.mqtt_settings ['MQTT_KEEPALIVE'], ) self.mqtt_client.loop_start() except Exception as e: homie.mqtt.paho_mqtt_client.logger.warning ('MQTT Unable to connect to Broker {}'.format(e))
class Seller: ''' Set objects for sale and publish them on 'Available-items' topic ''' def __init__(self, number_items, broker='localhost', auth=None): self.number_of_items = number_items self.auth = auth self.client = Client() if auth != None: (usr, pwd) = auth self.client.username_pw_set(usr, pwd) self.client.connect(broker) def sell_process(self, update=False): available_itms = ''.join( [str(x) + ' ' for x in range(1, self.number_of_items + 1)]) self.client.publish('Available-items', available_itms) while update: self.client.publish('Available-items', available_itms) time.sleep(3 * random.random()) def sell(self): Process(target=self.sell_process, args=()).start()
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()
def config(self, mqtt_client: MqttClient): if self.username and self.password: mqtt_client.username_pw_set(self.username, self.password) mqtt_client.connect( self.host, self.port, )
def connect(client: mqtt.Client, args: argparse.Namespace): """Connect to an MQTT broker with supplied arguments.""" if args.username: client.username_pw_set(args.username, args.password) # TLS if args.tls: # TLS is enabled if args.tls_version is None: # Use highest TLS version args.tls_version = ssl.PROTOCOL_TLS if args.tls_ca_certs is not None: args.tls_ca_certs = os.path.expandvars(args.tls_ca_certs) if args.tls_certfile is not None: args.tls_certfile = os.path.expandvars(args.tls_certfile) if args.tls_keyfile is not None: args.tls_keyfile = os.path.expandvars(args.tls_keyfile) client.tls_set( ca_certs=args.tls_ca_certs, certfile=args.tls_certfile, keyfile=args.tls_keyfile, cert_reqs=getattr(ssl, args.tls_cert_reqs), tls_version=args.tls_version, ciphers=(args.tls_ciphers or None), ) client.connect(args.host, args.port)
def init_client(): #variabili di sistema settate access_key = os.environ["AWS_ACCESS_KEY_ID"] secret_key = os.environ["AWS_SECRET_ACCESS_KEY"] port = 443 region = "us-east-2" # This is specific to your AWS account host = "a3pwbt0axh6wnd-ats.iot.us-east-2.amazonaws.com".format(region) extra_headers = functools.partial( get_amazon_auth_headers, access_key, secret_key, region, host, port, ) client = Client(transport="websockets") client.ws_set_options(headers=extra_headers) # Use client as normal from here client.on_connect = on_connect client.on_message = on_message client.on_publish = on_publish client.tls_set() client.connect(host, 443,60) return client
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(): global args parser = ArgumentParser(description=__doc__) parser.add_argument( "--host", default='localhost', help='hostname of mqtt broker' ) parser.add_argument( "--topic", default='velogen/raw', help='comma separated list of MQTT topics to subscribe to' ) args = parser.parse_args() c = Client() c.on_connect = on_connect c.on_disconnect = on_disconnect c.on_message = on_message c.connect(args.host) atexit.register(commit) while True: ts = datetime.now().timestamp() for tp, rts in rx_ts_dict.items(): if rts is not None: # dump to file after 30 s of silence if ts - rts > 30: clean_write(tp) rx_ts_dict[tp] = None c.loop(1.0)
def main(): client = Client(protocol=MQTTv311) client.username_pw_set(USERNAME, password=PASSWORD) client.connect(HOST, port=PORT, keepalive=60) host1 = "98:07:2D:35:7B:00" host2 = "98:07:2D:40:95:83" 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.publish(TOPIC1, payload=dumps(data1)) client.publish(TOPIC2, payload=dumps(data2)) sleep(30) except KeyboardInterrupt: print("Disconnected to SensorTags") tag1.disconnect() tag2.disconnect()
def main(): print("Hello! this is aggry! I send wonderful data :)") client = Client(client_id="aggry") client.on_connect = on_connect client.on_message = on_message if debug: client.on_log = on_log else: print("Debug mode disabled by configuration.") # Swarm does not handle dependencies sleep(2) try: rc = client.connect("broker", 1883, 60) except: # just try again print("connect: trying again...") sleep(4) client.connect("broker", 1883, 60) # main loop client.loop_forever()
def get_client(project_id: str, cloud_region: str, registry_id: str, device_id: str, password: str, mqtt_bridge_hostname: str, mqtt_bridge_port: str, ca_certs: str): client_id = 'projects/{}/locations/{}/registries/{}/devices/{}'.format( project_id, cloud_region, registry_id, device_id) secho('Client ID: ', fg='bright_green', nl=False) echo('\'{}\''.format(client_id)) client = Client(client_id=client_id) client.username_pw_set(username='******', password=password) client.tls_set(ca_certs=ca_certs, tls_version=ssl.PROTOCOL_TLSv1_2) # Assign callbacks client.on_connect = on_connect client.on_publish = on_publish client.on_disconnect = on_disconnect client.on_message = on_message # Connect to MQTT bridge client.connect(mqtt_bridge_hostname, mqtt_bridge_port) client.loop_start() return client
def set_up(host, port, subscribe_to_topics_func): global _instance, _subscribe_to_topics_func _subscribe_to_topics_func = subscribe_to_topics_func _instance = Client() _instance.on_connect = _on_connect _instance.on_message = _on_message _instance.connect(host, port) _instance.loop_start()
def ensure_mqtt(host): mqtt_client = MQTTClient() mqtt_client.on_connect = mqtt_on_connect mqtt_client.message_callback_add('embrace/sensors', mqtt_on_message_sensor) mqtt_client.message_callback_add('embrace/topology', mqtt_on_message_topology) mqtt_client.connect(host, 1883, 60) return mqtt_client
def check_broker(): from paho.mqtt.client import Client try: client = Client() client.connect('localhost', 1883) return True except Exception as e: return False
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 main(): try: client = Client("Misol") # create new instance client.connect("192.168.1.3") # connect to broker client.publish("/devices/misol/meta/name", "Misol Meteostation", qos=0, retain=True) for order, topic in enumerate(TOPICS, 1): publish(client, topic, order) log.debug("Connected to MQTT") s = Serial('/dev/ttyUSB0', 9600, timeout=60) log.debug("Connected to serial") while True: log.debug("Start Read") raw = s.read(21) checksum = sum(i for i in raw[:16]) & 0xFF assert checksum == raw[16], "Wrong checksum" wd = wdata.from_buffer_copy(raw) rwd: RawWeatherData = wd.rawdata wind = ((wd.rawdata.WSP8 << 8) + wd.rawdata.WIND) / 8 * 1.12 uvi = next((i for i, v in enumerate(UVI) if rwd.UVI <= v), 13) payload = { 'wind_direction': (wd.rawdata.DIR8 << 8) + wd.rawdata.DIR, 'battery_low': rwd.BAT, 'temperature': (rwd.TMP - 400) / 10.0, 'humidity': rwd.HM, 'wind_speed': round(wind), 'wind_gust': round(rwd.GUST * 1.12), 'rain': rwd.RAIN, 'uvi': uvi, 'light': round(rwd.LIGHT / 10.0), 'bar': round(rwd.BAR / 100.0, 2), 'last_update': int(time.time()) } for k, v in payload.items(): info = client.publish(f"{BASE}/{k}", v, retain=True) assert info.rc == MQTT_ERR_SUCCESS, f"MQTT Error: {info.rc}" log.debug("Updated MQTT") except AssertionError as e: log.error(e) except: log.exception("Exception")
class mqtt_client_connect(): def __init__(self, broker="10.129.7.199", port=1883, username="******", password="******", client_id="12345"): self.broker = broker self.port = port self.username = username self.password = password self.payload = None self.client_id = client_id self.num = 1 self.flag = 0 try: # self.mqttc=Client(clean_session=False,client_id="12345") self.mqttc = Client(client_id=self.client_id) self.mqttc.on_connect = self.on_connect self.mqttc.on_publish = self.on_publish self.mqttc.on_subscribe = self.on_subscribe self.mqttc.username_pw_set(self.username, self.password) self.mqttc.connect(self.broker, port=self.port) self.mqttc.loop_start() except: print( "mqtt_client_connect error: mqttc connect failed Please check Broker and Port...." ) # ====================================================== def on_connect(self, client, userdata, flags, rc): #rc为0 返回连接成功 if rc == 0: self.flag = 1 print("OnConnetc, rc: " + str(rc), 'successful ' + str(client._username)) else: self.flag = 0 print("OnConnetc, rc: " + str(rc), 'unsuccessful ' + str(client._username)) def on_disconnect(self, client, userdata, rc): if rc != 0: self.flag = 0 print("Unexpected MQTT disconnection. Will auto-reconnect") def on_publish(self, client, userdata, mid): print("OnPublish, mid: " + str(mid) + " " + str(client._username)) def on_subscribe(self, client, userdata, mid, granted_qos): print("Subscribed: " + str(mid) + " " + str(granted_qos) + " 订阅成功 " + str(client._username)) self.mqttc.on_message = self.on_message def on_message(self, client, userdata, msg): strcurtime = time.strftime("%Y-%m-%d %H:%M:%S") print(strcurtime + ": " + msg.topic + " " + str(msg.qos) + " " + str(msg.payload) + str(client._username))
def create_client(host, port, username, password): """Creating an MQTT Client Object""" client = MqttClient() if username and password: client.username_pw_set(username=username, password=password) client.connect(host=host, port=port) return client
def __subscribe(self): ip_list = self.settings.get("slaves", ["127.0.0.1"]) for ip in ip_list: client = Client() client.connect(ip, 1883, self.settings.get("mqtt_timeout", 60)) client.on_connect = self.__on_connect client.on_message = self.__on_message client.loop_start() self.client_list.append(client)
def main(): influxdb_client = InfluxDBClient(INFLUXDB_HOST, INFLUXDB_PORT, INFLUXDB_USERNAME, INFLUXDB_PASSWORD, INFLUXDB_DATABASE) #First the database is initialized mqtt_client = MQTTClient( MQTT_CLIENT_ID, userdata=influxdb_client) #Then we create a client object mqtt_client.username_pw_set(MQTT_USERNAME, MQTT_PASSWORD) #and set the username and password for the MQTT client mqtt_client.tls_set() mqtt_client.on_connect = mqtt_connect_callback #We tell the client which functions are to be run on connecting mqtt_client.on_message = mqtt_message_callback #and on receiving a message mqtt_client.connect(MQTT_HOST, MQTT_PORT) #we can connect to the broker with the broker host and port mqtt_client.loop_forever()
def publish_job(): """ 打卡任务 """ client = Client() client.on_connect = on_connect with open('captured_packet.json', encoding='utf-8') as f: packet_info = json.load(f) # 连接代理服务器 print('🙈 正在连接代理服务器...') client.connect(packet_info['dst host'], 1883) client.loop_forever()
class MQTT(Component): def init(self, url): self.url = url host, port = parse_bind(self.url) self.client = Client() self.client.on_connect = self._on_connect self.client.on_message = self._on_message self.client.connect(host, port) self.client.loop_start() def _on_connect(self, client, userdata, flags, rc): print("Connected with result code {0}".format(rc)) def _on_message(self, client, userdata, msg): print("{0} {1}".format(msg.topic, msg.payload))
class MQTTEventSink(EventSink): def __init__(self, broker, topic="iot-1/d/%012x/evt/%s/json", hostname=None, hostport=1883, username=None, password=None, keepalive=60): EventSink.__init__(self, broker) self._client = Paho() self._client.on_connect = \ lambda mosq, obj, rc: self._on_connect(mosq, obj, rc) self._client.on_disconnect = \ lambda mosq, obj, rc: self._on_disconnect(mosq, obj, rc) self._client.on_publish = \ lambda mosq, obj, mid: self._on_publish(mosq, obj, mid) self._topic_format = topic self._topic = self._topic_format % (0, "%s") self._hostname = hostname self._hostport = hostport self._username = username self._password = password self._keepalive = keepalive self._loopflag = False self._neta = None def _on_connect(self, mosq, obj, rc): self._topic = self._topic_format % (get_mac(), "%s") log.debug("MQTT publisher connected: " + str(rc)) def _on_disconnect(self, mosq, obj, rc): log.debug("MQTT publisher disconnected: " + str(rc)) def _on_publish(self, mosq, obj, mid): #log.debug("MQTT publisher published: " + str(mid)) pass def _try_connect(self): if self._username is not None and self._password is not None: self._client.username_pw_set(self._username, self._password) try: self._client.connect(self._hostname, self._hostport, self._keepalive) except socket.gaierror: return False self._client.loop_start() self._loopflag = True return True def on_start(self): return self._try_connect() def send(self, encoded_event): # Fill in the blank "%s" left in self._topic import json # extract the actual topic string event = json.loads(encoded_event) topic_event_type = event["d"]["event"] topic = self._topic % topic_event_type # Check to see if event is from neighbors # and need to be published to Mqtt server if "published" in event["d"]: if event["d"]["published"] == 1: return True else: del event["d"]["published"] # Publish message res, mid = self._client.publish(topic, encoded_event) if res == paho.mqtt.client.MQTT_ERR_SUCCESS: log.info("MQTT message published to " + topic) elif res == paho.mqtt.client.MQTT_ERR_NO_CONN: log.error("MQTT publisher failure: No connection") return False else: log.error("MQTT publisher failure: Unknown error") return False return True def check_available(self, event): if self._neta is not None and not self._neta: return False if not self._loopflag: if not self._try_connect(): log.error("MQTT publisher failure: Cannot connect") return False return True def on_event(self, event, topic): et = event.get_type() ed = event.get_raw_data() if et == "internet_access": self._neta = ed def encode_event(self, event): # return event.to_json() return json.dumps({"d": event.to_map()})
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()
class PipaMQTTClient(object): def __init__(self, client_id, host, port=1883, **kwargs): self._logger = logging.getLogger("gsensors.PipaMQTTClient") self._host = host self._port = port self._mqtt_client = Client(client_id=client_id, clean_session=False) self._mqtt_client.on_connect = self.on_connect self._mqtt_client.on_disconnect = self.on_disconnect self._mqtt_client.on_message = self.on_message self.worker = None self.worker_runner = None self.topics_sources = {} self.running = False self.connected = False def publish(self, topic, payload=None, qos=0, retain=False): # check connected if not self.connected: raise RuntimeError("MQTT client not connected ! ") if not self.running: raise RuntimeError("MQTT client not running ! ") self._mqtt_client.publish(topic, payload=payload, qos=qos, retain=retain) def PublishAction(self, topic, payload=None, retain=False): if payload is None: def _action(source, value): data = "%s" % value self._logger.debug("publish %s: %s" % (topic, data)) self.publish(topic, payload=data, retain=retain) else: def _action(*args, **kwargs): self._logger.debug("publish %s: %s" % (topic, payload)) self.publish(topic, payload=payload, retain=retain) return _action def on_disconnect(self, client, userdata, rc): self._logger.error("Disconnected with result code: "+str(rc)) self.connected = False self.connect() def on_connect(self, client, userdata, flags, rc): if rc == 0: self._logger.info("Connected to MQTT broker") self.connected = True # Subscribing in on_connect() means that if we lose the connection and # reconnect then subscriptions will be renewed. #client.subscribe("$SYS/#") #client.subscribe("#") for topic in self.topics_sources.keys(): client.subscribe(topic) else: self._logger.error("Connection fail with error: %s" % rc) def on_message(self, client, userdata, msg): self._logger.debug("get a msg %s: %s" % (msg.topic, msg.payload)) if msg.topic in self.topics_sources: source = self.topics_sources[msg.topic] source.update(msg) def register_source(self, source, topic): # check that topic has no wildcard assert "#" not in topic if topic in self.topics_sources: raise ValueError("topic already monitored") self.topics_sources[topic] = source self._mqtt_client.subscribe(topic) return source def connect(self): self.worker_runner = gevent.spawn(self._connect) def _connect(self): while not self.connected: try: #self._mqtt_client.reinitialise() self._mqtt_client.connect(host=self._host, port=self._port, keepalive=60) except socket.error as err: self._logger.error("Imposible to connect to MQTT: %s" % err) self._logger.info("Will retry in 2 seconds") gevent.sleep(2) def wait_connected(self): while not self.connected: gevent.sleep(1) def start(self): if self.running: return self.running = True self.worker = gevent.spawn(self._mqtt_loop) self.connect() def _mqtt_loop(self): while self.running: self._mqtt_client.loop(timeout=0.02) gevent.sleep(0.01)
from paho.mqtt.client import Client as MQTTClient from client.models import ServerAPIModel from client.core import make_device_client # Init mqtt client mqtt_client = MQTTClient('paho_lol') mqtt_client.connect('mqtt.acandale.com', 1883, 6000) # Create the model model = ServerAPIModel('http://localhost:8000', 'test') # Create the client cl = make_device_client(model, 'my_client', mqtt_client) # Call methods cl.no_argument_handler('payload') cl.one_argument_handler('payload', 'first_arg') cl.two_argument_handler('payload', 'first_arg', 'second_arg')
class MqttApplication(Application): """ An abstract base Application for running some type of MQTT client-based Application. """ def __init__(self, broker, hostname=None, hostport=1883, username=None, password=None, keepalive=60, **kwargs): super(MqttApplication, self).__init__(broker=broker, **kwargs) self._client = MqttClient() self._client.on_connect = \ lambda mqtt_client, obj, rc: self._on_connect(mqtt_client, obj, rc) self._client.on_disconnect = \ lambda mqtt_client, obj, rc: self._on_disconnect(mqtt_client, obj, rc) self._client.on_publish = \ lambda mqtt_client, obj, mid: self._on_publish(mqtt_client, obj, mid) self._client.on_subscribe = \ lambda mqtt_client, userdata, mid, qos: self._on_subscribe(mqtt_client, mid, qos) self._client.on_message = \ lambda mqtt_client, userdata, msg: self._on_message(mqtt_client, msg.payload, msg.topic, msg.qos, msg.retain) self._hostname = hostname self._hostport = hostport self._username = username self._password = password self._keepalive = keepalive self._is_connected = False @property def is_connected(self): return self._is_connected # Your API for pub-sub via MQTT: def mqtt_publish(self, raw_data, topic, **kwargs): """ Publishes the given data to the specified topic. :param raw_data: :type raw_data: str :param topic: :param kwargs: e.g. qos, retain; passed to self._client.publish :return: err_code, msg_id """ return self._client.publish(topic, raw_data, **kwargs) def mqtt_subscribe(self, topic, **kwargs): """ Subscribes to the specified topic. :param topic: :param kwargs: e.g. qos; passed to self._client.publish :return: err_code, msg_id """ return self._client.subscribe(topic, **kwargs) # To make use of either publish or subscribe, make sure to implement these! def _on_publish(self, mqtt_client, obj, mid): log.debug("MQTT app %s published msg %d: %s" % (self.name, mid, obj)) def _on_subscribe(self, mqtt_client, mid, qos): log.debug("MQTT app %s subscribe response msg %d: qos=%s" % (self.name, mid, qos)) def _on_message(self, mqtt_client, payload, topic, qos, retain): """Called when a message arrives on a topic we subscribed to.""" log.debug("MQTT app %s received message on topic %s: %s" % (self.name, topic, payload)) # You may want to override these functions in your concrete Application, but make sure to call super()! def _on_connect(self, mqtt_client, obj, rc): log.debug("MQTT app %s connected: %s" % (self.name, str(rc))) # need to start AFTER connecting, which is async! self._is_connected = True def _on_disconnect(self, mqtt_client, obj, rc): # sink will try reconnecting once EventReporter queries if it's available. self._is_connected = False log.debug("MQTT app %s disconnected: %s" % (self.name, str(rc))) def _try_connect(self): if self._username is not None and self._password is not None: self._client.username_pw_set(self._username, self._password) try: # NOTE: this is an async connection! self._client.connect(self._hostname, self._hostport, self._keepalive) self._client.loop_start() except socket.gaierror: return False return True def on_start(self): super(MqttApplication, self).on_start() return self._try_connect()
from paho.mqtt.client import Client def on_connect(client, userdata, rc): client.subscribe("#") def on_message(client, userdata, msg): print(msg.topic+" "+str(msg.payload)) client = Client() client.on_message = on_message client.on_connect = on_connect client.connect("broker.mqttdashboard.com") client.loop_forever()