// 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>()); }
public async Task ModuleTwin_Contains_ModelId() { // Setup // Create a module. TestModule testModule = await TestModule.GetTestModuleAsync(DevicePrefix, ModulePrefix, Logger).ConfigureAwait(false); // Send model ID with MQTT connect packet to make the module plug and play. var options = new ClientOptions { ModelId = TestModelId, }; using var moduleClient = ModuleClient.CreateFromConnectionString(testModule.ConnectionString, Client.TransportType.Mqtt_Tcp_Only, options); await moduleClient.OpenAsync().ConfigureAwait(false); // Act // Get module twin. using var registryManager = RegistryManager.CreateFromConnectionString(Configuration.IoTHub.ConnectionString); Twin twin = await registryManager.GetTwinAsync(testModule.DeviceId, testModule.Id).ConfigureAwait(false); // Assert twin.ModelId.Should().Be(TestModelId, "because the module was created as plug and play"); // Cleanup await registryManager.RemoveDeviceAsync(testModule.DeviceId).ConfigureAwait(false); }
public static async Task <TestModule> CreateAndConnect(string connectionString, ITransportSettings[] settings) { ModuleClient moduleClient = ModuleClient.CreateFromConnectionString(connectionString, settings); await moduleClient.OpenAsync(); return(new TestModule(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); }
static void Main(string[] args) { try { try { ModuleClient moduleClient = ModuleClient.CreateFromConnectionString(ModuleConnectionString); moduleClient.OpenAsync().Wait(); SendMessages(moduleClient).Wait(); Twin twin = moduleClient.GetTwinAsync().Result; Console.WriteLine($"Module Twin Desired Properties: {twin.Properties.Desired.ToJson(Formatting.Indented)}"); Console.WriteLine($"Module Twin Tags: {twin.Tags.ToJson(Formatting.Indented)}"); } catch (Exception e) { Console.WriteLine(e); } Console.WriteLine("Exited!\n"); } catch (Exception ex) { Console.WriteLine("Error in sample: {0}", ex.Message); } }
private async Task CreateTemporaryConnection() { var moduleConnectionString = GetModuleConnectionStringAsync(_iotHubConnectionString, _deviceId, _modules[0].Name) .Result; var tmpClient = ModuleClient.CreateFromConnectionString(moduleConnectionString, new ITransportSettings[] { new AmqpTransportSettings(TransportType.Amqp_Tcp_Only) { RemoteCertificateValidationCallback = (sender, certificate, chain, sslPolicyErrors) => true, OpenTimeout = new TimeSpan(1) } } ); try { await tmpClient.OpenAsync(); } catch { // ignored } }
private void InitializeClient() { // If the client reports Connected status, it is already in operational state. if (s_connectionStatus != ConnectionStatus.Connected && _moduleConnectionStrings.Any()) { lock (_initLock) { _logger.LogDebug($"Attempting to initialize the client instance, current status={s_connectionStatus}"); // If the module client instance has been previously initialized, then dispose it. // The s_wasEverConnected variable is required to store if the client ever reported Connected status. if (s_wasEverConnected && s_connectionStatus == ConnectionStatus.Disconnected) { s_moduleClient?.Dispose(); s_wasEverConnected = false; } s_moduleClient = ModuleClient.CreateFromConnectionString(_moduleConnectionStrings.First(), _transportType); s_moduleClient.SetConnectionStatusChangesHandler(ConnectionStatusChangeHandler); s_moduleClient.OperationTimeoutInMilliseconds = (uint)s_operationTimeout.TotalMilliseconds; } try { // Force connection now s_moduleClient.OpenAsync().GetAwaiter().GetResult(); _logger.LogDebug($"Initialized the client instance."); } catch (UnauthorizedException) { // Handled by the ConnectionStatusChangeHandler } } }
/// <inheritdoc /> public void ReInit(string connectionString, TransportType transportType) { var newClient = ModuleClient.CreateFromConnectionString(connectionString, transportType); _client.Dispose(); _client = newClient; }
private async Task ModuleClient_Gives_ConnectionStatus_DeviceDisabled_Base( Client.TransportType protocol, Func <RegistryManager, string, Task> registryManagerOperation) { AmqpTransportSettings amqpTransportSettings = new AmqpTransportSettings(protocol); ITransportSettings[] transportSettings = new ITransportSettings[] { amqpTransportSettings }; TestModule testModule = await TestModule.GetTestModuleAsync(DevicePrefix + $"_{Guid.NewGuid()}", ModulePrefix).ConfigureAwait(false); ConnectionStatus? status = null; ConnectionStatusChangeReason?statusChangeReason = null; int deviceDisabledReceivedCount = 0; ConnectionStatusChangesHandler statusChangeHandler = (s, r) => { if (r == ConnectionStatusChangeReason.Device_Disabled) { status = s; statusChangeReason = r; deviceDisabledReceivedCount++; } }; using (ModuleClient moduleClient = ModuleClient.CreateFromConnectionString(testModule.ConnectionString, transportSettings)) { moduleClient.SetConnectionStatusChangesHandler(statusChangeHandler); _log.WriteLine($"Created {nameof(DeviceClient)} ID={TestLogging.IdOf(moduleClient)}"); Console.WriteLine("ModuleClient OpenAsync."); await moduleClient.OpenAsync().ConfigureAwait(false); // Receiving the module twin should succeed right now. Console.WriteLine("ModuleClient GetTwinAsync."); var twin = await moduleClient.GetTwinAsync().ConfigureAwait(false); Assert.IsNotNull(twin); // Delete/disable the device in IoT Hub. using (RegistryManager registryManager = RegistryManager.CreateFromConnectionString(Configuration.IoTHub.ConnectionString)) { await registryManagerOperation(registryManager, testModule.DeviceId).ConfigureAwait(false); } // Artificial sleep waiting for the connection status change handler to get triggered. int sleepCount = 50; for (int i = 0; i < sleepCount; i++) { await Task.Delay(TimeSpan.FromSeconds(10)).ConfigureAwait(false); if (deviceDisabledReceivedCount == 1) { break; } } Assert.AreEqual(1, deviceDisabledReceivedCount); Assert.AreEqual(ConnectionStatus.Disconnected, status); Assert.AreEqual(ConnectionStatusChangeReason.Device_Disabled, statusChangeReason); } }
public void ModuleClient_CreateFromConnectionStringWithClientOptions_DoesNotThrow() { // setup var clientOptions = new ClientOptions { ModelId = "tempModuleId" }; // act var moduleClient = ModuleClient.CreateFromConnectionString(FakeConnectionString, clientOptions); }
private async Task SendSingleMessageModule(ITransportSettings[] transportSettings) { TestModule testModule = await TestModule.GetTestModuleAsync(DevicePrefix, ModulePrefix, Logger).ConfigureAwait(false); using var moduleClient = ModuleClient.CreateFromConnectionString(testModule.ConnectionString, transportSettings); await moduleClient.OpenAsync().ConfigureAwait(false); await SendSingleMessageModuleAsync(moduleClient, testModule.DeviceId).ConfigureAwait(false); await moduleClient.CloseAsync().ConfigureAwait(false); }
private async Task SendSingleMessageModule(TestDeviceType type, ITransportSettings[] transportSettings) { TestModule testModule = await TestModule.GetTestModuleAsync(DevicePrefix, ModulePrefix).ConfigureAwait(false); using (ModuleClient moduleClient = ModuleClient.CreateFromConnectionString(testModule.ConnectionString, transportSettings)) { await moduleClient.OpenAsync().ConfigureAwait(false); await SendSingleMessageModuleAndVerifyAsync(moduleClient, testModule.DeviceId).ConfigureAwait(false); await moduleClient.CloseAsync().ConfigureAwait(false); } }
/// <summary> /// Helper to create module client /// </summary> /// <param name="cs"></param> /// <param name="transportSetting"></param> /// <returns></returns> private static async Task<ModuleClient> CreateAsync(IotHubConnectionStringBuilder cs, ITransportSettings transportSetting) { if (transportSetting == null) { if (cs == null) { return await ModuleClient.CreateFromEnvironmentAsync(); } return ModuleClient.CreateFromConnectionString(cs.ToString()); } var ts = new ITransportSettings[] { transportSetting }; if (cs == null) { return await ModuleClient.CreateFromEnvironmentAsync(ts); } return ModuleClient.CreateFromConnectionString(cs.ToString(), ts); }
public static async Task <TestModule> CreateAndConnect(string connectionString, ITransportSettings[] settings, int retryCount = int.MaxValue) { ModuleClient moduleClient = ModuleClient.CreateFromConnectionString(connectionString, settings); IRetryPolicy defaultRetryStrategy = new ExponentialBackoff( retryCount: retryCount, minBackoff: TimeSpan.FromMilliseconds(100), maxBackoff: TimeSpan.FromSeconds(10), deltaBackoff: TimeSpan.FromMilliseconds(100)); moduleClient.SetRetryPolicy(defaultRetryStrategy); await moduleClient.OpenAsync(); return(new TestModule(moduleClient)); }
/// <summary> /// Initializes the DeviceClient and sets up the callback to receive /// messages containing temperature information /// </summary> static async Task Init(string connectionString, bool bypassCertVerification = false) { Console.WriteLine("Connection String: {0}", connectionString); var mqttSetting = new MqttTransportSettings(TransportType.Mqtt_Tcp_Only); // During dev you might want to bypass the cert verification. It is highly recommended to verify certs systematically in production if (bypassCertVerification) { Console.WriteLine("Certificate verification is bypassed."); mqttSetting.RemoteCertificateValidationCallback = (sender, certificate, chain, sslPolicyErrors) => true; } ITransportSettings[] settings = { mqttSetting }; // Open a connection to the Edge runtime //var ioTHubModuleClient = DeviceClient.CreateFromConnectionString(connectionString, settings); //Andrey Fedorov ModuleClient ioTHubModuleClient = null; //Andrey Fedorov if (string.IsNullOrEmpty(connectionString)) //Andrey Fedorov { ioTHubModuleClient = await ModuleClient.CreateFromEnvironmentAsync(settings); //Andrey Fedorov } else //Andrey Fedorov { ioTHubModuleClient = ModuleClient.CreateFromConnectionString(connectionString, 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); // this direct method will allow to reset the temperature sensor values back to their initial state await ioTHubModuleClient.SetMethodHandlerAsync("reset", ResetMethod, null); // we don't pass ioTHubModuleClient as we're not sending any messages out to the message bus // Register callback to be called when a message is received by the module await ioTHubModuleClient.SetInputMessageHandlerAsync("control", ControlMessageHandler, null); // as this runs in a loop we don't await SendSimulationData(ioTHubModuleClient); }
public IClient Create(IIdentity identity, string connectionString, ITransportSettings[] transportSettings) { if (identity is IModuleIdentity) { ModuleClient moduleClient = ModuleClient.CreateFromConnectionString(connectionString, transportSettings); return(new ModuleClientWrapper(moduleClient)); } else if (identity is IDeviceIdentity) { DeviceClient deviceClient = DeviceClient.CreateFromConnectionString(connectionString, transportSettings); return(new DeviceClientWrapper(deviceClient)); } throw new InvalidOperationException($"Invalid client identity type {identity.GetType()}"); }
public ModuleSimulationService(ModuleSettings settings, SimulationSettingsModule simulationSettings, ITelemetryMessageService telemetryMessagingService, IErrorMessageService errorMessagingService, ICommissioningMessageService commissioningMessagingService, ILoggerFactory loggerFactory) { if (settings == null) { throw new ArgumentNullException(nameof(settings)); } if (simulationSettings == null) { throw new ArgumentNullException(nameof(simulationSettings)); } if (telemetryMessagingService == null) { throw new ArgumentNullException(nameof(telemetryMessagingService)); } if (errorMessagingService == null) { throw new ArgumentNullException(nameof(errorMessagingService)); } if (commissioningMessagingService == null) { throw new ArgumentNullException(nameof(commissioningMessagingService)); } if (loggerFactory == null) { throw new ArgumentNullException(nameof(loggerFactory)); } string logPrefix = "system".BuildLogPrefix(); ModuleSettings = settings; SimulationSettings = simulationSettings; _logger = loggerFactory.CreateLogger <ModuleSimulationService>(); _telemetryMessagingService = telemetryMessagingService; _errorMessagingService = errorMessagingService; _commissioningMessagingService = commissioningMessagingService; _telemetryInterval = 10; _stopProcessing = false; _moduleClient = ModuleClient.CreateFromConnectionString(ModuleSettings.ConnectionString, Microsoft.Azure.Devices.Client.TransportType.Mqtt); _logger.LogDebug($"{logPrefix}::{ModuleSettings.ArtifactId}::Logger created."); _logger.LogDebug($"{logPrefix}::{ModuleSettings.ArtifactId}::Module simulator created."); }
// Initialize the device client instance over Mqtt protocol (TCP, with fallback over Websocket), setting the ModelId into ClientOptions. // This method also sets a connection status change callback, that will get triggered any time the device's connection status changes. private static void InitializeDeviceClientAsync() { var options = new ClientOptions { ModelId = ModelId, }; s_deviceClient = ModuleClient.CreateFromConnectionString(s_deviceConnectionString, TransportType.Mqtt, options); //s_deviceClient = DeviceClient.CreateFromConnectionString(s_deviceConnectionString, TransportType.Mqtt, options); s_deviceClient.SetConnectionStatusChangesHandler((status, reason) => { s_logger.LogDebug($"Connection status change registered - status={status}, reason={reason}."); }); }
private void Connect() { if (Client == null) { try { Client = ModuleClient.CreateFromConnectionString(_options.ModuleConnectionString, TransportType.Amqp); } catch (Exception e) { Client = null; // Set to null for reconection throw e; } } }
public async Task <ConnectResponse> ConnectAsync(string transport, string connectionString, Certificate caCertificate) { Console.WriteLine("ConnectAsync for " + transport); var client = ModuleClient.CreateFromConnectionString(connectionString, GlueUtils.TransportNameToType(transport)); await client.OpenAsync().ConfigureAwait(false); var connectionId = modulePrefix + Convert.ToString(++objectCount); Console.WriteLine("Connected successfully. Connection Id = " + connectionId); objectMap[connectionId] = client; return(new ConnectResponse { ConnectionId = connectionId }); }
public async Task ModuleClient_SetDefaultReceiveCallbackAsync_SetCallback_Amqp() { var moduleClient = ModuleClient.CreateFromConnectionString(FakeConnectionString, TransportType.Amqp_Tcp_Only); IDelegatingHandler innerHandler = Substitute.For <IDelegatingHandler>(); moduleClient.InnerHandler = innerHandler; await moduleClient.SetMessageHandlerAsync((message, context) => Task.FromResult(MessageResponse.Completed), "custom data").ConfigureAwait(false); await innerHandler.Received(1).EnableEventReceiveAsync(false, Arg.Any <CancellationToken>()).ConfigureAwait(false); await innerHandler.DidNotReceiveWithAnyArgs().EnableReceiveMessageAsync(Arg.Any <CancellationToken>()).ConfigureAwait(false); await innerHandler.DidNotReceiveWithAnyArgs().DisableEventReceiveAsync(false, Arg.Any <CancellationToken>()).ConfigureAwait(false); }
//private static TransportType s_transportType = TransportType.Amqp_WebSocket_Only; //private static TransportType s_transportType = TransportType.Mqtt_WebSocket_Only; public static int Main(string[] args) { if (string.IsNullOrEmpty(s_deviceConnectionString) && args.Length > 0) { s_deviceConnectionString = args[0]; } if (string.IsNullOrEmpty(s_deviceConnectionString)) { Console.WriteLine("Please provide a device connection string"); Console.WriteLine("Usage: DeviceClientC2DStreamingSample [iotHubDeviceConnString]"); return(1); } if (s_deviceConnectionString.Contains("ModuleId=")) { Console.WriteLine("Creating a module client using " + s_transportType); using (ModuleClient moduleClient = ModuleClient.CreateFromConnectionString(s_deviceConnectionString, s_transportType)) { if (moduleClient == null) { Console.WriteLine("Failed to create DeviceClient!"); return(1); } var sample = new DeviceStreamSample(null, moduleClient); sample.RunSampleAsync().GetAwaiter().GetResult(); } } else { Console.WriteLine("Creating a device client using " + s_transportType); using (DeviceClient deviceClient = DeviceClient.CreateFromConnectionString(s_deviceConnectionString, s_transportType)) { if (deviceClient == null) { Console.WriteLine("Failed to create ModuleClient!"); return(1); } var sample = new DeviceStreamSample(deviceClient, null); sample.RunSampleAsync().GetAwaiter().GetResult(); } } Console.WriteLine("Done.\n"); return(0); }
private async Task SendMethodAndRespondAsync(Client.TransportType transport, Func <ModuleClient, string, MsTestLogger, Task <Task> > setDeviceReceiveMethod, TimeSpan responseTimeout = default, ServiceClientTransportSettings serviceClientTransportSettings = default) { TestModule testModule = await TestModule.GetTestModuleAsync(_devicePrefix, _modulePrefix, Logger).ConfigureAwait(false); using var moduleClient = ModuleClient.CreateFromConnectionString(testModule.ConnectionString, transport); Task methodReceivedTask = await setDeviceReceiveMethod(moduleClient, MethodName, Logger).ConfigureAwait(false); await Task .WhenAll( ServiceSendMethodAndVerifyResponseAsync(testModule.DeviceId, testModule.Id, MethodName, DeviceResponseJson, ServiceRequestJson, Logger, responseTimeout, serviceClientTransportSettings), methodReceivedTask) .ConfigureAwait(false); await moduleClient.CloseAsync().ConfigureAwait(false); }
private async Task SendSingleMessageModule(TestDeviceType type, ITransportSettings[] transportSettings) { TestModule testModule = await TestModule.GetTestModuleAsync(DevicePrefix, ModulePrefix).ConfigureAwait(false); using (ModuleClient moduleClient = ModuleClient.CreateFromConnectionString(testModule.ConnectionString, transportSettings)) { await moduleClient.OpenAsync().ConfigureAwait(false); string payload; string p1Value; Client.Message testMessage = ComposeD2CTestMessage(out payload, out p1Value); await moduleClient.SendEventAsync(testMessage).ConfigureAwait(false); await moduleClient.CloseAsync().ConfigureAwait(false); } }
/// <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 = ModuleClient.CreateFromConnectionString(""); moduleClient.SetConnectionStatusChangesHandler(OnConnectionStatusChanged); await moduleClient.OpenAsync(); Console.WriteLine("IoT Hub module client initialized."); timer = new Timer(new TimerCallback(Program.SendEvent), null, 5000 /*dueTime*/, 5000 /*period*/); }
private async Task TestSecurityMessageModuleAsync(Client.TransportType transport) { TestModule testModule = await TestModule.GetTestModuleAsync(_devicePrefix, _modulePrefix, Logger).ConfigureAwait(false); using (var moduleClient = ModuleClient.CreateFromConnectionString(testModule.ConnectionString, transport)) { try { await SendSingleSecurityMessageModuleAsync(moduleClient, testModule.DeviceId, _logAnalyticsClient).ConfigureAwait(false); } finally { await moduleClient.CloseAsync().ConfigureAwait(false); } } }
public ModuleSimulationService(ModuleSettings settings, SimulationSettingsModule simulationSettings, IDTDLMessageService dtdlMessagingService, IDTDLCommandService dtdlCommandService, ILoggerFactory loggerFactory) { if (settings == null) { throw new ArgumentNullException(nameof(settings)); } if (simulationSettings == null) { throw new ArgumentNullException(nameof(simulationSettings)); } if (dtdlMessagingService == null) { throw new ArgumentNullException(nameof(dtdlMessagingService)); } if (loggerFactory == null) { throw new ArgumentNullException(nameof(loggerFactory)); } string logPrefix = "system".BuildLogPrefix(); ModuleSettings = settings; SimulationSettings = simulationSettings; _logger = loggerFactory.CreateLogger <ModuleSimulationService>(); _dtdlMessagingService = dtdlMessagingService; _dtdlCommandService = dtdlCommandService; _telemetryInterval = 10; _stopProcessing = false; _moduleClient = ModuleClient.CreateFromConnectionString(ModuleSettings.ConnectionString, Microsoft.Azure.Devices.Client.TransportType.Mqtt); _logger.LogDebug($"{logPrefix}::{ModuleSettings.ArtifactId}::Logger created."); _logger.LogDebug($"{logPrefix}::{ModuleSettings.ArtifactId}::Module simulator created."); //Default DTDL Model _defaultModel = ModuleSettings?.SupportedModels?.SingleOrDefault(i => i.ModelId == ModuleSettings.DefaultModelId); if (_defaultModel == null) { throw new Exception("No supported model corresponds to the default model Id."); } }
public IClient Create(IIdentity identity, string connectionString, ITransportSettings[] transportSettings) { Preconditions.CheckNotNull(identity, nameof(identity)); Preconditions.CheckNotNull(transportSettings, nameof(transportSettings)); Preconditions.CheckNonWhiteSpace(connectionString, nameof(connectionString)); if (identity is IModuleIdentity) { ModuleClient moduleClient = ModuleClient.CreateFromConnectionString(connectionString, transportSettings); return(new ModuleClientWrapper(moduleClient)); } else if (identity is IDeviceIdentity) { DeviceClient deviceClient = DeviceClient.CreateFromConnectionString(connectionString, transportSettings); return(new DeviceClientWrapper(deviceClient)); } throw new InvalidOperationException($"Invalid client identity type {identity.GetType()}"); }
/// <summary> /// If a ModuleClient configuration is specified, /// creates a module client from the configuration, /// Otherwise creates a ModuleClientWrapper which delegates to the IoT sdk's ModuleClient. /// according to the LocalConfiguration.ClientConnectionString /// </summary> /// <returns>A new instance of IModuleClient</returns> private static IModuleClient CreateClient() { NameValueCollection agentConfig = (NameValueCollection)ConfigurationManager.GetSection("General"); var moduleClientDll = agentConfig["ModuleClientDll"]; var moduleClientTypeName = agentConfig["ModuleClientFullName"]; if (!string.IsNullOrEmpty(moduleClientDll) && !string.IsNullOrEmpty(moduleClientTypeName)) { Assembly assembly = Assembly.LoadFrom(Path.GetFullPath(moduleClientDll)); Type type = assembly.GetType(moduleClientTypeName); return((IModuleClient)Activator.CreateInstance(type)); } return(new ModuleClientWrapper(ModuleClient.CreateFromConnectionString( AuthenticationMethodProvider.GetModuleConnectionString(), LocalIoTHubConfiguration.IotInterface.TransportType))); }
// Tests_SRS_DEVICECLIENT_33_001: [** If the given eventMessageInternal argument is null, fail silently **]** public async Task ModuleClient_OnReceiveEventMessageCalled_NullMessageRequest() { ModuleClient moduleClient = ModuleClient.CreateFromConnectionString(fakeConnectionString, TransportType.Mqtt_Tcp_Only); var innerHandler = Substitute.For <IDelegatingHandler>(); moduleClient.InnerHandler = innerHandler; bool isMessageHandlerCalled = false; await moduleClient.SetInputMessageHandlerAsync("endpoint1", (message, context) => { isMessageHandlerCalled = true; return(Task.FromResult(MessageResponse.Completed)); }, "custom data"); await moduleClient.InternalClient.OnReceiveEventMessageCalled(null, null); Assert.IsFalse(isMessageHandlerCalled); }