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(self, mocker, cls_type, init_kwargs, pipeline_config):
stage = cls_type(**init_kwargs)
stage.nucleus = pipeline_nucleus.PipelineNucleus(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)
stage.nucleus = pipeline_nucleus.PipelineNucleus(
pipeline_configuration=mocker.MagicMock())
stage.nucleus.pipeline_configuration.hostname = "some.fake-host.name.com"
stage.send_op_down = mocker.MagicMock()
stage.send_event_up = mocker.MagicMock()
mocker.spy(stage, "report_background_exception")
return stage
def stage(self, mocker, request, cls_type, init_kwargs, mock_transport):
stage = cls_type(**init_kwargs)
stage.nucleus = pipeline_nucleus.PipelineNucleus(
pipeline_configuration=mocker.MagicMock())
stage.send_op_down = mocker.MagicMock()
stage.send_event_up = mocker.MagicMock()
mocker.spy(stage, "report_background_exception")
# 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.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
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_background_exception = None
self.on_message_received = None
self._registration_id = pipeline_configuration.registration_id
# 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())
#
# 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())
#
# 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()))
def _on_pipeline_event(event):
# error because no events should
logger.error("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")
def _on_background_exception():
if self.on_background_exception:
self.on_background_exception
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()
# Set the running flag
self._running = True