def _mqtt_on_connect(self, _mqttc, _userdata, _flags, result_code):
"""On connect callback.
Resubscribe to all topics we were subscribed to and publish birth
message.
"""
import paho.mqtt.client as mqtt
if result_code != mqtt.CONNACK_ACCEPTED:
_LOGGER.error('Unable to connect to the MQTT broker: %s',
mqtt.connack_string(result_code))
self._mqttc.disconnect()
return
old_topics = self.topics
self.topics = {key: value for key, value in self.topics.items()
if value is None}
for topic, qos in old_topics.items():
# qos is None if we were in process of subscribing
if qos is not None:
self.hass.add_job(self.async_subscribe, topic, qos)
if self.birth_message:
self.hass.add_job(self.async_publish(
self.birth_message.get(ATTR_TOPIC),
self.birth_message.get(ATTR_PAYLOAD),
self.birth_message.get(ATTR_QOS),
self.birth_message.get(ATTR_RETAIN)))
def _mqtt_on_connect(self, _mqttc, _userdata, _flags,
result_code: int) -> None:
"""On connect callback.
Resubscribe to all topics we were subscribed to and publish birth
message.
"""
import paho.mqtt.client as mqtt
if result_code != mqtt.CONNACK_ACCEPTED:
_LOGGER.error('Unable to connect to the MQTT broker: %s',
mqtt.connack_string(result_code))
self._mqttc.disconnect()
return
# Group subscriptions to only re-subscribe once for each topic.
keyfunc = attrgetter('topic')
for topic, subs in groupby(sorted(self.subscriptions, key=keyfunc),
keyfunc):
# Re-subscribe with the highest requested qos
max_qos = max(subscription.qos for subscription in subs)
self.hass.add_job(self._async_perform_subscription, topic, max_qos)
if self.birth_message:
self.hass.add_job(
self.async_publish(*attr.astuple(self.birth_message)))
def __on_disconnect(self, client, userdata, result_code):
# pylint: disable=W0613
"""
Client has been disconnected from the server
:param client: Client that received the message
:param userdata: User data (unused)
:param result_code: Disconnection reason (0: expected, 1: error)
"""
if result_code:
# rc != 0: unexpected disconnection
_logger.error(
"Unexpected disconnection from the MQTT server: %s (%d)",
paho.connack_string(result_code),
result_code,
)
# Try to reconnect
self.__stop_timer()
self.__start_timer(2)
# Notify the caller, if any
if self.on_disconnect is not None:
try:
self.on_disconnect(self, result_code)
except Exception as ex:
_logger.exception("Error notifying MQTT listener: %s", ex)
def start_mqtt():
global mqtt_client
try:
log.info('Start MQTT Client')
# Create the MQTT Client
mqtt_client = mqtt.Client(client_id=settings.MQTT_CLIENT_ID)
# Turn on extr MQTT logging if enabled in the settings.
if settings.MQTT_LOGGING:
mqtt_client.enable_logger(AppLogger.logger)
else:
mqtt_client.disable_logger()
# Assign callback functions
mqtt_client.on_connect = on_connect
mqtt_client.on_subscribe = on_subscribe
mqtt_client.on_message = on_message
# Connect to the MQTT broker using the server and port in the settings file.
connack_code = mqtt_client.connect(settings.MQTT_SERVER, settings.MQTT_PORT)
log.info('MQTT connect reply to {}, {}: {}'.format(settings.MQTT_SERVER, settings.MQTT_PORT,
mqtt.connack_string(connack_code)))
# Blocking call that processes network traffic, dispatches callbacks and
# handles reconnecting.
mqtt_client.loop_forever()
except Exception as ex:
log.error('Exception in start_mqtt()! exception: {}'.format(ex))
raise
def start_mqtt():
global mqtt_client
try:
log.debug('Start MQTT Client')
mqtt_client = mqtt.Client(client_id=settings.MQTT_CLIENT_ID)
if settings.MQTT_LOGGING:
# Add MQTT logging to the app logs
mqtt_client.enable_logger(AppLogger.logger)
else:
mqtt_client.disable_logger()
# Assign callback functions
mqtt_client.on_connect = on_connect
mqtt_client.on_message = on_message
mqtt_client.on_publish = on_publish
mqtt_client.on_subscribe = on_subscribe
# Set a Will to be sent by the broker in case the client disconnects unexpectedly.
# QOS 2: The broker will deliver the message exactly once by using a four step handshake.
mqtt_client.will_set('/will/oops', payload='{} has vanished!'.format(settings.MQTT_CLIENT_ID), qos=2)
connack_code = mqtt_client.connect(settings.MQTT_SERVER, settings.MQTT_PORT)
log.info('MQTT connect reply to {}, {}: {}'.format(settings.MQTT_SERVER, settings.MQTT_PORT,
mqtt.connack_string(connack_code)))
# Blocking call that processes network traffic, dispatches callbacks and
# handles reconnecting.
mqtt_client.loop_forever()
except Exception as ex:
log.error('Exception in start_mqtt()! exception: {}'.format(ex))
raise
def _on_disconnect(self, client, userdata, rc):
"""DISCONNECT received"""
_log.debug('disconnected: %s', mqtt.connack_string(rc))
self.adapter.stop()
self.adapter = None
self._schedule_reconnect()
def __on_connect(self, client, userdata, flags, result_code):
# pylint: disable=W0613
"""
Client connected to the server
:param client: Connected Paho client
:param userdata: User data (unused)
:param flags: Response flags sent by the broker
:param result_code: Connection result code (0: success, others: error)
"""
if result_code:
# result_code != 0: something wrong happened
_logger.error(
"Error connecting the MQTT server: %s (%d)",
paho.connack_string(result_code),
result_code,
)
else:
# Connection is OK: stop the reconnection timer
self.__stop_timer()
# Notify the caller, if any
if self.on_connect is not None:
try:
self.on_connect(self, result_code)
except Exception as ex:
_logger.exception("Error notifying MQTT listener: %s", ex)
def on_connect(client, unused_userdata, unused_flags, rc):
"""Callback for when a device connects."""
print('on_connect', mqtt.connack_string(rc))
# After a successful connect, reset backoff time and stop backing off.
global should_backoff
global minimum_backoff_time
should_backoff = False
minimum_backoff_time = 1
def on_connect(client, userdata, flags, rc):
print("Connected", connack_string(rc))
# Subscribing in on_connect() means that if we lose the connection and
# reconnect then subscriptions will be renewed.
for t in args.t:
print('subscribing to', t)
client.subscribe(t)
def on_connect(unused_client, unused_userdata, unused_flags, rc):
print(dt.now(), ': on_connect', mqtt.connack_string(rc))
# After a successful connect, reset backoff time and stop backing off.
global should_backoff
global minimum_backoff_time
should_backoff = False
minimum_backoff_time = 1
def _on_connect(self, client, userdata, flags, rc):
if rc == mqttc.MQTT_ERR_SUCCESS:
self.log.info("connected")
self.state = self.state_connected
# TODO deliver saved msgs
else:
self.log.error(mqttc.connack_string(rc))
def on_connect(client, userdata, flags, rc):
logging.info("MQTT Connected with result code " + str(rc) + ": " +
mqtt.connack_string(rc))
# Subscribing in on_connect() means that if we lose the connection and
# reconnect then subscriptions will be renewed.
client.subscribe(MQTT_PREFIX + "/switch/#")
connect_topic = MQTT_PREFIX + "/status"
mqtt_client.publish(connect_topic, payload="connected", qos=0, retain=True)
def on_connect(client, userdata, flags, rc):
if rc == 0:
logger.info('MQTT connection established.')
else:
logger.error('Connection error with result code {} - {}'.format(
str(rc), mqtt.connack_string(rc)))
#kill main thread
os._exit(1)
def _cb_on_connect(self, mqtt_client, userdata, flags, rc):
if rc == 0:
LOG.info('MQTT connection attempt succeeded.')
self._loop.call_soon_threadsafe(self._is_mqtt_connected.set)
else:
LOG.warning('MQTT connection attempt failed: %s',
mqtt.connack_string(rc))
self._loop.call_soon_threadsafe(self._is_mqtt_connected.clear)
def mqtt_connect(client, userdata, flags, rc):
"""Callback for MQTT connects."""
print("MQTT connected: " + mqtt.connack_string(rc))
if rc != 0:
print("Could not connect. Error: " + str(rc))
else:
client.subscribe(args.rtl_topic)
def on_connect(client, userdata, flags, rc):
if rc == 0:
print_line('MQTT connection established', console=True, sd_notify=True)
print()
else:
print_line('Connection error with result code {} - {}'.format(str(rc), mqtt.connack_string(rc)), error=True)
#kill main thread
os._exit(1)
def on_connect(client, userdata, flags, rc):
print("Result from connect: {}".format(
mqtt.connack_string(rc)))
# Check whether the result form connect is the CONNACK_ACCEPTED
#connack code
if rc == mqtt.CONNACK_ACCEPTED:
# Subscribe to the commands topic filter
client.subscribe(VehicleCommandProcessor.commands_topic, qos=2)
def on_connect(client, userdata, flags, rc):
""" Callback for when the client receives a CONNACK response from the server. """
log.info("MQTT Connection: " + mqtt.connack_string(rc))
if rc != 0:
log.error("Could not connect. RC: " + str(rc))
exit()
# Subscribing in on_connect() means that if we lose the connection and reconnect then subscriptions will be renewed.
client.subscribe(MQTT_TOPIC_PREFIX)
def on_connect(client, userdata, flags, rc):
try:
print("Connect result: {}".format(mqtt.connack_string(rc)))
client.connected_flag = True
client.subscribe(MQ_TOPIC, qos=1)
except Exception as e:
print ("Exception", e)
def _mqtt_on_connect(self, client, userdata, flags_dict, rc):
if rc == 0:
logger.info('Connected to MQTT server')
# subscribe
self.mqtt_client.subscribe('/send_command/#')
else:
logger.error('Error connecting to MQTT server (%d): %s',
rc, paho.connack_string(rc))
def on_connect(client, unused_userdata, unused_flags, rc):
"""Callback for when a device connects."""
print('on_connect', mqtt.connack_string(rc))
gateway_state.connected = True
# Subscribe to the config topic.
client.subscribe(gateway_state.mqtt_config_topic, qos=1)
def _on_disconnect(self, mqttclient, userdata, rc):
"""MQTT callback at disconnect.
Method signature according to Paho documentation.
"""
self.logger.warning("Now disconnected from MQTT broker. Host: {}, Port: {}, Result: '{}'".format(
mqttclient._host, mqttclient._port, mqtt.connack_string(rc)))
self._set_broker_connectionstatus(False)
def on_connect(unused_client, unused_userdata, unused_flags, rc):
"""Callback for when a device connects."""
logger.info('on_connect {}'.format(mqtt.connack_string(rc)))
# After a successful connect, reset backoff time and stop backing off.
global minimum_backoff_time
minimum_backoff_time = 1
gateway_state.connected = True
def on_disconnect(self, client, userdata, rc):
self.available = "offline"
if rc != 0:
self.logger.error(
"[MQTT] on_disconnect - Unexpected disconnection." +
mqtt.connack_string(rc))
else:
self.logger.warning(
"[MQTT] on_disconnect - Successfully disconnect")
def on_connect(self, client, userdata, flags, rc):
if rc == 0:
self.notify("mqttBridge", "(re)connected to server!")
self.subscribe(self._topic, 0)
# Not sure this will be triggered using client.loop_forever
else:
self.notify("mqttBridge",
"Connection failed: " + paho.connack_string(rc))
def on_connect(client, user_data, flags, connection_result_code):
if connection_result_code == 0:
logger.info("Connected to MQTT Broker")
else:
logger.error("Failed to connect to MQTT Broker: " +
mqtt.connack_string(connection_result_code))
client.subscribe(TOPIC)
def _on_connect(client, userdata, flags, rc):
"""Internal callback"""
#pylint: disable=invalid-name, unused-argument
if rc == 0:
if len(userdata) > 0:
_do_publish(client)
else:
raise mqtt.MQTTException(paho.connack_string(rc))
def on_connect(client, userdata, flags, result):
# logger.debug("MQTT Connection result: " + pahomqtt.connack_string(result))
if result == 0:
# got connected OK
logger.debug("MQTT Connected OK.")
# subscribe here, so that we always renew subs after reconnecting
paho_client.subscribe(MQTT_TOPIC_PREFIX + "/" + mac_address)
else:
logger.error("MQTT Connect failed: " + pahomqtt.connack_string(result) + " Check .env credentials.")
def on_connect(client, ud, flags, rc):
terminal_label.config(text=mqtt.connack_string(rc))
if rc == 5:
add_worker_btn.config(state='disabled')
pin_card_btn.config(state='disabled')
stop_btn.config(state='disabled')
remove_worker_btn.config(state='disabled')
unpin_card_btn.config(state='disabled')
make_report_btn.config(state='disabled')
def on_connect(self, client, userdata, flags, rc):
log.log(logging.INFO if not rc else logging.ERROR,
mqtt.connack_string(rc))
if rc:
return None
self.connected = True
self.subscriptions.clear()
self.subscription_changed()
def _create_error_from_connack_rc_code(rc):
"""
Given a paho CONNACK rc code, return an Exception that can be raised
"""
message = mqtt.connack_string(rc)
if rc in paho_connack_rc_to_error:
return paho_connack_rc_to_error[rc](message)
else:
return exceptions.ProtocolClientError("Unknown CONNACK rc={}".format(rc))
def _on_connect(client, self, flags, rc):
"""Can't subscribe to a topic until after we're connected"""
if rc == mqtt.MQTT_ERR_SUCCESS:
LOGGER.info(
"Successfully connected, subscribing to sensors channel")
self.refresh_subscriptions()
else:
LOGGER.error("on_connect: received an error: %s",
mqtt.connack_string(rc))
def on_connect(unused_client, unused_userdata, unused_flags, rc):
"""Callback for when a device connects."""
print('on_connect', mqtt.connack_string(rc))
# After a successful connect, reset backoff time and stop backing off.
global should_backoff
global minimum_backoff_time
should_backoff = False
minimum_backoff_time = 1
def _on_connect(client, userdata, flags, rc):
"""Internal callback"""
#pylint: disable=invalid-name, unused-argument
if rc == 0:
if len(userdata) > 0:
_do_publish(client)
else:
raise mqtt.MQTTException(paho.connack_string(rc))
def on_mqtt_connect(client, userdata, rc):
logging.info("MQTT Connection returned result: " +
mqtt.connack_string(rc))
# Subscribing in on_connect() means that if we lose the connection and
# reconnect then subscriptions will be renewed.
self.mqttc.subscribe(self.config.mqtt.display_topic + '/set')
self.mqttc.subscribe(self.config.mqtt.light_topic + '/set')
self.mqttc.subscribe(self.config.mqtt.brightness_topic + '/set')
def on_connect(client, userdata, flags, rc):
if rc == 0:
print('MQTT connection established')
print()
else:
print('Connection error with result code {} - {}'.format(
str(rc), mqtt.connack_string(rc)))
#kill main thread
sys.exit(1)
def mqtt_connect(client, userdata, flags, rc):
"""Callback for MQTT connects."""
logging.info("MQTT connected: " + mqtt.connack_string(rc))
if rc != 0:
logging.error("Could not connect. Error: " + str(rc))
else:
logging.info("Subscribing to: " + args.rtl_topic)
client.subscribe(args.rtl_topic)
def on_connect(mosq, userdata, rc):
logging.info("Connection to broker: %s", paho.connack_string(rc))
if rc == 0:
mqttc.publish("/clients/" + client_id, "Online")
map = userdata['map']
for topic in map:
logging.info("Subscribing to topic %s" % topic)
mqttc.subscribe(topic, 0)
def on_connect(client, userdata, flags, rc):
print("Result from connect: {}".format(
mqtt.connack_string(rc)))
# Проверяем, получено ли при подключении от сервера CONNACK_ACCEPTED код (подтвреждающий успешное подключение)
if rc == mqtt.CONNACK_ACCEPTED:
# Подписываемся на соотвествующую тему mqtt
client.subscribe(
DeviceCommandProcessor.commands_topic,
qos=2)
def _mqtt_on_connect(self, _mqttc, _userdata, _flags,
result_code: int) -> None:
"""On connect callback.
Resubscribe to all topics we were subscribed to and publish birth
message.
"""
# pylint: disable-next=import-outside-toplevel
import paho.mqtt.client as mqtt
if result_code != mqtt.CONNACK_ACCEPTED:
_LOGGER.error(
"Unable to connect to the MQTT broker: %s",
mqtt.connack_string(result_code),
)
return
self.connected = True
dispatcher_send(self.hass, MQTT_CONNECTED)
_LOGGER.info(
"Connected to MQTT server %s:%s (%s)",
self.conf[CONF_BROKER],
self.conf[CONF_PORT],
result_code,
)
# Group subscriptions to only re-subscribe once for each topic.
keyfunc = attrgetter("topic")
self.hass.add_job(
self._async_perform_subscriptions,
[
# Re-subscribe with the highest requested qos
(topic, max(subscription.qos for subscription in subs))
for topic, subs in groupby(
sorted(self.subscriptions, key=keyfunc), keyfunc)
],
)
if (CONF_BIRTH_MESSAGE in self.conf
and ATTR_TOPIC in self.conf[CONF_BIRTH_MESSAGE]):
async def publish_birth_message(birth_message):
await self._ha_started.wait(
) # Wait for Home Assistant to start
await self._discovery_cooldown(
) # Wait for MQTT discovery to cool down
await self.async_publish(
topic=birth_message.topic,
payload=birth_message.payload,
qos=birth_message.qos,
retain=birth_message.retain,
)
birth_message = PublishMessage(**self.conf[CONF_BIRTH_MESSAGE])
asyncio.run_coroutine_threadsafe(
publish_birth_message(birth_message), self.hass.loop)
def _on_connect(self, client, userdata, flags, return_code):
logger.info('connected to mqtt broker: {}'.format(mqtt.connack_string(return_code)))
if self._online_topic:
logger.info('publishing to "{}"'.format(self._online_topic))
self._client.publish(self._online_topic, '1', retain=True)
if self._marquee_topic:
logger.info('subscribing to "{}"'.format(self._marquee_topic))
self._client.subscribe(self._marquee_topic)
def _on_connect(c, userdata, flags, rc):
"""Internal callback"""
if rc != 0:
raise mqtt.MQTTException(paho.connack_string(rc))
if type(userdata['topics']) is list:
for t in userdata['topics']:
c.subscribe(t, userdata['qos'])
else:
c.subscribe(userdata['topics'], userdata['qos'])
def on_connect(self, client, userdata, flags, rc):
logging.debug("Connected with result code " + str(rc))
logging.debug(mqtt.connack_string(rc))
self.client.message_callback_add('crestron/button', self.cb_button)
self.client.subscribe("crestron/#")
self.connected = True
self.crestron_connect()
def rcstr(cls, retcode):
"""
Returns a string representation of the return code
Args:
retcode (int): MQTT Connection return code
Returns:
A string representation of the return code
"""
return connack_string(retcode)
def _on_connect(self, mqttclient, userdata, flags, rc):
"""MQTT callback at connection attempts.
This callback is responsible for doing the subscriptions, and to
publish capabilities and default values.
Method signature according to Paho documentation.
"""
if rc != mqtt.CONNACK_ACCEPTED:
self.logger.warning(" Failed connection to MQTT broker. Host: {}, Port: {}, Result: '{}'".format(
mqttclient._host, mqttclient._port, mqtt.connack_string(rc)))
self._set_broker_connectionstatus(False)
return
self.logger.info(" Successful connection to MQTT broker. Host: {}, Port: {}, Result: '{}'".format(
mqttclient._host, mqttclient._port, mqtt.connack_string(rc)))
self._set_broker_connectionstatus(True)
self._subscribe_to_inputsignals()
self._publish_capablities_and_defaultvalues()
def _on_connect(client, userdata, rc):
if rc == 0:
msg = "Connected to mqtt broker with result code "+str(rc)
logging.info(msg)
if DeviceId is None:
logging.info("device id not specified")
raise Exception("DeviceId not specified")
topic = "client/" + ClientId + "/in/device/" + DeviceId + "/asset/+/command"
logging.info("subscribing to: " + topic)
result = client.subscribe(topic) #Subscribing in _on_connect() means that if we lose the connection and reconnect then subscriptions will be renewed.
logging.info(str(result)) # result is not a string on all platforms.
else:
logging.error("Failed to connect to mqtt broker: " + mqtt.connack_string(rc))
def on_connect(self, client, userdata, flags, rc):
"""
Invoked on successful connection to a broker after connection request
:param client: The client instance for this callback
:param userdata: The private user data as set in Client() or userdata_set()
:param flags: Response flags sent by the broker
:param rc: The connection result
:return:
"""
self._connect_result_code = rc
self._disconnect_result_code = sys.maxsize
log.info("Connected with result code : {0} : {1} ".format(str(rc), paho.connack_string(rc)))
def on_connect(client, userdata, rc):
if rc == 0:
msg = "Connected to mqtt broker with result code "+str(rc)
print(msg)
if DeviceId is None:
print("device id not specified")
raise Exception("DeviceId not specified")
topic = "client/" + ClientId + "/in/device/" + DeviceId + "/asset/+/command"
print("subscribing to: " + topic)
result = client.subscribe(topic) #Subscribing in on_connect() means that if we lose the connection and reconnect then subscriptions will be renewed.
print(result)
else:
print("Failed to connect to mqtt broker: " + mqtt.connack_string(rc))
def disconnect(self):
"""
Disconnects from MQTT Broker
:return:
"""
self._paho_client.disconnect()
ten_ms_count = 0
while (ten_ms_count != self._conn_disconn_timeout * 100) and (self._disconnect_result_code == sys.maxsize):
ten_ms_count += 1
time.sleep(0.01)
if self._disconnect_result_code == sys.maxsize:
log.error("Disconnect timeout.")
raise Exception("Disconnection Timeout")
elif self._disconnect_result_code == 0:
log.info("Disconnected from MQTT Broker.")
log.info("Disconnect time consumption: " + str(float(ten_ms_count) * 10) + "ms.")
# Disconnect is successful. Stopping background network loop.
self._paho_client.loop_stop()
else:
log.error("Disconnect error with result code : {0} : {1} ".
format(str(self._disconnect_result_code), paho.connack_string(self._disconnect_result_code)))
raise Exception("Disconnect error with result code : {0} : {1} ".
format(str(self._disconnect_result_code), paho.connack_string(self._disconnect_result_code)))
def on_connect(client, userdata, flags, rc):
log.info("MQTT Client connection results: {}".format(mqtt.connack_string(rc)))
# Subscribing in on_connect() means that if we lose the connection and
# reconnect then subscriptions will be renewed.
# QOS 0: The broker will deliver the message once, with no confirmation.
# QOS 1: The broker will deliver the message at least once, with confirmation required.
# QOS 2: The broker will deliver the message exactly once by using a four step handshake.
#
# A list of tuples (i.e. topic, qos). Both topic and qos must be present in the tuple.
try:
client.subscribe(topics)
except Exception as ex:
log.error('Client Subscribe exception. ex={}'.format(ex))
def on_disconnect(self, client, userdata, rc):
"""
Invoked when disconnected from broker. Two scenarios are possible:
1) Broker rejects a connection request
2) Client initiated disconnect
:param client: The client instance for this callback
:param userdata: The private user data as set in Client() or userdata_set()
:param rc: The connection result
:return:
"""
self._connect_result_code = sys.maxsize
self._disconnect_result_code = rc
log.info("Disconnected with result code : {0} : {1} ".format(str(rc), paho.connack_string(rc)))
def on_connect(client, userdata, rc):
if rc == 0:
print( "Connected to mqtt broker with result code "+str(rc))
ioMapOutput = bytearray.fromhex(ioMap)
print("sending io map: " + str(ioMapOutput) + "topic = " + ioMapTopic)
_mqttClient.publish(ioMapTopic, ioMapOutput, 0, False)
print("sending outputs: " + str(outputs))
_mqttClient.publish(outputsTopic, outputs, 0, False)
print("sending relays: " + str(relays))
_mqttClient.publish(relaysTopic, relays, 0, False)
print("sending pin types: " + str(pinTypes))
_mqttClient.publish(pinTypesTopic, pinTypes, 0, False)
print "Messages sent"
_mqttClient.disconnect()
sys.exit()
else:
print("Failed to connect to mqtt broker: " + mqtt.connack_string(rc))
def on_connect(client, userdata, rc):
global _mqttConnected
try:
if rc == 0:
_mqttConnected = True
logging.info("Connected to mqtt broker with result code "+str(rc))
if _callbacks:
for topic, definitions in _callbacks.iteritems():
_subscribe(topic)
for definition in definitions:
if definition.level == 'asset' and definition.direction == 'in' and definition.toMonitor == 'state': # refresh the state of all assets being monitored when reconnecting. Other events can't be refreshed.
curVal = getAssetState(definition.id)
if curVal:
if 'state' in curVal:
definition.callback(curVal['state'])
elif 'value' in curVal:
definition.callback(curVal)
else:
logging.error("Failed to connect to mqtt broker: " + mqtt.connack_string(rc))
except Exception:
logging.exception("failed to connect")
def connect_soc(self):
"""
Establishes connection with MQTT Broker
:return:
"""
# Set up TLS support
if self.tls_conf:
if self.identity is None:
raise ValueError("Identity required to be set")
# Creating the tls context
if ssl is None:
raise ValueError("This platform has no SSL/TLS")
# Validate CA certificate path
if self.identity.root_ca_cert is None and not hasattr(ssl.SSLContext, 'load_default_certs'):
raise ValueError("Error : CA certificate path is missing")
else:
if self.identity.root_ca_cert and not (os.path.exists(self.identity.root_ca_cert)):
raise ValueError("Error : Wrong CA certificate path")
if self.tls_conf.tls_version is None:
tls_version = ssl.PROTOCOL_TLSv1_2
# If the python version supports it, use highest TLS version automatically
if hasattr(ssl, "PROTOCOL_TLS"):
tls_version = ssl.PROTOCOL_TLS
else:
tls_version = getattr(ssl, self.tls_conf.tls_version)
context = ssl.SSLContext(tls_version)
# Validate client certificate path
if self.identity.cert_file:
if os.path.exists(self.identity.cert_file):
client_cert_available = True
else:
raise ValueError("Error : Wrong client certificate path")
else:
client_cert_available = False
# Validate client key file path
if self.identity.key_file:
if os.path.exists(self.identity.key_file):
client_key_available = True
else:
raise ValueError("Error : Wrong client key path.")
else:
client_key_available = False
'''
Multiple conditions for certificate validations
# 1. Both Client certificate and key file should be present
# 2. If client certificate is not there throw an error
# 3. If client key is not there throw an error
# 4. If both are not there proceed without client certificate and key
'''
if client_cert_available and client_key_available:
context.load_cert_chain(self.identity.cert_file, self.identity.key_file)
elif not client_cert_available and client_key_available:
raise ValueError("Error : Client key found, but client certificate not found")
elif client_cert_available and not client_key_available:
raise ValueError("Error : Client certificate found, but client key not found")
else:
log.info("Client Certificate and Client Key are not provided")
if getattr(ssl, self.tls_conf.cert_required) == ssl.CERT_NONE and hasattr(context, 'check_hostname'):
context.check_hostname = False
context.verify_mode = ssl.CERT_REQUIRED if self.tls_conf.cert_required is None else getattr(ssl,
self.tls_conf.cert_required)
if self.identity.root_ca_cert is not None:
context.load_verify_locations(self.identity.root_ca_cert)
else:
context.load_default_certs()
if self.tls_conf.cipher is not None:
context.set_ciphers(self.tls_conf.ciphers)
# Setting the verify_flags to VERIFY_CRL_CHECK_CHAIN in this mode
# certificate revocation lists (CRLs) of all certificates in the
# peer cert chain are checked if the path of CRLs in PEM or DER format
# is specified
crl_path = read_liota_config('CRL_PATH', 'crl_path')
if crl_path and crl_path != "None" and crl_path != "":
if os.path.exists(crl_path):
context.verify_flags = ssl.VERIFY_CRL_CHECK_CHAIN
context.load_verify_locations(cafile=crl_path)
else:
raise ValueError("Error : Wrong Client CRL path {0}".format(crl_path))
# Setting the tls context
self._paho_client.tls_set_context(context)
if getattr(ssl, self.tls_conf.cert_required) != ssl.CERT_NONE:
# Default to secure, sets context.check_hostname attribute
# if available
self._paho_client.tls_insecure_set(False)
else:
# But with ssl.CERT_NONE, we can not check_hostname
self._paho_client.tls_insecure_set(True)
else:
log.info("TLS configuration is not set")
# Set up username-password
if self.enable_authentication:
if self.identity is None:
raise ValueError("Identity required to be set")
else:
if self.identity.username is None:
raise ValueError("Username not found")
elif self.identity.password is None:
raise ValueError("Password not found")
else:
self._paho_client.username_pw_set(self.identity.username, self.identity.password)
else:
log.info("Authentication is disabled")
if self.qos_details:
# Set QoS parameters
self._paho_client.max_inflight_messages_set(self.qos_details.in_flight)
self._paho_client.max_queued_messages_set(self.qos_details.queue_size)
self._paho_client.message_retry_set(self.qos_details.retry)
# Connect with MQTT Broker
self._paho_client.connect(host=self.url, port=self.port, keepalive=self.keep_alive)
# Start network loop to handle auto-reconnect
self._paho_client.loop_start()
ten_ms_count = 0
while (ten_ms_count != self._conn_disconn_timeout * 100) and (self._connect_result_code == sys.maxsize):
ten_ms_count += 1
time.sleep(0.01)
if self._connect_result_code == sys.maxsize:
log.error("Connection timeout.")
# Stopping background network loop as connection establishment failed.
self._paho_client.loop_stop()
raise Exception("Connection Timeout")
elif self._connect_result_code == 0:
log.info("Connected to MQTT Broker.")
log.info("Connect time consumption: " + str(float(ten_ms_count) * 10) + "ms.")
else:
log.error("Connection error with result code : {0} : {1} ".
format(str(self._connect_result_code), paho.connack_string(self._connect_result_code)))
# Stopping background network loop as connection establishment failed.
self._paho_client.loop_stop()
raise Exception("Connection error with result code : {0} : {1} ".
format(str(self._connect_result_code), paho.connack_string(self._connect_result_code)))
def connect_soc(self):
"""
Establishes connection with MQTT Broker
:return:
"""
# Set up TLS support
if self.tls_details:
# Validate CA certificate path
if self.remote_system_identity.root_ca_cert:
if not(os.path.exists(self.remote_system_identity.root_ca_cert)):
log.error("Error : Wrong CA certificate path.")
raise ValueError("Error : Wrong CA certificate path.")
else:
log.error("Error : Wrong CA certificate path.")
raise ValueError("Error : CA certificate path is missing")
# Validate client certificate path
if self.edge_system_identity.cert_file:
if os.path.exists(self.edge_system_identity.cert_file):
client_cert_available = True
else:
log.error("Error : Wrong client certificate path.")
raise ValueError("Error : Wrong client certificate path.")
else:
client_cert_available = False
# Validate client key file path
if self.edge_system_identity.key_file:
if os.path.exists(self.edge_system_identity.key_file):
client_key_available = True
else:
log.error("Error : Wrong client key path.")
raise ValueError("Error : Wrong client key path.")
else:
client_key_available = False
'''
Multiple conditions for certificate validations
# 1. Both Client certificate and key file should be present
# 2. If both are not there proceed without client certificate and key
# 3. If client certificate is not there throw an error
# 4. If client key is not there throw an error
'''
if client_cert_available and client_key_available:
log.debug("Certificates : ", self.remote_system_identity.root_ca_cert, self.edge_system_identity.cert_file,
self.edge_system_identity.key_file)
self._paho_client.tls_set(self.remote_system_identity.root_ca_cert, self.edge_system_identity.cert_file,
self.edge_system_identity.key_file,
cert_reqs=getattr(ssl, self.tls_details.cert_required),
tls_version=getattr(ssl, self.tls_details.tls_version),
ciphers=self.tls_details.cipher)
elif not client_cert_available and not client_key_available:
self._paho_client.tls_set(self.remote_system_identity.root_ca_cert,
cert_reqs=getattr(ssl, self.tls_details.cert_required),
tls_version=getattr(ssl, self.tls_details.tls_version),
ciphers=self.tls_details.cipher)
elif not client_cert_available and client_key_available:
log.error("Error : Client key found, but client certificate not found")
raise ValueError("Error : Client key found, but client certificate not found")
else:
log.error("Error : Client key found, but client certificate not found")
raise ValueError("Error : Client certificate found, but client key not found")
log.info("TLS support is set up.")
# Set up username-password
if self.enable_authentication:
if not self.remote_system_identity.username:
log.error("Username not found")
raise ValueError("Username not found")
elif not self.remote_system_identity.password:
log.error("Password not found")
raise ValueError("Password not found")
else:
self._paho_client.username_pw_set(self.remote_system_identity.username, self.remote_system_identity.password)
if self.qos_details:
# Set QoS parameters
self._paho_client.max_inflight_messages_set(self.qos_details.in_flight)
self._paho_client.max_queued_messages_set(self.qos_details.queue_size)
self._paho_client.message_retry_set(self.qos_details.retry)
# Connect with MQTT Broker
self._paho_client.connect(host=self.url, port=self.port, keepalive=self.keep_alive)
# Start network loop to handle auto-reconnect
self._paho_client.loop_start()
ten_ms_count = 0
while (ten_ms_count != self._conn_disconn_timeout * 100) and (self._connect_result_code == sys.maxsize):
ten_ms_count += 1
time.sleep(0.01)
if self._connect_result_code == sys.maxsize:
log.error("Connection timeout.")
# Stopping background network loop as connection establishment failed.
self._paho_client.loop_stop()
raise Exception("Connection Timeout")
elif self._connect_result_code == 0:
log.info("Connected to MQTT Broker.")
log.info("Connect time consumption: " + str(float(ten_ms_count) * 10) + "ms.")
else:
log.error("Connection error with result code : {0} : {1} ".
format(str(self._connect_result_code), paho.connack_string(self._connect_result_code)))
# Stopping background network loop as connection establishment failed.
self._paho_client.loop_stop()
raise Exception("Connection error with result code : {0} : {1} ".
format(str(self._connect_result_code), paho.connack_string(self._connect_result_code)))
def connect(self, keepalive=60):
# tls
try:
self._iot_mqtt_client_handler.tls_set(self._cafile, self._cert, self._key, ssl.CERT_REQUIRED, ssl.PROTOCOL_SSLv23)
except ValueError as ve:
send_output(self.wrapper_debug, self.wrapper_Tx, "C F " + ve.message)
return
except:
send_output(self.wrapper_debug, self.wrapper_Tx, "C F TLS Error")
return
# connect
try:
self._iot_mqtt_client_handler.connect(self._serverURL, self._serverPORT, keepalive)
self._iot_mqtt_client_handler.loop_start()
except BaseException as e:
send_output(self.wrapper_debug, self.wrapper_Tx, "C F " + e.message)
return
cnt_sec = 0
while cnt_sec < MAX_CONN_TIME and self.conn_res == -1: # waiting for connecting to complete (on_connect)
cnt_sec += 1
time.sleep(1)
if self.conn_res != -1:
send_output(self.wrapper_debug, self.wrapper_Tx, "C " + str(self.conn_res) + " " + mqtt.connack_string(self.conn_res)) # 0 for connected
else:
send_output(self.wrapper_debug, self.wrapper_Tx, "C F Connection time out")
return self.conn_res
def _on_connect(c, userdata, flags, rc):
"""Internal callback"""
if rc == 0:
_do_publish(c)
else:
raise mqtt.MQTTException(paho.connack_string(rc))
def on_connect(client, userdata, rc):
print 'Connection result:', connack_string(rc)
def on_disconnect(client, userdata, rc):
self.connected = False
log.info('MQTT disconnect: {}'.format(mqtt.connack_string(rc)))
