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
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 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
def execute(self, chat_id, args):
client = Client(userdata=self.user_data)
connect_result = client.connect(self.config["server"])
if not connect_result == MQTT_ERR_SUCCESS:
raise Exception(
"Client connection error {}".format(connect_result))
topics = self.get_topic_list()
for topic in topics:
(subs_result, subs_id) = client.subscribe(topic)
client.on_message = self.on_message
if not subs_result == MQTT_ERR_SUCCESS:
raise Exception("Subscription error {}".format(subs_result))
time_start = time.time()
while True:
client.loop()
if self.user_data["messages_received"] >= len(topics):
break
if time.time() - time_start > 10:
break
self.bot.sendMessage(chat_id, self.format_output())
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
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 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():
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 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
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 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 __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)
mqtt_client = MQTTClient(MQTT_CLIENT_ID, userdata=influxdb_client)
mqtt_client.username_pw_set(MQTT_USERNAME, MQTT_PASSWORD)
mqtt_client.tls_set()
mqtt_client.on_connect = mqtt_connect_callback
mqtt_client.on_message = mqtt_message_callback
mqtt_client.connect(MQTT_HOST, MQTT_PORT)
mqtt_client.loop_forever()
def setup_mqtt_client():
def on_connect(client, *args):
client.subscribe(MQTT_TOPIC)
temp_client = Client()
temp_client.username_pw_set(**MQTT_CREDS)
temp_client.on_connect = on_connect
temp_client.on_message = on_message
temp_client.connect(MQTT_BROKER, 1883, 60)
return temp_client
def get_client(name, signals, *args, **kwargs):
'''
Create a MQTT client and bind connect, disconnect, and message callbacks.
'''
client = Client(*args, **kwargs)
client.connected = threading.Event()
client.on_connect = ft.partial(on_connect, name)
client.on_disconnect = ft.partial(
lambda *args, **kwargs: logging.debug('disconnected'))
client.on_message = ft.partial(on_message, 'dropbot', signals)
return client
def loop(self, ip, port, clientId='', username='', password='', **kwargs):
if MqttConnect.mqtt:
MqttConnect.mqtt.loop_stop()
mqtt = Client(clientId)
mqtt.username_pw_set(username, password)
mqtt.connect(ip, int(port))
mqtt.on_log = self.on_log
mqtt.on_connect = self.on_connect
mqtt.on_message = self.on_message
mqtt.loop_start()
MqttConnect.mqtt = mqtt
def run_mqtt_listener():
mqtt_broker_url = '167.86.108.163'
MQTT_HOST = os.getenv('MQTT_HOST', mqtt_broker_url)
client_name = 'mqtt-csw-importer'
topic = 'update_csw'
print("Sono partito")
print("->167.86.108.163")
print("->mqtt-csw-importer")
def _on_connect(client, userdata, flags, rc):
print("Connesso con successo al topic", topic)
def _on_log(client, userdata, level, buf):
# print("log", level, buf)
pass
def _on_message(client, userdata, message):
message = str(message.payload.decode("utf-8"))
payload = json.loads(message)['rndt_xml']
print('received event', payload)
print(
'----ENDED------------------------------------------------------')
cmd = 'pycsw-admin.py -c load_records -f /etc/pycsw/pycsw.cfg -p /home/pycsw/datatemp'
filename = "/home/pycsw/datatemp/temp1.xml"
try:
with open(filename, 'w') as file:
file.write(payload)
execute(cmd)
# execute('rm -f ' + filename)
except Exception as e:
print('Exception', e)
try:
client = Client(client_id='{}_{}'.format(client_name,
random.randint(1, 10000)),
clean_session=True)
print('Connecting to MQTT broker at ')
client.connect(MQTT_HOST)
except ConnectionRefusedError as e:
print('Connection refused by MQTT broker at ')
raise ConnectionRefusedError
client.on_connect = _on_connect
client.on_message = _on_message
client.on_log = _on_log
client.subscribe(topic)
client.loop_forever()
# client.loop_start()
print('loop started')
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
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 mqtt_client(server):
# ESP8266: import ubinascii, utime
import time
machine_id = b'ESP8266-999999'
# setup Mosquitto
# on Python3:
# pip install paho-mqtt
from paho.mqtt.client import Client as MQTTClient
mqttc = MQTTClient(machine_id, server)
mqttc.connect(server)
mqttc.on_message = callback_function_PahoMQTT
mqttc.subscribe('test/#')
mqttc.loop_start()
while True:
time.sleep(1)
mqttc.loop_stop()
def run(client: mqtt.Client):
client.publish(
f"homeassistant/switch/{CONFIG.get_device_name()}/screen/config",
f'{{"unique_id": "screen-{CONFIG.get_device_name()}", "name": "{CONFIG.get_device_name()} Screen", "device": {{"identifiers": ["{CONFIG.get_device_name()}"], "name": "{CONFIG.get_device_name()}"}}, "~": "homeassistant/switch/{CONFIG.get_device_name()}/screen", "availability_topic": "~/state", "command_topic": "~/set", "retain": true}}',
retain=True)
client.publish(
f"homeassistant/switch/{CONFIG.get_device_name()}/screen/state",
"online",
retain=True)
logging.info("Set mqtt toptic state to online")
client.subscribe(
f"homeassistant/switch/{CONFIG.get_device_name()}/screen/set")
client.on_message = on_message
client.loop_forever()
def main():
p = argparse.ArgumentParser()
p.add_argument('-a',
'--account-path',
help='Path to JSON file containing Google account details')
args = p.parse_args()
google_session = get_google_session(args.account_path)
brokers = {}
clients = []
reporter = Reporter(google_session)
for device_id, device, desc in generate_devices_from_config():
if not device.url.startswith('mqtt://'):
continue
device_name, host, port, username, password = parse_mqtt_url(
device.url)
broker = (host, port, username, password)
brokers.setdefault(broker, {}).setdefault(device_name,
[]).append(device)
for (host, port, username, password), devices in brokers.items():
client = Client(clean_session=True, userdata=devices)
client.on_message = reporter.on_msg
if username is not None:
client.username_pw_set(username, password)
client.connect(host, port)
for device_name in devices:
# log(f'{device_name} --> STATE')
client.subscribe(f'stat/{device_name}/RESULT')
client.publish(f'cmnd/{device_name}/state')
client.loop_start()
clients.append(client)
try:
while 1:
time.sleep(5)
except KeyboardInterrupt:
print('Ctrl-C')
for client in clients:
client.loop_stop()
def run_client(settings):
def on_connect(*args, **kwargs):
print("connected")
def on_message(*args, **kwargs):
print("message received", args, kwargs)
client = MQTTClient()
client.on_connect = on_connect
client.on_message = on_message
client.connect(server, settings["mqtt_settings"]["port"], 60)
t0 = time.time()
while True:
time.sleep(1)
client.loop()
td = time.time() - t0
f = lambda x: np.log(x / 10) * 10 + 50
data = '{"meat_temp": %.1f, "oven_temp": %.1f}' % (f(td), f(td + 100))
print("publishing data")
client.publish("test_topic", data)
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()
def get_mqtt_payload(topic):
mqttBroker = "localhost"
client = Client("Temperature_Inside")
if topic == "PYWATERING":
client.on_connect = on_connect_st
elif topic == "PLANT1":
client.on_connect = on_connect_plant1
elif topic == "PLANT2":
client.on_connect = on_connect_plant2
elif topic == "PLANT3":
client.on_connect = on_connect_plant3
elif topic == "PLANT4":
client.on_connect = on_connect_plant4
client.on_message = on_message
client.username_pw_set(username=uname, password=passwd)
client.connect("localhost")
client.loop_start()
time.sleep(2)
client.loop_stop()
return global_message
def test_mqtt_telemetry():
cfg.TELEMETRY_DEFAULT_INPUTS = 'pilot/angle,pilot/throttle'
cfg.TELEMETRY_DONKEY_NAME = 'test{}'.format(randint(0, 1000))
cfg.TELEMETRY_MQTT_JSON_ENABLE = True
# 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/#" % cfg.TELEMETRY_DONKEY_NAME
sub.subscribe(name)
t = MqttTelemetry(cfg)
t.add_step_inputs(inputs=['my/voltage'], types=['float'])
t.publish()
timestamp = t.report({'my/speed': 16, 'my/voltage': 12})
t.run(33.3, 22.2, 11.1)
assert t.qsize == 2
time.sleep(1.5)
t.publish()
assert t.qsize == 0
time.sleep(0.5)
res = str.encode('[{"ts": %s, "values": {"my/speed": 16, "my/voltage": 11.1, "pilot/angle": 33.3, '
'"pilot/throttle": 22.2}}]' % timestamp)
assert on_message_mock.call_args_list[0][0][2].payload == res
def mqtt_cmnd(topic,
payload=None,
resp_topic=None,
host=None,
port=1883,
username=None,
password=None):
resp_q = queue.Queue(1)
c = MQTTClient(clean_session=True)
if username is not None:
c.username_pw_set(username, password)
c.connect(host, port)
c.subscribe(resp_topic or topic)
c.on_message = lambda client, userdata, msg: resp_q.put(msg.payload)
c.publish(topic, payload)
c.loop_start()
try:
return resp_q.get(timeout=1)
except queue.Empty:
raise TimeoutError from None
finally:
c.loop_stop()
def __init__(self, client_id, config, wait=True):
"""
initialize mqtt client
:param client_id: client id
:param config: keeper configuration
:param wait: whether to wait for connection
"""
self.logger = Logger()
user = config.get("mqtt.user")
pwd = config.get("mqtt.pass")
client = Client(client_id=client_id)
client.on_connect = self._on_connect
client.on_disconnect = self._on_disconnect
client.on_message = self._on_message
client.enable_logger(self.logger)
if user and pwd:
client.username_pw_set(user, pwd)
client.connect_async(config["mqtt.broker"], config["mqtt.port"], 30)
self.client = client
self.connected = False
self.manager = None
self.wait = wait
def main():
parser = argparse.ArgumentParser(description=help_text)
parser.add_argument('-l',
'--log-level',
action='store',
type=str,
dest='log_level',
help='Log level',
default='INFO')
args = parser.parse_args()
numeric_level = getattr(logging, args.log_level.upper(), None)
if not isinstance(numeric_level, int):
raise ValueError('Invalid log level: %s' % args.log_level)
coloredlogs.install(level=numeric_level)
logger.info('Log level set to %s', args.log_level)
client = Client()
client.username_pw_set("****", "****")
client.on_connect = on_connect
client.on_message = on_message
client.connect(MQTT_ADRESS, MQTT_PORT, 60)
client.loop_forever()
def client(self):
client = Client(client_id=self._auth.client_id)
client.tls_set_context(self.ssl_context)
client.on_connect = self.on_connect
client.on_message = self.on_message
return client
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()
