def __init__(self, pipeline_configuration):
"""
Constructor for instantiating a pipeline adapter object.
:param auth_provider: The authentication provider
:param pipeline_configuration: The configuration generated based on user inputs
"""
# NOTE: This pipeline DOES NOT handle SasToken management!
# (i.e. using a SasTokenStage)
# It instead relies on the parallel MQTT pipeline to handle that.
#
# Because they share a pipeline configuration, and MQTT has renewal logic we can be sure
# that the SasToken in the pipeline configuration is valid.
#
# Furthermore, because HTTP doesn't require constant connections or long running tokens,
# there's no need to reauthorize connections, so we can just pass the token from the config
# when needed for auth.
#
# This is not an ideal solution, but it's the simplest one for the time being.
# Contains data and information shared globally within the pipeline
self._nucleus = pipeline_nucleus.PipelineNucleus(
pipeline_configuration)
self._pipeline = (pipeline_stages_base.PipelineRootStage(
self._nucleus).append_stage(
pipeline_stages_iothub_http.IoTHubHTTPTranslationStage(
)).append_stage(pipeline_stages_http.HTTPTransportStage()))
callback = EventedCallback()
op = pipeline_ops_base.InitializePipelineOperation(callback=callback)
self._pipeline.run_op(op)
callback.wait_for_completion()
def stage_base_configuration(self, stage, mocker):
"""
This fixture configures the stage for testing. This is automatically
applied, so it will be called before your test runs, but it's not
guaranteed to be called before any other fixtures run. If you have
a fixture that needs to rely on the stage being configured, then
you have to add a manual dependency inside that fixture (like we do in
next_stage_succeeds_all_ops below)
"""
class NextStageForTest(pipeline_stages_base.PipelineStage):
def _execute_op(self, op):
pass
next = NextStageForTest()
root = (pipeline_stages_base.PipelineRootStage(
config.BasePipelineConfig()).append_stage(stage).append_stage(next)
)
mocker.spy(stage, "_execute_op")
mocker.spy(stage, "run_op")
mocker.spy(next, "_execute_op")
mocker.spy(next, "run_op")
return root
def stage(self, mocker, request, cls_type, init_kwargs):
mock_transport = mocker.patch(
"azure.iot.device.common.pipeline.pipeline_stages_http.HTTPTransport",
autospec=True)
stage = cls_type(**init_kwargs)
stage.pipeline_root = pipeline_stages_base.PipelineRootStage(
pipeline_configuration=mocker.MagicMock())
stage.send_op_down = mocker.MagicMock()
# Set up the Transport on the stage
if request.param == "SAS":
op = pipeline_ops_http.SetHTTPConnectionArgsOperation(
hostname="fake_hostname",
server_verification_cert="fake_server_verification_cert",
sas_token="fake_sas_token",
callback=mocker.MagicMock(),
)
else:
op = pipeline_ops_http.SetHTTPConnectionArgsOperation(
hostname="fake_hostname",
server_verification_cert="fake_server_verification_cert",
client_cert="fake_client_cert",
callback=mocker.MagicMock(),
)
stage.run_op(op)
assert stage.transport is mock_transport.return_value
return stage
def stage(self, mocker, cls_type, init_kwargs, pipeline_config):
stage = cls_type(**init_kwargs)
stage.pipeline_root = stage.pipeline_root = pipeline_stages_base.PipelineRootStage(
pipeline_config)
stage.send_op_down = mocker.MagicMock()
stage.send_event_up = mocker.MagicMock()
return stage
def stage(self, mocker, cls_type, init_kwargs):
stage = cls_type(**init_kwargs)
stage.pipeline_root = pipeline_stages_base.PipelineRootStage(
pipeline_configuration=mocker.MagicMock())
stage.pipeline_root.hostname = "some.fake-host.name.com"
stage.send_op_down = mocker.MagicMock()
return stage
def stage(self, mocker, cls_type, init_kwargs, pipeline_config):
stage = cls_type(**init_kwargs)
stage.pipeline_root = pipeline_stages_base.PipelineRootStage(
pipeline_config)
stage.send_op_down = mocker.MagicMock()
stage.send_event_up = mocker.MagicMock()
mocker.spy(stage, "report_background_exception")
return stage
def stage(self, mocker, cls_type, init_kwargs):
stage = cls_type(**init_kwargs)
pl_config = config.IoTHubPipelineConfig()
stage.pipeline_root = pipeline_stages_base.PipelineRootStage(
pipeline_configuration=pl_config)
stage.send_op_down = mocker.MagicMock()
stage.send_event_up = mocker.MagicMock()
stage.device_id = "fake_device_id"
stage.module_id = None
stage.hostname = "fake_hostname"
return stage
def stage(mocker):
stage = pipeline_stages_mqtt.MQTTClientStage()
root = pipeline_stages_base.PipelineRootStage()
stage.previous = root
root.next = stage
stage.pipeline_root = root
mocker.spy(root, "handle_pipeline_event")
mocker.spy(stage, "on_connected")
mocker.spy(stage, "on_disconnected")
return stage
def test_receives_correct_config(self, stage, transport, mocker, op_set_connection_args):
stage.pipeline_root = pipeline_stages_base.PipelineRootStage(
config.BasePipelineConfig(websockets="__fake_boolean__")
)
stage.run_op(op_set_connection_args)
assert transport.call_args == mocker.call(
client_id=fake_client_id,
hostname=fake_hostname,
username=fake_username,
ca_cert=fake_ca_cert,
x509_cert=fake_certificate,
websockets="__fake_boolean__",
)
def stage(self, mocker, request, cls_type, init_kwargs, mock_transport):
stage = cls_type(**init_kwargs)
stage.pipeline_root = pipeline_stages_base.PipelineRootStage(
pipeline_configuration=mocker.MagicMock())
stage.send_op_down = mocker.MagicMock()
# Set up the Transport on the stage
op = pipeline_ops_base.InitializePipelineOperation(
callback=mocker.MagicMock())
stage.run_op(op)
assert stage.transport is mock_transport.return_value
return stage
def __init__(self, pipeline_configuration):
"""
Constructor for instantiating a pipeline adapter object.
:param auth_provider: The authentication provider
:param pipeline_configuration: The configuration generated based on user inputs
"""
self._pipeline = (pipeline_stages_base.PipelineRootStage(
pipeline_configuration).append_stage(
pipeline_stages_base.SasTokenRenewalStage()).append_stage(
pipeline_stages_iothub_http.IoTHubHTTPTranslationStage(
)).append_stage(pipeline_stages_http.HTTPTransportStage()))
callback = EventedCallback()
op = pipeline_ops_base.InitializePipelineOperation(callback=callback)
self._pipeline.run_op(op)
callback.wait_for_completion()
def stage(self, mocker, cls_type, init_kwargs, mock_transport):
stage = cls_type(**init_kwargs)
stage.pipeline_root = pipeline_stages_base.PipelineRootStage(
pipeline_configuration=mocker.MagicMock())
stage.send_op_down = mocker.MagicMock()
stage.send_event_up = mocker.MagicMock()
# Set up the Transport on the stage
op = pipeline_ops_mqtt.SetMQTTConnectionArgsOperation(
client_id="fake_client_id",
hostname="fake_hostname",
username="******",
ca_cert="fake_ca_cert",
client_cert="fake_client_cert",
sas_token="fake_sas_token",
callback=mocker.MagicMock(),
)
stage.run_op(op)
assert stage.transport is mock_transport.return_value
return stage
def __init__(self, auth_provider, pipeline_configuration):
"""
Constructor for instantiating a pipeline adapter object.
:param auth_provider: The authentication provider
:param pipeline_configuration: The configuration generated based on user inputs
"""
self._pipeline = (pipeline_stages_base.PipelineRootStage(
pipeline_configuration=pipeline_configuration).append_stage(
pipeline_stages_iothub.UseAuthProviderStage()).append_stage(
pipeline_stages_iothub_http.IoTHubHTTPTranslationStage(
)).append_stage(pipeline_stages_http.HTTPTransportStage()))
callback = EventedCallback()
if isinstance(auth_provider, X509AuthenticationProvider):
op = pipeline_ops_iothub.SetX509AuthProviderOperation(
auth_provider=auth_provider, callback=callback)
else: # Currently everything else goes via this block.
op = pipeline_ops_iothub.SetAuthProviderOperation(
auth_provider=auth_provider, callback=callback)
self._pipeline.run_op(op)
callback.wait_for_completion()
def __init__(self, auth_provider, pipeline_configuration):
"""
Constructor for instantiating a pipeline adapter object
:param auth_provider: The authentication provider
:param pipeline_configuration: The configuration generated based on user inputs
"""
self.feature_enabled = {
constant.C2D_MSG: False,
constant.INPUT_MSG: False,
constant.METHODS: False,
constant.TWIN: False,
constant.TWIN_PATCHES: False,
}
# Event Handlers - Will be set by Client after instantiation of this object
self.on_connected = None
self.on_disconnected = None
self.on_c2d_message_received = None
self.on_input_message_received = None
self.on_method_request_received = None
self.on_twin_patch_received = None
# Currently a single timeout stage and a single retry stage for MQTT retry only.
# Later, a higher level timeout and a higher level retry stage.
self._pipeline = (pipeline_stages_base.PipelineRootStage(
pipeline_configuration=pipeline_configuration
).append_stage(pipeline_stages_iothub.UseAuthProviderStage(
)).append_stage(pipeline_stages_iothub.TwinRequestResponseStage(
)).append_stage(pipeline_stages_base.CoordinateRequestAndResponseStage(
)).append_stage(
pipeline_stages_iothub_mqtt.IoTHubMQTTTranslationStage()
).append_stage(pipeline_stages_base.ReconnectStage()).append_stage(
pipeline_stages_base.AutoConnectStage()).append_stage(
pipeline_stages_base.ConnectionLockStage()).append_stage(
pipeline_stages_base.RetryStage()).append_stage(
pipeline_stages_base.OpTimeoutStage()).append_stage(
pipeline_stages_mqtt.MQTTTransportStage()))
def _on_pipeline_event(event):
if isinstance(event, pipeline_events_iothub.C2DMessageEvent):
if self.on_c2d_message_received:
self.on_c2d_message_received(event.message)
else:
logger.warning(
"C2D message event received with no handler. dropping."
)
elif isinstance(event, pipeline_events_iothub.InputMessageEvent):
if self.on_input_message_received:
self.on_input_message_received(event.input_name,
event.message)
else:
logger.warning(
"input message event received with no handler. dropping."
)
elif isinstance(event, pipeline_events_iothub.MethodRequestEvent):
if self.on_method_request_received:
self.on_method_request_received(event.method_request)
else:
logger.warning(
"Method request event received with no handler. Dropping."
)
elif isinstance(
event,
pipeline_events_iothub.TwinDesiredPropertiesPatchEvent):
if self.on_twin_patch_received:
self.on_twin_patch_received(event.patch)
else:
logger.warning(
"Twin patch event received with no handler. Dropping.")
else:
logger.warning("Dropping unknown pipeline event {}".format(
event.name))
def _on_connected():
if self.on_connected:
self.on_connected()
def _on_disconnected():
if self.on_disconnected:
self.on_disconnected()
self._pipeline.on_pipeline_event_handler = _on_pipeline_event
self._pipeline.on_connected_handler = _on_connected
self._pipeline.on_disconnected_handler = _on_disconnected
callback = EventedCallback()
if isinstance(auth_provider, X509AuthenticationProvider):
op = pipeline_ops_iothub.SetX509AuthProviderOperation(
auth_provider=auth_provider, callback=callback)
else: # Currently everything else goes via this block.
op = pipeline_ops_iothub.SetAuthProviderOperation(
auth_provider=auth_provider, callback=callback)
self._pipeline.run_op(op)
callback.wait_for_completion()
def __init__(self, auth_provider):
"""
Constructor for instantiating a pipeline adapter object
:param auth_provider: The authentication provider
"""
self.feature_enabled = {
constant.C2D_MSG: False,
constant.INPUT_MSG: False,
constant.METHODS: False,
constant.TWIN: False,
constant.TWIN_PATCHES: False,
}
# Event Handlers - Will be set by Client after instantiation of this object
self.on_connected = None
self.on_disconnected = None
self.on_c2d_message_received = None
self.on_input_message_received = None
self.on_method_request_received = None
self.on_twin_patch_received = None
self._pipeline = (
pipeline_stages_base.PipelineRootStage()
.append_stage(pipeline_stages_iothub.UseAuthProviderStage())
.append_stage(pipeline_stages_iothub.HandleTwinOperationsStage())
.append_stage(pipeline_stages_base.CoordinateRequestAndResponseStage())
.append_stage(pipeline_stages_iothub_mqtt.IoTHubMQTTConverterStage())
.append_stage(pipeline_stages_base.EnsureConnectionStage())
.append_stage(pipeline_stages_base.SerializeConnectOpsStage())
.append_stage(pipeline_stages_mqtt.MQTTTransportStage())
)
def _on_pipeline_event(event):
if isinstance(event, pipeline_events_iothub.C2DMessageEvent):
if self.on_c2d_message_received:
self.on_c2d_message_received(event.message)
else:
logger.warning("C2D message event received with no handler. dropping.")
elif isinstance(event, pipeline_events_iothub.InputMessageEvent):
if self.on_input_message_received:
self.on_input_message_received(event.input_name, event.message)
else:
logger.warning("input message event received with no handler. dropping.")
elif isinstance(event, pipeline_events_iothub.MethodRequestEvent):
if self.on_method_request_received:
self.on_method_request_received(event.method_request)
else:
logger.warning("Method request event received with no handler. Dropping.")
elif isinstance(event, pipeline_events_iothub.TwinDesiredPropertiesPatchEvent):
if self.on_twin_patch_received:
self.on_twin_patch_received(event.patch)
else:
logger.warning("Twin patch event received with no handler. Dropping.")
else:
logger.warning("Dropping unknown pipeline event {}".format(event.name))
def _on_connected():
if self.on_connected:
self.on_connected()
def _on_disconnected():
if self.on_disconnected:
self.on_disconnected()
self._pipeline.on_pipeline_event_handler = _on_pipeline_event
self._pipeline.on_connected_handler = _on_connected
self._pipeline.on_disconnected_handler = _on_disconnected
def remove_this_code(call):
if call.error:
raise call.error
if isinstance(auth_provider, X509AuthenticationProvider):
op = pipeline_ops_iothub.SetX509AuthProviderOperation(
auth_provider=auth_provider, callback=remove_this_code
)
else: # Currently everything else goes via this block.
op = pipeline_ops_iothub.SetAuthProviderOperation(
auth_provider=auth_provider, callback=remove_this_code
)
self._pipeline.run_op(op)
def add_pipeline_root(stage, mocker):
root = pipeline_stages_base.PipelineRootStage()
mocker.spy(root, "handle_pipeline_event")
stage.previous = root
stage.pipeline_root = root
def __init__(self, pipeline_configuration):
"""
Constructor for instantiating a pipeline
:param security_client: The security client which stores credentials
"""
self.responses_enabled = {provisioning_constants.REGISTER: False}
# Event Handlers - Will be set by Client after instantiation of pipeline
self.on_connected = None
self.on_disconnected = None
self.on_message_received = None
self._registration_id = pipeline_configuration.registration_id
self._pipeline = (
#
# The root is always the root. By definition, it's the first stage in the pipeline.
#
pipeline_stages_base.PipelineRootStage(
pipeline_configuration=pipeline_configuration)
#
# SasTokenRenewalStage comes near the root by default because it should be as close
# to the top of the pipeline as possible, and does not need to be after anything.
#
.append_stage(pipeline_stages_base.SasTokenRenewalStage())
#
# RegistrationStage needs to come early because this is the stage that converts registration
# or query requests into request and response objects which are used by later stages
#
.append_stage(pipeline_stages_provisioning.RegistrationStage())
#
# PollingStatusStage needs to come after RegistrationStage because RegistrationStage counts
# on PollingStatusStage to poll until the registration is complete.
#
.append_stage(pipeline_stages_provisioning.PollingStatusStage())
#
# CoordinateRequestAndResponseStage needs to be after RegistrationStage and PollingStatusStage
# because these 2 stages create the request ops that CoordinateRequestAndResponseStage
# is coordinating. It needs to be before ProvisioningMQTTTranslationStage because that stage
# operates on ops that CoordinateRequestAndResponseStage produces
#
.append_stage(
pipeline_stages_base.CoordinateRequestAndResponseStage())
#
# ProvisioningMQTTTranslationStage comes here because this is the point where we can translate
# all operations directly into MQTT. After this stage, only pipeline_stages_base stages
# are allowed because ProvisioningMQTTTranslationStage removes all the provisioning-ness from the ops
#
.append_stage(pipeline_stages_provisioning_mqtt.
ProvisioningMQTTTranslationStage())
#
# AutoConnectStage comes here because only MQTT ops have the need_connection flag set
# and this is the first place in the pipeline wherer we can guaranetee that all network
# ops are MQTT ops.
#
.append_stage(pipeline_stages_base.AutoConnectStage())
#
# ReconnectStage needs to be after AutoConnectStage because ReconnectStage sets/clears
# the virtually_conencted flag and we want an automatic connection op to set this flag so
# we can reconnect autoconnect operations.
#
.append_stage(pipeline_stages_base.ReconnectStage())
#
# ConnectionLockStage needs to be after ReconnectStage because we want any ops that
# ReconnectStage creates to go through the ConnectionLockStage gate
#
.append_stage(pipeline_stages_base.ConnectionLockStage())
#
# RetryStage needs to be near the end because it's retrying low-level MQTT operations.
#
.append_stage(pipeline_stages_base.RetryStage())
#
# OpTimeoutStage needs to be after RetryStage because OpTimeoutStage returns the timeout
# errors that RetryStage is watching for.
#
.append_stage(pipeline_stages_base.OpTimeoutStage())
#
# MQTTTransportStage needs to be at the very end of the pipeline because this is where
# operations turn into network traffic
#
.append_stage(pipeline_stages_mqtt.MQTTTransportStage()))
def _on_pipeline_event(event):
logger.warning("Dropping unknown pipeline event {}".format(
event.name))
def _on_connected():
if self.on_connected:
self.on_connected("connected")
def _on_disconnected():
if self.on_disconnected:
self.on_disconnected("disconnected")
self._pipeline.on_pipeline_event_handler = _on_pipeline_event
self._pipeline.on_connected_handler = _on_connected
self._pipeline.on_disconnected_handler = _on_disconnected
callback = EventedCallback()
op = pipeline_ops_base.InitializePipelineOperation(callback=callback)
self._pipeline.run_op(op)
callback.wait_for_completion()
def __init__(self, security_client, pipeline_configuration):
"""
Constructor for instantiating a pipeline
:param security_client: The security client which stores credentials
"""
self.responses_enabled = {provisioning_constants.REGISTER: False}
# Event Handlers - Will be set by Client after instantiation of pipeline
self.on_connected = None
self.on_disconnected = None
self.on_message_received = None
self._registration_id = security_client.registration_id
self._pipeline = (
pipeline_stages_base.PipelineRootStage(
pipeline_configuration=pipeline_configuration).append_stage(
pipeline_stages_provisioning.UseSecurityClientStage()).
append_stage(
pipeline_stages_provisioning.RegistrationStage()).append_stage(
pipeline_stages_provisioning.PollingStatusStage()).
append_stage(
pipeline_stages_base.CoordinateRequestAndResponseStage()
).append_stage(pipeline_stages_provisioning_mqtt.
ProvisioningMQTTTranslationStage()).append_stage(
pipeline_stages_base.ReconnectStage()).
append_stage(pipeline_stages_base.AutoConnectStage()).append_stage(
pipeline_stages_base.ConnectionLockStage()).append_stage(
pipeline_stages_base.RetryStage()).append_stage(
pipeline_stages_base.OpTimeoutStage()).append_stage(
pipeline_stages_mqtt.MQTTTransportStage()))
def _on_pipeline_event(event):
logger.warning("Dropping unknown pipeline event {}".format(
event.name))
def _on_connected():
if self.on_connected:
self.on_connected("connected")
def _on_disconnected():
if self.on_disconnected:
self.on_disconnected("disconnected")
self._pipeline.on_pipeline_event_handler = _on_pipeline_event
self._pipeline.on_connected_handler = _on_connected
self._pipeline.on_disconnected_handler = _on_disconnected
callback = EventedCallback()
if isinstance(security_client, X509SecurityClient):
op = pipeline_ops_provisioning.SetX509SecurityClientOperation(
security_client=security_client, callback=callback)
elif isinstance(security_client, SymmetricKeySecurityClient):
op = pipeline_ops_provisioning.SetSymmetricKeySecurityClientOperation(
security_client=security_client, callback=callback)
else:
logger.error(
"Provisioning not equipped to handle other security client.")
self._pipeline.run_op(op)
callback.wait_for_completion()
def __init__(self, security_client):
"""
Constructor for instantiating a pipeline
:param security_client: The security client which stores credentials
"""
# Event Handlers - Will be set by Client after instantiation of pipeline
self.on_connected = None
self.on_disconnected = None
self.on_message_received = None
self._pipeline = (
pipeline_stages_base.PipelineRootStage()
.append_stage(pipeline_stages_provisioning.UseSecurityClientStage())
.append_stage(pipeline_stages_provisioning_mqtt.ProvisioningMQTTConverterStage())
.append_stage(pipeline_stages_base.EnsureConnectionStage())
.append_stage(pipeline_stages_base.SerializeConnectOpsStage())
.append_stage(pipeline_stages_mqtt.MQTTTransportStage())
)
def _on_pipeline_event(event):
if isinstance(event, pipeline_events_provisioning.RegistrationResponseEvent):
if self.on_message_received:
self.on_message_received(
event.request_id,
event.status_code,
event.key_values,
event.response_payload,
)
else:
logger.warning("Provisioning event received with no handler. dropping.")
else:
logger.warning("Dropping unknown pipeline event {}".format(event.name))
def _on_connected():
if self.on_connected:
self.on_connected("connected")
def _on_disconnected():
if self.on_disconnected:
self.on_disconnected("disconnected")
self._pipeline.on_pipeline_event_handler = _on_pipeline_event
self._pipeline.on_connected_handler = _on_connected
self._pipeline.on_disconnected_handler = _on_disconnected
callback = EventedCallback()
if isinstance(security_client, X509SecurityClient):
op = pipeline_ops_provisioning.SetX509SecurityClientOperation(
security_client=security_client, callback=callback
)
elif isinstance(security_client, SymmetricKeySecurityClient):
op = pipeline_ops_provisioning.SetSymmetricKeySecurityClientOperation(
security_client=security_client, callback=callback
)
else:
logger.error("Provisioning not equipped to handle other security client.")
self._pipeline.run_op(op)
callback.wait_for_completion()
if op.error:
logger.error("{} failed: {}".format(op.name, op.error))
raise op.error
def __init__(self, auth_provider, pipeline_configuration):
"""
Constructor for instantiating a pipeline adapter object
:param auth_provider: The authentication provider
:param pipeline_configuration: The configuration generated based on user inputs
"""
self.feature_enabled = {
constant.C2D_MSG: False,
constant.INPUT_MSG: False,
constant.METHODS: False,
constant.TWIN: False,
constant.TWIN_PATCHES: False,
}
# Event Handlers - Will be set by Client after instantiation of this object
self.on_connected = None
self.on_disconnected = None
self.on_c2d_message_received = None
self.on_input_message_received = None
self.on_method_request_received = None
self.on_twin_patch_received = None
# Currently a single timeout stage and a single retry stage for MQTT retry only.
# Later, a higher level timeout and a higher level retry stage.
self._pipeline = (
#
# The root is always the root. By definition, it's the first stage in the pipeline.
#
pipeline_stages_base.PipelineRootStage(
pipeline_configuration=pipeline_configuration)
#
# UseAuthProviderStage comes near the root by default because it doesn't need to be after
# anything, but it does need to be before IoTHubMQTTTranslationStage.
#
.append_stage(pipeline_stages_iothub.UseAuthProviderStage())
#
# TwinRequestResponseStage comes near the root by default because it doesn't need to be
# after anything
#
.append_stage(pipeline_stages_iothub.TwinRequestResponseStage())
#
# CoordinateRequestAndResponseStage needs to be after TwinRequestResponseStage because
# TwinRequestResponseStage creates the request ops that CoordinateRequestAndResponseStage
# is coordinating. It needs to be before IoTHubMQTTTranslationStage because that stage
# operates on ops that CoordinateRequestAndResponseStage produces
#
.append_stage(
pipeline_stages_base.CoordinateRequestAndResponseStage())
#
# IoTHubMQTTTranslationStage comes here because this is the point where we can translate
# all operations directly into MQTT. After this stage, only pipeline_stages_base stages
# are allowed because IoTHubMQTTTranslationStage removes all the IoTHub-ness from the ops
#
.append_stage(
pipeline_stages_iothub_mqtt.IoTHubMQTTTranslationStage())
#
# AutoConnectStage comes here because only MQTT ops have the need_connection flag set
# and this is the first place in the pipeline wherer we can guaranetee that all network
# ops are MQTT ops.
#
.append_stage(pipeline_stages_base.AutoConnectStage())
#
# ReconnectStage needs to be after AutoConnectStage because ReconnectStage sets/clears
# the virtually_conencted flag and we want an automatic connection op to set this flag so
# we can reconnect autoconnect operations. This is important, for example, if a
# send_message causes the transport to automatically connect, but that connection fails.
# When that happens, the ReconenctState will hold onto the ConnectOperation until it
# succeeds, and only then will return success to the AutoConnectStage which will
# allow the publish to continue.
#
.append_stage(pipeline_stages_base.ReconnectStage())
#
# ConnectionLockStage needs to be after ReconnectStage because we want any ops that
# ReconnectStage creates to go through the ConnectionLockStage gate
#
.append_stage(pipeline_stages_base.ConnectionLockStage())
#
# RetryStage needs to be near the end because it's retrying low-level MQTT operations.
#
.append_stage(pipeline_stages_base.RetryStage())
#
# OpTimeoutStage needs to be after RetryStage because OpTimeoutStage returns the timeout
# errors that RetryStage is watching for.
#
.append_stage(pipeline_stages_base.OpTimeoutStage())
#
# MQTTTransportStage needs to be at the very end of the pipeline because this is where
# operations turn into network traffic
#
.append_stage(pipeline_stages_mqtt.MQTTTransportStage()))
def _on_pipeline_event(event):
if isinstance(event, pipeline_events_iothub.C2DMessageEvent):
if self.on_c2d_message_received:
self.on_c2d_message_received(event.message)
else:
logger.warning(
"C2D message event received with no handler. dropping."
)
elif isinstance(event, pipeline_events_iothub.InputMessageEvent):
if self.on_input_message_received:
self.on_input_message_received(event.input_name,
event.message)
else:
logger.warning(
"input message event received with no handler. dropping."
)
elif isinstance(event, pipeline_events_iothub.MethodRequestEvent):
if self.on_method_request_received:
self.on_method_request_received(event.method_request)
else:
logger.warning(
"Method request event received with no handler. Dropping."
)
elif isinstance(
event,
pipeline_events_iothub.TwinDesiredPropertiesPatchEvent):
if self.on_twin_patch_received:
self.on_twin_patch_received(event.patch)
else:
logger.warning(
"Twin patch event received with no handler. Dropping.")
else:
logger.warning("Dropping unknown pipeline event {}".format(
event.name))
def _on_connected():
if self.on_connected:
self.on_connected()
def _on_disconnected():
if self.on_disconnected:
self.on_disconnected()
self._pipeline.on_pipeline_event_handler = _on_pipeline_event
self._pipeline.on_connected_handler = _on_connected
self._pipeline.on_disconnected_handler = _on_disconnected
callback = EventedCallback()
if isinstance(auth_provider, X509AuthenticationProvider):
op = pipeline_ops_iothub.SetX509AuthProviderOperation(
auth_provider=auth_provider, callback=callback)
else: # Currently everything else goes via this block.
op = pipeline_ops_iothub.SetAuthProviderOperation(
auth_provider=auth_provider, callback=callback)
self._pipeline.run_op(op)
callback.wait_for_completion()
def __init__(self, pipeline_configuration):
"""
Constructor for instantiating a pipeline adapter object
:param auth_provider: The authentication provider
:param pipeline_configuration: The configuration generated based on user inputs
"""
self.feature_enabled = {
constant.C2D_MSG: False,
constant.INPUT_MSG: False,
constant.METHODS: False,
constant.TWIN: False,
constant.TWIN_PATCHES: False,
}
# Handlers - Will be set by Client after instantiation of this object
self.on_connected = None
self.on_disconnected = None
self.on_new_sastoken_required = None
self.on_background_exception = None
self.on_c2d_message_received = None
self.on_input_message_received = None
self.on_method_request_received = None
self.on_twin_patch_received = None
# Contains data and information shared globally within the pipeline
self._nucleus = pipeline_nucleus.PipelineNucleus(pipeline_configuration)
self._pipeline = (
#
# The root is always the root. By definition, it's the first stage in the pipeline.
#
pipeline_stages_base.PipelineRootStage(self._nucleus)
#
# SasTokenStage comes near the root by default because it should be as close
# to the top of the pipeline as possible, and does not need to be after anything.
#
.append_stage(pipeline_stages_base.SasTokenStage())
#
# EnsureDesiredPropertiesStage needs to be above TwinRequestResponseStage because it
# sends GetTwinOperation ops and that stage handles those ops.
#
.append_stage(pipeline_stages_iothub.EnsureDesiredPropertiesStage())
#
# TwinRequestResponseStage comes near the root by default because it doesn't need to be
# after anything
#
.append_stage(pipeline_stages_iothub.TwinRequestResponseStage())
#
# CoordinateRequestAndResponseStage needs to be after TwinRequestResponseStage because
# TwinRequestResponseStage creates the request ops that CoordinateRequestAndResponseStage
# is coordinating. It needs to be before IoTHubMQTTTranslationStage because that stage
# operates on ops that CoordinateRequestAndResponseStage produces
#
.append_stage(pipeline_stages_base.CoordinateRequestAndResponseStage())
#
# IoTHubMQTTTranslationStage comes here because this is the point where we can translate
# all operations directly into MQTT. After this stage, only pipeline_stages_base stages
# are allowed because IoTHubMQTTTranslationStage removes all the IoTHub-ness from the ops
#
.append_stage(pipeline_stages_iothub_mqtt.IoTHubMQTTTranslationStage())
#
# AutoConnectStage comes here because only MQTT ops have the need_connection flag set
# and this is the first place in the pipeline where we can guarantee that all network
# ops are MQTT ops.
#
.append_stage(pipeline_stages_base.AutoConnectStage())
#
# ConnectionStateStage needs to be after AutoConnectStage because the AutoConnectStage
# can create ConnectOperations and we (may) want to queue connection related operations
# in the ConnectionStateStage
#
.append_stage(pipeline_stages_base.ConnectionStateStage())
#
# ConnectionLockStage needs to be after ConnectionStateStage because we want any ops that
# ConnectionStateStage creates to go through the ConnectionLockStage gate
#
.append_stage(pipeline_stages_base.ConnectionLockStage())
#
# RetryStage needs to be near the end because it's retrying low-level MQTT operations.
#
.append_stage(pipeline_stages_base.RetryStage())
#
# OpTimeoutStage needs to be after RetryStage because OpTimeoutStage returns the timeout
# errors that RetryStage is watching for.
#
.append_stage(pipeline_stages_base.OpTimeoutStage())
#
# MQTTTransportStage needs to be at the very end of the pipeline because this is where
# operations turn into network traffic
#
.append_stage(pipeline_stages_mqtt.MQTTTransportStage())
)
# Define behavior for domain-specific events
def _on_pipeline_event(event):
if isinstance(event, pipeline_events_iothub.C2DMessageEvent):
if self.on_c2d_message_received:
self.on_c2d_message_received(event.message)
else:
logger.error("C2D message event received with no handler. dropping.")
elif isinstance(event, pipeline_events_iothub.InputMessageEvent):
if self.on_input_message_received:
self.on_input_message_received(event.message)
else:
logger.error("input message event received with no handler. dropping.")
elif isinstance(event, pipeline_events_iothub.MethodRequestEvent):
if self.on_method_request_received:
self.on_method_request_received(event.method_request)
else:
logger.error("Method request event received with no handler. Dropping.")
elif isinstance(event, pipeline_events_iothub.TwinDesiredPropertiesPatchEvent):
if self.on_twin_patch_received:
self.on_twin_patch_received(event.patch)
else:
logger.error("Twin patch event received with no handler. Dropping.")
else:
logger.error("Dropping unknown pipeline event {}".format(event.name))
def _on_connected():
if self.on_connected:
self.on_connected()
else:
logger.debug("IoTHub Pipeline was connected, but no handler was set")
def _on_disconnected():
if self.on_disconnected:
self.on_disconnected()
else:
logger.debug("IoTHub Pipeline was disconnected, but no handler was set")
def _on_new_sastoken_required():
if self.on_new_sastoken_required:
self.on_new_sastoken_required()
else:
logger.debug("IoTHub Pipeline requires new SASToken, but no handler was set")
def _on_background_exception(e):
if self.on_background_exception:
self.on_background_exception(e)
else:
logger.debug(
"IoTHub Pipeline experienced background exception, but no handler was set"
)
# Set internal event handlers
self._pipeline.on_pipeline_event_handler = _on_pipeline_event
self._pipeline.on_connected_handler = _on_connected
self._pipeline.on_disconnected_handler = _on_disconnected
self._pipeline.on_new_sastoken_required_handler = _on_new_sastoken_required
self._pipeline.on_background_exception_handler = _on_background_exception
# Initialize the pipeline
callback = EventedCallback()
op = pipeline_ops_base.InitializePipelineOperation(callback=callback)
self._pipeline.run_op(op)
callback.wait_for_completion()
# Set the running flag
self._running = True
