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 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 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 setMqttClient(client: Client):
client.on_message = on_message
client.on_connect = on_connect
client.connect(server, port)
client.loop_start()
self.client = client
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 _are_valid_credentials(self, username, password):
"""Checks whether credentials are valid"""
def _on_connect(client, userdata, flags, rc):
"""A callback that matches the MQTT client signature, that triggers when connection was established"""
userdata.set_return_code(rc)
client.disconnect()
client.loop_stop()
client.should_stop = True
con_result = ConnectionResult()
client = Client(userdata=con_result)
client.username_pw_set(username, password)
client.on_connect = _on_connect
start_time = time.time()
client.should_stop = False
client.connect_async(self.host, self.port)
client.loop_start()
while not client.should_stop and time.time(
) - start_time < self.timeout:
time.sleep(0.001)
return con_result.did_succeed
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 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 _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 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 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 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 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()
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 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 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 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 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 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 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 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 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 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 connauth(host, clientid=None, user=None, passwd=None, **kw):
"""
connauth helps in checking if a client can connect to a broker with specific client id and/or credentials
:param host: Host to connect to
:param clientid: Client ID to use. If not specified paho-mqtt generates a random id.
:param user: User name of the client. If None or empty, connection is attempted without user, pwd
:param passwd: Password of the client. If None, only user name is sent
:param kw: Client.connect() keyword arguments (excluding host)
:return: Two comma separated values - The result code and it's string representation
"""
rc = {"rc": None}
c = Client(clientid, userdata=rc)
if user is not None and user is not "":
c.username_pw_set(user, passwd)
c.on_connect = SimpleMqttClient._on_connauth
#print("connecting to ({})".format(host))
r = c.connect(host, **kw)
#print("connect() returned r.__class__ = ({}), r = ({})".format(r.__class__, r))
r = c.loop_forever()
return rc["rc"], connack_string(rc["rc"])
def connauth(host, client_id=None, user=None, passwd=None, **kw):
"""
Helper to check if a client can connect to a broker with specific
client ID and/or credentials.
:param host: Host to connect to
:param client_id: Client ID to use. If not specified paho-mqtt
generates a random id.
:param user: User name of the client. If None or empty, connection is
attempted without username and password
:param passwd: Password of the client. If None, only user name is sent
:param kw: Client.connect() keyword arguments (excluding host)
:return: Two comma separated values. The result code and its string
representation
"""
return_code = {"rc": None}
client = Client(client_id, userdata=return_code)
if user is not None and user != "":
client.username_pw_set(user, passwd)
client.on_connect = SimpleMqttClient._on_connauth
client.connect(host, **kw)
client.loop_forever()
return return_code["rc"], connack_string(return_code["rc"])
def create_client(
hostname: str = leader_hostname,
last_will: Optional[dict] = None,
client_id: Optional[str] = None,
keepalive=60,
max_retries=3,
) -> Client:
"""
Create a MQTT client and connect to a host.
"""
def on_connect(client: Client, userdata, flags, rc: int, properties=None):
if rc > 1:
from pioreactor.logging import create_logger
logger = create_logger("pubsub.create_client", to_mqtt=False)
logger.error(f"Connection failed with error code {rc=}: {connack_string(rc)}")
client = Client(client_id=client_id)
client.on_connect = on_connect
if last_will is not None:
client.will_set(**last_will)
for retries in range(1, max_retries + 1):
try:
client.connect(hostname, keepalive=keepalive)
except (socket.gaierror, OSError):
if retries == max_retries:
break
time.sleep(retries * 2)
else:
client.loop_start()
break
return client
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 __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
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()
