private static async Task <string> BuildConnectionStringAsync(RegistryManager registryManager, DeviceItem deviceItem, TraceWriter log) { var iotHubConnectionString = IotHubConnectionStringBuilder.Create(Environment.GetEnvironmentVariable("IoTHubConnectionString")); var device = await registryManager.GetDeviceAsync(deviceItem.Name); var deviceKeyInfo = new DeviceAuthenticationWithRegistrySymmetricKey(deviceItem.Name, device.Authentication.SymmetricKey.PrimaryKey); var deviceConnectionString = ClientIotHubConnectionStringBuilder.Create(iotHubConnectionString.HostName, deviceKeyInfo); return(deviceConnectionString.ToString()); }
/// <summary> /// Populates an <see cref="IotHubConnectionStringBuilder"/> instance based on the properties of the current instance. /// </summary> /// <param name="iotHubConnectionStringBuilder">Instance to populate.</param> /// <returns>The populated <see cref="IotHubConnectionStringBuilder"/> instance.</returns> public IotHubConnectionStringBuilder Populate(IotHubConnectionStringBuilder iotHubConnectionStringBuilder) { if (iotHubConnectionStringBuilder == null) { throw new ArgumentNullException("iotHubConnectionStringBuilder"); } iotHubConnectionStringBuilder.DeviceId = this.DeviceId; iotHubConnectionStringBuilder.UsingX509Cert = true; iotHubConnectionStringBuilder.Certificate = this.Certificate; iotHubConnectionStringBuilder.SharedAccessSignature = null; iotHubConnectionStringBuilder.SharedAccessKey = null; iotHubConnectionStringBuilder.SharedAccessKeyName = null; return(iotHubConnectionStringBuilder); }
/// <summary> /// Create a DeviceClient from individual parameters /// </summary> /// <param name="hostname">The fully-qualified DNS hostname of IoT Hub</param> /// <param name="authenticationMethod">The authentication method that is used</param> /// <param name="transportType">The transportType used (Http1 or Amqp)</param> /// <returns>DeviceClient</returns> public static DeviceClient Create(string hostname, IAuthenticationMethod authenticationMethod, TransportType transportType) { if (hostname == null) { throw new ArgumentNullException("hostname"); } if (authenticationMethod == null) { throw new ArgumentNullException("authMethod"); } var connectionStringBuilder = IotHubConnectionStringBuilder.Create(hostname, authenticationMethod); return(CreateFromConnectionString(connectionStringBuilder.ToString(), transportType)); }
/// <summary> /// Create a InternalClient from individual parameters /// </summary> /// <param name="hostname">The fully-qualified DNS hostname of IoT Hub</param> /// <param name="gatewayHostname">The fully-qualified DNS hostname of Gateway</param> /// <param name="authenticationMethod">The authentication method that is used</param> /// <param name="transportType">The transportType used (Http1, Amqp or Mqtt), <see cref="TransportType"/></param> /// <param name="options">The options that allow configuration of the device client instance during initialization.</param> /// <returns>InternalClient</returns> public static InternalClient Create(string hostname, string gatewayHostname, IAuthenticationMethod authenticationMethod, TransportType transportType, ClientOptions options = default) { if (hostname == null) { throw new ArgumentNullException(nameof(hostname)); } if (authenticationMethod == null) { throw new ArgumentNullException(nameof(authenticationMethod)); } IotHubConnectionStringBuilder connectionStringBuilder = IotHubConnectionStringBuilder.Create(hostname, gatewayHostname, authenticationMethod); if (authenticationMethod is DeviceAuthenticationWithX509Certificate) { if (connectionStringBuilder.Certificate == null) { throw new ArgumentException("certificate must be present in DeviceAuthenticationWithX509Certificate"); } // If the file upload transport settings hasn't been specified, we will create one using the client certificate on the connection string if (options?.FileUploadTransportSettings == null) { var fileUploadTransportSettings = new Http1TransportSettings { ClientCertificate = connectionStringBuilder.Certificate }; if (options == null) { options = new ClientOptions { FileUploadTransportSettings = fileUploadTransportSettings }; } else { options.FileUploadTransportSettings = fileUploadTransportSettings; } } InternalClient dc = CreateFromConnectionString(connectionStringBuilder.ToString(), PopulateCertificateInTransportSettings(connectionStringBuilder, transportType), options); dc.Certificate = connectionStringBuilder.Certificate; return(dc); } return(CreateFromConnectionString(connectionStringBuilder.ToString(), authenticationMethod, transportType, null, options)); }
/// <summary> /// Create a InternalClient from individual parameters /// </summary> /// <param name="hostname">The fully-qualified DNS hostname of IoT hub</param> /// <param name="gatewayHostname">The fully-qualified DNS hostname of Gateway</param> /// <param name="authenticationMethod">The authentication method that is used</param> /// <param name="transportSettings">Prioritized list of transportTypes and their settings</param> /// <param name="options">The options that allow configuration of the device client instance during initialization.</param> /// <returns>InternalClient</returns> internal static InternalClient Create( string hostname, string gatewayHostname, IAuthenticationMethod authenticationMethod, ITransportSettings[] transportSettings, ClientOptions options = default) { if (hostname == null) { throw new ArgumentNullException(nameof(hostname)); } if (authenticationMethod == null) { throw new ArgumentNullException(nameof(authenticationMethod)); } if (!string.IsNullOrWhiteSpace(options?.ModelId) && transportSettings.Any(x => x.GetTransportType() == TransportType.Http1)) { throw new InvalidOperationException("Plug and Play is not supported over the HTTP transport."); } var connectionStringBuilder = IotHubConnectionStringBuilder.Create(hostname, gatewayHostname, authenticationMethod); // Make sure client options is initialized with the correct transport setting. EnsureOptionsIsSetup(connectionStringBuilder.Certificate, ref options); if (authenticationMethod is DeviceAuthenticationWithX509Certificate) { if (connectionStringBuilder.Certificate == null) { throw new ArgumentException("No certificate was found. To use certificate authentication certificate must be present."); } InternalClient dc = CreateFromConnectionString( connectionStringBuilder.ToString(), PopulateCertificateInTransportSettings(connectionStringBuilder, transportSettings), options); dc.Certificate = connectionStringBuilder.Certificate; return(dc); } return(CreateFromConnectionString(connectionStringBuilder.ToString(), authenticationMethod, transportSettings, null, options)); }
internal static IAuthenticationMethod GetAuthenticationMethod(IotHubConnectionStringBuilder csBuilder) { if (csBuilder.SharedAccessKeyName != null) { return(new DeviceAuthenticationWithSharedAccessPolicyKey( csBuilder.DeviceId, csBuilder.SharedAccessKeyName, csBuilder.SharedAccessKey)); } else if (csBuilder.SharedAccessKey != null) { if (csBuilder.ModuleId != null) { return(new ModuleAuthenticationWithRegistrySymmetricKey( csBuilder.DeviceId, csBuilder.ModuleId, csBuilder.SharedAccessKey)); } else { return(new DeviceAuthenticationWithRegistrySymmetricKey( csBuilder.DeviceId, csBuilder.SharedAccessKey)); } } else if (csBuilder.SharedAccessSignature != null) { return(csBuilder.ModuleId == null ? (IAuthenticationMethod) new DeviceAuthenticationWithToken( csBuilder.DeviceId, csBuilder.SharedAccessSignature) : new ModuleAuthenticationWithToken( csBuilder.DeviceId, csBuilder.ModuleId, csBuilder.SharedAccessSignature)); } else if (csBuilder.UsingX509Cert) { return(new DeviceAuthenticationWithX509Certificate(csBuilder.DeviceId, csBuilder.Certificate)); } throw new InvalidOperationException($"Unsupported authentication method in '{csBuilder}'."); }
static internal IAuthenticationMethod GetAuthenticationMethod(IotHubConnectionStringBuilder iotHubConnectionStringBuilder) { if (iotHubConnectionStringBuilder.SharedAccessKeyName != null) { return(new DeviceAuthenticationWithSharedAccessPolicyKey( iotHubConnectionStringBuilder.DeviceId, iotHubConnectionStringBuilder.SharedAccessKeyName, iotHubConnectionStringBuilder.SharedAccessKey)); } else if (iotHubConnectionStringBuilder.SharedAccessKey != null) { return(new DeviceAuthenticationWithRegistrySymmetricKey( iotHubConnectionStringBuilder.DeviceId, iotHubConnectionStringBuilder.SharedAccessKey)); } else if (iotHubConnectionStringBuilder.SharedAccessSignature != null) { return(new DeviceAuthenticationWithToken(iotHubConnectionStringBuilder.DeviceId, iotHubConnectionStringBuilder.SharedAccessSignature)); } throw new InvalidOperationException("Unsupported Authentication Method {0}".FormatInvariant(iotHubConnectionStringBuilder)); }
public IotHubConnectionString(IotHubConnectionStringBuilder builder) { if (builder == null) { throw new ArgumentNullException("builder"); } this.HostName = builder.HostName; this.SharedAccessKeyName = builder.SharedAccessKeyName; this.SharedAccessKey = builder.SharedAccessKey; this.SharedAccessSignature = builder.SharedAccessSignature; this.IotHubName = builder.IotHubName; this.DeviceId = builder.DeviceId; #if WINDOWS_UWP this.HttpsEndpoint = new UriBuilder("https", builder.HostName).Uri; #else this.HttpsEndpoint = new UriBuilder(Uri.UriSchemeHttps, builder.HostName).Uri; #endif #if !WINDOWS_UWP this.AmqpEndpoint = new UriBuilder(CommonConstants.AmqpsScheme, builder.HostName, AmqpConstants.DefaultSecurePort).Uri; #endif }
public IotHubConnectionString(IotHubConnectionStringBuilder builder) { if (builder == null) { throw new ArgumentNullException("builder"); } this.Audience = builder.HostName; this.HostName = builder.GatewayHostName == null || builder.GatewayHostName == "" ? builder.HostName : builder.GatewayHostName; this.SharedAccessKeyName = builder.SharedAccessKeyName; this.SharedAccessKey = builder.SharedAccessKey; this.SharedAccessSignature = builder.SharedAccessSignature; this.IotHubName = builder.IotHubName; this.DeviceId = builder.DeviceId; this.ModuleId = builder.ModuleId; #if NETSTANDARD1_3 this.HttpsEndpoint = new UriBuilder("https", this.HostName).Uri; #elif !NETMF this.HttpsEndpoint = new UriBuilder(Uri.UriSchemeHttps, this.HostName).Uri; #elif NETMF this.HttpsEndpoint = new Uri("https://" + this.HostName); #endif #if !NETMF this.AmqpEndpoint = new UriBuilder(CommonConstants.AmqpsScheme, this.HostName, AmqpConstants.DefaultSecurePort).Uri; if (builder.AuthenticationMethod is AuthenticationWithTokenRefresh) { this.TokenRefresher = (AuthenticationWithTokenRefresh)builder.AuthenticationMethod; } else if (!string.IsNullOrEmpty(this.SharedAccessKey)) { this.TokenRefresher = this.ModuleId.IsNullOrWhiteSpace() ? new DeviceAuthenticationWithSakRefresh(this.DeviceId, this) : new ModuleAuthenticationWithSakRefresh(this.DeviceId, this.ModuleId, this) as AuthenticationWithTokenRefresh; } #endif }
static ITransportSettings[] PopulateCertificateInTransportSettings(IotHubConnectionStringBuilder connectionStringBuilder, ITransportSettings[] transportSettings) { foreach (var transportSetting in transportSettings) { switch (transportSetting.GetTransportType()) { case TransportType.Amqp_WebSocket_Only: case TransportType.Amqp_Tcp_Only: ((AmqpTransportSettings)transportSetting).ClientCertificate = connectionStringBuilder.Certificate; break; case TransportType.Http1: ((Http1TransportSettings)transportSetting).ClientCertificate = connectionStringBuilder.Certificate; break; case TransportType.Mqtt: throw new InvalidOperationException("Unsupported Transport {0}".FormatInvariant(transportSetting.GetTransportType())); } } return(transportSettings); }
internal static IotHubConnectionStringBuilder CreateWithIAuthenticationOverride( string iotHubConnectionString, IAuthenticationMethod authenticationMethod) { var iotHubConnectionStringBuilder = new IotHubConnectionStringBuilder { HostName = "TEMP.HUB", }; if (authenticationMethod == null) { iotHubConnectionStringBuilder.Parse(iotHubConnectionString); iotHubConnectionStringBuilder.AuthenticationMethod = AuthenticationMethodFactory.GetAuthenticationMethod(iotHubConnectionStringBuilder); } else { iotHubConnectionStringBuilder.AuthenticationMethod = authenticationMethod; iotHubConnectionStringBuilder.Parse(iotHubConnectionString); } return(iotHubConnectionStringBuilder); }
private static ITransportSettings[] PopulateCertificateInTransportSettings(IotHubConnectionStringBuilder connectionStringBuilder, TransportType transportType) { switch (transportType) { case TransportType.Amqp: return(new ITransportSettings[] { new AmqpTransportSettings(TransportType.Amqp_Tcp_Only) { ClientCertificate = connectionStringBuilder.Certificate }, new AmqpTransportSettings(TransportType.Amqp_WebSocket_Only) { ClientCertificate = connectionStringBuilder.Certificate } }); case TransportType.Amqp_Tcp_Only: return(new ITransportSettings[] { new AmqpTransportSettings(TransportType.Amqp_Tcp_Only) { ClientCertificate = connectionStringBuilder.Certificate } }); case TransportType.Amqp_WebSocket_Only: return(new ITransportSettings[] { new AmqpTransportSettings(TransportType.Amqp_WebSocket_Only) { ClientCertificate = connectionStringBuilder.Certificate } }); case TransportType.Http1: return(new ITransportSettings[] { new Http1TransportSettings() { ClientCertificate = connectionStringBuilder.Certificate } }); case TransportType.Mqtt: return(new ITransportSettings[] { new MqttTransportSettings(TransportType.Mqtt_Tcp_Only) { ClientCertificate = connectionStringBuilder.Certificate }, new MqttTransportSettings(TransportType.Mqtt_WebSocket_Only) { ClientCertificate = connectionStringBuilder.Certificate } }); case TransportType.Mqtt_Tcp_Only: return(new ITransportSettings[] { new MqttTransportSettings(TransportType.Mqtt_Tcp_Only) { ClientCertificate = connectionStringBuilder.Certificate } }); case TransportType.Mqtt_WebSocket_Only: return(new ITransportSettings[] { new MqttTransportSettings(TransportType.Mqtt_WebSocket_Only) { ClientCertificate = connectionStringBuilder.Certificate } }); default: throw new InvalidOperationException("Unsupported Transport {0}".FormatInvariant(transportType)); } }
internal static InternalClient CreateFromConnectionString( string connectionString, IAuthenticationMethod authenticationMethod, ITransportSettings[] transportSettings, IDeviceClientPipelineBuilder pipelineBuilder, ClientOptions options = default) { if (connectionString == null) { throw new ArgumentNullException(nameof(connectionString)); } if (transportSettings == null) { throw new ArgumentNullException(nameof(transportSettings)); } if (transportSettings.Length == 0) { throw new ArgumentOutOfRangeException(nameof(connectionString), "Must specify at least one TransportSettings instance"); } var builder = IotHubConnectionStringBuilder.CreateWithIAuthenticationOverride( connectionString, authenticationMethod); IotHubConnectionString iotHubConnectionString = builder.ToIotHubConnectionString(); foreach (ITransportSettings transportSetting in transportSettings) { switch (transportSetting.GetTransportType()) { case TransportType.Amqp_WebSocket_Only: case TransportType.Amqp_Tcp_Only: if (!(transportSetting is AmqpTransportSettings)) { throw new InvalidOperationException("Unknown implementation of ITransportSettings type"); } break; case TransportType.Http1: if (!(transportSetting is Http1TransportSettings)) { throw new InvalidOperationException("Unknown implementation of ITransportSettings type"); } break; case TransportType.Mqtt_WebSocket_Only: case TransportType.Mqtt_Tcp_Only: if (!(transportSetting is MqttTransportSettings)) { throw new InvalidOperationException("Unknown implementation of ITransportSettings type"); } break; default: throw new InvalidOperationException("Unsupported Transport Type {0}".FormatInvariant(transportSetting.GetTransportType())); } } pipelineBuilder = pipelineBuilder ?? BuildPipeline(); // Defer concrete InternalClient creation to OpenAsync var client = new InternalClient(iotHubConnectionString, transportSettings, pipelineBuilder, options); if (Logging.IsEnabled) { Logging.CreateFromConnectionString(client, $"HostName={iotHubConnectionString.HostName};DeviceId={iotHubConnectionString.DeviceId};ModuleId={iotHubConnectionString.ModuleId}", transportSettings, options); } return(client); }
public IotHubConnectionString(IotHubConnectionStringBuilder builder) { if (builder == null) { throw new ArgumentNullException("builder"); } this.Audience = builder.HostName; this.HostName = builder.GatewayHostName == null || builder.GatewayHostName == "" ? builder.HostName : builder.GatewayHostName; this.SharedAccessKeyName = builder.SharedAccessKeyName; this.SharedAccessKey = builder.SharedAccessKey; this.SharedAccessSignature = builder.SharedAccessSignature; this.IotHubName = builder.IotHubName; this.DeviceId = builder.DeviceId; this.ModuleId = builder.ModuleId; #if NETSTANDARD1_3 this.HttpsEndpoint = new UriBuilder("https", this.HostName).Uri; #elif !NETMF this.HttpsEndpoint = new UriBuilder(Uri.UriSchemeHttps, this.HostName).Uri; #elif NETMF this.HttpsEndpoint = new Uri("https://" + this.HostName); #endif #if !NETMF this.AmqpEndpoint = new UriBuilder(CommonConstants.AmqpsScheme, this.HostName, DefaultSecurePort).Uri; if (builder.AuthenticationMethod is AuthenticationWithTokenRefresh) { this.TokenRefresher = (AuthenticationWithTokenRefresh)builder.AuthenticationMethod; if (Logging.IsEnabled) { Logging.Info(this, $"{nameof(IAuthenticationMethod)} is {nameof(AuthenticationWithTokenRefresh)}: {Logging.IdOf(TokenRefresher)}"); } if (Logging.IsEnabled) { Logging.Associate(this, TokenRefresher, nameof(TokenRefresher)); } Debug.Assert(TokenRefresher != null); } else if (!string.IsNullOrEmpty(this.SharedAccessKey)) { if (this.ModuleId.IsNullOrWhiteSpace()) { this.TokenRefresher = new DeviceAuthenticationWithSakRefresh(this.DeviceId, this) as AuthenticationWithTokenRefresh; if (Logging.IsEnabled) { Logging.Info(this, $"{nameof(IAuthenticationMethod)} is {nameof(DeviceAuthenticationWithSakRefresh)}: {Logging.IdOf(TokenRefresher)}"); } } else { this.TokenRefresher = new ModuleAuthenticationWithSakRefresh(this.DeviceId, this.ModuleId, this) as AuthenticationWithTokenRefresh; if (Logging.IsEnabled) { Logging.Info(this, $"{nameof(IAuthenticationMethod)} is {nameof(ModuleAuthenticationWithSakRefresh)}: {Logging.IdOf(TokenRefresher)}"); } } if (Logging.IsEnabled) { Logging.Associate(this, TokenRefresher, nameof(TokenRefresher)); } Debug.Assert(TokenRefresher != null); } #endif }
public static IotHubConnectionString Parse(string connectionString) { var builder = IotHubConnectionStringBuilder.Create(connectionString); return(builder.ToIotHubConnectionString()); }
public IotHubConnectionString(IotHubConnectionStringBuilder builder) { if (builder == null) { throw new ArgumentNullException(nameof(builder)); } Audience = builder.HostName; IsUsingGateway = !string.IsNullOrEmpty(builder.GatewayHostName); HostName = IsUsingGateway ? builder.GatewayHostName : builder.HostName; SharedAccessKeyName = builder.SharedAccessKeyName; SharedAccessKey = builder.SharedAccessKey; IotHubName = builder.IotHubName; DeviceId = builder.DeviceId; ModuleId = builder.ModuleId; HttpsEndpoint = new UriBuilder(Uri.UriSchemeHttps, HostName).Uri; AmqpEndpoint = new UriBuilder(CommonConstants.AmqpsScheme, HostName, DefaultSecurePort).Uri; if (builder.AuthenticationMethod is AuthenticationWithTokenRefresh authWithTokenRefresh) { TokenRefresher = authWithTokenRefresh; if (Logging.IsEnabled) { Logging.Info( this, $"{nameof(IAuthenticationMethod)} is {nameof(AuthenticationWithTokenRefresh)}: {Logging.IdOf(TokenRefresher)}"); Logging.Associate(this, TokenRefresher, nameof(TokenRefresher)); } Debug.Assert(TokenRefresher != null); } else if (!string.IsNullOrEmpty(SharedAccessKey)) { if (ModuleId.IsNullOrWhiteSpace()) { // Since the SDK creates the instance of disposable DeviceAuthenticationWithSakRefresh, the SDK needs to // dispose it once the client is disposed. TokenRefresher = new DeviceAuthenticationWithSakRefresh( DeviceId, this, builder.SasTokenTimeToLive, builder.SasTokenRenewalBuffer, disposeWithClient: true); if (Logging.IsEnabled) { Logging.Info( this, $"{nameof(IAuthenticationMethod)} is {nameof(DeviceAuthenticationWithSakRefresh)}: {Logging.IdOf(TokenRefresher)}"); } } else { // Since the SDK creates the instance of disposable ModuleAuthenticationWithSakRefresh, the SDK needs to // dispose it once the client is disposed. TokenRefresher = new ModuleAuthenticationWithSakRefresh( DeviceId, ModuleId, this, builder.SasTokenTimeToLive, builder.SasTokenRenewalBuffer, disposeWithClient: true); if (Logging.IsEnabled) { Logging.Info(this, $"{nameof(IAuthenticationMethod)} is {nameof(ModuleAuthenticationWithSakRefresh)}: {Logging.IdOf(TokenRefresher)}"); } } if (Logging.IsEnabled) { Logging.Associate(this, TokenRefresher, nameof(TokenRefresher)); } Debug.Assert(TokenRefresher != null); } // SharedAccessSignature should be set only if it is non-null and the authentication method of the device client is // not of type AuthenticationWithTokenRefresh. // Setting the sas value for an AuthenticationWithTokenRefresh authentication type will result in tokens not being renewed. // This flow can be hit if the same authentication method is always used to initialize the client; // as in, on disposal and reinitialization. This is because the value of the sas token computed is stored within the authentication method, // and on reinitialization the client is incorrectly identified as a fixed-sas-token-initialized client, // instead of being identified as a sas-token-refresh-enabled-client. else if (!string.IsNullOrWhiteSpace(builder.SharedAccessSignature)) { SharedAccessSignature = builder.SharedAccessSignature; } }
/// <summary> /// Create a InternalClient from individual parameters /// </summary> /// <param name="hostname">The fully-qualified DNS hostname of IoT hub</param> /// <param name="gatewayHostname">The fully-qualified DNS hostname of Gateway</param> /// <param name="authenticationMethod">The authentication method that is used</param> /// <param name="transportType">The transportType used (Http1, Amqp or Mqtt), <see cref="TransportType"/></param> /// <param name="options">The options that allow configuration of the device client instance during initialization.</param> /// <returns>InternalClient</returns> internal static InternalClient Create( string hostname, string gatewayHostname, IAuthenticationMethod authenticationMethod, TransportType transportType, ClientOptions options = default) { if (hostname == null) { throw new ArgumentNullException(nameof(hostname)); } if (authenticationMethod == null) { throw new ArgumentNullException(nameof(authenticationMethod)); } if (transportType != TransportType.Amqp_Tcp_Only && transportType != TransportType.Mqtt_Tcp_Only && authenticationMethod is DeviceAuthenticationWithX509Certificate certificate && certificate.ChainCertificates != null) { throw new ArgumentException("Certificate chains are only supported on Amqp_Tcp_Only and Mqtt_Tcp_Only"); } if (!string.IsNullOrWhiteSpace(options?.ModelId) && transportType == TransportType.Http1) { throw new InvalidOperationException("Plug and Play is not supported over the HTTP transport."); } var connectionStringBuilder = IotHubConnectionStringBuilder.Create(hostname, gatewayHostname, authenticationMethod); // Make sure client options is initialized with the correct transport setting. EnsureOptionsIsSetup(connectionStringBuilder.Certificate, ref options); if (authenticationMethod is DeviceAuthenticationWithX509Certificate) { if (connectionStringBuilder.Certificate == null) { throw new ArgumentException("No certificate was found. To use certificate authentication certificate must be present."); } InternalClient internalClient = CreateFromConnectionString( connectionStringBuilder.ToString(), authenticationMethod, PopulateCertificateInTransportSettings(connectionStringBuilder, transportType), null, options); internalClient.Certificate = connectionStringBuilder.Certificate; // Install all the intermediate certificates in the chain if specified. if (connectionStringBuilder.ChainCertificates != null) { try { CertificateInstaller.EnsureChainIsInstalled(connectionStringBuilder.ChainCertificates); } catch (Exception ex) { if (Logging.IsEnabled) { Logging.Error(null, $"{nameof(CertificateInstaller)} failed to read or write to cert store due to: {ex}"); } throw new UnauthorizedException($"Failed to provide certificates in the chain - {ex.Message}", ex); } } return(internalClient); } return(CreateFromConnectionString(connectionStringBuilder.ToString(), authenticationMethod, transportType, null, options)); }
public IotHubConnectionString(IotHubConnectionStringBuilder builder) { if (builder == null) { throw new ArgumentNullException(nameof(builder)); } Audience = builder.HostName; HostName = string.IsNullOrEmpty(builder.GatewayHostName) ? builder.HostName : builder.GatewayHostName; SharedAccessKeyName = builder.SharedAccessKeyName; SharedAccessKey = builder.SharedAccessKey; SharedAccessSignature = builder.SharedAccessSignature; IotHubName = builder.IotHubName; DeviceId = builder.DeviceId; ModuleId = builder.ModuleId; HttpsEndpoint = new UriBuilder(Uri.UriSchemeHttps, HostName).Uri; AmqpEndpoint = new UriBuilder(CommonConstants.AmqpsScheme, HostName, DefaultSecurePort).Uri; if (builder.AuthenticationMethod is AuthenticationWithTokenRefresh) { TokenRefresher = (AuthenticationWithTokenRefresh)builder.AuthenticationMethod; if (Logging.IsEnabled) { Logging.Info(this, $"{nameof(IAuthenticationMethod)} is {nameof(AuthenticationWithTokenRefresh)}: {Logging.IdOf(TokenRefresher)}"); } if (Logging.IsEnabled) { Logging.Associate(this, TokenRefresher, nameof(TokenRefresher)); } Debug.Assert(TokenRefresher != null); } else if (!string.IsNullOrEmpty(SharedAccessKey)) { if (ModuleId.IsNullOrWhiteSpace()) { TokenRefresher = new DeviceAuthenticationWithSakRefresh(DeviceId, this) as AuthenticationWithTokenRefresh; if (Logging.IsEnabled) { Logging.Info(this, $"{nameof(IAuthenticationMethod)} is {nameof(DeviceAuthenticationWithSakRefresh)}: {Logging.IdOf(TokenRefresher)}"); } } else { TokenRefresher = new ModuleAuthenticationWithSakRefresh(DeviceId, ModuleId, this) as AuthenticationWithTokenRefresh; if (Logging.IsEnabled) { Logging.Info(this, $"{nameof(IAuthenticationMethod)} is {nameof(ModuleAuthenticationWithSakRefresh)}: {Logging.IdOf(TokenRefresher)}"); } } if (Logging.IsEnabled) { Logging.Associate(this, TokenRefresher, nameof(TokenRefresher)); } Debug.Assert(TokenRefresher != null); } }
static async Task Main(string[] args) { var interval = 1; var connectionString = ""; var registryManager = RegistryManager.CreateFromConnectionString(connectionString); var numberOfDevices = Enumerable.Range(1, 50); var devices = new ConcurrentBag <DeviceItem>(); await ForEachAsync(numberOfDevices, 10, async (deviceNumber) => { var deviceName = $"SimulatedFridge-{deviceNumber:0000}"; Console.WriteLine($"Registering device ({deviceName})"); var device = await registryManager.GetDeviceAsync(deviceName); if (device == null) { device = await registryManager.AddDeviceAsync(new Device(deviceName)); } devices.Add(new DeviceItem() { Id = deviceName, }); var twin = new Twin() { Tags = { ["IsSimulated"] = "Y" } }; await registryManager.UpdateTwinAsync(device.Id, twin, "*"); }); await ForEachAsync(numberOfDevices, 10, async (deviceNumber) => { var deviceName = $"SimulatedLightBulbs-{deviceNumber:0000}"; Console.WriteLine($"Registering device ({deviceName})"); var device = await registryManager.GetDeviceAsync(deviceName); if (device == null) { device = await registryManager.AddDeviceAsync(new Device(deviceName)); } devices.Add(new DeviceItem() { Id = deviceName, }); var twin = new Twin() { Tags = { ["IsSimulated"] = "Y" } }; await registryManager.UpdateTwinAsync(device.Id, twin, "*"); }); await ForEachAsync(devices, 100, async (deviceItem) => { var device = await registryManager.GetDeviceAsync(deviceItem.Id); var iotHubConnectionString = IotHubConnectionStringBuilder.Create(connectionString); var deviceKeyInfo = new DeviceAuthenticationWithRegistrySymmetricKey(deviceItem.Id, device.Authentication.SymmetricKey.PrimaryKey); var deviceConnectionStringBuilder = ClientIotHubConnectionStringBuilder.Create(iotHubConnectionString.HostName, deviceKeyInfo); var deviceConnectionString = deviceConnectionStringBuilder.ToString(); var deviceClient = DeviceClient.CreateFromConnectionString(deviceConnectionString); await deviceClient.OpenAsync(); var message = FetchClientMessage(deviceItem); while (true) { await deviceClient.SendEventAsync(message); Console.WriteLine($"Sent data for ({deviceItem.Id})"); await Task.Delay(interval * 1000); message = FetchClientMessage(deviceItem); } }); await Task.Delay(1000); Console.ReadKey(); }
/// <summary> /// Populates an <see cref="IotHubConnectionStringBuilder"/> instance based on a snapshot of the properties of /// the current instance. /// </summary> /// <param name="iotHubConnectionStringBuilder">Instance to populate.</param> /// <returns>The populated <see cref="IotHubConnectionStringBuilder"/> instance.</returns> public override IotHubConnectionStringBuilder Populate(IotHubConnectionStringBuilder iotHubConnectionStringBuilder) { iotHubConnectionStringBuilder = base.Populate(iotHubConnectionStringBuilder); iotHubConnectionStringBuilder.DeviceId = DeviceId; return(iotHubConnectionStringBuilder); }
internal static InternalClient CreateFromConnectionString( string connectionString, IAuthenticationMethod authenticationMethod, ITransportSettings[] transportSettings, IDeviceClientPipelineBuilder pipelineBuilder, ClientOptions options = default) { if (connectionString == null) { throw new ArgumentNullException(nameof(connectionString)); } if (transportSettings == null) { throw new ArgumentNullException(nameof(transportSettings)); } if (transportSettings.Length == 0) { throw new ArgumentOutOfRangeException(nameof(connectionString), "Must specify at least one TransportSettings instance"); } if (!string.IsNullOrWhiteSpace(options?.ModelId) && transportSettings.Any(x => x.GetTransportType() == TransportType.Http1)) { throw new InvalidOperationException("Plug and Play is not supported over the HTTP transport."); } var builder = IotHubConnectionStringBuilder.CreateWithIAuthenticationOverride( connectionString, authenticationMethod); // Clients that derive their authentication method from AuthenticationWithTokenRefresh will need to specify // the token time to live and renewal buffer values through the corresponding AuthenticationWithTokenRefresh // implementation constructors instead, and these values are irrelevant for cert-based auth. if (!(builder.AuthenticationMethod is AuthenticationWithTokenRefresh) && !(builder.AuthenticationMethod is DeviceAuthenticationWithX509Certificate)) { builder.SasTokenTimeToLive = options?.SasTokenTimeToLive ?? default; builder.SasTokenRenewalBuffer = options?.SasTokenRenewalBuffer ?? default; } var iotHubConnectionString = builder.ToIotHubConnectionString(); foreach (ITransportSettings transportSetting in transportSettings) { switch (transportSetting.GetTransportType()) { case TransportType.Amqp_WebSocket_Only: case TransportType.Amqp_Tcp_Only: if (!(transportSetting is AmqpTransportSettings)) { throw new InvalidOperationException("Unknown implementation of ITransportSettings type"); } break; case TransportType.Http1: if (!(transportSetting is Http1TransportSettings)) { throw new InvalidOperationException("Unknown implementation of ITransportSettings type"); } break; case TransportType.Mqtt_WebSocket_Only: case TransportType.Mqtt_Tcp_Only: if (!(transportSetting is MqttTransportSettings)) { throw new InvalidOperationException("Unknown implementation of ITransportSettings type"); } break; default: throw new InvalidOperationException( $"Unsupported Transport Type {transportSetting.GetTransportType()}"); } } if (authenticationMethod is DeviceAuthenticationWithX509Certificate && builder.Certificate == null) { throw new ArgumentException("No certificate was found. To use certificate authentication certificate must be present."); } // Make sure client options is initialized with the correct transport setting. EnsureOptionsIsSetup(builder.Certificate, ref options); pipelineBuilder ??= BuildPipeline(); // Defer concrete InternalClient creation to OpenAsync var client = new InternalClient(iotHubConnectionString, transportSettings, pipelineBuilder, options); if (Logging.IsEnabled) { Logging.CreateFromConnectionString( client, $"HostName={iotHubConnectionString.HostName};DeviceId={iotHubConnectionString.DeviceId};ModuleId={iotHubConnectionString.ModuleId}", transportSettings, options); } return(client); }