// Tests_SRS_DEVICECLIENT_33_004: [** It shall call DisableEventReceiveAsync when the last delegate has been removed. **]**
public async Task ModuleClient_SetReceiveCallbackAsync_RemoveCallback()
{
ModuleClient moduleClient = ModuleClient.CreateFromConnectionString(fakeConnectionString, TransportType.Mqtt_Tcp_Only);
var innerHandler = Substitute.For <IDelegatingHandler>();
moduleClient.InnerHandler = innerHandler;
await moduleClient.SetInputMessageHandlerAsync("endpoint1", (message, context) => Task.FromResult(MessageResponse.Completed), "custom data");
await moduleClient.SetInputMessageHandlerAsync("endpoint2", (message, context) => Task.FromResult(MessageResponse.Completed), "custom data");
await innerHandler.Received(1).EnableEventReceiveAsync(Arg.Any <CancellationToken>());
await innerHandler.DidNotReceiveWithAnyArgs().DisableEventReceiveAsync(Arg.Any <CancellationToken>());
await moduleClient.SetInputMessageHandlerAsync("endpoint1", null, null);
await innerHandler.Received(1).EnableEventReceiveAsync(Arg.Any <CancellationToken>());
await innerHandler.DidNotReceiveWithAnyArgs().DisableEventReceiveAsync(Arg.Any <CancellationToken>());
await moduleClient.SetInputMessageHandlerAsync("endpoint2", null, null);
await innerHandler.Received(1).EnableEventReceiveAsync(Arg.Any <CancellationToken>());
await innerHandler.Received(1).DisableEventReceiveAsync(Arg.Any <CancellationToken>());
}
/// <summary>
/// Initializes the ModuleClient and sets up the callback to receive
/// messages containing temperature information
/// </summary>
internal static async Task Init()
{
Logger.LoggingLevel = LogSeverity.Verbose;
AmqpTransportSettings amqpSetting = new AmqpTransportSettings(TransportType.Amqp_Tcp_Only);
ITransportSettings[] settings = { amqpSetting };
// Open a connection to the Edge runtime
ModuleClient ioTHubModuleClient = await ModuleClient
.CreateFromEnvironmentAsync(settings)
.ConfigureAwait(false);
await ioTHubModuleClient.OpenAsync().ConfigureAwait(false);
Console.WriteLine("IoT Hub module client initialized.");
// Register callbacks for messages to the module
await ioTHubModuleClient
.SetInputMessageHandlerAsync(EndpointNames.FromLeafDevice, LeafDeviceInputMessageHandler, ioTHubModuleClient)
.ConfigureAwait(false);
await ioTHubModuleClient
.SetInputMessageHandlerAsync(EndpointNames.FromClassifier, ClassifierCallbackMessageHandler, ioTHubModuleClient)
.ConfigureAwait(false);
// Register a callback for updates to the module twin's desired properties.
await ioTHubModuleClient
.SetDesiredPropertyUpdateCallbackAsync(OnDesiredPropertiesUpdate, null)
.ConfigureAwait(false);
}
/// <summary>
/// Initializes the ModuleClient and sets up the callback to receive
/// messages containing temperature information
/// </summary>
static async Task Init(bool debug = false)
{
#if DEBUG
while (debug && !Debugger.IsAttached)
{
Console.WriteLine("Module waiting for debugger to attach...");
await Task.Delay(1000);
}
;
#endif
MqttTransportSettings mqttSetting = new MqttTransportSettings(TransportType.Mqtt_Tcp_Only);
ITransportSettings[] settings = { mqttSetting };
// Open a connection to the Edge runtime
ModuleClient ioTHubModuleClient = await ModuleClient.CreateFromEnvironmentAsync(settings);
await ioTHubModuleClient.OpenAsync();
Console.WriteLine("IoT Hub module client initialized.");
// Register callback to be called when a message is received by the module
await ioTHubModuleClient.SetInputMessageHandlerAsync("compressMessage", CompressMessage, ioTHubModuleClient);
await ioTHubModuleClient.SetInputMessageHandlerAsync("decompressMessage", DecompressMessage, ioTHubModuleClient);
}
/// <summary>
/// Initializes the ModuleClient and sets up the callback to receive
/// messages containing temperature information
/// </summary>
static async Task Init()
{
// Use Mqtt as it is more reliable than ampq
MqttTransportSettings mqttSetting = new MqttTransportSettings(TransportType.Mqtt_Tcp_Only);
ITransportSettings[] settings = { mqttSetting };
// Open a connection to the Edge runtime
ModuleClient ioTHubModuleClient = await ModuleClient.CreateFromEnvironmentAsync(settings);
await ioTHubModuleClient.OpenAsync();
wrappedModuleClient = new WrappedModuleClient(ioTHubModuleClient);
Logger.LogInfo("IoT Hub module client initialized.");
// get module twin settings
var moduleTwin = await ioTHubModuleClient.GetTwinAsync();
await OnDesiredPropertiesUpdate(moduleTwin.Properties.Desired, ioTHubModuleClient);
// Attach a callback for updates to the module twin's desired properties.
await ioTHubModuleClient.SetDesiredPropertyUpdateCallbackAsync(OnDesiredPropertiesUpdate, null);
// Register callback to be called when a message is received by the module
await ioTHubModuleClient.SetInputMessageHandlerAsync(TrackerModule.TelemetryInputName, ProcessTelemetry, ioTHubModuleClient);
// Register callback to be called when a message is received by the module
await ioTHubModuleClient.SetInputMessageHandlerAsync(TrackerModule.BalloonInputName, ProcessBalloonData, ioTHubModuleClient);
}
/// <summary>
/// Initializes the ModuleClient and sets up the callback to receive
/// messages containing temperature information
/// </summary>
static async Task Init()
{
MqttTransportSettings mqttSetting = new MqttTransportSettings(TransportType.Mqtt_Tcp_Only);
ITransportSettings[] settings = { mqttSetting };
// Open a connection to the Edge runtime
ModuleClient ioTHubModuleClient = await ModuleClient.CreateFromEnvironmentAsync(settings);
await ioTHubModuleClient.OpenAsync();
Console.WriteLine("IoT Hub module client initialized.");
// Get environment variables scoped for this module
_edgeDeviceId = Environment.GetEnvironmentVariable(DeviceIdVariableName);
_edgeModuleId = Environment.GetEnvironmentVariable(ModuleIdVariableName);
_iothubHostName = Environment.GetEnvironmentVariable(IotHubHostnameVariableName);
_gatewayHostName = Environment.GetEnvironmentVariable(GatewayHostnameVariableName);
// Initialize leaf device cache
_leafDevices = new MemoryDeviceRepository();
// Register callback to be called when a message is received by the module
await ioTHubModuleClient.SetMethodHandlerAsync(ItmCallbackMethodName, DeviceRegistered, ioTHubModuleClient);
await ioTHubModuleClient.SetInputMessageHandlerAsync(ItmMessageInputName, PipeMessage, ioTHubModuleClient);
}
/// <summary>
/// Initializes the ModuleClient and sets up the callback to receive
/// messages containing temperature information
/// </summary>
static async Task Init()
{
// the module client is in charge of sending messages in the context of this module (VehicleTelemetry)
ioTHubModuleClient = await ModuleClient.CreateFromEnvironmentAsync(TransportType.Mqtt);
await ioTHubModuleClient.OpenAsync();
Console.WriteLine("IoT Hub module client initialized.");
// Register callback to be called when a message is received by this module
await ioTHubModuleClient.SetInputMessageHandlerAsync("input1", PipeMessage, ioTHubModuleClient);
//the device client is responsible for managing device twin information at the device level
//obtaining the device connection string is currently not supported by DeviceClient
//TODO: 7 - set device connection string for the device client
//ioTHubDeviceClient = DeviceClient.CreateFromConnectionString("<connectionstring>");
await ioTHubDeviceClient.SetDesiredPropertyUpdateCallbackAsync(onDesiredPropertiesUpdateAsync, null);
var twin = await ioTHubDeviceClient.GetTwinAsync();
var desired = twin.Properties.Desired;
await UpdateReportedPropertiesFromDesired(desired);
await GenerateMessage(ioTHubModuleClient);
}
/// <summary>
/// Initializes the ModuleClient and sets up the callback to receive
/// messages containing temperature information
/// </summary>
static async Task Init()
{
MqttTransportSettings mqttSetting = new MqttTransportSettings(TransportType.Mqtt_Tcp_Only);
ITransportSettings[] settings = { mqttSetting };
// Open a connection to the Edge runtime
ModuleClient ioTHubModuleClient = await ModuleClient.CreateFromEnvironmentAsync(settings);
await ioTHubModuleClient.OpenAsync();
Console.WriteLine("IoT Hub module client initialized.");
// Register callback to be called when a message is received by the module
await ioTHubModuleClient.SetInputMessageHandlerAsync("input-echo", PipeMessage, ioTHubModuleClient);
// Register a Timer that will send every X seconds
var myTimer = new System.Timers.Timer();
myTimer.Elapsed += new System.Timers.ElapsedEventHandler((object source, System.Timers.ElapsedEventArgs e) => {
var now = DateTime.Now.ToString("g");
var message = new Message(Encoding.UTF8.GetBytes($"Sending event at {now}"));
ioTHubModuleClient.SendEventAsync("output", message);
});
myTimer.Interval = 30 * 1000; // Every 30 seconds
myTimer.Enabled = true;
}
/// <summary>
/// Initializes the ModuleClient and sets up the callback to receive
/// messages containing temperature information
/// </summary>
static async Task Init()
{
MqttTransportSettings mqttSetting = new MqttTransportSettings(TransportType.Mqtt_Tcp_Only);
ITransportSettings[] settings = { mqttSetting };
// Open a connection to the Edge runtime
ModuleClient ioTHubModuleClient = await ModuleClient.CreateFromEnvironmentAsync(settings);
await ioTHubModuleClient.OpenAsync();
Console.WriteLine("IoT Hub module client initialized.");
// Register callback to be called when a message is received by the module
await ioTHubModuleClient.SetInputMessageHandlerAsync("input1", PipeMessage, ioTHubModuleClient);
// Create a timer with 10 seconds interval.
var aTimer = new System.Timers.Timer(10000);
// Hook up the Elapsed event for the timer.
aTimer.Elapsed += async(sender, e) => await SendMessage(ioTHubModuleClient);
aTimer.AutoReset = true;
aTimer.Enabled = true;
}
/// <summary>
/// Initializes the ModuleClient and sets up the callback to receive
/// messages
/// </summary>
static async Task Init()
{
AmqpTransportSettings amqpSetting = new AmqpTransportSettings(TransportType.Amqp_Tcp_Only);
ITransportSettings[] settings = { amqpSetting };
// Open a connection to the Edge runtime
ModuleClient ioTHubModuleClient = await ModuleClient.CreateFromEnvironmentAsync(settings);
await ioTHubModuleClient.OpenAsync();
Console.WriteLine("IoT Hub module client initialized.");
var moduleTwin = await ioTHubModuleClient.GetTwinAsync();
var moduleTwinCollection = moduleTwin.Properties.Desired;
desiredPropertiesData = new DesiredPropertiesData(moduleTwinCollection);
// callback for updating desired properties through the portal or rest api
await ioTHubModuleClient.SetDesiredPropertyUpdateCallbackAsync(OnDesiredPropertiesUpdate, null);
// Register callback to be called when a message is received by the module
await ioTHubModuleClient.SetInputMessageHandlerAsync("input1", PipeMessage, ioTHubModuleClient);
// as this runs in a loop we don't await
SendSimulationData(ioTHubModuleClient);
}
/// <summary>
/// Initializes the ModuleClient and sets up the callback to receive
/// messages containing temperature information
/// </summary>
static async Task Init()
{
MqttTransportSettings mqttSetting = new MqttTransportSettings(TransportType.Mqtt_Tcp_Only);
ITransportSettings[] settings = { mqttSetting };
// Open a connection to the Edge runtime
ioTHubModuleClient = await ModuleClient.CreateFromEnvironmentAsync(settings).ConfigureAwait(false);
await ioTHubModuleClient.OpenAsync().ConfigureAwait(false);
Console.WriteLine("IoT Hub module client initialized.");
// Read the TemperatureThreshold value from the module twin's desired properties
var moduleTwin = await ioTHubModuleClient.GetTwinAsync().ConfigureAwait(false);
await OnDesiredPropertiesUpdate(moduleTwin.Properties.Desired, ioTHubModuleClient);
// Attach a callback for updates to the module twin's desired properties.
await ioTHubModuleClient.SetDesiredPropertyUpdateCallbackAsync(OnDesiredPropertiesUpdate, null).ConfigureAwait(false);
// Register a callback for messages that are received by the module.
await ioTHubModuleClient.SetInputMessageHandlerAsync("input1", FilterMessagesAsync, ioTHubModuleClient).ConfigureAwait(false);
await ioTHubModuleClient.SetMethodHandlerAsync(heartbeat, HeartbeatAsync, null).ConfigureAwait(false);
Console.WriteLine("Set Heartbeat Method Handler:HeartbeatAsync.");
}
/// <summary>
/// Initializes the ModuleClient and sets up the callback to receive
/// messages containing temperature information
/// </summary>
static async Task Init()
{
MqttTransportSettings mqttSetting = new MqttTransportSettings(TransportType.Mqtt_Tcp_Only);
ITransportSettings[] settings = { mqttSetting };
// Open a connection to the Edge runtime
ModuleClient ioTHubModuleClient = await ModuleClient.CreateFromEnvironmentAsync(settings);
await ioTHubModuleClient.OpenAsync();
Console.WriteLine("Proxy module client initialized.");
// Register callback to be called when a direct method message is received by the module
await ioTHubModuleClient.SetMethodHandlerAsync("GetDeviceIdFromDirectMethod", DelegateDirectMethod, ioTHubModuleClient);
// Register callback to be called when a message is received by the module
await ioTHubModuleClient.SetInputMessageHandlerAsync("MessageFromConverter", DelegateMessageEvents, ioTHubModuleClient);
// Read the Threshold value from the module twin's desired properties
var moduleTwin = await ioTHubModuleClient.GetTwinAsync();
//await OnDesiredPropertiesUpdate(moduleTwin.Properties.Desired, ioTHubModuleClient);
// Attach a callback for updates to the module twin's desired properties.
await ioTHubModuleClient.SetDesiredPropertyUpdateCallbackAsync(OnDesiredPropertiesUpdate, null);
}
/// <summary>
/// Initializes the ModuleClient and sets up the callback to receive
/// messages containing temperature information
/// </summary>
static async Task Init()
{
MqttTransportSettings mqttSetting = new MqttTransportSettings(TransportType.Mqtt_Tcp_Only);
ITransportSettings[] settings = { mqttSetting };
// Open a connection to the Edge runtime
ModuleClient ioTHubModuleClient = await ModuleClient.CreateFromEnvironmentAsync(settings);
await ioTHubModuleClient.OpenAsync();
Console.WriteLine("IoT Hub module client initialized.");
// Register callback to be called when a message is received by the module
// await ioTHubModuleClient.SetImputMessageHandlerAsync("input1", PipeMessage, iotHubModuleClient);
// Read TemperatureThreshold from Module Twin Desired Properties
// var moduleTwin = await ioTHubModuleClient.GetTwinAsync();
// var moduleTwinCollection = moduleTwin.Properties.Desired;
// try {
// temperatureThreshold = moduleTwinCollection["TemperatureThreshold"];
// } catch(ArgumentOutOfRangeException e) {
// Console.WriteLine($"Property TemperatureThreshold not exist: {e.Message}");
// }
// Attach callback for Twin desired properties updates
//await ioTHubModuleClient.SetDesiredPropertyUpdateCallbackAsync(onDesiredPropertiesUpdate, null);
// Register callback to be called when a message is received by the module
await ioTHubModuleClient.SetInputMessageHandlerAsync("input1", FilterMessages, ioTHubModuleClient);
Console.WriteLine("Done setting up callbacks.");
}
/// <summary>
/// Initializes the ModuleClient and sets up the callback to receive
/// messages containing temperature information
/// </summary>
static async Task Init()
{
AmqpTransportSettings amqpSetting = new AmqpTransportSettings(TransportType.Amqp_Tcp_Only);
ITransportSettings[] settings = { amqpSetting };
// Open a connection to the Edge runtime
ModuleClient ioTHubModuleClient = await ModuleClient.CreateFromEnvironmentAsync(settings);
await ioTHubModuleClient.OpenAsync();
Console.WriteLine("IoT Hub module client initialized.");
// Read the TemperatureThreshold value from the module twin's desired properties
var moduleTwin = await ioTHubModuleClient.GetTwinAsync();
// Execute callback function during Init for Twin desired properties
await OnDesiredPropertiesUpdate(moduleTwin.Properties.Desired, ioTHubModuleClient);
// Attach a callback for updates to the module twin's desired properties.
await ioTHubModuleClient.SetDesiredPropertyUpdateCallbackAsync(OnDesiredPropertiesUpdate, null);
// Register a callback for messages that are received by the module.
await ioTHubModuleClient.SetInputMessageHandlerAsync("input1", FilterMessages, ioTHubModuleClient);
}
/// <summary>
/// Initializes the ModuleClient and sets up the callback to receive
/// messages containing temperature information
/// </summary>
static async Task Init()
{
AmqpTransportSettings amqpSetting = new AmqpTransportSettings(TransportType.Amqp_Tcp_Only);
ITransportSettings[] settings = { amqpSetting };
// Open a connection to the Edge runtime
ModuleClient ioTHubModuleClient = await ModuleClient.CreateFromEnvironmentAsync(settings);
await ioTHubModuleClient.OpenAsync();
Console.WriteLine("IoT Hub module client initialized.");
// Register callback to be called when a message is received by the module
//await ioTHubModuleClient.SetInputMessageHandlerAsync("input1", PipeMessage, ioTHubModuleClient);
// Read the TemperatureThreshold value from the module twin's desired properties
var moduleTwin = await ioTHubModuleClient.GetTwinAsync();
var moduleTwinCollection = moduleTwin.Properties.Desired;
try {
temperatureThreshold = moduleTwinCollection["TemperatureThreshold"];
} catch (ArgumentOutOfRangeException e) {
Console.WriteLine($"Property TemperatureThreshold not exist: {e.Message}");
}
// Attach a callback for updates to the module twin's desired properties.
await ioTHubModuleClient.SetDesiredPropertyUpdateCallbackAsync(OnDesiredPropertiesUpdate, null);
// Register a callback for messages that are received by the module.
await ioTHubModuleClient.SetInputMessageHandlerAsync("input1", FilterMessages, ioTHubModuleClient);
}
/// <summary>
/// Initializes the ModuleClient and sets up the callback to receive
/// messages containing temperature information
/// </summary>
static async Task Init()
{
MqttTransportSettings mqttSetting = new MqttTransportSettings(TransportType.Mqtt_Tcp_Only);
ITransportSettings[] settings = { mqttSetting };
// Open a connection to the Edge runtime
ModuleClient ioTHubModuleClient = await ModuleClient.CreateFromEnvironmentAsync(settings);
await ioTHubModuleClient.OpenAsync();
Console.WriteLine("IoT Hub module client initialized.");
// Read the COM Port value from the module twin's desired properties
// var moduleTwin = await ioTHubModuleClient.GetTwinAsync();
// await OnDesiredPropertiesUpdate(moduleTwin.Properties.Desired, ioTHubModuleClient);
// Attach a callback for updates to the module twin's desired properties.
//await ioTHubModuleClient.SetDesiredPropertyUpdateCallbackAsync(OnDesiredPropertiesUpdate, null);
// Register callback to be called when a message is received by the module
await ioTHubModuleClient.SetInputMessageHandlerAsync(SerialModule.BalloonInputName, ProcessBalloonMessage, ioTHubModuleClient);
serialModule = new SerialModule();
await serialModule.Initialize();
}
/// <summary>
/// Initializes the ModuleClient and sets up the callback to receive
/// messages containing temperature information
/// </summary>
static async Task Init()
{
AmqpTransportSettings amqpSetting = new AmqpTransportSettings(TransportType.Amqp_Tcp_Only);
ITransportSettings[] settings = { amqpSetting };
// Open a connection to the Edge runtime
ModuleClient ioTHubModuleClient = await ModuleClient.CreateFromEnvironmentAsync(settings);
await ioTHubModuleClient.OpenAsync();
Console.WriteLine("IoT Hub module client initialized.");
// The Edge runtime gives us the connection string we need -- it is injected as an environment variable
string connectionString = Environment.GetEnvironmentVariable("EdgeHubConnectionString");
Console.WriteLine($"Using connection string: {connectionString ?? "n/a"}");
// try
// {
// serviceClient = Microsoft.Azure.Devices.ServiceClient.CreateFromConnectionString(connectionString);
// }
// catch (Exception ex)
// {
// Console.WriteLine($"Error creating service client: {ex.ToString()}");
// }
// Register callback to be called when a message is received by the module
await ioTHubModuleClient.SetInputMessageHandlerAsync("input1", PipeMessage, ioTHubModuleClient);
}
/// <summary>
/// Initializes the ModuleClient and sets up the callback to receive
/// messages containing temperature information
/// </summary>
static async Task Init()
{
MqttTransportSettings mqttSetting = new MqttTransportSettings(TransportType.Mqtt_Tcp_Only);
ITransportSettings[] settings = { mqttSetting };
// Open a connection to the Edge runtime
ModuleClient ioTHubModuleClient = await ModuleClient.CreateFromEnvironmentAsync(settings);
await ioTHubModuleClient.OpenAsync();
Console.WriteLine("IoT Hub module client initialized.");
// Register callback to be called when a message is received by the module
await ioTHubModuleClient.SetInputMessageHandlerAsync("input1", PipeMessage, ioTHubModuleClient);
var storageConnectionString = Environment.GetEnvironmentVariable("BLOB_STORAGE_CONNECTION_STR");
if (CloudStorageAccount.TryParse(storageConnectionString, out CloudStorageAccount storageAccount))
{
var cloudBlobClient = storageAccount.CreateCloudBlobClient();
cloudBlobContainer = cloudBlobClient.GetContainerReference(LOCAL_BLOB_CONTAINER_NAME);
await cloudBlobContainer.CreateIfNotExistsAsync();
}
else
{
// Otherwise, let the user know that they need to define the environment variable.
Console.WriteLine(
"A connection string has not been defined in the system environment variables. " +
"Add an environment variable named 'BLOB_STORAGE_CONNECTION_STR' with your storage " +
"connection string as a value.");
}
}
/// <summary>
/// Initializes the ModuleClient and sets up the callback to receive
/// messages containing temperature information
/// </summary>
static async Task Init()
{
IConfiguration configuration = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("config/appsettings.json", optional: true)
.AddEnvironmentVariables()
.Build();
int delay = configuration.GetValue("Delay", 5000);
AmqpTransportSettings amqpSetting = new AmqpTransportSettings(TransportType.Amqp_Tcp_Only);
ITransportSettings[] settings = { amqpSetting };
// Open a connection to the Edge runtime
ModuleClient ioTHubModuleClient = await ModuleClient.CreateFromEnvironmentAsync(settings);
await ioTHubModuleClient.OpenAsync();
Console.WriteLine("IoT Hub module client initialized.");
// Register callback to be called when a message is received by the module
await ioTHubModuleClient.SetInputMessageHandlerAsync("input1", PipeMessage, ioTHubModuleClient);
// Start sending messages
await SendTempMessages(ioTHubModuleClient, delay);
}
static async Task Main(string[] args)
{
Logger.LogInformation($"Starting Relayer with the following settings: \r\n{Settings.Current}");
ModuleClient moduleClient = null;
try
{
moduleClient = await ModuleUtil.CreateModuleClientAsync(
Settings.Current.TransportType,
ModuleUtil.DefaultTimeoutErrorDetectionStrategy,
ModuleUtil.DefaultTransientRetryStrategy,
Logger);
(CancellationTokenSource cts, ManualResetEventSlim completed, Option <object> handler) = ShutdownHandler.Init(TimeSpan.FromSeconds(5), Logger);
// Receive a message and call ProcessAndSendMessageAsync to send it on its way
await moduleClient.SetInputMessageHandlerAsync(Settings.Current.InputName, ProcessAndSendMessageAsync, moduleClient);
await cts.Token.WhenCanceled();
completed.Set();
handler.ForEach(h => GC.KeepAlive(h));
Logger.LogInformation("Relayer Main() finished.");
}
catch (Exception ex)
{
Logger.LogError(ex, "Error occurred during Relayer.");
}
finally
{
moduleClient?.CloseAsync();
moduleClient?.Dispose();
}
}
public async Task Initialize(IApplicationBuilder applicationBuilder)
{
await _moduleClient.SetInputMessageHandlerAsync(Constants.Inputs.SubscriberInbound,
new MessageHandler(async(message, userContext) =>
{
var moduleClient = userContext as ModuleClient;
if (moduleClient == null)
{
throw new InvalidOperationException("UserContext doesn't contain " + "expected values");
}
byte[] messageBytes = message.GetBytes();
string messageString = Encoding.UTF8.GetString(messageBytes);
var healthJob = new HealthCheckJob(_jobDependencyLocator, JsonConvert.DeserializeObject <ElapsedScheduleMessage>(messageString));
await healthJob.Run();
await moduleClient.CompleteAsync(message);
return(MessageResponse.Completed);
}), _moduleClient, _tokenSource.Token);
await _moduleClient.SetDesiredPropertyUpdateCallbackAsync(
new DesiredPropertyUpdateCallback(async(mr, o) =>
{
var job = new DesiredPropertyChangedJob(_jobDependencyLocator, mr);
await job.Run();
}), _moduleClient);
var twin = await _moduleClient.GetTwinAsync();
var spinupJob = new DesiredPropertyChangedJob(_jobDependencyLocator, twin.Properties.Desired);
await spinupJob.Run();
}
public async Task StartAsync(CancellationToken cancellationToken)
{
using (LogContext.PushProperty("FunctionId", nameof(StartAsync)))
{
Log.Information("Opening Edge Module Connection");
await ModuleClient.OpenAsync();
Log.Information("Initializing InfluxDBRecorder");
await TimeSeriesRecorder.InitializeAsync();
Log.Information("Beginning to Process Messages");
await ModuleClient.SetInputMessageHandlerAsync("telemetry", new MessageHandler(
async(message, e) =>
{
Log.Information("Processing message..");
var telemetryJson = Encoding.UTF8.GetString(message.GetBytes());
try
{
await TimeSeriesRecorder.RecordMessageAsync(telemetryJson);
}
catch (Exception ex)
{
Log.Error(ex, $"Error for message {telemetryJson}");
}
return(await Task.FromResult(MessageResponse.Completed));
}
), ModuleClient);
}
}
// Tests_SRS_DEVICECLIENT_33_002: [** The OnReceiveEventMessageCalled shall invoke the specified delegate. **]**
public async Task ModuleClient_OnReceiveEventMessageCalled_SpecifiedCallbackCalled()
{
ModuleClient moduleClient = ModuleClient.CreateFromConnectionString(fakeConnectionString, TransportType.Mqtt_Tcp_Only);
var innerHandler = Substitute.For <IDelegatingHandler>();
moduleClient.InnerHandler = innerHandler;
bool isDefaultCallbackCalled = false;
await moduleClient.SetMessageHandlerAsync((message, context) =>
{
isDefaultCallbackCalled = true;
return(Task.FromResult(MessageResponse.Completed));
}, "custom data");
bool isSpecificCallbackCalled = false;
await moduleClient.SetInputMessageHandlerAsync("endpoint2", (message, context) =>
{
isSpecificCallbackCalled = true;
return(Task.FromResult(MessageResponse.Completed));
}, "custom data");
Message testMessage = new Message();
testMessage.LockToken = "AnyLockToken";
await moduleClient.InternalClient.OnReceiveEventMessageCalled("endpoint2", testMessage);
Assert.IsFalse(isDefaultCallbackCalled);
Assert.IsTrue(isSpecificCallbackCalled);
}
/// <summary>
/// Initializes the ModuleClient and sets up the callback to receive
/// messages containing temperature information
/// </summary>
static async Task Init()
{
MqttTransportSettings mqttSetting = new MqttTransportSettings(TransportType.Mqtt_Tcp_Only);
ITransportSettings[] settings = { mqttSetting };
// Open a connection to the Edge runtime
ModuleClient ioTHubModuleClient = await ModuleClient.CreateFromEnvironmentAsync(settings);
await ioTHubModuleClient.OpenAsync();
Console.WriteLine("IoT Hub module client initialized.");
// Register callback to be called when a message is received by the module
await ioTHubModuleClient.SetInputMessageHandlerAsync("input1", PipeMessage, ioTHubModuleClient);
httpClient = new HttpClient
{
BaseAddress = new Uri(Environment.GetEnvironmentVariable("LOCAL_EVENT_GRID_URI"))
};
httpClient.DefaultRequestHeaders.Add("aeg-sas-key", Environment.GetEnvironmentVariable("EVENT_GRID_SAS_KEY"));
topicName = Environment.GetEnvironmentVariable("TOPIC_NAME");
await CreateEventGridTopicAsync();
}
/// <summary>
/// Callback to handle Twin desired properties updates�
/// </summary>
static async Task OnDesiredPropertiesUpdate(TwinCollection desiredProperties, object userContext)
{
ModuleClient ioTHubModuleClient = userContext as ModuleClient;
try
{
// stop all activities while updating configuration
await ioTHubModuleClient.SetInputMessageHandlerAsync(
"input1",
DummyCallBack,
null);
m_run = false;
await Task.WhenAll(m_task_list);
m_task_list.Clear();
m_run = true;
await UpdateStartFromTwin(desiredProperties, ioTHubModuleClient);
}
catch (AggregateException ex)
{
foreach (Exception exception in ex.InnerExceptions)
{
Console.WriteLine();
Console.WriteLine("Error when receiving desired property: {0}", exception);
}
}
catch (Exception ex)
{
Console.WriteLine();
Console.WriteLine("Error when receiving desired property: {0}", ex.Message);
}
}
/// <summary>
/// Initializes the ModuleClient and sets up the callback to receive
/// messages containing temperature information
/// </summary>
static async Task Init()
{
MqttTransportSettings mqttSetting = new MqttTransportSettings(TransportType.Mqtt_Tcp_Only);
ITransportSettings[] settings = { mqttSetting };
// Open a connection to the Edge runtime
ModuleClient ioTHubModuleClient = await ModuleClient.CreateFromEnvironmentAsync(settings);
await ioTHubModuleClient.OpenAsync();
Console.WriteLine("IoT Hub module client initialized.");
// Read the Humidity value from the module twin's desired properties
var moduleTwin = await ioTHubModuleClient.GetTwinAsync();
var moduleTwinCollection = moduleTwin.Properties.Desired;
try
{
humidityFilter = moduleTwinCollection["Humidity"];
}
catch (ArgumentOutOfRangeException e)
{
Console.WriteLine($"Property Humidity does not exist: {e.Message}");
}
// Attach a callback for updates to the module twin's properties.
await ioTHubModuleClient.SetDesiredPropertyUpdateCallbackAsync(OnDesiredPropertiesUpdate, null);
// Register callback to be called when a message is received by the module
await ioTHubModuleClient.SetInputMessageHandlerAsync("input1", FilterHumidityMessage, ioTHubModuleClient);
}
/// <summary>
/// Inicializa o ModuleClient e configura o retorno de chamada para receber
/// mensagens contendo informações de temperatura
/// </summary>
static async Task Init()
{
AmqpTransportSettings amqpSetting = new AmqpTransportSettings(TransportType.Amqp_Tcp_Only);
ITransportSettings[] settings = { amqpSetting };
// Abra uma conexão com o tempo de execução do Edge
ModuleClient ioTHubModuleClient = await ModuleClient.CreateFromEnvironmentAsync(settings);
await ioTHubModuleClient.OpenAsync();
Console.WriteLine("*** Cliente do módulo IoT Hub inicializado ***");
// Obtem os valores das *propriedades desejadas* do módulo gêmeo
var moduleTwin = await ioTHubModuleClient.GetTwinAsync();
// Atribui *propriedades desejadas* ao método de tratamento
await OnDesiredPropertiesUpdate(moduleTwin.Properties.Desired, ioTHubModuleClient);
// Anexa método para tratar as *propriedades desejadas* do módulo gêmeo sempre que tiver atualizações.
await ioTHubModuleClient.SetDesiredPropertyUpdateCallbackAsync(OnDesiredPropertiesUpdate, null);
// Registra um método responsável por tratar as mensagens recebidas pelo módulo (filtrar e encaminhar).
await ioTHubModuleClient.SetInputMessageHandlerAsync(_inputName, FilterMessages, ioTHubModuleClient);
}
/// <summary>
/// Initializes the ModuleClient and sets up the callback to receive
/// messages containing temperature information
/// </summary>
static async Task Init()
{
MqttTransportSettings mqttSetting = new MqttTransportSettings(TransportType.Mqtt_Tcp_Only);
ITransportSettings[] settings = { mqttSetting };
// Open a connection to the Edge runtime
ModuleClient ioTHubModuleClient = await ModuleClient.CreateFromEnvironmentAsync(settings);
await ioTHubModuleClient.OpenAsync();
Console.WriteLine("IoT Hub module client initialized.");
// Read the TemperatureThreshold value from the module twin's desired properties
var moduleTwin = await ioTHubModuleClient.GetTwinAsync();
await OnDesiredPropertiesUpdate(moduleTwin.Properties.Desired, ioTHubModuleClient);
// Attach a callback for updates to the module twin's desired properties.
await ioTHubModuleClient.SetDesiredPropertyUpdateCallbackAsync(OnDesiredPropertiesUpdate, null);
// Register callback to be called when a message is received by the module
await ioTHubModuleClient.SetInputMessageHandlerAsync("input1", PipeMessage, ioTHubModuleClient);
InitFileWatcher();
DisplayImage(logoImagePath);
Console.WriteLine("Successfully initialized ScreenshotWatcher module.");
}
static async Task <int> MainAsync()
{
Logger.LogInformation("TemperatureFilter Main() started.");
IConfiguration configuration = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("config/appsettings.json", optional: true)
.AddEnvironmentVariables()
.Build();
TransportType transportType = configuration.GetValue("ClientTransportType", TransportType.Amqp_Tcp_Only);
ModuleClient moduleClient = await ModuleUtil.CreateModuleClientAsync(
transportType,
ModuleUtil.DefaultTimeoutErrorDetectionStrategy,
ModuleUtil.DefaultTransientRetryStrategy,
Logger);
(CancellationTokenSource cts, ManualResetEventSlim completed, Option <object> handler) = ShutdownHandler.Init(TimeSpan.FromSeconds(5), Logger);
ModuleConfig moduleConfig = await GetConfigurationAsync(moduleClient);
Logger.LogInformation($"Using TemperatureThreshold value of {moduleConfig.TemperatureThreshold}");
var userContext = Tuple.Create(moduleClient, moduleConfig);
await moduleClient.SetInputMessageHandlerAsync("input1", PrintAndFilterMessages, userContext);
await cts.Token.WhenCanceled();
completed.Set();
handler.ForEach(h => GC.KeepAlive(h));
Logger.LogInformation("TemperatureFilter Main() finished.");
return(0);
}
/// <summary>
/// Initializes the ModuleClient and sets up the callback to receive
/// messages containing temperature information
/// </summary>
static async Task Init()
{
MqttTransportSettings mqttSetting = new MqttTransportSettings(TransportType.Mqtt_Tcp_Only);
ITransportSettings[] settings = { mqttSetting };
// Retrieve storage account from connection string.
var storageAccountName = Environment.GetEnvironmentVariable("STORAGE_ACCOUNT_NAME");
var storageAccountKey = Environment.GetEnvironmentVariable("STORAGE_ACCOUNT_KEY");
var storageConnectionString = $"DefaultEndpointsProtocol=https;AccountName={storageAccountName};AccountKey={storageAccountKey}";
CloudStorageAccount storageAccount = CloudStorageAccount.Parse(storageConnectionString);
// Create the blob client.
Console.WriteLine("Creating blob client");
blobClient = storageAccount.CreateCloudBlobClient();
// Open a connection to the Edge runtime
ioTHubModuleClient = await ModuleClient.CreateFromEnvironmentAsync(settings);
await ioTHubModuleClient.OpenAsync();
Console.WriteLine("IoT Hub module client initialized.");
await ioTHubModuleClient.SetInputMessageHandlerAsync("messagesToUpload", UploadMessage, ioTHubModuleClient);
await ioTHubModuleClient.SetMethodHandlerAsync("HearBeat", HeartBeat, null);
Console.WriteLine("Set Heartbeat Method Handler:HeartBeat.");
}
/// <summary>
/// Callback to handle Twin desired properties updates�
/// </summary>
static async Task OnDesiredPropertiesUpdate(TwinCollection desiredProperties, object userContext)
{
ModuleClient ioTHubModuleClient = userContext as ModuleClient;
try
{
// stop all activities while updating configuration
await ioTHubModuleClient.SetInputMessageHandlerAsync(
"driveProfileInput",
DummyCallBack,
null);
await DoTwinUpdate(desiredProperties, ioTHubModuleClient);
}
catch (AggregateException ex)
{
foreach (Exception exception in ex.InnerExceptions)
{
Console.WriteLine();
Console.WriteLine("Error when receiving desired property: {0}", exception);
}
}
catch (Exception ex)
{
Console.WriteLine();
Console.WriteLine("Error when receiving desired property: {0}", ex.Message);
}
}
