async Task <ICloudProxy> GetCloudProxyWithConnectionStringKey(string connectionStringConfigKey, IEdgeHub edgeHub)
{
const int ConnectionPoolSize = 10;
string deviceConnectionString = await SecretsHelper.GetSecretFromConfigKey(connectionStringConfigKey);
var converters = new MessageConverterProvider(new Dictionary <Type, IMessageConverter>()
{
{ typeof(Client.Message), new DeviceClientMessageConverter() },
{ typeof(Twin), new TwinMessageConverter() },
{ typeof(TwinCollection), new TwinCollectionMessageConverter() }
});
ICloudConnectionProvider cloudConnectionProvider = new CloudConnectionProvider(converters, ConnectionPoolSize, new ClientProvider(), Option.None <UpstreamProtocol>(), Mock.Of <ITokenProvider>(), Mock.Of <IDeviceScopeIdentitiesCache>(), TimeSpan.FromMinutes(60), true);
cloudConnectionProvider.BindEdgeHub(edgeHub);
var deviceIdentity = Mock.Of <IDeviceIdentity>(m => m.Id == ConnectionStringHelper.GetDeviceId(deviceConnectionString));
var clientCredentials = new SharedKeyCredentials(deviceIdentity, deviceConnectionString, string.Empty);
Try <ICloudConnection> cloudConnection = await cloudConnectionProvider.Connect(clientCredentials, (_, __) => { });
Assert.True(cloudConnection.Success);
Assert.True(cloudConnection.Value.IsActive);
Assert.True(cloudConnection.Value.CloudProxy.HasValue);
return(cloudConnection.Value.CloudProxy.OrDefault());
}
public async Task CanListenForDesiredPropertyUpdates()
{
var update = new TaskCompletionSource <IMessage>();
var cloudListener = new Mock <ICloudListener>();
string deviceConnectionStringKey = "device2ConnStrKey";
cloudListener.Setup(x => x.OnDesiredPropertyUpdates(It.IsAny <IMessage>()))
.Callback((IMessage m) => update.TrySetResult(m))
.Returns(TaskEx.Done);
ICloudProxy cloudProxy = await this.GetCloudProxyWithConnectionStringKey(deviceConnectionStringKey);
cloudProxy.BindCloudListener(cloudListener.Object);
await cloudProxy.SetupDesiredPropertyUpdatesAsync();
var desired = new TwinCollection()
{
["desiredPropertyTest"] = Guid.NewGuid().ToString()
};
await UpdateDesiredProperty(ConnectionStringHelper.GetDeviceId(await SecretsHelper.GetSecretFromConfigKey(deviceConnectionStringKey)), desired);
await update.Task;
await cloudProxy.RemoveDesiredPropertyUpdatesAsync();
IMessage expected = new EdgeMessage.Builder(Encoding.UTF8.GetBytes(desired.ToJson())).Build();
expected.SystemProperties[SystemProperties.EnqueuedTime] = "";
expected.SystemProperties[SystemProperties.Version] = desired.Version.ToString();
IMessage actual = update.Task.Result;
Assert.Equal(expected.Body, actual.Body);
Assert.Equal(expected.Properties, actual.Properties);
Assert.Equal(expected.SystemProperties.Keys, actual.SystemProperties.Keys);
}
public bool AuthenticateUser(UserDto user, string repositoryUrl, GeminiContext gemini)
{
//UserWidgetData<List<UserWidgetDataDetails>> userDataRaw = gemini.UserWidgetStore.Get<List<UserWidgetDataDetails>>(user.Entity.Id, Constants.AppId, Constants.ControlId);
var allUserDataRaw = gemini.UserWidgetStore.GetAll().Where(f => f.AppId == Constants.AppId && f.ControlId == Constants.ControlId);
if (allUserDataRaw == null || allUserDataRaw.Count() == 0)
{
return(false);
}
var data = allUserDataRaw.Select(f => f.Value.FromJson <List <UserWidgetDataDetails> >()).First().Find(s => s.Provider == SourceControlProvider.GitHub && s.RepositoryUrl == repositoryUrl);
if (data == null)
{
return(false);
}
if (data.AccessToken.IsEmpty())
{
return(false);
}
Username = data.Username;
Password = SecretsHelper.Decrypt(data.Password, SecretsHelper.EncryptionKey);
AccessToken = data.AccessToken;
return(true);
}
public async Task ConnectWithInvalidConnectionStringTest()
{
var edgeHub = Mock.Of <IEdgeHub>();
ICloudConnectionProvider cloudConnectionProvider = new CloudConnectionProvider(MessageConverterProvider, ConnectionPoolSize, new ClientProvider(), Option.None <UpstreamProtocol>(), TokenProvider, DeviceScopeIdentitiesCache, TimeSpan.FromMinutes(60));
cloudConnectionProvider.BindEdgeHub(edgeHub);
var deviceIdentity1 = Mock.Of <IIdentity>(m => m.Id == "device1");
var clientCredentials1 = new SharedKeyCredentials(deviceIdentity1, "dummyConnStr", null);
Try <ICloudConnection> result = await cloudConnectionProvider.Connect(clientCredentials1, null);
Assert.False(result.Success);
Assert.IsType <AggregateException>(result.Exception);
string deviceConnectionString = await SecretsHelper.GetSecretFromConfigKey("device1ConnStrKey");
// Change the connection string key, deliberately.
char updatedLastChar = (char)(deviceConnectionString[deviceConnectionString.Length - 1] + 1);
deviceConnectionString = deviceConnectionString.Substring(0, deviceConnectionString.Length - 1) + updatedLastChar;
var deviceIdentity2 = Mock.Of <IIdentity>(m => m.Id == ConnectionStringHelper.GetDeviceId(deviceConnectionString));
var clientCredentials2 = new SharedKeyCredentials(deviceIdentity2, deviceConnectionString, null);
Try <ICloudConnection> cloudProxy = cloudConnectionProvider.Connect(clientCredentials2, null).Result;
Assert.False(cloudProxy.Success);
}
static async Task CheckMessageInEventHub(IList <IMessage> sentMessages, DateTime startTime)
{
string eventHubConnectionString = await SecretsHelper.GetSecretFromConfigKey("eventHubConnStrKey");
var eventHubReceiver = new EventHubReceiver(eventHubConnectionString);
var cloudMessages = new List <EventData>();
bool messagesFound = false;
//Add retry mechanism to make sure all the messages sent reached Event Hub. Retry 3 times.
for (int i = 0; i < EventHubMessageReceivedRetry; i++)
{
cloudMessages.AddRange(await eventHubReceiver.GetMessagesFromAllPartitions(startTime));
messagesFound = MessageHelper.CompareMessagesAndEventData(sentMessages, cloudMessages);
if (messagesFound)
{
break;
}
await Task.Delay(TimeSpan.FromSeconds(20));
}
await eventHubReceiver.Close();
Assert.NotNull(cloudMessages);
Assert.NotEmpty(cloudMessages);
Assert.True(messagesFound);
}
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));
}
// [InlineData(TransportType.Mqtt_WebSocket_Only)] // Disabled: need a valid server cert for WebSocket to work
public async void Receive_C2D_SingleMessage_ShouldSucceed(TransportType transportType)
{
// Arrange
string iotHubConnectionString = await SecretsHelper.GetSecretFromConfigKey("iotHubConnStrKey");
RegistryManager rm = RegistryManager.CreateFromConnectionString(iotHubConnectionString);
(string deviceName, string deviceConnectionString) = await RegistryManagerHelper.CreateDevice(DeviceNamePrefix, iotHubConnectionString, rm);
ServiceClient serviceClient = null;
DeviceClient deviceClient = null;
try
{
serviceClient = ServiceClient.CreateFromConnectionString(iotHubConnectionString);
await serviceClient.OpenAsync();
ITransportSettings[] settings = this.GetTransportSettings(transportType);
deviceClient = DeviceClient.CreateFromConnectionString(deviceConnectionString, settings);
// Dummy ReceiveAsync to ensure mqtt subscription registration before SendAsync() is called on service client.
await deviceClient.ReceiveAsync(TimeSpan.FromSeconds(2));
// Act
Message message = this.CreateMessage(out string payload);
await serviceClient.SendAsync(deviceName, message);
// Assert
await this.VerifyReceivedC2DMessage(deviceClient, payload, message.Properties[MessagePropertyName]);
}
finally
{
await this.Cleanup(deviceClient, serviceClient, rm, deviceName);
}
}
private async Task LoadUserData()
{
var userName = await SecretsHelper.GetUserName();
await Task.Delay(1000);
Account account = await Accounts.GetAccount(userName);
UserName = account.Url;
Points = account.Reputation;
GalleryProfile galleryProfile = await Accounts.GetGalleryProfile(userName);
Trophies = new ObservableCollection <Trophy>(galleryProfile.Trophies);
await Task.Delay(500);
await LoadAlbums(userName);
await Task.Delay(500);
await LoadImages(userName);
await Task.Delay(500);
await LoadFavourites(userName);
}
// ReSharper disable once UnusedMember.Local
async Task <int> OnExecuteAsync()
{
try
{
string connectionString = this.DeviceConnectionString ??
await SecretsHelper.GetSecretFromConfigKey("iotHubConnStrKey");
string endpoint = this.EventHubCompatibleEndpointWithEntityPath ??
await SecretsHelper.GetSecretFromConfigKey("eventHubConnStrKey");
var test = new LeafDevice(
connectionString,
endpoint,
this.DeviceId,
this.CertificateFileName,
this.EdgeHostName);
await test.RunAsync();
}
catch (Exception ex)
{
Console.WriteLine(ex);
return(1);
}
Console.WriteLine("Success!");
return(0);
}
public ActionResult Authenticate(string code, int state)
{
GitHub gitHub = new GitHub(); //Creates a new GitHub object
UserWidgetData <List <UserWidgetDataDetails> > userDataRaw = GeminiContext.UserWidgetStore.Get <List <UserWidgetDataDetails> >(CurrentUser.Entity.Id, Constants.AppId, Constants.ControlId);
if (userDataRaw != null)
{
var data = userDataRaw.Value.Find(f => f.Provider == SourceControlProvider.GitHub && f.AccessToken.IsEmpty());
// Need to check that state is the same as we've sent otherwise ABORT (cross-site request forgery attacks) !
if (!code.IsEmpty() && CurrentUser.Entity.Id == state)
{
if (data != null)
{
var password = SecretsHelper.Decrypt(data.Password, SecretsHelper.EncryptionKey);
try
{
var response = gitHub.GetResponse(string.Format("https://github.com/login/oauth/access_token?client_id={0}&client_secret={1}&code={2}&state={3}", data.Username, password, code, state), RestSharp.Method.GET);
if (response != null)
{
var token = response.Content.FromJson <AuthenticateToken>();
if (token.access_token.IsNullOrWhiteSpace())
{
GeminiApp.LogException(new Exception(response.Content.FromJson <Error>().error)
{
Source = "GitHub Authentication"
}, false);
gitHub.DeleteLoginDetails(CurrentUser, data, GeminiContext);
//If request fails we need to make sure we delete the record associated with this authentication request from DB. Otherwise we'll have several records with empty access token
}
else
{
data.AccessToken = token.access_token;
gitHub.SaveLoginDetails(CurrentUser, data, GeminiContext);
}
}
}
catch (Exception ex)
{
GeminiApp.LogException(ex, false);
}
}
}
else
{
GeminiApp.LogException(new UnauthorizedAccessException("Code/State invalid")
{
Source = SourceControlProvider.GitHub.ToString()
}, false);
gitHub.DeleteLoginDetails(CurrentUser, data, GeminiContext);
}
}
return(Redirect(CurrentProject.HomePageUrl));
}
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));
}
private async Task SignOut()
{
State = BUSY;
AuthenticationHelper.SetAuthIntention(false);
await SecretsHelper.FlushSecrets();
State = NOT_AUTHENTICATED;
}
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));
}
public async void Receive_C2D_SingleMessage_AfterOfflineMessage_ShouldSucceed()
{
// Arrange
string iotHubConnectionString = await SecretsHelper.GetSecretFromConfigKey("iotHubConnStrKey");
string edgeDeviceId = ConnectionStringHelper.GetDeviceId(ConfigHelper.TestConfig[Service.Constants.ConfigKey.IotHubConnectionString]);
RegistryManager rm = RegistryManager.CreateFromConnectionString(iotHubConnectionString);
var edgeDevice = await rm.GetDeviceAsync(edgeDeviceId);
(string deviceName, string deviceConnectionString) = await RegistryManagerHelper.CreateDevice(DeviceNamePrefix, iotHubConnectionString, rm, scope : edgeDevice.Scope);
ServiceClient serviceClient = null;
DeviceClient deviceClient = null;
try
{
serviceClient = ServiceClient.CreateFromConnectionString(iotHubConnectionString);
await serviceClient.OpenAsync();
ITransportSettings[] settings = this.GetTransportSettings();
deviceClient = DeviceClient.CreateFromConnectionString(deviceConnectionString, settings);
// Dummy ReceiveAsync to ensure mqtt subscription registration before SendAsync() is called on service client.
await deviceClient.ReceiveAsync(TimeSpan.FromSeconds(1));
var device = await rm.GetDeviceAsync(deviceName);
// Wait for device to be connected to cloud
await this.WaitForDeviceConnectionStateTimeoutAfter(rm, deviceName, DeviceConnectionState.Connected, TimeSpan.FromSeconds(60));
await deviceClient.CloseAsync();
// Wait for the connection to be closed on the Edge side by checking device connection state
await this.WaitForDeviceConnectionStateTimeoutAfter(rm, deviceName, DeviceConnectionState.Disconnected, TimeSpan.FromSeconds(60));
// Act
// Send message before device is listening
Message message = this.CreateMessage(out string payload);
await serviceClient.SendAsync(deviceName, message);
deviceClient = DeviceClient.CreateFromConnectionString(deviceConnectionString, settings);
// Assert
await this.VerifyReceivedC2DMessage(deviceClient, payload, message.Properties[MessagePropertyName]);
// Act
// send new message after offline was received
message = this.CreateMessage(out payload);
await serviceClient.SendAsync(deviceName, message);
// Assert
await this.VerifyReceivedC2DMessage(deviceClient, payload, message.Properties[MessagePropertyName]);
}
finally
{
await this.Cleanup(deviceClient, serviceClient, rm, deviceName);
}
}
private async Task <JObject> ShakeHands()
{
string userName = await SecretsHelper.GetUserName();
const string urlPattern = "account/{0}/images/count";
string url = string.Format(urlPattern, userName);
JObject result = await NetworkHelper.ExecuteRequest(url);
return(result);
}
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));
}
static async Task UpdateDesiredProperty(string deviceId, TwinCollection desired)
{
string connectionString = await SecretsHelper.GetSecretFromConfigKey("iotHubConnStrKey");
RegistryManager registryManager = RegistryManager.CreateFromConnectionString(connectionString);
Twin twin = await registryManager.GetTwinAsync(deviceId);
twin.Properties.Desired = desired;
twin = await registryManager.UpdateTwinAsync(deviceId, twin, twin.ETag);
desired["$version"] = twin.Properties.Desired.Version;
}
async Task <ICloudProxy> GetCloudProxyFromConnectionStringKey(string connectionStringConfigKey, IEdgeHub edgeHub)
{
const int ConnectionPoolSize = 10;
string deviceConnectionString = await SecretsHelper.GetSecretFromConfigKey(connectionStringConfigKey);
string deviceId = ConnectionStringHelper.GetDeviceId(deviceConnectionString);
string iotHubHostName = ConnectionStringHelper.GetHostName(deviceConnectionString);
string sasKey = ConnectionStringHelper.GetSharedAccessKey(deviceConnectionString);
var converters = new MessageConverterProvider(
new Dictionary <Type, IMessageConverter>()
{
{ typeof(Message), new DeviceClientMessageConverter() },
{ typeof(Twin), new TwinMessageConverter() },
{ typeof(TwinCollection), new TwinCollectionMessageConverter() }
});
var credentialsCache = Mock.Of <ICredentialsCache>();
var metadataStore = new Mock <IMetadataStore>();
metadataStore.Setup(m => m.GetMetadata(It.IsAny <string>())).ReturnsAsync(new ConnectionMetadata("dummyValue"));
ICloudConnectionProvider cloudConnectionProvider = new CloudConnectionProvider(
converters,
ConnectionPoolSize,
new ClientProvider(Option.None <string>()),
Option.None <UpstreamProtocol>(),
Mock.Of <Util.ITokenProvider>(),
Mock.Of <IDeviceScopeIdentitiesCache>(),
credentialsCache,
Mock.Of <IIdentity>(i => i.Id == $"{deviceId}/$edgeHub"),
TimeSpan.FromMinutes(60),
true,
TimeSpan.FromSeconds(20),
false,
Option.None <IWebProxy>(),
metadataStore.Object,
true,
true);
cloudConnectionProvider.BindEdgeHub(edgeHub);
var clientTokenProvider = new ClientTokenProvider(new SharedAccessKeySignatureProvider(sasKey), iotHubHostName, deviceId, TimeSpan.FromHours(1));
string token = await clientTokenProvider.GetTokenAsync(Option.None <TimeSpan>());
var deviceIdentity = new DeviceIdentity(iotHubHostName, deviceId);
var clientCredentials = new TokenCredentials(deviceIdentity, token, string.Empty, Option.None <string>(), Option.None <string>(), false);
Try <ICloudConnection> cloudConnection = await cloudConnectionProvider.Connect(clientCredentials, (_, __) => { });
Assert.True(cloudConnection.Success);
Assert.True(cloudConnection.Value.IsActive);
Assert.True(cloudConnection.Value.CloudProxy.HasValue);
return(cloudConnection.Value.CloudProxy.OrDefault());
}
async Task <(string, string)> RegistryArgsFromSecret(string address)
{
// Expects our Key Vault to contain a secret with the following properties:
// key - based on registry hostname (e.g.,
// edgerelease.azurecr.io => edgerelease-azurecr-io)
// value - "<user> <password>" (separated by a space)
string key = address.Replace('.', '-');
string value = await SecretsHelper.GetSecret(key);
string[] vals = value.Split(' ', StringSplitOptions.RemoveEmptyEntries);
return(vals[0], vals[1]);
}
private async Task <string> UpdateFile(string file, string rtfFile)
{
string connectionString = SecretsHelper.GetAzureConnectionString();
string containerName = SecretsHelper.GetAzureContainerName();
string containerURL = SecretsHelper.GetAzureContainerURL();
var container = new BlobContainerClient(connectionString, containerName);
container.CreateIfNotExistsAsync();
var blob = container.GetBlobClient(rtfFile);
await blob.UploadAsync(rtfFile);
return($"{containerURL}/{rtfFile}");
}
//Speech Button
private async void SpeechButton_Click(object sender, RoutedEventArgs e)
{
var speechConfig =
SpeechConfig.FromSubscription(SecretsHelper.GetAzureServiceApiKey(), SecretsHelper.GetAzureRegion());
using (var audioConfig = AudioConfig.FromDefaultMicrophoneInput())
using (var recognizer = new SpeechRecognizer(speechConfig, audioConfig))
{
var result = await recognizer.RecognizeOnceAsync();
contentRichTextBox.Document.Blocks.Add(new Paragraph(new Run(result.Text)));
}
}
public async Task ConnectTest()
{
ICloudConnectionProvider cloudConnectionProvider = new CloudConnectionProvider(MessageConverterProvider, ConnectionPoolSize, new ClientProvider(), Option.None <UpstreamProtocol>());
string deviceConnectionString = await SecretsHelper.GetSecretFromConfigKey("device1ConnStrKey");
var deviceIdentity = Mock.Of <IDeviceIdentity>(m => m.Id == ConnectionStringHelper.GetDeviceId(deviceConnectionString));
var clientCredentials = new SharedKeyCredentials(deviceIdentity, deviceConnectionString, null);
Try <ICloudConnection> cloudProxy = cloudConnectionProvider.Connect(clientCredentials, null).Result;
Assert.True(cloudProxy.Success);
bool result = await cloudProxy.Value.CloseAsync();
Assert.True(result);
}
async Task StartProtocolHead()
{
string certificateValue = await SecretsHelper.GetSecret("IotHubMqttHeadCert");
byte[] cert = Convert.FromBase64String(certificateValue);
var certificate = new X509Certificate2(cert);
// TODO for now this is empty as will suffice for SAS X.509 thumbprint auth but we will need other CA certs for X.509 CA validation
var trustBundle = new List <X509Certificate2>();
string edgeDeviceConnectionString = await SecretsHelper.GetSecretFromConfigKey("edgeCapableDeviceConnStrKey");
// TODO - After IoTHub supports MQTT, remove this and move to using MQTT for upstream connections
await ConnectToIotHub(edgeDeviceConnectionString);
ConfigHelper.TestConfig[EdgeHubConstants.ConfigKey.IotHubConnectionString] = edgeDeviceConnectionString;
IDependencyManager dependencyManager = new DependencyManager(ConfigHelper.TestConfig, certificate, trustBundle, this.sslProtocols);
Hosting hosting = Hosting.Initialize(ConfigHelper.TestConfig, certificate, dependencyManager, true, this.sslProtocols);
this.hosting = hosting;
IContainer container = hosting.Container;
// CloudConnectionProvider and RoutingEdgeHub have a circular dependency. So set the
// EdgeHub on the CloudConnectionProvider before any other operation
ICloudConnectionProvider cloudConnectionProvider = await container.Resolve <Task <ICloudConnectionProvider> >();
IEdgeHub edgeHub = await container.Resolve <Task <IEdgeHub> >();
cloudConnectionProvider.BindEdgeHub(edgeHub);
IConfigSource configSource = await container.Resolve <Task <IConfigSource> >();
ConfigUpdater configUpdater = await container.Resolve <Task <ConfigUpdater> >();
await configUpdater.Init(configSource);
ILogger logger = container.Resolve <ILoggerFactory>().CreateLogger("EdgeHub");
MqttProtocolHead mqttProtocolHead = await container.Resolve <Task <MqttProtocolHead> >();
AmqpProtocolHead amqpProtocolHead = await container.Resolve <Task <AmqpProtocolHead> >();
var httpProtocolHead = new HttpProtocolHead(hosting.WebHost);
this.protocolHead = new EdgeHubProtocolHead(new List <IProtocolHead> {
mqttProtocolHead, amqpProtocolHead, httpProtocolHead
}, logger);
await this.protocolHead.StartAsync();
}
private async Task Save()
{
State = BUSY;
JObject payload = new JObject();
payload["bio"] = Bio;
payload["public_images"] = PublicImages;
payload["messaging_enabled"] = MessagingEnabled;
payload["album_privacy"] = ToAlbumPrivacy(AlbumPrivacyIndex);
payload["show_mature"] = ShowMature;
payload["newsletter_subscribed"] = SubscribeNewsletter;
await Accounts.SaveAccountSettings(await SecretsHelper.GetUserName(), payload);
State = AUTHENTICATED;
}
private async Task <string> UploadFile(string rtfFile, string fileName)
{
string file = string.Empty;
var account = CloudStorageAccount.Parse(SecretsHelper.GetAzureConnectionString());
var client = account.CreateCloudBlobClient();
var container = client.GetContainerReference("notes");
var blob = container.GetBlockBlobReference(fileName);
using (FileStream fileStream = new FileStream(rtfFile, FileMode.Open))
{
await blob.UploadFromStreamAsync(fileStream);
file = blob.Uri.OriginalString;
}
return(file);
}
public override async Task OnStartAsync(StartKind startKind, IActivatedEventArgs args)
{
if (AuthenticationHelper.IsAuthIntended())
{
splash.IsLoading = true;
JObject result = null;
bool isSuccess = false;
string errorMessage = "Could not connect to the internet";
try
{
result = await ShakeHands();
}
catch (AuthException e)
{
if (e.Reason == AuthException.AuthExceptionReason.HttpError)
{
errorMessage = e.Message;
}
else
{
isSuccess = true;
}
}
if (result != null && result.HasValues)
{
isSuccess = (bool)result["success"];
if (!isSuccess)
{
await SecretsHelper.RefreshAccessToken();
result = await ShakeHands();
isSuccess = (bool)result["success"];
errorMessage = JsonConvert.SerializeObject(result["data"], Formatting.Indented);
}
}
if (!isSuccess)
{
ShowError(errorMessage, "Connection Error");
return;
}
}
NavigationService.Navigate(typeof(FrontPage));
}
static async Task CheckMessageInEventHub(Dictionary <string, IList <IMessage> > sentMessagesByDevice, DateTime startTime)
{
string eventHubConnectionString = await SecretsHelper.GetSecretFromConfigKey("eventHubConnStrKey");
var eventHubReceiver = new EventHubReceiver(eventHubConnectionString);
var receivedMessagesByPartition = new Dictionary <string, List <EventData> >();
bool messagesFound = false;
// If this test becomes flaky, use PartitionReceiver as a background Task to continuously retrieve messages.
for (int i = 0; i < EventHubMessageReceivedRetry; i++) // Retry for event hub being slow to process messages.
{
foreach (string deviceId in sentMessagesByDevice.Keys)
{
if (receivedMessagesByPartition.ContainsKey(deviceId))
{
receivedMessagesByPartition[deviceId].AddRange(await eventHubReceiver.GetMessagesForDevice(deviceId, startTime));
}
else
{
receivedMessagesByPartition[deviceId] = await eventHubReceiver.GetMessagesForDevice(deviceId, startTime);
}
}
messagesFound = MessageHelper.ValidateSentMessagesWereReceived(sentMessagesByDevice, receivedMessagesByPartition);
if (messagesFound)
{
break;
}
else
{
logger.LogInformation($"Messages not found in event hub for attempt {i}");
}
await Task.Delay(TimeSpan.FromSeconds(20));
}
foreach (string device in receivedMessagesByPartition.Keys)
{
Assert.NotNull(receivedMessagesByPartition[device]);
Assert.NotEmpty(receivedMessagesByPartition[device]);
}
Assert.True(messagesFound);
}
public bool AuthenticateUser(IssueDto args)
{
UserWidgetData <UserWidgetDataDetails> userDataRaw = GeminiContext.UserWidgetStore.Get <UserWidgetDataDetails>(CurrentUser.Entity.Id, Constants.AppId, Constants.ControlId);
if (userDataRaw == null)
{
return(false);
}
Username = userDataRaw.Value.Username;
Password = SecretsHelper.Decrypt(userDataRaw.Value.Password, SecretsHelper.EncryptionKey);
RepositoryUrl = userDataRaw.Value.RepositoryUrl;
return(true);
}
private async Task LoadSettings()
{
var userName = await SecretsHelper.GetUserName();
Account account = await Accounts.GetAccount(userName);
Bio = account.Bio;
await Task.Delay(100);
AccountSettings settings = await Accounts.GetAccountSettings(userName);
PublicImages = settings.PublicImages;
MessagingEnabled = settings.MessagingEnabled;
AlbumPrivacyIndex = ToIndex(settings.AlbumPrivacy);
ShowMature = settings.ShowMature;
SubscribeNewsletter = settings.NewsletterSubscribed;
IsLoaded = true;
}
public async Task SendMessageMultipleDevicesTest()
{
IList <IMessage> messages = MessageHelper.GenerateMessages(4);
DateTime startTime = DateTime.UtcNow.Subtract(ClockSkew);
string device2ConnectionString = await SecretsHelper.GetSecretFromConfigKey(Device2ConnStrKey);
string device3ConnectionString = await SecretsHelper.GetSecretFromConfigKey(Device3ConnStrKey);
string deviceId2 = IotHubConnectionStringBuilder.Create(device2ConnectionString).DeviceId;
string deviceId3 = IotHubConnectionStringBuilder.Create(device3ConnectionString).DeviceId;
ICloudProxy cloudProxy2 = await this.GetCloudProxyFromConnectionStringKey(Device2ConnStrKey);
ICloudProxy cloudProxy3 = await this.GetCloudProxyFromConnectionStringKey(Device3ConnStrKey);
Dictionary <string, IList <IMessage> > sentMessagesByDevice = new Dictionary <string, IList <IMessage> >();
sentMessagesByDevice.Add(deviceId2, new List <IMessage>());
sentMessagesByDevice.Add(deviceId3, new List <IMessage>());
for (int i = 0; i < messages.Count; i = i + 2)
{
IMessage device2Message = messages[i];
IMessage device3Message = messages[i + 1];
await cloudProxy2.SendMessageAsync(device2Message);
await cloudProxy3.SendMessageAsync(device3Message);
sentMessagesByDevice[deviceId2].Add(device2Message);
sentMessagesByDevice[deviceId3].Add(device3Message);
}
bool disconnectResult = await cloudProxy2.CloseAsync();
Assert.True(disconnectResult);
disconnectResult = await cloudProxy3.CloseAsync();
Assert.True(disconnectResult);
await CheckMessageInEventHub(sentMessagesByDevice, startTime);
}
