// 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); } }