public static async Task <IEnumerable <string> > CreateDevices(string hubConnectionString, IEnumerable <string> deviceIds)
{
if (deviceIds.Count() <= 1)
{
return(new string[] { await CreateDevice(hubConnectionString, deviceIds.FirstOrDefault()) });
}
IotHubConnectionStringBuilder connection = IotHubConnectionStringBuilder.Create(hubConnectionString);
RegistryManager registryManager = RegistryManager.CreateFromConnectionString(connection.ToString());
var tempIds = deviceIds;
do
{
await registryManager.AddDevices2Async(tempIds.Take(100).Select(deviceId => new Device(deviceId)));
tempIds = tempIds.Skip(100);
} while (tempIds.Any());
ConcurrentBag <Device> devices = new ConcurrentBag <Device>();
tempIds = deviceIds;
do
{
await Task.WhenAll(tempIds.Take(50).Select(x => AddDevice(devices, x, registryManager)));
tempIds = tempIds.Skip(50);
} while (tempIds.Any());
return(devices.Select(x => "HostName=" + connection.HostName + ";DeviceId=" + x.Id + ";SharedAccessKey=" + x.Authentication.SymmetricKey.PrimaryKey));
}
/// <summary>
/// Registers devices with the IoT Hub.
/// </summary>
/// <param name="registryManager">An instance of <c>RegistryManager</c></param>
/// <param name="deviceIds">The list of device ids to register.</param>
/// <param name="enable">Devices will be registered with enabled state if this is set to true.</param>
/// <returns>Any errors returned during the bulk register operation (and bulk update operation if devices are being enabled also).</returns>
private async Task <IEnumerable <DeviceRegistryOperationError> > RegisterDevices(RegistryManager registryManager, List <string> deviceIds, bool enable = false)
{
IEnumerable <DeviceRegistryOperationError> registerErrors = deviceIds.Where(
id => !AzureIoTDeviceIdRegex.IsMatch(id)
)
.Select(
id => new DeviceRegistryOperationError()
{
ErrorCode = ErrorCode.ArgumentInvalid,
DeviceId = id,
ErrorStatus = String.Format(Labels.AzureIoTDeviceIdInvalid, id)
}
);
IEnumerable <DeviceRegistryOperationError> updateErrors = Enumerable.Empty <DeviceRegistryOperationError>();
List <Device> deviceList = deviceIds.Where(
id => AzureIoTDeviceIdRegex.IsMatch(id)
).Select(
id => { return(new Device(id)
{
Status = enable ? DeviceStatus.Enabled : DeviceStatus.Disabled
}); }
).ToList();
if (deviceList.Count > 0)
{
BulkRegistryOperationResult registerResult = await registryManager.AddDevices2Async(deviceList);
if (!registerResult.IsSuccessful)
{
// Some devices were already registered.
// Explicity enable those devices only if the argument is set to true, otherwise skip this step.
if (enable)
{
IEnumerable <string> deviceIdsToUpdate = registerResult.Errors
.Where(
error => error.ErrorCode == ErrorCode.DeviceAlreadyExists
)
.Select(
error => error.DeviceId
);
updateErrors = await SetStatuses(registryManager, deviceIdsToUpdate, DeviceStatus.Enabled);
}
}
registerErrors = registerErrors.Concat(GetRegistryOperationErrors(registerResult, ErrorCode.DeviceAlreadyExists));
}
return(registerErrors.Concat(updateErrors));
}
/// <summary>
/// Register a list of devices
/// </summary>
/// <param name="devices"></param>
/// <returns></returns>
public static async Task <BulkRegistryOperationResult> AddDevices2Async(IEnumerable <Device> devices)
{
BulkRegistryOperationResult operationResults;
try
{
operationResults = await registryManager.AddDevices2Async(devices);
return(operationResults);
}
catch (Exception ex)
{
Console.WriteLine($"{Utils.FormatExceptionMessage(ex)}");
throw ex;
}
}
private async Task <string[]> RegisterBatchDeviceAsync(
RegistryManager registryManager,
string[] ids,
CancellationToken cancellationToken)
{
var devices = from id in ids
select new Device(id)
{
Authentication = new AuthenticationMechanism
{
SymmetricKey = new SymmetricKey()
}
};
try
{
var result = await registryManager.AddDevices2Async(
devices,
cancellationToken);
if (result.IsSuccessful)
{
_telemetryClient.TrackMetric(
"registration-count",
ids.Length);
return(ids);
}
else
{
throw new InvalidOperationException(
$"{result.Errors.Length} errors detected while registering devices");
}
}
catch (Exception ex)
{
_telemetryClient.TrackException(ex);
throw;
}
}
private async void cmd01RegisterNewDevice_Click(object sender, RoutedEventArgs e)
{
RegistryManager rm = RegistryManager.CreateFromConnectionString(m_ownerConnection);
Device[] devArr = new Device[10];
for (int i = 0; i < 10; i++)
{
devArr[i] = new Device($"wpf{i}");
}
foreach (var item in await rm.GetDevicesAsync(1000))
{
if (item.Id.StartsWith("wpf"))
{
await rm.RemoveDevices2Async(new Device[] { item });
}
}
var resultAdd = await rm.AddDevices2Async(devArr);
foreach (var item in resultAdd.Errors)
{
Debug.WriteLine(item);
}
//SAS
var builder = Microsoft.Azure.Devices.IotHubConnectionStringBuilder.Create(m_ownerConnection);
Device pc = await rm.GetDeviceAsync("PC");
var sasBuilder = new SharedAccessSignatureBuilder()
{
Key = pc.Authentication.SymmetricKey.PrimaryKey,
Target = String.Format("{0}/devices/{1}", builder.HostName, WebUtility.UrlEncode(pc.Id)),
TimeToLive = TimeSpan.FromDays(5)
};
string sas = $"HostName={builder.HostName};DeviceId={pc.Id};SharedAccessSignature={sasBuilder.ToSignature()}";
Debug.WriteLine($"SAS: {sas}");
}
private static async Task BulkCreateDevicesAsync(List <Device> devices, RegistryManager registryManager, DeviceProvisionStats stats)
{
try
{
var bulkResult = await registryManager.AddDevices2Async(devices);
var totalErrors = bulkResult?.Errors?.Length ?? 0;
var totalCreated = devices.Count - totalErrors;
if (totalCreated > 0)
{
stats.IncrementCreated(totalCreated);
}
if (totalErrors > 0)
{
stats.IncrementErrors(totalErrors);
}
}
catch (Exception ex)
{
Console.Error.WriteLine(ex);
}
}
private async Task <IDictionary <string, string> > CreateIoTHubDevicesAndGetConnectionStringsAsync(
IDictionary <string, List <DeviceDescription> > allDevices)
{
var result = new ConcurrentDictionary <string, string>();
string[] deviceIds = allDevices.Keys.ToArray();
Console.WriteLine($"{_actionMessage} devices...");
if (RemoveDevices)
{
await RemoveDevicesAsync(deviceIds);
}
else
{
const int maxDevicesPerCall = 100;
int numberOfCallsRequired = (int)Math.Ceiling(deviceIds.Length / (double)maxDevicesPerCall);
for (int i = 0; i < numberOfCallsRequired; i++)
{
string[] deviceIdsForCall = deviceIds.Skip(i * maxDevicesPerCall).Take(maxDevicesPerCall).ToArray();
BulkRegistryOperationResult bulkCreationResult =
await _registryManager.AddDevices2Async(deviceIdsForCall.Select(id => new Device(id)));
if (!bulkCreationResult.IsSuccessful)
{
Console.WriteLine("Failed creating devices...");
foreach (DeviceRegistryOperationError creationError in bulkCreationResult.Errors)
{
Console.WriteLine($"Device {creationError.DeviceId}: {creationError.ErrorStatus}");
}
throw new Exception();
}
}
}
Console.WriteLine($"{_actionMessage} devices completed.");
if (!RemoveDevices)
{
Console.WriteLine("Retrieving connection strings...");
await InitializeBlobContainerAsync();
string sasToken = _deviceExportContainer.GetSharedAccessSignature(new SharedAccessBlobPolicy(), "saspolicy");
var containerSasUri = $"{_deviceExportContainer.Uri}{sasToken}";
var job = await _registryManager.ExportDevicesAsync(containerSasUri, false);
while (true)
{
job = await _registryManager.GetJobAsync(job.JobId);
if (job.Status == JobStatus.Completed ||
job.Status == JobStatus.Failed ||
job.Status == JobStatus.Cancelled)
{
// Job has finished executing
break;
}
await Task.Delay(TimeSpan.FromSeconds(5));
}
var exportedDevices = new List <ExportImportDevice>();
var blob = _deviceExportContainer.GetBlobReference("devices.txt");
using (var streamReader = new StreamReader(await blob.OpenReadAsync(), Encoding.UTF8))
{
while (streamReader.Peek() != -1)
{
string line = await streamReader.ReadLineAsync();
var device = JsonConvert.DeserializeObject <ExportImportDevice>(line);
exportedDevices.Add(device);
}
}
await _deviceExportContainer.DeleteIfExistsAsync();
await File.WriteAllTextAsync(CreatedDevicesJsonFileName, JsonConvert.SerializeObject(exportedDevices));
foreach (ExportImportDevice device in exportedDevices.OrderBy(d => d.Id))
{
result[device.Id] =
$"HostName={_iotHubConnectionStringBuilder.HostName};DeviceId={device.Id};SharedAccessKey={device.Authentication.SymmetricKey.PrimaryKey}";
}
Console.WriteLine("Retrieval complete.");
}
return(result);
}
private Task <BulkRegistryOperationResult> CreateEdgeDevicesAsync(IEnumerable <Device> edgeDevices)
{
return(_registryManager.AddDevices2Async(edgeDevices));
}
private static async Task BulkCreateAsync(RegistryManager registryManager, CancellationToken cancellationToken)
{
var devices = ReadFromCsv("devices.csv");
// devices must be unique, so get existing devices
var existingTwin = devices
.Select(x => registryManager.GetTwinAsync(x.Id))
.ToArray();
await Task.WhenAll(existingTwin);
var existingDevices = existingTwin
.Select(task => task.Result)
.Where(x => x != null)
.ToArray();
if (existingDevices.Length > 0)
{
Console.WriteLine($"{existingDevices.Length} devices already exist.");
}
// only insert devices that don't exist yet
var devicesToUpload = devices
.Where(device => existingDevices.All(existing => existing.DeviceId != device.Id))
.Select(deviceInfo => new Device(deviceInfo.Id)
{
Status = deviceInfo.Enabed ? DeviceStatus.Enabled : DeviceStatus.Disabled
})
.ToList();
if (devicesToUpload.Any())
{
Console.WriteLine($"Creating {devicesToUpload.Count} devices..");
var result = await registryManager.AddDevices2Async(devicesToUpload, cancellationToken);
if (!result.IsSuccessful)
{
throw new AggregateException("Device creation failed!",
result.Errors.Select(e => new Exception(JsonSerializer.Serialize(new
{
deviceId = e.DeviceId,
code = e.ErrorCode,
status = e.ErrorStatus,
moduleid = e.ModuleId
}))));
}
}
// need etag from cloud before updating, so fetch all devices again
existingTwin = devices
.Select(deviceInfo => registryManager.GetTwinAsync(deviceInfo.Id))
.ToArray();
await Task.WhenAll(existingTwin);
var devicesInCloud = existingTwin
.Select(task => task.Result)
.ToArray();
var twins = devices
.Select(d => new Twin(d.Id)
{
Tags = new TwinCollection(JsonSerializer.Serialize(new
{
country = d.Country,
building = d.Building,
floor = d.Floor,
sensorType = d.SensorType
})),
ETag = devicesInCloud.Single(cloudDevice => cloudDevice.DeviceId == d.Id).ETag
})
.ToList();
Console.WriteLine($"Updating twin state (and setting tags) on all {twins.Count} devices..");
await registryManager.UpdateTwins2Async(twins, cancellationToken);
}