def _execute_op(self, op):
if isinstance(op, pipeline_ops_mqtt.SetMQTTConnectionArgsOperation):
# pipeline_ops_mqtt.SetMQTTConnectionArgsOperation is where we create our MQTTTransport object and set
# all of its properties.
logger.info("{}({}): got connection args".format(
self.name, op.name))
self.hostname = op.hostname
self.username = op.username
self.client_id = op.client_id
self.ca_cert = op.ca_cert
self.sas_token = op.sas_token
self.client_cert = op.client_cert
self.transport = MQTTTransport(
client_id=self.client_id,
hostname=self.hostname,
username=self.username,
ca_cert=self.ca_cert,
x509_cert=self.client_cert,
)
self.transport.on_mqtt_connected_handler = self._on_mqtt_connected
self.transport.on_mqtt_connection_failure_handler = self._on_mqtt_connection_failure
self.transport.on_mqtt_disconnected_handler = self._on_mqtt_disconnected
self.transport.on_mqtt_message_received_handler = self._on_mqtt_message_received
self._active_connect_op = None
self._active_disconnect_op = None
self.pipeline_root.transport = self.transport
operation_flow.complete_op(self, op)
elif isinstance(op, pipeline_ops_base.ConnectOperation):
logger.info("{}({}): connecting".format(self.name, op.name))
self._cancel_active_connect_disconnect_ops()
self._active_connect_op = op
try:
self.transport.connect(password=self.sas_token)
except Exception as e:
self._active_connect_op = None
raise e
elif isinstance(op, pipeline_ops_base.ReconnectOperation):
logger.info("{}({}): reconnecting".format(self.name, op.name))
# We set _active_connect_op here because a reconnect is the same as a connect for "active operation" tracking purposes.
self._cancel_active_connect_disconnect_ops()
self._active_connect_op = op
try:
self.transport.reconnect(password=self.sas_token)
except Exception as e:
self._active_connect_op = None
raise e
elif isinstance(op, pipeline_ops_base.DisconnectOperation):
logger.info("{}({}): disconnecting".format(self.name, op.name))
self._cancel_active_connect_disconnect_ops()
self._active_disconnect_op = op
try:
self.transport.disconnect()
except Exception as e:
self._active_disconnect_op = None
raise e
elif isinstance(op, pipeline_ops_mqtt.MQTTPublishOperation):
logger.info("{}({}): publishing on {}".format(
self.name, op.name, op.topic))
@pipeline_thread.invoke_on_pipeline_thread_nowait
def on_published():
logger.info("{}({}): PUBACK received. completing op.".format(
self.name, op.name))
operation_flow.complete_op(self, op)
self.transport.publish(topic=op.topic,
payload=op.payload,
callback=on_published)
elif isinstance(op, pipeline_ops_mqtt.MQTTSubscribeOperation):
logger.info("{}({}): subscribing to {}".format(
self.name, op.name, op.topic))
@pipeline_thread.invoke_on_pipeline_thread_nowait
def on_subscribed():
logger.info("{}({}): SUBACK received. completing op.".format(
self.name, op.name))
operation_flow.complete_op(self, op)
self.transport.subscribe(topic=op.topic, callback=on_subscribed)
elif isinstance(op, pipeline_ops_mqtt.MQTTUnsubscribeOperation):
logger.info("{}({}): unsubscribing from {}".format(
self.name, op.name, op.topic))
@pipeline_thread.invoke_on_pipeline_thread_nowait
def on_unsubscribed():
logger.info(
"{}({}): UNSUBACK received. completing op.".format(
self.name, op.name))
operation_flow.complete_op(self, op)
self.transport.unsubscribe(topic=op.topic,
callback=on_unsubscribed)
else:
operation_flow.pass_op_to_next_stage(self, op)
def _run_op(self, op):
if isinstance(op, pipeline_ops_base.InitializePipelineOperation):
# If there is a gateway hostname, use that as the hostname for connection,
# rather than the hostname itself
if self.pipeline_root.pipeline_configuration.gateway_hostname:
logger.debug(
"Gateway Hostname Present. Setting Hostname to: {}".format(
self.pipeline_root.pipeline_configuration.
gateway_hostname))
hostname = self.pipeline_root.pipeline_configuration.gateway_hostname
else:
logger.debug(
"Gateway Hostname not present. Setting Hostname to: {}".
format(self.pipeline_root.pipeline_configuration.hostname))
hostname = self.pipeline_root.pipeline_configuration.hostname
# Create the Transport object, set it's handlers
logger.debug("{}({}): got connection args".format(
self.name, op.name))
self.transport = MQTTTransport(
client_id=op.client_id,
hostname=hostname,
username=op.username,
server_verification_cert=self.pipeline_root.
pipeline_configuration.server_verification_cert,
x509_cert=self.pipeline_root.pipeline_configuration.x509,
websockets=self.pipeline_root.pipeline_configuration.
websockets,
cipher=self.pipeline_root.pipeline_configuration.cipher,
proxy_options=self.pipeline_root.pipeline_configuration.
proxy_options,
)
self.transport.on_mqtt_connected_handler = CallableWeakMethod(
self, "_on_mqtt_connected")
self.transport.on_mqtt_connection_failure_handler = CallableWeakMethod(
self, "_on_mqtt_connection_failure")
self.transport.on_mqtt_disconnected_handler = CallableWeakMethod(
self, "_on_mqtt_disconnected")
self.transport.on_mqtt_message_received_handler = CallableWeakMethod(
self, "_on_mqtt_message_received")
# There can only be one pending connection operation (Connect, ReauthorizeConnection, Disconnect)
# at a time. The existing one must be completed or canceled before a new one is set.
# Currently, this means that if, say, a connect operation is the pending op and is executed
# but another connection op is begins by the time the CONNACK is received, the original
# operation will be cancelled, but the CONNACK for it will still be received, and complete the
# NEW operation. This is not desirable, but it is how things currently work.
# We are however, checking the type, so the CONNACK from a cancelled Connect, cannot successfully
# complete a Disconnect operation.
self._pending_connection_op = None
op.complete()
elif isinstance(op, pipeline_ops_base.ConnectOperation):
logger.info("{}({}): connecting".format(self.name, op.name))
self._cancel_pending_connection_op()
self._pending_connection_op = op
self._start_connection_watchdog(op)
# Use SasToken as password if present. If not present (e.g. using X509),
# then no password is required because auth is handled via other means.
if self.pipeline_root.pipeline_configuration.sastoken:
password = str(
self.pipeline_root.pipeline_configuration.sastoken)
else:
password = None
try:
self.transport.connect(password=password)
except Exception as e:
logger.error("transport.connect raised error")
logger.error(traceback.format_exc())
self._cancel_connection_watchdog(op)
self._pending_connection_op = None
op.complete(error=e)
elif isinstance(
op, pipeline_ops_base.DisconnectOperation) or isinstance(
op, pipeline_ops_base.ReauthorizeConnectionOperation):
logger.info("{}({}): disconnecting or reauthorizing".format(
self.name, op.name))
self._cancel_pending_connection_op()
self._pending_connection_op = op
# We don't need a watchdog on disconnect because there's no callback to wait for
# and we respond to a watchdog timeout by calling disconnect, which is what we're
# already doing.
try:
self.transport.disconnect()
except Exception as e:
logger.error("transport.disconnect raised error")
logger.error(traceback.format_exc())
self._pending_connection_op = None
op.complete(error=e)
elif isinstance(op, pipeline_ops_mqtt.MQTTPublishOperation):
logger.info("{}({}): publishing on {}".format(
self.name, op.name, op.topic))
@pipeline_thread.invoke_on_pipeline_thread_nowait
def on_published():
logger.debug("{}({}): PUBACK received. completing op.".format(
self.name, op.name))
op.complete()
try:
self.transport.publish(topic=op.topic,
payload=op.payload,
callback=on_published)
except transport_exceptions.ConnectionDroppedError:
self.send_event_up(pipeline_events_base.DisconnectedEvent())
raise
elif isinstance(op, pipeline_ops_mqtt.MQTTSubscribeOperation):
logger.info("{}({}): subscribing to {}".format(
self.name, op.name, op.topic))
@pipeline_thread.invoke_on_pipeline_thread_nowait
def on_subscribed():
logger.debug("{}({}): SUBACK received. completing op.".format(
self.name, op.name))
op.complete()
try:
self.transport.subscribe(topic=op.topic,
callback=on_subscribed)
except transport_exceptions.ConnectionDroppedError:
self.send_event_up(pipeline_events_base.DisconnectedEvent())
raise
elif isinstance(op, pipeline_ops_mqtt.MQTTUnsubscribeOperation):
logger.info("{}({}): unsubscribing from {}".format(
self.name, op.name, op.topic))
@pipeline_thread.invoke_on_pipeline_thread_nowait
def on_unsubscribed():
logger.debug(
"{}({}): UNSUBACK received. completing op.".format(
self.name, op.name))
op.complete()
try:
self.transport.unsubscribe(topic=op.topic,
callback=on_unsubscribed)
except transport_exceptions.ConnectionDroppedError:
self.send_event_up(pipeline_events_base.DisconnectedEvent())
raise
else:
# This code block should not be reached in correct program flow.
# This will raise an error when executed.
self.send_op_down(op)
def _execute_op(self, op):
if isinstance(op, pipeline_ops_mqtt.SetMQTTConnectionArgsOperation):
# pipeline_ops_mqtt.SetMQTTConnectionArgsOperation is where we create our MQTTTransport object and set
# all of its properties.
logger.info("{}({}): got connection args".format(
self.name, op.name))
self.hostname = op.hostname
self.username = op.username
self.client_id = op.client_id
self.ca_cert = op.ca_cert
self.sas_token = op.sas_token
self.client_cert = op.client_cert
self.transport = MQTTTransport(
client_id=self.client_id,
hostname=self.hostname,
username=self.username,
ca_cert=self.ca_cert,
x509_cert=self.client_cert,
)
self.transport.on_mqtt_connected_handler = self._on_mqtt_connected
self.transport.on_mqtt_connection_failure_handler = self._on_mqtt_connection_failure
self.transport.on_mqtt_disconnected_handler = self._on_mqtt_disconnected
self.transport.on_mqtt_message_received_handler = self._on_mqtt_message_received
# There can only be one pending connection operation (Connect, Reconnect, Disconnect)
# at a time. The existing one must be completed or canceled before a new one is set.
# Currently, this means that if, say, a connect operation is the pending op and is executed
# but another connection op is begins by the time the CONACK is received, the original
# operation will be cancelled, but the CONACK for it will still be received, and complete the
# NEW operation. This is not desirable, but it is how things currently work.
# We are however, checking the type, so the CONACK from a cancelled Connect, cannot successfully
# complete a Disconnect operation.
self._pending_connection_op = None
self.pipeline_root.transport = self.transport
operation_flow.complete_op(self, op)
elif isinstance(op, pipeline_ops_base.UpdateSasTokenOperation):
logger.info("{}({}): saving sas token and completing".format(
self.name, op.name))
self.sas_token = op.sas_token
operation_flow.complete_op(self, op)
elif isinstance(op, pipeline_ops_base.ConnectOperation):
logger.info("{}({}): connecting".format(self.name, op.name))
self._cancel_pending_connection_op()
self._pending_connection_op = op
try:
self.transport.connect(password=self.sas_token)
except Exception as e:
logger.error("transport.connect raised error", exc_info=True)
self._pending_connection_op = None
op.error = e
operation_flow.complete_op(self, op)
elif isinstance(op, pipeline_ops_base.ReconnectOperation):
logger.info("{}({}): reconnecting".format(self.name, op.name))
# We set _active_connect_op here because a reconnect is the same as a connect for "active operation" tracking purposes.
self._cancel_pending_connection_op()
self._pending_connection_op = op
try:
self.transport.reconnect(password=self.sas_token)
except Exception as e:
logger.error("transport.reconnect raised error", exc_info=True)
self._pending_connection_op = None
op.error = e
operation_flow.complete_op(self, op)
elif isinstance(op, pipeline_ops_base.DisconnectOperation):
logger.info("{}({}): disconnecting".format(self.name, op.name))
self._cancel_pending_connection_op()
self._pending_connection_op = op
try:
self.transport.disconnect()
except Exception as e:
logger.error("transport.disconnect raised error",
exc_info=True)
self._pending_connection_op = None
op.error = e
operation_flow.complete_op(self, op)
elif isinstance(op, pipeline_ops_mqtt.MQTTPublishOperation):
logger.info("{}({}): publishing on {}".format(
self.name, op.name, op.topic))
@pipeline_thread.invoke_on_pipeline_thread_nowait
def on_published():
logger.info("{}({}): PUBACK received. completing op.".format(
self.name, op.name))
operation_flow.complete_op(self, op)
self.transport.publish(topic=op.topic,
payload=op.payload,
callback=on_published)
elif isinstance(op, pipeline_ops_mqtt.MQTTSubscribeOperation):
logger.info("{}({}): subscribing to {}".format(
self.name, op.name, op.topic))
@pipeline_thread.invoke_on_pipeline_thread_nowait
def on_subscribed():
logger.info("{}({}): SUBACK received. completing op.".format(
self.name, op.name))
operation_flow.complete_op(self, op)
self.transport.subscribe(topic=op.topic, callback=on_subscribed)
elif isinstance(op, pipeline_ops_mqtt.MQTTUnsubscribeOperation):
logger.info("{}({}): unsubscribing from {}".format(
self.name, op.name, op.topic))
@pipeline_thread.invoke_on_pipeline_thread_nowait
def on_unsubscribed():
logger.info(
"{}({}): UNSUBACK received. completing op.".format(
self.name, op.name))
operation_flow.complete_op(self, op)
self.transport.unsubscribe(topic=op.topic,
callback=on_unsubscribed)
else:
operation_flow.pass_op_to_next_stage(self, op)
def _run_op(self, op):
if isinstance(op, pipeline_ops_mqtt.SetMQTTConnectionArgsOperation):
# pipeline_ops_mqtt.SetMQTTConnectionArgsOperation is where we create our MQTTTransport object and set
# all of its properties.
logger.debug("{}({}): got connection args".format(
self.name, op.name))
self.sas_token = op.sas_token
self.transport = MQTTTransport(
client_id=op.client_id,
hostname=op.hostname,
username=op.username,
server_verification_cert=op.server_verification_cert,
x509_cert=op.client_cert,
websockets=self.pipeline_root.pipeline_configuration.
websockets,
cipher=self.pipeline_root.pipeline_configuration.cipher,
proxy_options=self.pipeline_root.pipeline_configuration.
proxy_options,
)
self.transport.on_mqtt_connected_handler = CallableWeakMethod(
self, "_on_mqtt_connected")
self.transport.on_mqtt_connection_failure_handler = CallableWeakMethod(
self, "_on_mqtt_connection_failure")
self.transport.on_mqtt_disconnected_handler = CallableWeakMethod(
self, "_on_mqtt_disconnected")
self.transport.on_mqtt_message_received_handler = CallableWeakMethod(
self, "_on_mqtt_message_received")
# There can only be one pending connection operation (Connect, ReauthorizeConnection, Disconnect)
# at a time. The existing one must be completed or canceled before a new one is set.
# Currently, this means that if, say, a connect operation is the pending op and is executed
# but another connection op is begins by the time the CONNACK is received, the original
# operation will be cancelled, but the CONNACK for it will still be received, and complete the
# NEW operation. This is not desirable, but it is how things currently work.
# We are however, checking the type, so the CONNACK from a cancelled Connect, cannot successfully
# complete a Disconnect operation.
self._pending_connection_op = None
op.complete()
elif isinstance(op, pipeline_ops_base.UpdateSasTokenOperation):
logger.debug("{}({}): saving sas token and completing".format(
self.name, op.name))
self.sas_token = op.sas_token
op.complete()
elif isinstance(op, pipeline_ops_base.ConnectOperation):
logger.info("{}({}): connecting".format(self.name, op.name))
self._cancel_pending_connection_op()
self._pending_connection_op = op
try:
self.transport.connect(password=self.sas_token)
except Exception as e:
logger.error("transport.connect raised error")
logger.error(traceback.format_exc())
self._pending_connection_op = None
op.complete(error=e)
elif isinstance(op, pipeline_ops_base.ReauthorizeConnectionOperation):
logger.info("{}({}): reauthorizing".format(self.name, op.name))
# We set _active_connect_op here because reauthorizing the connection is the same as a connect for "active operation" tracking purposes.
self._cancel_pending_connection_op()
self._pending_connection_op = op
try:
self.transport.reauthorize_connection(password=self.sas_token)
except Exception as e:
logger.error("transport.reauthorize_connection raised error")
logger.error(traceback.format_exc())
self._pending_connection_op = None
op.complete(error=e)
elif isinstance(op, pipeline_ops_base.DisconnectOperation):
logger.info("{}({}): disconnecting".format(self.name, op.name))
self._cancel_pending_connection_op()
self._pending_connection_op = op
try:
self.transport.disconnect()
except Exception as e:
logger.error("transport.disconnect raised error")
logger.error(traceback.format_exc())
self._pending_connection_op = None
op.complete(error=e)
elif isinstance(op, pipeline_ops_mqtt.MQTTPublishOperation):
logger.info("{}({}): publishing on {}".format(
self.name, op.name, op.topic))
@pipeline_thread.invoke_on_pipeline_thread_nowait
def on_published():
logger.debug("{}({}): PUBACK received. completing op.".format(
self.name, op.name))
op.complete()
self.transport.publish(topic=op.topic,
payload=op.payload,
callback=on_published)
elif isinstance(op, pipeline_ops_mqtt.MQTTSubscribeOperation):
logger.info("{}({}): subscribing to {}".format(
self.name, op.name, op.topic))
@pipeline_thread.invoke_on_pipeline_thread_nowait
def on_subscribed():
logger.debug("{}({}): SUBACK received. completing op.".format(
self.name, op.name))
op.complete()
self.transport.subscribe(topic=op.topic, callback=on_subscribed)
elif isinstance(op, pipeline_ops_mqtt.MQTTUnsubscribeOperation):
logger.info("{}({}): unsubscribing from {}".format(
self.name, op.name, op.topic))
@pipeline_thread.invoke_on_pipeline_thread_nowait
def on_unsubscribed():
logger.debug(
"{}({}): UNSUBACK received. completing op.".format(
self.name, op.name))
op.complete()
self.transport.unsubscribe(topic=op.topic,
callback=on_unsubscribed)
else:
# This code block should not be reached in correct program flow.
# This will raise an error when executed.
self.send_op_down(op)
def _run_op(self, op):
if isinstance(op, pipeline_ops_mqtt.SetMQTTConnectionArgsOperation):
# pipeline_ops_mqtt.SetMQTTConnectionArgsOperation is where we create our MQTTTransport object and set
# all of its properties.
logger.info("{}({}): got connection args".format(
self.name, op.name))
self.hostname = op.hostname
self.username = op.username
self.client_id = op.client_id
self.ca_cert = op.ca_cert
self.sas_token = None
self.trusted_certificate_chain = None
self.transport = MQTTTransport(
client_id=self.client_id,
hostname=self.hostname,
username=self.username,
ca_cert=self.ca_cert,
)
self.transport.on_mqtt_connected = self.on_connected
self.transport.on_mqtt_disconnected = self.on_disconnected
self.transport.on_mqtt_message_received = self._on_message_received
self.pipeline_root.transport = self.transport
operation_flow.complete_op(self, op)
elif isinstance(op, pipeline_ops_base.SetSasTokenOperation):
# When we get a sas token from above, we just save it for later
logger.info("{}({}): got password".format(self.name, op.name))
self.sas_token = op.sas_token
operation_flow.complete_op(self, op)
elif isinstance(
op,
pipeline_ops_base.SetClientAuthenticationCertificateOperation):
# When we get a certificate from above, we just save it for later
logger.info("{}({}): got certificate".format(self.name, op.name))
self.trusted_certificate_chain = op.certificate
operation_flow.complete_op(self, op)
elif isinstance(op, pipeline_ops_base.ConnectOperation):
logger.info("{}({}): conneting".format(self.name, op.name))
@pipeline_thread.invoke_on_pipeline_thread_nowait
def on_connected():
logger.info("{}({}): on_connected. completing op.".format(
self.name, op.name))
self.transport.on_mqtt_connected = self.on_connected
self.on_connected()
operation_flow.complete_op(self, op)
# A note on exceptions handling in Connect, Disconnct, and Reconnet:
#
# All calls into self.transport can raise an exception, and this is OK.
# The exception handler in PipelineStage.run_op() will catch these errors
# and propagate them to the caller. This is an intentional design of the
# pipeline, that stages, etc, don't need to worry about catching exceptions
# except for special cases.
#
# The code right below this comment is This is a special case. In addition
# to this "normal" exception handling, we add another exception handler
# into this class' Connect, Reconnect, and Disconnect code. We need to
# do this because transport.on_mqtt_connected and transport.on_mqtt_disconnected
# are both _handler_ functions instead of _callbacks_.
#
# Because they're handlers instead of callbacks, we need to change the
# handlers while the connection is established. We do this so we can
# know when the protocol is connected so we can move on to the next step.
# Once the connection is established, we change the handler back to its
# old value before finishing.
#
# The exception handling below is to reset the handler back to its original
# value in the case where transport.connect raises an exception. Again,
# this extra exception handling is only necessary in the Connect, Disconnect,
# and Reconnect case because they're the only cases that use handlers instead
# of callbacks.
#
self.transport.on_mqtt_connected = on_connected
try:
self.transport.connect(
password=self.sas_token,
client_certificate=self.trusted_certificate_chain)
except Exception as e:
self.transport.on_mqtt_connected = self.on_connected
raise e
elif isinstance(op, pipeline_ops_base.ReconnectOperation):
logger.info("{}({}): reconnecting".format(self.name, op.name))
@pipeline_thread.invoke_on_pipeline_thread_nowait
def on_connected():
logger.info("{}({}): on_connected. completing op.".format(
self.name, op.name))
self.transport.on_mqtt_connected = self.on_connected
self.on_connected()
operation_flow.complete_op(self, op)
# See "A note on exception handling" above
self.transport.on_mqtt_connected = on_connected
try:
self.transport.reconnect(self.sas_token)
except Exception as e:
self.transport.on_mqtt_connected = self.on_connected
raise e
elif isinstance(op, pipeline_ops_base.DisconnectOperation):
logger.info("{}({}): disconnecting".format(self.name, op.name))
@pipeline_thread.invoke_on_pipeline_thread_nowait
def on_disconnected():
logger.info("{}({}): on_disconnected. completing op.".format(
self.name, op.name))
self.transport.on_mqtt_disconnected = self.on_disconnected
self.on_disconnected()
operation_flow.complete_op(self, op)
# See "A note on exception handling" above
self.transport.on_mqtt_disconnected = on_disconnected
try:
self.transport.disconnect()
except Exception as e:
self.transport.on_mqtt_disconnected = self.on_disconnected
raise e
elif isinstance(op, pipeline_ops_mqtt.MQTTPublishOperation):
logger.info("{}({}): publishing on {}".format(
self.name, op.name, op.topic))
@pipeline_thread.invoke_on_pipeline_thread_nowait
def on_published():
logger.info("{}({}): PUBACK received. completing op.".format(
self.name, op.name))
operation_flow.complete_op(self, op)
self.transport.publish(topic=op.topic,
payload=op.payload,
callback=on_published)
elif isinstance(op, pipeline_ops_mqtt.MQTTSubscribeOperation):
logger.info("{}({}): subscribing to {}".format(
self.name, op.name, op.topic))
@pipeline_thread.invoke_on_pipeline_thread_nowait
def on_subscribed():
logger.info("{}({}): SUBACK received. completing op.".format(
self.name, op.name))
operation_flow.complete_op(self, op)
self.transport.subscribe(topic=op.topic, callback=on_subscribed)
elif isinstance(op, pipeline_ops_mqtt.MQTTUnsubscribeOperation):
logger.info("{}({}): unsubscribing from {}".format(
self.name, op.name, op.topic))
@pipeline_thread.invoke_on_pipeline_thread_nowait
def on_unsubscribed():
logger.info(
"{}({}): UNSUBACK received. completing op.".format(
self.name, op.name))
operation_flow.complete_op(self, op)
self.transport.unsubscribe(topic=op.topic,
callback=on_unsubscribed)
else:
operation_flow.pass_op_to_next_stage(self, op)
def _run_op(self, op):
if isinstance(op, pipeline_ops_base.InitializePipelineOperation):
# If there is a gateway hostname, use that as the hostname for connection,
# rather than the hostname itself
if self.pipeline_root.pipeline_configuration.gateway_hostname:
logger.debug(
"Gateway Hostname Present. Setting Hostname to: {}".format(
self.pipeline_root.pipeline_configuration.
gateway_hostname))
hostname = self.pipeline_root.pipeline_configuration.gateway_hostname
else:
logger.debug(
"Gateway Hostname not present. Setting Hostname to: {}".
format(self.pipeline_root.pipeline_configuration.hostname))
hostname = self.pipeline_root.pipeline_configuration.hostname
# Create the Transport object, set it's handlers
logger.debug("{}({}): got connection args".format(
self.name, op.name))
self.transport = MQTTTransport(
client_id=op.client_id,
hostname=hostname,
username=op.username,
server_verification_cert=self.pipeline_root.
pipeline_configuration.server_verification_cert,
x509_cert=self.pipeline_root.pipeline_configuration.x509,
websockets=self.pipeline_root.pipeline_configuration.
websockets,
cipher=self.pipeline_root.pipeline_configuration.cipher,
proxy_options=self.pipeline_root.pipeline_configuration.
proxy_options,
keep_alive=self.pipeline_root.pipeline_configuration.
keep_alive,
)
self.transport.on_mqtt_connected_handler = self._on_mqtt_connected
self.transport.on_mqtt_connection_failure_handler = self._on_mqtt_connection_failure
self.transport.on_mqtt_disconnected_handler = self._on_mqtt_disconnected
self.transport.on_mqtt_message_received_handler = self._on_mqtt_message_received
# There can only be one pending connection operation (Connect, Disconnect)
# at a time. The existing one must be completed or canceled before a new one is set.
# Currently, this means that if, say, a connect operation is the pending op and is executed
# but another connection op is begins by the time the CONNACK is received, the original
# operation will be cancelled, but the CONNACK for it will still be received, and complete the
# NEW operation. This is not desirable, but it is how things currently work.
# We are however, checking the type, so the CONNACK from a cancelled Connect, cannot successfully
# complete a Disconnect operation.
# Note that a ReauthorizeConnectionOperation will never be pending because it will
# instead spawn separate Connect and Disconnect operations.
self._pending_connection_op = None
op.complete()
elif isinstance(op, pipeline_ops_base.ShutdownPipelineOperation):
try:
self.transport.shutdown()
except Exception as e:
logger.info("transport.shutdown raised error")
logger.info(traceback.format_exc())
op.complete(error=e)
else:
op.complete()
elif isinstance(op, pipeline_ops_base.ConnectOperation):
logger.debug("{}({}): connecting".format(self.name, op.name))
self._cancel_pending_connection_op()
self._pending_connection_op = op
self._start_connection_watchdog(op)
# Use SasToken as password if present. If not present (e.g. using X509),
# then no password is required because auth is handled via other means.
if self.pipeline_root.pipeline_configuration.sastoken:
password = str(
self.pipeline_root.pipeline_configuration.sastoken)
else:
password = None
try:
self.transport.connect(password=password)
except Exception as e:
logger.info("transport.connect raised error")
logger.info(traceback.format_exc())
self._cancel_connection_watchdog(op)
self._pending_connection_op = None
op.complete(error=e)
elif isinstance(op, pipeline_ops_base.DisconnectOperation):
logger.debug("{}({}): disconnecting".format(self.name, op.name))
self._cancel_pending_connection_op()
self._pending_connection_op = op
# We don't need a watchdog on disconnect because there's no callback to wait for
# and we respond to a watchdog timeout by calling disconnect, which is what we're
# already doing.
try:
# The connect after the disconnect will be triggered upon completion of the
# disconnect in the on_disconnected handler
self.transport.disconnect(clear_inflight=op.hard)
except Exception as e:
logger.info(
"transport.disconnect raised error while disconnecting")
logger.info(traceback.format_exc())
self._pending_connection_op = None
op.complete(error=e)
elif isinstance(op, pipeline_ops_base.ReauthorizeConnectionOperation):
logger.debug(
"{}({}): reauthorizing. Will issue disconnect and then a connect"
.format(self.name, op.name))
self_weakref = weakref.ref(self)
reauth_op = op # rename for clarity
def on_disconnect_complete(op, error):
this = self_weakref()
if error:
# Failing a disconnect should still get us disconnected, so can proceed anyway
logger.debug(
"Disconnect failed during reauthorization, continuing with connect"
)
connect_op = reauth_op.spawn_worker_op(
pipeline_ops_base.ConnectOperation)
# NOTE: this relies on the fact that before the disconnect is completed it is
# unset as the pending connection op. Otherwise there would be issues here.
this.run_op(connect_op)
disconnect_op = pipeline_ops_base.DisconnectOperation(
callback=on_disconnect_complete)
disconnect_op.hard = False
self.run_op(disconnect_op)
elif isinstance(op, pipeline_ops_mqtt.MQTTPublishOperation):
logger.debug("{}({}): publishing on {}".format(
self.name, op.name, op.topic))
@pipeline_thread.invoke_on_pipeline_thread_nowait
def on_complete(cancelled=False):
if cancelled:
op.complete(error=pipeline_exceptions.OperationCancelled(
"Operation cancelled before PUBACK received"))
else:
logger.debug(
"{}({}): PUBACK received. completing op.".format(
self.name, op.name))
op.complete()
try:
self.transport.publish(topic=op.topic,
payload=op.payload,
callback=on_complete)
except Exception as e:
op.complete(error=e)
elif isinstance(op, pipeline_ops_mqtt.MQTTSubscribeOperation):
logger.debug("{}({}): subscribing to {}".format(
self.name, op.name, op.topic))
@pipeline_thread.invoke_on_pipeline_thread_nowait
def on_complete(cancelled=False):
if cancelled:
op.complete(error=pipeline_exceptions.OperationCancelled(
"Operation cancelled before SUBACK received"))
else:
logger.debug(
"{}({}): SUBACK received. completing op.".format(
self.name, op.name))
op.complete()
try:
self.transport.subscribe(topic=op.topic, callback=on_complete)
except Exception as e:
op.complete(error=e)
elif isinstance(op, pipeline_ops_mqtt.MQTTUnsubscribeOperation):
logger.debug("{}({}): unsubscribing from {}".format(
self.name, op.name, op.topic))
@pipeline_thread.invoke_on_pipeline_thread_nowait
def on_complete(cancelled=False):
if cancelled:
op.complete(error=pipeline_exceptions.OperationCancelled(
"Operation cancelled before UNSUBACK received"))
else:
logger.debug(
"{}({}): UNSUBACK received. completing op.".format(
self.name, op.name))
op.complete()
try:
self.transport.unsubscribe(topic=op.topic,
callback=on_complete)
except Exception as e:
op.complete(error=e)
else:
# This code block should not be reached in correct program flow.
# This will raise an error when executed.
self.send_op_down(op)