private async void SettingsUpdated()
{
connectionString = AppSettings.ConnectionString;
deviceId = AppSettings.DeviceId;
if (!string.IsNullOrEmpty(connectionString) && !string.IsNullOrEmpty(deviceId))
{
if (client != null)
{
await client.CloseAsync();
}
if (registryManager != null)
{
await registryManager.CloseAsync();
}
client = ServiceClient.CreateFromConnectionString(connectionString);
registryManager = RegistryManager.CreateFromConnectionString(connectionString);
GetDeviceTwinState();
MessagingCenter.Subscribe <App>(this, "RefreshTimerElapsed", (sender) => GetDeviceTwinState());
}
OnPropertyChanged(nameof(IsRegistered));
((Command)DoorOneCommand).ChangeCanExecute();
((Command)DoorTwoCommand).ChangeCanExecute();
}
async Task Cleanup(DeviceClient deviceClient, ServiceClient serviceClient, RegistryManager rm, string deviceName)
{
if (deviceClient != null)
{
try
{
await deviceClient.CloseAsync();
}
catch
{
// ignore
}
}
if (serviceClient != null)
{
await serviceClient.CloseAsync();
}
// wait for the connection to be closed on the Edge side
await Task.Delay(TimeSpan.FromSeconds(20));
if (rm != null)
{
await RegistryManagerHelper.RemoveDevice(deviceName, rm);
await rm.CloseAsync();
}
}
public async Task BulkOperations_UpdateTwins2Module_Ok()
{
var tagName = Guid.NewGuid().ToString();
var tagValue = Guid.NewGuid().ToString();
TestModule testModule = await TestModule.GetTestModuleAsync(DevicePrefix, ModulePrefix).ConfigureAwait(false);
using (RegistryManager registryManager = RegistryManager.CreateFromConnectionString(Configuration.IoTHub.ConnectionString))
{
Twin twin = await registryManager.GetTwinAsync(testModule.DeviceId, testModule.Id).ConfigureAwait(false);
twin.Tags = new TwinCollection();
twin.Tags[tagName] = tagValue;
var result = await registryManager.UpdateTwins2Async(new List <Twin> {
twin
}, true).ConfigureAwait(false);
Assert.IsTrue(result.IsSuccessful, $"UpdateTwins2Async error:\n{ResultErrorsToString(result)}");
Twin twinUpd = await registryManager.GetTwinAsync(testModule.DeviceId, testModule.Id).ConfigureAwait(false);
Assert.AreEqual(twin.DeviceId, twinUpd.DeviceId, "Device ID changed");
Assert.AreEqual(twin.ModuleId, twinUpd.ModuleId, "Module ID changed");
Assert.IsNotNull(twinUpd.Tags, "Twin.Tags is null");
Assert.IsTrue(twinUpd.Tags.Contains(tagName), "Twin doesn't contain the tag");
Assert.AreEqual((string)twin.Tags[tagName], (string)twinUpd.Tags[tagName], "Tag value changed");
await registryManager.CloseAsync().ConfigureAwait(false);
}
}
public static void UnInitializeEnvironment(RegistryManager rm)
{
Task.Run(async() =>
{
await rm.CloseAsync();
}).Wait();
}
public async Task MultipleSendersSingleReceiverTest(ITransportSettings[] transportSettings)
{
int.TryParse(ConfigHelper.TestConfig["StressTest_MessagesCount_MultipleSenders"], out int messagesCount);
TestModule sender1 = null;
TestModule sender2 = null;
TestModule receiver = null;
string edgeDeviceConnectionString = await SecretsHelper.GetSecretFromConfigKey("edgeCapableDeviceConnStrKey");
IotHubConnectionStringBuilder connectionStringBuilder = IotHubConnectionStringBuilder.Create(edgeDeviceConnectionString);
RegistryManager rm = RegistryManager.CreateFromConnectionString(edgeDeviceConnectionString);
try
{
sender1 = await this.GetModule(rm, connectionStringBuilder.HostName, connectionStringBuilder.DeviceId, "senderA", false, transportSettings);
sender2 = await this.GetModule(rm, connectionStringBuilder.HostName, connectionStringBuilder.DeviceId, "senderB", false, transportSettings);
receiver = await this.GetModule(rm, connectionStringBuilder.HostName, connectionStringBuilder.DeviceId, "receiverA", true, transportSettings);
Task <int> task1 = sender1.SendMessagesByCountAsync("output1", 0, messagesCount, TimeSpan.FromMinutes(8));
Task <int> task2 = sender2.SendMessagesByCountAsync("output1", messagesCount, messagesCount, TimeSpan.FromMinutes(8));
int[] results = await Task.WhenAll(task1, task2);
int sentMessagesCount = results.Sum();
Assert.Equal(messagesCount * 2, sentMessagesCount);
await Task.Delay(TimeSpan.FromSeconds(20));
ISet <int> receivedMessages = receiver.GetReceivedMessageIndices();
Assert.Equal(sentMessagesCount, receivedMessages.Count);
}
finally
{
if (rm != null)
{
await rm.CloseAsync();
}
if (sender1 != null)
{
await sender1.Disconnect();
}
if (sender2 != null)
{
await sender2.Disconnect();
}
if (receiver != null)
{
await receiver.Disconnect();
}
}
// wait for the connection to be closed on the Edge side
await Task.Delay(TimeSpan.FromSeconds(20));
}
private async Task updateDeviceIdsComboBoxes(bool runIfNullOrEmpty = true)
{
if (!String.IsNullOrEmpty(activeIoTHubConnectionString) || runIfNullOrEmpty)
{
List <string> deviceIdsForEvent = new List <string>();
List <string> deviceIdsForC2DMessage = new List <string>();
List <string> deviceIdsForDeviceMethod = new List <string>();
RegistryManager registryManager = RegistryManager.CreateFromConnectionString(activeIoTHubConnectionString);
var devices = await registryManager.GetDevicesAsync(MAX_COUNT_OF_DEVICES);
foreach (var device in devices)
{
deviceIdsForEvent.Add(device.Id);
deviceIdsForC2DMessage.Add(device.Id);
deviceIdsForDeviceMethod.Add(device.Id);
}
await registryManager.CloseAsync();
deviceIDsComboBoxForEvent.DataSource = deviceIdsForEvent.OrderBy(c => c).ToList();
deviceIDsComboBoxForCloudToDeviceMessage.DataSource = deviceIdsForC2DMessage.OrderBy(c => c).ToList();
deviceIDsComboBoxForDeviceMethod.DataSource = deviceIdsForDeviceMethod.OrderBy(c => c).ToList();
deviceIDsComboBoxForEvent.SelectedIndex = deviceSelectedIndexForEvent;
deviceIDsComboBoxForCloudToDeviceMessage.SelectedIndex = deviceSelectedIndexForC2DMessage;
deviceIDsComboBoxForDeviceMethod.SelectedIndex = deviceSelectedIndexForDeviceMethod;
}
}
private static async Task DisconnectFromHub()
{
if (registryManager != null)
{
await registryManager.CloseAsync();
}
}
private async void deleteButton_Click(object sender, EventArgs e)
{
try
{
RegistryManager registryManager = RegistryManager.CreateFromConnectionString(activeIoTHubConnectionString);
string selectedDeviceId = devicesGridView.CurrentRow.Cells[0].Value.ToString();
using (new CenterDialog(this))
{
var dialogResult = MessageBox.Show($"Are you sure you want to delete the following device?\n[{selectedDeviceId}]", "Warning", MessageBoxButtons.YesNo, MessageBoxIcon.Warning);
if (dialogResult == DialogResult.Yes)
{
await registryManager.RemoveDeviceAsync(selectedDeviceId);
using (new CenterDialog(this))
{
MessageBox.Show("Device deleted successfully!", "Info", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
await updateDevicesGridView();
await registryManager.CloseAsync();
}
}
}
catch (Exception ex)
{
using (new CenterDialog(this))
{
MessageBox.Show(ex.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
}
public async Task MultipleSendersMultipleReceivers_Count_Test(ITransportSettings[] transportSettings)
{
// The modules limit is because ProtocolGatewayFixture currently uses a fixed EdgeDevice
// Need to figure out a way to create ProtocolGatewayFixture with configurable EdgeDevice
const int ModulesCount = 2;
int.TryParse(ConfigHelper.TestConfig["StressTest_MessagesCount_MultipleSendersMultipleReceivers"], out int messagesCount);
List <TestModule> senders = null;
List <TestModule> receivers = null;
string edgeDeviceConnectionString = await SecretsHelper.GetSecretFromConfigKey("edgeCapableDeviceConnStrKey");
IotHubConnectionStringBuilder connectionStringBuilder = IotHubConnectionStringBuilder.Create(edgeDeviceConnectionString);
RegistryManager rm = RegistryManager.CreateFromConnectionString(edgeDeviceConnectionString);
try
{
senders = await this.GetModules(rm, connectionStringBuilder.HostName, connectionStringBuilder.DeviceId, "sender", ModulesCount, false, transportSettings);
receivers = await this.GetModules(rm, connectionStringBuilder.HostName, connectionStringBuilder.DeviceId, "receiver", ModulesCount, true, transportSettings);
TimeSpan timeout = TimeSpan.FromMinutes(2);
IEnumerable <Task <int> > tasks = senders.Select(s => s.SendMessagesByCountAsync("output1", 0, messagesCount, timeout));
int[] results = await Task.WhenAll(tasks);
int sentMessagesCount = results.Sum();
Assert.Equal(messagesCount * ModulesCount, sentMessagesCount);
await Task.Delay(TimeSpan.FromSeconds(20));
int receivedMessagesCount = 0;
receivers.ForEach(r => receivedMessagesCount += r.GetReceivedMessageIndices().Count);
Assert.Equal(sentMessagesCount, receivedMessagesCount);
}
finally
{
if (rm != null)
{
await rm.CloseAsync();
}
if (senders != null)
{
await Task.WhenAll(senders.Select(s => s.Disconnect()));
}
if (receivers != null)
{
await Task.WhenAll(receivers.Select(r => r.Disconnect()));
}
await(rm?.CloseAsync() ?? Task.CompletedTask);
}
// wait for the connection to be closed on the Edge side
await Task.Delay(TimeSpan.FromSeconds(20));
}
async Task SendTelemetryMultipleInputsTest(ITransportSettings[] transportSettings)
{
int messagesCount = 30;
TestModule sender = null;
TestModule receiver = null;
string edgeDeviceConnectionString = await SecretsHelper.GetSecretFromConfigKey("edgeCapableDeviceConnStrKey");
IotHubConnectionStringBuilder connectionStringBuilder = IotHubConnectionStringBuilder.Create(edgeDeviceConnectionString);
RegistryManager rm = RegistryManager.CreateFromConnectionString(edgeDeviceConnectionString);
try
{
sender = await TestModule.CreateAndConnect(rm, connectionStringBuilder.HostName, connectionStringBuilder.DeviceId, "sender11", transportSettings);
receiver = await TestModule.CreateAndConnect(rm, connectionStringBuilder.HostName, connectionStringBuilder.DeviceId, "receiver11", transportSettings);
await receiver.SetupReceiveMessageHandler("input1");
await receiver.SetupReceiveMessageHandler("input2");
Task <int> task1 = sender.SendMessagesByCountAsync("output1", 0, messagesCount, TimeSpan.FromMinutes(2), TimeSpan.FromSeconds(2));
Task <int> task2 = sender.SendMessagesByCountAsync("output2", 0, messagesCount, TimeSpan.FromMinutes(2), TimeSpan.FromSeconds(3));
int[] sentMessagesCounts = await Task.WhenAll(task1, task2);
Assert.Equal(messagesCount, sentMessagesCounts[0]);
Assert.Equal(messagesCount, sentMessagesCounts[1]);
await Task.Delay(TimeSpan.FromSeconds(20));
ISet <int> receivedMessages = receiver.GetReceivedMessageIndices("input1");
Assert.Equal(messagesCount, receivedMessages.Count);
receivedMessages = receiver.GetReceivedMessageIndices("input2");
Assert.Equal(messagesCount, receivedMessages.Count);
}
finally
{
if (rm != null)
{
await rm.CloseAsync();
}
if (sender != null)
{
await sender.Disconnect();
}
if (receiver != null)
{
await receiver.Disconnect();
}
}
// wait for the connection to be closed on the Edge side
await Task.Delay(TimeSpan.FromSeconds(10));
}
private async void deleteButton_Click(object sender, EventArgs e)
{
try
{
deleteDeviceButton.Enabled = false;
RegistryManager registryManager = RegistryManager.CreateFromConnectionString(activeIoTHubConnectionString);
List <string> selectedDeviceIds = new List <string>();
foreach (DataGridViewRow item in devicesGridView.SelectedRows)
{
selectedDeviceIds.Add(item.Cells[0].Value.ToString());
}
using (new CenterDialog(this))
{
string deleteMessage;
if (selectedDeviceIds.Count > 40)
{
deleteMessage = $"Are you sure you want to delete the {selectedDeviceIds.Count} devices?";
}
else
{
deleteMessage = $"Are you sure you want to delete the following devices?\n{String.Join(Environment.NewLine, selectedDeviceIds)}";
}
var dialogResult = MessageBox.Show(deleteMessage, "Warning", MessageBoxButtons.YesNo, MessageBoxIcon.Warning);
if (dialogResult == DialogResult.Yes)
{
foreach (string deviceId in selectedDeviceIds)
{
await registryManager.RemoveDeviceAsync(deviceId);
}
using (new CenterDialog(this))
{
MessageBox.Show("Device(s) deleted successfully!", "Info", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
await updateDevicesGridView();
await registryManager.CloseAsync();
}
}
}
catch (Exception ex)
{
using (new CenterDialog(this))
{
MessageBox.Show(ex.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
finally
{
deleteDeviceButton.Enabled = true;
}
}
static void Main(string[] args)
{
MyRegistryManager = RegistryManager.CreateFromConnectionString(ConnectionString);
RegisterDeviceAsync().Wait();
AddTagsAndQuery().Wait();
Console.WriteLine("\nPress Enter to exit!");
Console.ReadLine();
MyRegistryManager.CloseAsync().Wait();
}
private async Task Twin_ServiceDoesNotCreateNullPropertyInCollection(Client.TransportType transport)
{
var propName1 = Guid.NewGuid().ToString();
var propName2 = Guid.NewGuid().ToString();
var propEmptyValue = "{}";
TestDevice testDevice = await TestDevice.GetTestDeviceAsync(DevicePrefix).ConfigureAwait(false);
RegistryManager registryManager = RegistryManager.CreateFromConnectionString(Configuration.IoTHub.ConnectionString);
using (var deviceClient = DeviceClient.CreateFromConnectionString(testDevice.ConnectionString, transport))
{
await deviceClient.UpdateReportedPropertiesAsync(new TwinCollection
{
[propName1] = null
}).ConfigureAwait(false);
var serviceTwin = await registryManager.GetTwinAsync(testDevice.Id).ConfigureAwait(false);
Assert.IsFalse(serviceTwin.Properties.Reported.Contains(propName1));
await deviceClient.UpdateReportedPropertiesAsync(new TwinCollection
{
[propName1] = new TwinCollection
{
[propName2] = null
}
}).ConfigureAwait(false);
serviceTwin = await registryManager.GetTwinAsync(testDevice.Id).ConfigureAwait(false);
Assert.IsTrue(serviceTwin.Properties.Reported.Contains(propName1));
String value1 = serviceTwin.Properties.Reported[propName1].ToString();
Assert.AreEqual(value1, propEmptyValue);
await deviceClient.UpdateReportedPropertiesAsync(new TwinCollection
{
[propName1] = new TwinCollection
{
[propName2] = null
}
}).ConfigureAwait(false);
serviceTwin = await registryManager.GetTwinAsync(testDevice.Id).ConfigureAwait(false);
Assert.IsTrue(serviceTwin.Properties.Reported.Contains(propName1));
String value2 = serviceTwin.Properties.Reported[propName1].ToString();
Assert.AreEqual(value2, propEmptyValue);
await deviceClient.CloseAsync().ConfigureAwait(false);
}
await registryManager.CloseAsync().ConfigureAwait(false);
}
private async Task RegistryManagerUpdateDesiredPropertyAsync(string deviceId, string propName, string propValue)
{
RegistryManager registryManager = RegistryManager.CreateFromConnectionString(Configuration.IoTHub.ConnectionString);
var twinPatch = new Twin();
twinPatch.Properties.Desired[propName] = propValue;
await registryManager.UpdateTwinAsync(deviceId, twinPatch, "*").ConfigureAwait(false);
await registryManager.CloseAsync().ConfigureAwait(false);
}
protected async Task StoreLimitValidationTestAsync()
{
int messagesCount = DefaultMessageCount;
TestModule sender = null;
TestModule receiver = null;
string edgeDeviceConnectionString = await SecretsHelper.GetSecretFromConfigKey("edgeCapableDeviceConnStrKey");
IotHubConnectionStringBuilder connectionStringBuilder = IotHubConnectionStringBuilder.Create(edgeDeviceConnectionString);
RegistryManager rm = RegistryManager.CreateFromConnectionString(edgeDeviceConnectionString);
Guid guid = Guid.NewGuid();
try
{
await Task.Delay(TimeSpan.FromSeconds(10));
sender = await TestModule.CreateAndConnect(rm, connectionStringBuilder.HostName, connectionStringBuilder.DeviceId, "sender1forstorelimits", StoreLimitTestTransportSettings, 0);
// Send messages to ensure that the max storage size limit is reached.
int sentMessagesCount = 0;
await Assert.ThrowsAsync <IotHubThrottledException>(
async() => sentMessagesCount = await sender.SendMessagesByCountAndSizeAsync("output1", 0, messagesCount, MessageSize, TimeSpan.FromSeconds(2), TimeSpan.FromMinutes(2)));
// Wait some more time to allow the delivered messages to be cleaned up due to TTL expiry.
await Task.Delay(TimeSpan.FromSeconds(60));
// Sending a few more messages should now succeed.
messagesCount = 2;
sentMessagesCount = await sender.SendMessagesByCountAndSizeAsync("output1", 0, messagesCount, MessageSize, TimeSpan.FromSeconds(2), TimeSpan.FromMinutes(2));
Assert.Equal(messagesCount, sentMessagesCount);
}
finally
{
if (rm != null)
{
await rm.CloseAsync();
}
if (sender != null)
{
await sender.Disconnect();
}
if (receiver != null)
{
await receiver.Disconnect();
}
}
// wait for the connection to be closed on the Edge side
await Task.Delay(TimeSpan.FromSeconds(10));
}
protected virtual void Dispose(bool disposing)
{
if (!_disposed)
{
if (disposing)
{
if (_deviceManager != null)
{
_deviceManager.CloseAsync().Wait();
}
}
_disposed = true;
}
}
private async void buttonDisconnectFromIoTHub_Click(object sender, RoutedEventArgs e)
{
try{
await registryManager.CloseAsync();
buttonDisconnectFromIoTHub.IsEnabled = false;
buttonConnectToIoTHub.IsEnabled = true;
tbIoTHubStatus.Text = "Disconnected";
registryManager = null;
AddLog("Disconnected from IoT Hub.");
}
catch (Exception ex)
{
AddLog(ex.Message, true);
}
}
public async Task AddDeviceIfNotExistsAsync(string deviceId, IOptions <IoTHubSettings> _iotHubSettings)
{
if (manager == null)
{
CreateManager(_iotHubSettings);
}
try
{
await manager.AddDeviceAsync(new Device(deviceId));
}
catch (Exception e)
{
Debug.WriteLine(e);
}
await manager.CloseAsync();
}
private void updateDeviceButton_Click(object sender, EventArgs e)
{
try
{
string selectedDeviceId = devicesGridView.CurrentRow.Cells[0].Value.ToString();
RegistryManager registryManager = RegistryManager.CreateFromConnectionString(activeIoTHubConnectionString);
DeviceUpdateForm updateForm = new DeviceUpdateForm(registryManager, MAX_COUNT_OF_DEVICES, selectedDeviceId);
updateForm.ShowDialog(this);
updateForm.Dispose();
updateDevicesGridView();
registryManager.CloseAsync();
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
/// <summary>
/// Factory method.
/// IMPORTANT: Not thread safe!
/// </summary>
/// <param name="namePrefix"></param>
/// <param name="type"></param>
/// <returns></returns>
public static async Task <TestDevice> GetTestDeviceAsync(string namePrefix, TestDeviceType type = TestDeviceType.Sasl)
{
string prefix = namePrefix + type + "_";
if (!s_deviceCache.TryGetValue(prefix, out TestDevice testDevice))
{
string deviceName = prefix + Guid.NewGuid();
s_log.WriteLine($"{nameof(GetTestDeviceAsync)}: Device with prefix {prefix} not found. Removing old devices.");
// Delete existing devices named this way and create a new one.
RegistryManager rm = RegistryManager.CreateFromConnectionString(Configuration.IoTHub.ConnectionString);
s_log.WriteLine($"{nameof(GetTestDeviceAsync)}: Creating device {deviceName} with type {type}.");
Client.IAuthenticationMethod auth = null;
Device requestDevice = new Device(deviceName);
if (type == TestDeviceType.X509)
{
requestDevice.Authentication = new AuthenticationMechanism()
{
X509Thumbprint = new X509Thumbprint()
{
PrimaryThumbprint = Configuration.IoTHub.GetCertificateWithPrivateKey().Thumbprint
}
};
auth = new DeviceAuthenticationWithX509Certificate(deviceName, Configuration.IoTHub.GetCertificateWithPrivateKey());
}
Device device = await rm.AddDeviceAsync(requestDevice).ConfigureAwait(false);
s_log.WriteLine($"{nameof(GetTestDeviceAsync)}: Pausing for {DelayAfterDeviceCreationSeconds}s after device was created.");
await Task.Delay(DelayAfterDeviceCreationSeconds * 1000).ConfigureAwait(false);
s_deviceCache[prefix] = new TestDevice(device, auth);
await rm.CloseAsync().ConfigureAwait(false);
}
TestDevice ret = s_deviceCache[prefix];
s_log.WriteLine($"{nameof(GetTestDeviceAsync)}: Using device {ret.Id}.");
return(ret);
}
private async Task Twin_ServiceSetsDesiredPropertyAndDeviceReceivesEvent_WithObseleteCallbackSetter(Client.TransportType transport)
{
var tcs = new TaskCompletionSource <bool>();
var propName = Guid.NewGuid().ToString();
var propValue = Guid.NewGuid().ToString();
TestDevice testDevice = await TestDevice.GetTestDeviceAsync(DevicePrefix).ConfigureAwait(false);
RegistryManager registryManager = RegistryManager.CreateFromConnectionString(Configuration.IoTHub.ConnectionString);
var deviceClient = DeviceClient.CreateFromConnectionString(testDevice.ConnectionString, transport);
#pragma warning disable CS0618
await deviceClient.SetDesiredPropertyUpdateCallback((patch, context) =>
{
return(Task.Run(() =>
{
try
{
Assert.AreEqual(patch[propName].ToString(), propValue);
}
catch (Exception e)
{
tcs.SetException(e);
}
finally
{
tcs.SetResult(true);
}
}));
}, null).ConfigureAwait(false);
#pragma warning restore CS0618
var twinPatch = new Twin();
twinPatch.Properties.Desired[propName] = propValue;
await registryManager.UpdateTwinAsync(testDevice.Id, twinPatch, "*").ConfigureAwait(false);
await tcs.Task.ConfigureAwait(false);
await deviceClient.CloseAsync().ConfigureAwait(false);
await registryManager.CloseAsync().ConfigureAwait(false);
}
private async Task UpdateDevicesGridView()
{
try
{
listDevicesButton.Text = "Refresh";
devicesListed = true;
RegistryManager registryManager = RegistryManager.CreateFromConnectionString(activeIoTHubConnectionString);
var devices = await registryManager.GetDevicesAsync(1000);
updateDevicesGridView();
await registryManager.CloseAsync();
}
catch (Exception ex)
{
listDevicesButton.Text = "List";
devicesListed = false;
MessageBox.Show(String.Format("Unable to retrieve list of devices.\n{0}", ex.Message), "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
async Task <Device> SetupDeviceAsync(string iotHubConnectionString)
{
IotHubConnectionStringBuilder hubConnectionStringBuilder = IotHubConnectionStringBuilder.Create(iotHubConnectionString);
bool deviceNameProvided;
this.deviceId = ConfigurationManager.AppSettings["End2End.DeviceName"];
if (!string.IsNullOrEmpty(this.deviceId))
{
deviceNameProvided = true;
}
else
{
deviceNameProvided = false;
this.deviceId = Guid.NewGuid().ToString("N");
}
RegistryManager registryManager = RegistryManager.CreateFromConnectionString(iotHubConnectionString);
if (!deviceNameProvided)
{
await registryManager.AddDeviceAsync(new Device(this.deviceId));
this.ScheduleCleanup(async() =>
{
await registryManager.RemoveDeviceAsync(this.deviceId);
await registryManager.CloseAsync();
});
}
Device device = await registryManager.GetDeviceAsync(this.deviceId);
this.deviceSas =
new Client.SharedAccessSignatureBuilder
{
Key = device.Authentication.SymmetricKey.PrimaryKey,
Target = $"{hubConnectionStringBuilder.HostName}/devices/{this.deviceId}",
KeyName = null,
TimeToLive = TimeSpan.FromMinutes(20)
}.ToSignature();
return(device);
}
private async void sasTokenButton_Click(object sender, EventArgs e)
{
try
{
RegistryManager registryManager = RegistryManager.CreateFromConnectionString(activeIoTHubConnectionString);
SASTokenForm sasForm = new SASTokenForm(registryManager, MAX_COUNT_OF_DEVICES, iotHubHostName);
sasForm.ShowDialog(this);
sasForm.Dispose();
await updateDevicesGridView();
await registryManager.CloseAsync();
}
catch (Exception ex)
{
using (new CenterDialog(this))
{
MessageBox.Show(ex.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
}
private async Task Twin_ServiceSetsDesiredPropertyAndDeviceReceivesItOnNextGet(Client.TransportType transport)
{
var propName = Guid.NewGuid().ToString();
var propValue = Guid.NewGuid().ToString();
TestDevice testDevice = await TestDevice.GetTestDeviceAsync(DevicePrefix).ConfigureAwait(false);
RegistryManager registryManager = RegistryManager.CreateFromConnectionString(Configuration.IoTHub.ConnectionString);
var twinPatch = new Twin();
twinPatch.Properties.Desired[propName] = propValue;
await registryManager.UpdateTwinAsync(testDevice.Id, twinPatch, "*").ConfigureAwait(false);
var deviceClient = DeviceClient.CreateFromConnectionString(testDevice.ConnectionString, transport);
var deviceTwin = await deviceClient.GetTwinAsync().ConfigureAwait(false);
Assert.AreEqual<string>(deviceTwin.Properties.Desired[propName].ToString(), propValue);
await deviceClient.CloseAsync().ConfigureAwait(false);
await registryManager.CloseAsync().ConfigureAwait(false);
}
async Task RunTestCase(ITransportSettings[] transportSettings, Func <DeviceClient, string, RegistryManager, Task> testCase)
{
string iotHubConnectionString = await SecretsHelper.GetSecretFromConfigKey("iotHubConnStrKey");
RegistryManager rm = RegistryManager.CreateFromConnectionString(iotHubConnectionString);
(DeviceClient deviceClient, string deviceName) = await InitializeDeviceClient(rm, iotHubConnectionString, transportSettings);
try
{
await testCase(deviceClient, deviceName, rm);
}
finally
{
await deviceClient.CloseAsync();
await RegistryManagerHelper.RemoveDevice(deviceName, rm);
await rm.CloseAsync();
}
}
/// <summary>
/// Factory method.
/// IMPORTANT: Not thread safe!
/// </summary>
/// <param name="namePrefix"></param>
/// <param name="type"></param>
/// <returns></returns>
public static async Task <TestModule> GetTestModuleAsync(string deviceNamePrefix, string moduleNamePrefix)
{
var log = TestLogging.GetInstance();
TestDevice testDevice = await TestDevice.GetTestDeviceAsync(deviceNamePrefix).ConfigureAwait(false);
string deviceName = testDevice.Id;
string moduleName = moduleNamePrefix + Guid.NewGuid();
RegistryManager rm = RegistryManager.CreateFromConnectionString(Configuration.IoTHub.ConnectionString);
log.WriteLine($"{nameof(GetTestModuleAsync)}: Creating module for device {deviceName}.");
Module requestModule = new Module(deviceName, moduleName);
Module module = await rm.AddModuleAsync(requestModule).ConfigureAwait(false);
await rm.CloseAsync().ConfigureAwait(false);
TestModule ret = new TestModule(module);
log.WriteLine($"{nameof(GetTestModuleAsync)}: Using device {ret.DeviceId} with module {ret.Id}.");
return(ret);
}
private async Task Twin_ClientHandlesRejectionInvalidPropertyName(Client.TransportType transport)
{
var propName1 = "$" + Guid.NewGuid().ToString();
var propName2 = Guid.NewGuid().ToString();
TestDevice testDevice = await TestDevice.GetTestDeviceAsync(DevicePrefix).ConfigureAwait(false);
RegistryManager registryManager = RegistryManager.CreateFromConnectionString(Configuration.IoTHub.ConnectionString);
using (var deviceClient = DeviceClient.CreateFromConnectionString(testDevice.ConnectionString, transport))
{
var exceptionThrown = false;
try
{
await deviceClient.UpdateReportedPropertiesAsync(new TwinCollection
{
[propName1] = 123,
[propName2] = "abcd"
}).ConfigureAwait(false);
}
catch (Exception)
{
exceptionThrown = true;
}
if (!exceptionThrown)
{
throw new AssertFailedException("Exception was expected, but not thrown.");
}
var serviceTwin = await registryManager.GetTwinAsync(testDevice.Id).ConfigureAwait(false);
Assert.IsFalse(serviceTwin.Properties.Reported.Contains(propName1));
await deviceClient.CloseAsync().ConfigureAwait(false);
}
await registryManager.CloseAsync().ConfigureAwait(false);
}
async Task SendLargeMessageHandleExceptionTest(ITransportSettings[] transportSettings)
{
TestModule sender = null;
string edgeDeviceConnectionString = await SecretsHelper.GetSecretFromConfigKey("edgeCapableDeviceConnStrKey");
IotHubConnectionStringBuilder connectionStringBuilder = IotHubConnectionStringBuilder.Create(edgeDeviceConnectionString);
RegistryManager rm = RegistryManager.CreateFromConnectionString(edgeDeviceConnectionString);
try
{
sender = await TestModule.CreateAndConnect(rm, connectionStringBuilder.HostName, connectionStringBuilder.DeviceId, "sender1", transportSettings);
Exception ex = null;
try
{
// create a large message
var message = new Message(new byte[400 * 1000]);
await sender.SendMessageAsync("output1", message);
}
catch (Exception e)
{
ex = e;
}
Assert.NotNull(ex);
}
finally
{
if (rm != null)
{
await rm.CloseAsync();
}
}
// wait for the connection to be closed on the Edge side
await Task.Delay(TimeSpan.FromSeconds(10));
}
private async void buttonDisconnect_Click(object sender, RoutedEventArgs e)
{
try
{
await registryManager.CloseAsync();
await serviceClient.CloseAsync();
WriteLog("Disconnected.");
buttonConnect.IsEnabled = true;
buttonDisconnect.IsEnabled = false;
buttonDeviceSelect.IsEnabled = false;
buttonAlert.IsEnabled = false;
buttonStop.IsEnabled = false;
buttonDeviceTwin.IsEnabled = false;
registedDeviceNames.Clear();
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
}
}
