public async Task RunSampleAsync()
{
try
{
Console.WriteLine($"RegistrationID = {_security.GetRegistrationID()}");
VerifyRegistrationIdFormat(_security.GetRegistrationID());
Console.Write("ProvisioningClient RegisterAsync . . . ");
DeviceRegistrationResult result = await _provClient.RegisterAsync().ConfigureAwait(false);
Console.WriteLine($"{result.Status}");
Console.WriteLine($"ProvisioningClient AssignedHub: {result.AssignedHub}; DeviceID: {result.DeviceId}");
if (result.Status != ProvisioningRegistrationStatusType.Assigned)
{
return;
}
Microsoft.Azure.Devices.Client.IAuthenticationMethod auth;
if (_security is SecurityProviderTpm)
{
Console.WriteLine("Creating TPM DeviceClient authentication.");
auth = new DeviceAuthenticationWithTpm(result.DeviceId, _security as SecurityProviderTpm);
}
else if (_security is SecurityProviderX509)
{
Console.WriteLine("Creating X509 DeviceClient authentication.");
auth = new DeviceAuthenticationWithX509Certificate(result.DeviceId, (_security as SecurityProviderX509).GetAuthenticationCertificate());
}
else if (_security is SecurityProviderSymmetricKey)
{
Console.WriteLine("Creating Symmetric Key DeviceClient authenication");
auth = new DeviceAuthenticationWithRegistrySymmetricKey(result.DeviceId, (_security as SecurityProviderSymmetricKey).GetPrimaryKey());
}
else
{
throw new NotSupportedException("Unknown authentication type.");
}
using (DeviceClient iotClient = DeviceClient.Create(result.AssignedHub, auth, Microsoft.Azure.Devices.Client.TransportType.Amqp))
{
Console.WriteLine("DeviceClient OpenAsync.");
await iotClient.OpenAsync().ConfigureAwait(false);
Console.WriteLine("DeviceClient SendEventAsync.");
await iotClient.SendEventAsync(new Microsoft.Azure.Devices.Client.Message(Encoding.UTF8.GetBytes("TestMessage"))).ConfigureAwait(false);
Console.WriteLine("DeviceClient CloseAsync.");
await iotClient.CloseAsync().ConfigureAwait(false);
}
}
catch (Exception)
{
throw;
}
}
public static async Task RunAsync(ProvisioningDeviceClient provisioningDeviceClient, SecurityProvider security)
{
Console.WriteLine($"RegistrationID = {security.GetRegistrationID()}");
Console.Write("ProvisioningClient RegisterAsync . . . ");
DeviceRegistrationResult result = await provisioningDeviceClient.RegisterAsync().ConfigureAwait(false);
Console.WriteLine($"{result.Status}");
Console.WriteLine($"ProvisioningClient AssignedHub: {result.AssignedHub}; DeviceID: {result.DeviceId}");
if (result.Status == ProvisioningRegistrationStatusType.Assigned)
{
X509Certificate2 certificate = (security as SecurityProviderX509).GetAuthenticationCertificate();
Console.WriteLine($"Registration certificate thumbprint: {certificate.Thumbprint}");
IAuthenticationMethod auth = new DeviceAuthenticationWithX509Certificate(result.DeviceId, certificate);
using (DeviceClient iotClient = DeviceClient.Create(result.AssignedHub, auth, TransportType.Amqp))
{
Console.WriteLine("DeviceClient OpenAsync.");
await iotClient.OpenAsync().ConfigureAwait(false);
Console.WriteLine("DeviceClient SendEventAsync.");
await iotClient.SendEventAsync(new Message(Encoding.UTF8.GetBytes("TestMessage"))).ConfigureAwait(false);
Console.WriteLine("DeviceClient CloseAsync.");
await iotClient.CloseAsync().ConfigureAwait(false);
}
}
}
public async Task <DeviceClient> RunAsync()
{
Console.WriteLine($"RegistrationID = {_security.GetRegistrationID()}");
VerifyRegistrationIdFormat(_security.GetRegistrationID());
Console.Write("ProvisioningClient RegisterAsync . . . ");
DeviceRegistrationResult result = await _provClient.RegisterAsync().ConfigureAwait(false);
Console.WriteLine($"{result.Status}");
Console.WriteLine($"ProvisioningClient AssignedHub: {result.AssignedHub}; DeviceID: {result.DeviceId}");
if (result.Status != ProvisioningRegistrationStatusType.Assigned)
{
return(null);
}
IAuthenticationMethod auth;
if (_security is SecurityProviderTpm)
{
Console.WriteLine("Creating TPM DeviceClient authentication.");
auth = new DeviceAuthenticationWithTpm(result.DeviceId, _security as SecurityProviderTpm);
}
else if (_security is SecurityProviderX509)
{
Console.WriteLine("Creating X509 DeviceClient authentication.");
auth = new DeviceAuthenticationWithX509Certificate(result.DeviceId, (_security as SecurityProviderX509).GetAuthenticationCertificate());
}
else if (_security is SecurityProviderSymmetricKey)
{
Console.WriteLine("Creating Symmetric Key DeviceClient authenication");
auth = new DeviceAuthenticationWithRegistrySymmetricKey(result.DeviceId, (_security as SecurityProviderSymmetricKey).GetPrimaryKey());
}
else
{
throw new NotSupportedException("Unknown authentication type.");
}
DeviceClient iotClient = DeviceClient.Create(result.AssignedHub, auth, TransportType.Amqp);
return(iotClient);
}
public async Task RunAsync()
{
Console.WriteLine($"RegistrationID = {security.GetRegistrationID()}");
// Register the Device with DPS
Console.Write("ProvisioningClient RegisterAsync . . . ");
DeviceRegistrationResult result = await provClient.RegisterAsync().ConfigureAwait(false);
Console.WriteLine($"Device Registration Status: {result.Status}");
Console.WriteLine($"ProvisioningClient AssignedHub: {result.AssignedHub}; DeviceID: {result.DeviceId}");
deviceId = result.DeviceId;
// Verify Device Registration Status
if (result.Status != ProvisioningRegistrationStatusType.Assigned)
{
throw new Exception($"DeviceRegistrationResult.Status is NOT 'Assigned'");
}
// Create x509 DeviceClient Authentication
Console.WriteLine("Creating X509 DeviceClient authentication.");
var auth = new DeviceAuthenticationWithX509Certificate(result.DeviceId, (security as SecurityProviderX509).GetAuthenticationCertificate());
Console.WriteLine("Simulated Device. Ctrl-C to exit.");
using (iotClient = DeviceClient.Create(result.AssignedHub, auth, TransportType.Amqp))
{
// Explicitly open DeviceClient to communicate with Azure IoT Hub
Console.WriteLine("DeviceClient OpenAsync.");
await iotClient.OpenAsync().ConfigureAwait(false);
// TODO 1: Setup OnDesiredPropertyChanged Event Handling to receive Desired Properties changes
Console.WriteLine("Connecting SetDesiredPropertyUpdateCallbackAsync event handler...");
await iotClient.SetDesiredPropertyUpdateCallbackAsync(OnDesiredPropertyChanged, null).ConfigureAwait(false);
// TODO 2: Load Device Twin Properties since device is just starting up
Console.WriteLine("Loading Device Twin Properties...");
var twin = await iotClient.GetTwinAsync().ConfigureAwait(false);
// Use OnDesiredPropertyChanged event handler to set the loaded Device Twin Properties (re-use!)
await OnDesiredPropertyChanged(twin.Properties.Desired, null);
// Start reading and sending device telemetry
Console.WriteLine("Start reading and sending device telemetry...");
await SendDeviceToCloudMessagesAsync(iotClient);
// Explicitly close DeviceClient
Console.WriteLine("DeviceClient CloseAsync.");
await iotClient.CloseAsync().ConfigureAwait(false);
}
}
public async Task <DeviceClient> ProvisionDeviceAndGetClientAsync()
{
Console.WriteLine($"RegistrationID = {_security.GetRegistrationID()}");
VerifyRegistrationIdFormat(_security.GetRegistrationID());
Console.Write("ProvisioningClient RegisterAsync . . . ");
DeviceRegistrationResult result = await _provClient.RegisterAsync().ConfigureAwait(false);
Console.WriteLine($"{result.Status}");
Console.WriteLine($"ProvisioningClient AssignedHub: {result.AssignedHub}; DeviceID: {result.DeviceId}");
if (result.Status != ProvisioningRegistrationStatusType.Assigned)
{
Console.WriteLine($"Provisioning failed : Status: {result.Status}");
return(null);
}
Console.WriteLine("Creating X509 DeviceClient authentication.");
IAuthenticationMethod auth = new DeviceAuthenticationWithX509Certificate(result.DeviceId, (_security as SecurityProviderX509).GetAuthenticationCertificate());
return(DeviceClient.Create(result.AssignedHub, auth, TransportType.Amqp));
}
public async Task RunAsync()
{
colorMessage($"\nRegistrationID = {_security.GetRegistrationID()}", ConsoleColor.Yellow);
// Register the Device with DPS.
whiteMessage("ProvisioningClient RegisterAsync . . . ");
DeviceRegistrationResult result = await _provClient.RegisterAsync().ConfigureAwait(false);
if (result.Status == ProvisioningRegistrationStatusType.Assigned)
{
greenMessage($"Device Registration Status: {result.Status}");
greenMessage($"ProvisioningClient AssignedHub: {result.AssignedHub}; DeviceID: {result.DeviceId}");
}
else
{
redMessage($"Device Registration Status: {result.Status}");
throw new Exception($"DeviceRegistrationResult.Status is NOT 'Assigned'");
}
// Create x509 DeviceClient Authentication.
whiteMessage("Creating X509 DeviceClient authentication.");
var auth = new DeviceAuthenticationWithX509Certificate(result.DeviceId, (_security as SecurityProviderX509).GetAuthenticationCertificate());
whiteMessage("Simulated Device. Ctrl-C to exit.");
using (s_deviceClient = DeviceClient.Create(result.AssignedHub, auth, TransportType.Amqp))
{
// Explicitly open DeviceClient to communicate with Azure IoT Hub.
whiteMessage("DeviceClient OpenAsync.");
await s_deviceClient.OpenAsync().ConfigureAwait(false);
// Setup OnDesiredPropertyChanged Event Handling to receive Desired Properties changes.
whiteMessage("Connecting SetDesiredPropertyUpdateCallbackAsync event handler...");
await s_deviceClient.SetDesiredPropertyUpdateCallbackAsync(OnDesiredPropertyChanged, null).ConfigureAwait(false);
// Load Device Twin Properties since device is just starting up.
whiteMessage("Loading Device Twin Properties...");
var twin = await s_deviceClient.GetTwinAsync().ConfigureAwait(false);
// Use OnDesiredPropertyChanged event handler to set the loaded Device Twin properties.
await OnDesiredPropertyChanged(twin.Properties.Desired, null);
// Start reading and sending device telemetry.
colorMessage("\nStart reading and sending device telemetry...\n", ConsoleColor.Yellow);
await SendDeviceToCloudMessagesAsync2(s_deviceClient);
// Explicitly close DeviceClient.
whiteMessage("DeviceClient CloseAsync.");
await s_deviceClient.CloseAsync().ConfigureAwait(false);
}
}
public async Task RunSampleAsync()
{
Console.WriteLine($"RegistrationID = {_security.GetRegistrationID()}");
VerifyRegistrationIdFormat(_security.GetRegistrationID());
Console.Write("ProvisioningClient RegisterAsync . . . ");
DeviceRegistrationResult result = await _provClient.RegisterAsync().ConfigureAwait(false);
Console.WriteLine($"{result.Status}");
Console.WriteLine($"ProvisioningClient AssignedHub: {result.AssignedHub}; DeviceID: {result.DeviceId}");
if (result.Status != ProvisioningRegistrationStatusType.Assigned)
{
return;
}
IAuthenticationMethod auth;
if (_security is SecurityProviderSymmetricKey)
{
Console.WriteLine("Creating Symmetric Key DeviceClient authenication");
auth = new DeviceAuthenticationWithRegistrySymmetricKey(result.DeviceId, (_security as SecurityProviderSymmetricKey).GetPrimaryKey());
}
else
{
throw new NotSupportedException("Unknown authentication type.");
}
deviceClient = DeviceClient.Create(result.AssignedHub, auth, TransportType.Amqp);
await deviceClient.OpenAsync().ConfigureAwait(false);
#pragma warning disable 4014
Task.Run(async() => await ListenCommands());
#pragma warning restore 4014
SendDeviceToCloudMessagesAsync();
}
public async Task RunAsync()
{
Console.WriteLine($"RegistrationID = {_security.GetRegistrationID()}");
Console.Write("ProvisioningClient RegisterAsync . . . ");
DeviceRegistrationResult result = await _provClient.RegisterAsync().ConfigureAwait(false);
Console.WriteLine($"Device Registration Status: {result.Status}");
Console.WriteLine($"ProvisioningClient AssignedHub: {result.AssignedHub}; DeviceID: {result.DeviceId}");
if (result.Status != ProvisioningRegistrationStatusType.Assigned)
{
throw new Exception($"DeviceRegistrationResult.Status is NOT 'Assigned'");
}
Console.WriteLine("Creating Symmetric Key DeviceClient authentication");
IAuthenticationMethod auth = new DeviceAuthenticationWithRegistrySymmetricKey(result.DeviceId, (_security as SecurityProviderSymmetricKey).GetPrimaryKey());
Console.WriteLine("Simulated Device. Ctrl-C to exit.");
using (iotClient = DeviceClient.Create(result.AssignedHub, auth, TransportType.Amqp))
{
Console.WriteLine("DeviceClient OpenAsync.");
await iotClient.OpenAsync().ConfigureAwait(false);
// TODO 1: Setup OnDesiredPropertyChanged Event Handling
Console.WriteLine("Connecting SetDesiredPropertyUpdateCallbackAsync event handler...");
await iotClient.SetDesiredPropertyUpdateCallbackAsync(OnDesiredPropertyChanged, null).ConfigureAwait(false);
// TODO 2: Load Device Twin Properties
Console.WriteLine("Loading Device Twin Properties...");
var twin = await iotClient.GetTwinAsync().ConfigureAwait(false);
await OnDesiredPropertyChanged(twin.Properties.Desired, null);
// Start reading and sending device telemetry
Console.WriteLine("Start reading and sending device telemetry...");
await SendDeviceToCloudMessagesAsync(iotClient);
//Console.WriteLine("DeviceClient CloseAsync.");
//await iotClient.CloseAsync().ConfigureAwait(false);
}
}
public async Task RunAsync()
{
colorMessage($"\nRegistrationID = {_security.GetRegistrationID()}", ConsoleColor.Yellow);
// Register the Device with DPS.
whiteMessage("ProvisioningClient RegisterAsync . . . ");
DeviceRegistrationResult result = await _provClient.RegisterAsync().ConfigureAwait(false);
if (result.Status == ProvisioningRegistrationStatusType.Assigned)
{
greenMessage($"Device Registration Status: {result.Status}");
greenMessage($"ProvisioningClient AssignedHub: {result.AssignedHub}; DeviceID: {result.DeviceId}");
}
else
{
redMessage($"Device Registration Status: {result.Status}");
throw new Exception($"DeviceRegistrationResult.Status is NOT 'Assigned'");
}
// Create x509 DeviceClient Authentication.
whiteMessage("Creating X509 DeviceClient authentication.");
var auth = new DeviceAuthenticationWithX509Certificate(result.DeviceId, (_security as SecurityProviderX509).GetAuthenticationCertificate());
whiteMessage("Simulated Device. Ctrl-C to exit.");
using (s_deviceClient = DeviceClient.Create(result.AssignedHub, auth, TransportType.Amqp))
{
// Explicitly open DeviceClient to communicate with Azure IoT Hub.
whiteMessage("DeviceClient OpenAsync.");
await s_deviceClient.OpenAsync().ConfigureAwait(false);
// Start reading and sending device telemetry.
colorMessage("\nStart reading and sending device telemetry...\n", ConsoleColor.Yellow);
await SendDeviceToCloudMessagesAsync(s_deviceClient);
await SendDeviceToCloudLogMessagesAsync(s_deviceClient);
// Explicitly close DeviceClient.
whiteMessage("DeviceClient CloseAsync.");
await s_deviceClient.CloseAsync().ConfigureAwait(false);
}
}
/// <summary>
/// Update the enrollment under test such that it forces it to reprovision to the hubs within <paramref name="iotHubsToReprovisionTo"/>
/// </summary>
private async Task UpdateEnrollmentToForceReprovision(EnrollmentType?enrollmentType, ProvisioningServiceClient provisioningServiceClient, ICollection <String> iotHubsToReprovisionTo, SecurityProvider security, string groupId)
{
if (enrollmentType == EnrollmentType.Individual)
{
IndividualEnrollment individualEnrollment = await provisioningServiceClient.GetIndividualEnrollmentAsync(security.GetRegistrationID()).ConfigureAwait(false);
individualEnrollment.IotHubs = iotHubsToReprovisionTo;
IndividualEnrollment individualEnrollmentResult = await provisioningServiceClient.CreateOrUpdateIndividualEnrollmentAsync(individualEnrollment).ConfigureAwait(false);
}
else
{
EnrollmentGroup enrollmentGroup = await provisioningServiceClient.GetEnrollmentGroupAsync(groupId).ConfigureAwait(false);
enrollmentGroup.IotHubs = iotHubsToReprovisionTo;
EnrollmentGroup enrollmentGroupResult = await provisioningServiceClient.CreateOrUpdateEnrollmentGroupAsync(enrollmentGroup).ConfigureAwait(false);
}
}
/// <summary>
/// Update the enrollment under test such that it forces it to reprovision to the hubs within <paramref name="iotHubsToReprovisionTo"/>
/// </summary>
private async Task UpdateEnrollmentToForceReprovision(EnrollmentType? enrollmentType, ProvisioningServiceClient provisioningServiceClient, ICollection<String> iotHubsToReprovisionTo, SecurityProvider security, string groupId)
{
if (enrollmentType == EnrollmentType.Individual)
{
IndividualEnrollment retrievedEnrollment = null;
await RetryOperationHelper
.RetryOperationsAsync(
async () =>
{
retrievedEnrollment = await provisioningServiceClient.GetIndividualEnrollmentAsync(security.GetRegistrationID()).ConfigureAwait(false);
},
s_provisioningServiceRetryPolicy,
s_retryableExceptions,
Logger)
.ConfigureAwait(false);
if (retrievedEnrollment == null)
{
throw new ArgumentException($"The individual enrollment entry with registration Id {security.GetRegistrationID()} could not be retrieved, exiting test.");
}
retrievedEnrollment.IotHubs = iotHubsToReprovisionTo;
IndividualEnrollment updatedEnrollment = null;
await RetryOperationHelper
.RetryOperationsAsync(
async () =>
{
updatedEnrollment = await provisioningServiceClient.CreateOrUpdateIndividualEnrollmentAsync(retrievedEnrollment).ConfigureAwait(false);
},
s_provisioningServiceRetryPolicy,
s_retryableExceptions,
Logger)
.ConfigureAwait(false);
if (updatedEnrollment == null)
{
throw new ArgumentException($"The individual enrollment entry with registration Id {security.GetRegistrationID()} could not be updated, exiting test.");
}
}
else
{
EnrollmentGroup retrievedEnrollmentGroup = null;
await RetryOperationHelper
.RetryOperationsAsync(
async () =>
{
retrievedEnrollmentGroup = await provisioningServiceClient.GetEnrollmentGroupAsync(groupId).ConfigureAwait(false);
},
s_provisioningServiceRetryPolicy,
s_retryableExceptions,
Logger)
.ConfigureAwait(false);
if (retrievedEnrollmentGroup == null)
{
throw new ArgumentException($"The enrollment group entry with group Id {groupId} could not be retrieved, exiting test.");
}
retrievedEnrollmentGroup.IotHubs = iotHubsToReprovisionTo;
EnrollmentGroup updatedEnrollmentGroup = null;
await RetryOperationHelper
.RetryOperationsAsync(
async () =>
{
updatedEnrollmentGroup = await provisioningServiceClient.CreateOrUpdateEnrollmentGroupAsync(retrievedEnrollmentGroup).ConfigureAwait(false);
},
s_provisioningServiceRetryPolicy,
s_retryableExceptions,
Logger)
.ConfigureAwait(false);
if (updatedEnrollmentGroup == null)
{
throw new ArgumentException($"The enrollment group entry with group Id {groupId} could not be updated, exiting test.");
}
}
}
/// <summary>
/// Provisions a device to a starting hub, tries to open a connection, send telemetry,
/// and (if supported by the protocol) send a twin update. Then, this method updates the enrollment
/// to provision the device to a different hub. Based on the provided reprovisioning settings, this
/// method then checks that the device was/was not reprovisioned as expected, and that the device
/// did/did not migrate twin data as expected.
/// </summary>
public async Task ProvisioningDeviceClient_ReprovisioningFlow(
Client.TransportType transportProtocol,
AttestationMechanismType attestationType,
EnrollmentType? enrollmentType,
bool setCustomProxy,
ReprovisionPolicy reprovisionPolicy,
AllocationPolicy allocationPolicy,
CustomAllocationDefinition customAllocationDefinition,
ICollection<string> iotHubsToStartAt,
ICollection<string> iotHubsToReprovisionTo,
string proxyServerAddress = null)
{
using ProvisioningServiceClient provisioningServiceClient = CreateProvisioningService(s_proxyServerAddress);
string groupId = null;
if (enrollmentType == EnrollmentType.Group)
{
if (attestationType == AttestationMechanismType.X509)
{
groupId = TestConfiguration.Provisioning.X509GroupEnrollmentName;
}
else
{
groupId = _idPrefix + AttestationTypeToString(attestationType) + "-" + Guid.NewGuid();
}
}
bool transportProtocolSupportsTwinOperations = transportProtocol != Client.TransportType.Http1;
using ProvisioningTransportHandler transport = CreateTransportHandlerFromName(transportProtocol);
using SecurityProvider security = await CreateSecurityProviderFromNameAsync(
attestationType,
enrollmentType,
groupId,
reprovisionPolicy,
allocationPolicy,
customAllocationDefinition,
iotHubsToStartAt)
.ConfigureAwait(false);
//Check basic provisioning
if (ImplementsWebProxy(transportProtocol) && setCustomProxy)
{
transport.Proxy = (proxyServerAddress != null) ? new WebProxy(s_proxyServerAddress) : null;
}
var provClient = ProvisioningDeviceClient.Create(
s_globalDeviceEndpoint,
TestConfiguration.Provisioning.IdScope,
security,
transport);
using var cts = new CancellationTokenSource(PassingTimeoutMiliseconds);
DeviceRegistrationResult result = await provClient.RegisterAsync(cts.Token).ConfigureAwait(false);
ValidateDeviceRegistrationResult(result);
#pragma warning disable CA2000 // Dispose objects before losing scope
// The certificate instance referenced in the DeviceAuthenticationWithX509Certificate instance is common for all tests in this class. It is disposed during class cleanup.
Client.IAuthenticationMethod auth = CreateAuthenticationMethodFromSecurityProvider(security, result.DeviceId);
#pragma warning restore CA2000 // Dispose objects before losing scope
await ConfirmRegisteredDeviceWorks(result, auth, transportProtocol, transportProtocolSupportsTwinOperations).ConfigureAwait(false);
//Check reprovisioning
await UpdateEnrollmentToForceReprovision(enrollmentType, provisioningServiceClient, iotHubsToReprovisionTo, security, groupId).ConfigureAwait(false);
result = await provClient.RegisterAsync(cts.Token).ConfigureAwait(false);
ConfirmDeviceInExpectedHub(result, reprovisionPolicy, iotHubsToStartAt, iotHubsToReprovisionTo, allocationPolicy);
await ConfirmDeviceWorksAfterReprovisioning(result, auth, transportProtocol, reprovisionPolicy, transportProtocolSupportsTwinOperations).ConfigureAwait(false);
if (attestationType == AttestationMechanismType.X509 && enrollmentType == EnrollmentType.Group)
{
Logger.Trace($"The test enrollment type {attestationType}-{enrollmentType} with group Id {groupId} is currently hardcoded - do not delete.");
}
else
{
Logger.Trace($"Deleting test enrollment type {attestationType}-{enrollmentType} with registration Id {security.GetRegistrationID()}.");
await DeleteCreatedEnrollmentAsync(enrollmentType, security, groupId, Logger).ConfigureAwait(false);
}
if (security is SecurityProviderX509 x509Security)
{
X509Certificate2 deviceCertificate = x509Security.GetAuthenticationCertificate();
deviceCertificate?.Dispose();
}
if (auth != null && auth is IDisposable disposableAuth)
{
disposableAuth?.Dispose();
}
}
