public override async void SubscribeToMqttTopics() { Logger.LogTrace(LogCategory.Processor, this.Name, $"Subscribing to topic: {ValueReceiveTopic}"); await ManagedMqttClient.SubscribeAsync(new List <TopicFilter> { new TopicFilterBuilder().WithTopic(ValueReceiveTopic).WithAtLeastOnceQoS().Build() }); }
public async Task Storage_Queue_Drains() { using (var testEnvironment = new TestEnvironment()) { testEnvironment.IgnoreClientLogErrors = true; testEnvironment.IgnoreServerLogErrors = true; var factory = new MqttFactory(); var server = await testEnvironment.StartServerAsync(); var managedClient = new ManagedMqttClient(testEnvironment.CreateClient(), new MqttNetLogger().CreateChildLogger()); var clientOptions = new MqttClientOptionsBuilder() .WithTcpServer("localhost", testEnvironment.ServerPort); var storage = new ManagedMqttClientTestStorage(); TaskCompletionSource <bool> connected = new TaskCompletionSource <bool>(); managedClient.ConnectedHandler = new MqttClientConnectedHandlerDelegate(e => { managedClient.ConnectedHandler = null; connected.SetResult(true); }); await managedClient.StartAsync(new ManagedMqttClientOptionsBuilder() .WithClientOptions(clientOptions) .WithStorage(storage) .WithAutoReconnectDelay(System.TimeSpan.FromSeconds(5)) .Build()); await connected.Task; await testEnvironment.Server.StopAsync(); await managedClient.PublishAsync(new MqttApplicationMessage { Topic = "1" }); //Message should have been added to the storage queue in PublishAsync, //and we are awaiting PublishAsync, so the message should already be //in storage at this point (i.e. no waiting). Assert.AreEqual(1, storage.GetMessageCount()); connected = new TaskCompletionSource <bool>(); managedClient.ConnectedHandler = new MqttClientConnectedHandlerDelegate(e => { managedClient.ConnectedHandler = null; connected.SetResult(true); }); await testEnvironment.Server.StartAsync(new MqttServerOptionsBuilder() .WithDefaultEndpointPort(testEnvironment.ServerPort).Build()); await connected.Task; //Wait 500ms here so the client has time to publish the queued message await Task.Delay(500); Assert.AreEqual(0, storage.GetMessageCount()); await managedClient.StopAsync(); } }
/// <summary> /// Sends the Observations to the MQTT broker /// </summary> /// <param name="sendAdditionalProperties">If true, the 'Writeable' and 'Forceable' properties will be sent in the Observation</param> /// <returns></returns> private async Task <bool> UpdateValues(SubscriptionReader si, ReadResult <SubscriptionResultItem> results, bool sendAdditionalProperties = false) { if (!results.Success) { Prompts.AddRange(results.Prompts); return(false); } var devices = results.DataRead.GroupBy(a => a.ValueItemChangeEvent.Id.Remove(a.ValueItemChangeEvent.Id.LastIndexOf('/')).Remove(0, 2)); foreach (var device in devices) { var observations = new List <Observation>(); var deviceMessage = new IotEdgeMessage { Format = "rec2.3", Observations = observations, DeviceId = device.Key }; AddUpdatedValuesToMessage(observations, device.Key, device.ToList(), si.CachedSubscribedItems, sendAdditionalProperties); var messageBuilder = new MqttApplicationMessageBuilder(); var message = messageBuilder.WithRetainFlag().WithAtLeastOnceQoS().WithTopic(ValuePushTopic).WithPayload(deviceMessage.ToJson()).Build(); Logger.LogTrace(LogCategory.Processor, this.Name, $"Sending Message to MQTT Broker: {deviceMessage.ToJson()}"); await ManagedMqttClient.PublishAsync(message); } return(true); }
public async Task Start_Stop() { using (var testEnvironment = new TestEnvironment()) { var factory = new MqttFactory(); var server = await testEnvironment.StartServerAsync(); var managedClient = new ManagedMqttClient(testEnvironment.CreateClient(), new MqttNetLogger().CreateChildLogger()); var clientOptions = new MqttClientOptionsBuilder() .WithTcpServer("localhost", testEnvironment.ServerPort); TaskCompletionSource <bool> connected = new TaskCompletionSource <bool>(); managedClient.ConnectedHandler = new MqttClientConnectedHandlerDelegate(e => { connected.SetResult(true); }); await managedClient.StartAsync(new ManagedMqttClientOptionsBuilder() .WithClientOptions(clientOptions) .Build()); await connected.Task; await managedClient.StopAsync(); Assert.AreEqual(0, (await server.GetClientStatusAsync()).Count); } }
private async Task ConnectMQTT() { string clientId = Guid.NewGuid().ToString(); string mqttURI = "124.107.183.2"; string mqttUser = "******"; string mqttPassword = "******"; int mqttPort = 1883; bool mqttSecure = false; var messageBuilder = new MqttClientOptionsBuilder() .WithClientId(clientId) .WithCredentials(mqttUser, mqttPassword) .WithTcpServer(mqttURI, mqttPort) .WithCleanSession(); var options = mqttSecure ? messageBuilder .WithTls() .Build() : messageBuilder .Build(); var managedOptions = new ManagedMqttClientOptionsBuilder() .WithAutoReconnectDelay(TimeSpan.FromSeconds(5)) .WithClientOptions(options) .Build(); mqttClient = (ManagedMqttClient) new MqttFactory().CreateManagedMqttClient(); await mqttClient.StartAsync(managedOptions); }
async Task <ManagedMqttClient> CreateManagedClientAsync( TestEnvironment testEnvironment, IMqttClient underlyingClient = null, TimeSpan?connectionCheckInterval = null) { await testEnvironment.StartServerAsync(); var clientOptions = new MqttClientOptionsBuilder() .WithTcpServer("localhost", testEnvironment.ServerPort); var managedOptions = new ManagedMqttClientOptionsBuilder() .WithClientOptions(clientOptions) .Build(); // Use a short connection check interval so that subscription operations are performed quickly // in order to verify against a previous implementation that performed subscriptions only // at connection check intervals managedOptions.ConnectionCheckInterval = connectionCheckInterval ?? TimeSpan.FromSeconds(0.1); var managedClient = new ManagedMqttClient(underlyingClient ?? testEnvironment.CreateClient(), new MqttNetLogger()); var connected = GetConnectedTask(managedClient); await managedClient.StartAsync(managedOptions); await connected; return(managedClient); }
public async Task ManagedClients_Will_Message_Send() { using (var testEnvironment = new TestEnvironment(TestContext)) { var receivedMessagesCount = 0; await testEnvironment.StartServerAsync(); var willMessage = new MqttApplicationMessageBuilder().WithTopic("My/last/will").WithAtMostOnceQoS().Build(); var clientOptions = new MqttClientOptionsBuilder() .WithTcpServer("localhost", testEnvironment.ServerPort) .WithWillMessage(willMessage); var dyingClient = testEnvironment.CreateClient(); var dyingManagedClient = new ManagedMqttClient(dyingClient, testEnvironment.ClientLogger); await dyingManagedClient.StartAsync(new ManagedMqttClientOptionsBuilder() .WithClientOptions(clientOptions) .Build()); var recievingClient = await testEnvironment.ConnectClientAsync(); await recievingClient.SubscribeAsync("My/last/will"); recievingClient.UseApplicationMessageReceivedHandler(context => Interlocked.Increment(ref receivedMessagesCount)); dyingManagedClient.Dispose(); await Task.Delay(1000); Assert.AreEqual(1, receivedMessagesCount); } }
public async Task Start_Stop() { using (var testEnvironment = new TestEnvironment(TestContext)) { var server = await testEnvironment.StartServerAsync(); var managedClient = new ManagedMqttClient(testEnvironment.CreateClient(), new MqttNetLogger()); var clientOptions = new MqttClientOptionsBuilder() .WithTcpServer("localhost", testEnvironment.ServerPort); var connected = GetConnectedTask(managedClient); await managedClient.StartAsync(new ManagedMqttClientOptionsBuilder() .WithClientOptions(clientOptions) .Build()); await connected; await managedClient.StopAsync(); await Task.Delay(500); Assert.AreEqual(0, (await server.GetClientStatusAsync()).Count); } }
protected override IEnumerable <Prompt> Execute_Subclass() { if (Signals == null || !Signals.Any()) { GetSignalNullReason(); return(Prompts); } try { StartMqttClient().Wait(); } catch (Exception ex) { Logger.LogError(LogCategory.Processor, this.Name, $"Starting MQTT Client failed"); Prompts.Add(ex.ToPrompt()); return(Prompts); } _tempSignals = Signals.ToList(); // Read existing subscriptions if (!ReadExistingSubscriptions(_tempSignals).Result) { Prompts.Add(new Prompt { Message = $"Did not successfully read all existing subscriptions." }); } // Subscribe and read new subscriptions if (!SubscribeAndReadNew(_tempSignals).Result) { Prompts.Add(new Prompt { Message = $"Did not successfully read all new subscriptions." }); } Logger.LogTrace(LogCategory.Processor, this.Name, "Waiting for all messages be be published..."); while (ManagedMqttClient.PendingApplicationMessagesCount > 0) { Logger.LogTrace(LogCategory.Processor, this.Name, $"{ManagedMqttClient.PendingApplicationMessagesCount} messages left waiting to be published.."); if (this.IsCancellationRequested) { return(new List <Prompt>()); } Task.Delay(1000).Wait(); } Logger.LogTrace(LogCategory.Processor, this.Name, "Stopping Managed MQTT Client.."); ManagedMqttClient.StopAsync().Wait(); while (ManagedMqttClient.IsStarted) { Logger.LogTrace(LogCategory.Processor, this.Name, "Still waiting for MQTT Client to Stop..."); Task.Delay(1000).Wait(); } // Update the cache with new values.. Signals = _tempSignals; return(Prompts); }
public ManagedMqttContext(IManagedMqttContextOptions options) { Factory = new MqttFactory(); Logger = Factory.DefaultLogger; Serializers = options.MessageSerializers.ToImmutableSortedDictionary(serializer => serializer.ContentType, serializer => serializer); ManagedMqttClient = Factory.CreateManagedMqttClient(); ManagedMqttClient.StartAsync(options.ManagedMqttClientOptions).ConfigureAwait(false).GetAwaiter().GetResult(); }
public void Start(string datastream, string simulationFile, ManagedMqttClient ml) { this.datastream = datastream; //Register datastream simulationDB = simulationFile; mlSend = ml; ThreadStart myThreadStart = new ThreadStart(this.init); workThread = new Thread(myThreadStart); workThread.Start(); }
public EdgeAgent(EdgeAgentOptions options) { Options = options; _mqttClient = new MqttFactory().CreateManagedMqttClient() as ManagedMqttClient; _mqttClient.ApplicationMessageReceived += mqttClient_MessageReceived; _mqttClient.Connected += mqttClient_Connected; _mqttClient.Disconnected += mqttClient_Disconnected; MqttTcpChannel.CustomCertificateValidationCallback = (x509Certificate, x509Chain, sslPolicyErrors, mqttClientTcpOptions) => { return(true); }; }
/// <summary> /// Returns a task that will finish when the <paramref name="managedClient"/> has connected /// </summary> Task GetConnectedTask(ManagedMqttClient managedClient) { TaskCompletionSource <bool> connected = new TaskCompletionSource <bool>(); managedClient.ConnectedHandler = new MqttClientConnectedHandlerDelegate(e => { managedClient.ConnectedHandler = null; connected.SetResult(true); }); return(connected.Task); }
/// <summary> /// Returns a task that will finish when the /// <paramref /// name="managedClient" /> /// has connected /// </summary> Task GetConnectedTask(ManagedMqttClient managedClient) { var connected = new TaskCompletionSource <bool>(); managedClient.ConnectedAsync += e => { connected.TrySetResult(true); return(PlatformAbstractionLayer.CompletedTask); }; return(connected.Task); }
protected override void CleanupBeforeCancellation() { try { ManagedMqttClient.StopAsync().Wait(); ManagedMqttClient.StopAsync().Dispose(); } catch (Exception ex) { Logger.LogError(LogCategory.Processor, this.Name, "Managed MQTT Client failed to stop.."); } }
protected override IEnumerable <Prompt> Execute_Subclass() { StartMqttClient().Wait(); for (;;) { if (IsCancellationRequested) { ManagedMqttClient.StopAsync().Wait(); return(Prompts); } Task.Delay(5000).Wait(); } }
/// <summary> /// Returns a task that will return the messages received on <paramref name="managedClient"/> /// when <paramref name="expectedNumberOfMessages"/> have been received /// </summary> private Task <List <MqttApplicationMessage> > SetupReceivingOfMessages(ManagedMqttClient managedClient, int expectedNumberOfMessages) { var receivedMessages = new List <MqttApplicationMessage>(); var allReceived = new TaskCompletionSource <List <MqttApplicationMessage> >(); managedClient.ApplicationMessageReceivedHandler = new MqttApplicationMessageReceivedHandlerDelegate(r => { receivedMessages.Add(r.ApplicationMessage); if (receivedMessages.Count == expectedNumberOfMessages) { allReceived.SetResult(receivedMessages); } }); return(allReceived.Task); }
/// <summary> /// Returns a task that will return the messages received on <paramref name="managedClient"/> /// when <paramref name="expectedNumberOfMessages"/> have been received /// </summary> Task <List <MqttApplicationMessage> > SetupReceivingOfMessages(ManagedMqttClient managedClient, int expectedNumberOfMessages) { var receivedMessages = new List <MqttApplicationMessage>(); var result = new TaskCompletionSource <List <MqttApplicationMessage> >(TaskCreationOptions.RunContinuationsAsynchronously); managedClient.ApplicationMessageReceivedHandler = new MqttApplicationMessageReceivedHandlerDelegate(r => { receivedMessages.Add(r.ApplicationMessage); if (receivedMessages.Count == expectedNumberOfMessages) { result.TrySetResult(receivedMessages); } }); return(result.Task); }
protected override IEnumerable <Prompt> Execute_Subclass() { try { StartMqttClient().Wait(); } catch (Exception ex) { Logger.LogError(LogCategory.Processor, this.Name, $"Starting MQTT Client failed"); Prompts.Add(ex.ToPrompt()); return(Prompts); } if (Signals == null) { Prompts.Add(new Prompt { Message = "There are no signals in the cache, please run the SetupProcessor or verify that it has run successfully.", Severity = PromptSeverity.MayNotContinue }); return(Prompts); } // Read existing subscriptions if (!ReadExistingSubscriptions(Signals).Result) { Prompts.Add(new Prompt { Message = $"Did not successfully read all existing subscriptions." }); } // Subscribe and read new subscriptions if (!SubscribeAndReadNew(Signals).Result) { Prompts.Add(new Prompt { Message = $"Did not successfully read all new subscriptions." }); } ManagedMqttClient.StopAsync().Wait(); ManagedMqttClient.Dispose(); // Update the cache with new values.. Signals = Signals; return(Prompts); }
/// <summary> /// Returns a task that will return the messages received on /// <paramref /// name="managedClient" /> /// when /// <paramref /// name="expectedNumberOfMessages" /> /// have been received /// </summary> Task <List <MqttApplicationMessage> > SetupReceivingOfMessages(ManagedMqttClient managedClient, int expectedNumberOfMessages) { var receivedMessages = new List <MqttApplicationMessage>(); var result = new AsyncTaskCompletionSource <List <MqttApplicationMessage> >(); managedClient.ApplicationMessageReceivedAsync += e => { receivedMessages.Add(e.ApplicationMessage); if (receivedMessages.Count == expectedNumberOfMessages) { result.TrySetResult(receivedMessages); } return(PlatformAbstractionLayer.CompletedTask); }; return(result.Task); }
public async Task Storage_Queue_Drains() { using (var testEnvironment = CreateTestEnvironment()) { testEnvironment.IgnoreClientLogErrors = true; testEnvironment.IgnoreServerLogErrors = true; await testEnvironment.StartServer(); var managedClient = new ManagedMqttClient(testEnvironment.CreateClient(), new MqttNetEventLogger()); var clientOptions = new MqttClientOptionsBuilder().WithTcpServer("localhost", testEnvironment.ServerPort); var storage = new ManagedMqttClientTestStorage(); var connected = GetConnectedTask(managedClient); await managedClient.StartAsync( new ManagedMqttClientOptionsBuilder().WithClientOptions(clientOptions).WithStorage(storage).WithAutoReconnectDelay(TimeSpan.FromSeconds(5)).Build()); await connected; await testEnvironment.Server.StopAsync(); await managedClient.EnqueueAsync("1"); //Message should have been added to the storage queue in PublishAsync, //and we are awaiting PublishAsync, so the message should already be //in storage at this point (i.e. no waiting). Assert.AreEqual(1, storage.GetMessageCount()); connected = GetConnectedTask(managedClient); await testEnvironment.Server.StartAsync(); await connected; //Wait 500ms here so the client has time to publish the queued message await Task.Delay(500); Assert.AreEqual(0, storage.GetMessageCount()); await managedClient.StopAsync(); } }
public async Task ManagedClients_Will_Message_Send() { using (var testEnvironment = CreateTestEnvironment()) { await testEnvironment.StartServer(); var receivedMessagesCount = 0; var clientOptions = new MqttClientOptionsBuilder().WithTcpServer("127.0.0.1", testEnvironment.ServerPort) .WithWillTopic("My/last/will") .WithWillQualityOfServiceLevel(MqttQualityOfServiceLevel.AtMostOnce) .Build(); var dyingClient = testEnvironment.CreateClient(); var dyingManagedClient = new ManagedMqttClient(dyingClient, testEnvironment.ClientLogger); await dyingManagedClient.StartAsync(new ManagedMqttClientOptionsBuilder().WithClientOptions(clientOptions).Build()); // Wait until the managed client is fully set up and running. await Task.Delay(1000); var receivingClient = await testEnvironment.ConnectClient(); receivingClient.ApplicationMessageReceivedAsync += e => { Interlocked.Increment(ref receivedMessagesCount); return(PlatformAbstractionLayer.CompletedTask); }; await receivingClient.SubscribeAsync("My/last/will"); // Disposing the client will not sent a DISCONNECT packet so that connection is terminated // which will lead to the will publish. dyingManagedClient.Dispose(); // Wait for arrival of the will message at the receiver. await Task.Delay(5000); Assert.AreEqual(1, receivedMessagesCount); } }
/// <summary> /// Sends the Observations to the MQTT broker /// </summary> /// <param name="sendAdditionalProperties">If true, the 'Writeable' and 'Forceable' properties will be sent in the Observation</param> /// <returns></returns> private async Task <bool> UpdateValues(SubscriptionReader si, ReadResult <SubscriptionResultItem> results, bool sendAdditionalProperties = false) { if (!results.Success) { Prompts.AddRange(results.Prompts); return(false); } if (results.DataRead.Any(a => a.ValueItemChangeEvent.State == EwsValueStateEnum.Error)) { CheckAndRetryValuesWithError(si, results); } var signalChanges = results.DataRead.GroupBy(a => a.ValueItemChangeEvent.Id.Remove(a.ValueItemChangeEvent.Id.LastIndexOf('/')).Remove(0, 2)).ToList(); var devices = _tempSignals.GroupBy(a => a.DatabasePath.Remove(a.DatabasePath.LastIndexOf('/'))); foreach (var device in devices) { var observations = new List <Observation>(); var deviceMessage = new IotEdgeMessage { Format = "rec2.3", Observations = observations, DeviceId = device.Key }; var signalChangesForDevice = signalChanges.FirstOrDefault(a => a.Key == device.Key); AddUpdatedValuesToMessage(observations, device.Key, signalChangesForDevice == null || !signalChangesForDevice.ToList().Any() ? new List <SubscriptionResultItem>() : signalChangesForDevice.ToList(), si.CachedSubscribedItems, sendAdditionalProperties); if (deviceMessage.Observations != null && deviceMessage.Observations.Count > 0) { var messageBuilder = new MqttApplicationMessageBuilder(); var managedMessageBuilder = new ManagedMqttApplicationMessageBuilder(); var message = messageBuilder.WithRetainFlag().WithAtLeastOnceQoS().WithTopic(ValuePushTopic).WithPayload(deviceMessage.ToJson()).Build(); Logger.LogTrace(LogCategory.Processor, this.Name, $"Sending Message to MQTT Broker: {deviceMessage.ToJson()}"); await ManagedMqttClient.PublishAsync(managedMessageBuilder.WithApplicationMessage(message).Build()); } } return(true); }
public static async Task <bool> ConnectMQTT() { if (mqttClient != null) { await mqttClient.StopAsync(); } Debug.Write("Connecting to MQTT..."); mqttClient = (ManagedMqttClient) new MqttFactory().CreateManagedMqttClient(); try { var options = new MqttClientOptionsBuilder() .WithClientId(Preferences.Get("deviceName", "")) //client name .WithTcpServer(Preferences.Get("brokerIp", "")) //mqtt server .WithCredentials(Preferences.Get("brokerUsername", ""), Preferences.Get("brokerPassword", "")) //username, password .Build(); var managedOptions = new ManagedMqttClientOptionsBuilder() .WithAutoReconnectDelay(TimeSpan.FromSeconds(5)) .WithClientOptions(options) .Build(); await mqttClient.StartAsync(managedOptions); } catch (Exception e) { Debug.WriteLine("error while connecting: " + e.Message); }; // if (!mqttClient.IsConnected) // { //#if !DEBUG // if (await App.Current.MainPage.DisplayAlert("MQTT connection failed", "do you want to enter settings?", "yes", "no")) // await App.Current.MainPage.Navigation.PushAsync(new SettingsPassword( new SettingsPage()), true); //#endif // Debug.WriteLine("connecting failed"); // return false; // } //Debug.WriteLine("connected"); return(true); }
public EdgeAgent(EdgeAgentOptions options) { Options = options; _mqttClient = new MqttFactory().CreateManagedMqttClient() as ManagedMqttClient; _mqttClient.ApplicationMessageReceived += mqttClient_MessageReceived; _mqttClient.Connected += mqttClient_Connected; _mqttClient.Disconnected += mqttClient_Disconnected; _heartbeatTimer = new Timer(); _heartbeatTimer.Interval = _options.Heartbeat; _heartbeatTimer.Elapsed += _heartbeatTimer_Elapsed; if (options.DataRecover) { _recoverHelper = new DataRecoverHelper(); _dataRecoverTimer = new Timer(); _dataRecoverTimer.Interval = DEAFAULT_DATARECOVER_INTERVAL; _dataRecoverTimer.Elapsed += _dataRecoverTimer_Elapsed; _dataRecoverTimer.Enabled = true; } MqttTcpChannel.CustomCertificateValidationCallback = (x509Certificate, x509Chain, sslPolicyErrors, mqttClientTcpOptions) => { return(true); }; }
public static void Main(string[] args) { // Read settings from env //Read settings: string MQTTServerAddress = Environment.GetEnvironmentVariable("MQTTServerAddress"); if (MQTTServerAddress == null || MQTTServerAddress == "") { System.Console.WriteLine("ERROR:Missing MQTTServerAddress env variable. Process Exit."); } else { settings.MQTTServerAddress = MQTTServerAddress; } string GOST = Environment.GetEnvironmentVariable("GOST"); if (GOST == null || GOST == "") { System.Console.WriteLine("ERROR:Missing GOST env variable. Process Exit."); } else { settings.GOST = GOST; } string DatabasePath = Environment.GetEnvironmentVariable("DatabasePath"); if (DatabasePath == null || DatabasePath == "") { System.Console.WriteLine("ERROR:Missing DatabasePath env variable. Process Exit."); } else { settings.DatabasePath = DatabasePath; } string SettingsFile = Environment.GetEnvironmentVariable("SettingsFile"); if (SettingsFile == null || SettingsFile == "") { System.Console.WriteLine("ERROR:Missing SettingsFile env variable. Process Exit."); } else { settings.SettingsFile = SettingsFile; } List <DatastreamControl> dsc = new List <DatastreamControl>(); ManagedMqttClient mlSend = (ManagedMqttClient) new MqttFactory().CreateManagedMqttClient(); // Setup and start a managed MQTT client. var optionsSend = new ManagedMqttClientOptionsBuilder() .WithAutoReconnectDelay(TimeSpan.FromSeconds(5)) .WithClientOptions(new MqttClientOptionsBuilder() .WithClientId(System.Guid.NewGuid().ToString()) .WithKeepAlivePeriod(TimeSpan.FromSeconds(120)) .WithCommunicationTimeout(TimeSpan.FromSeconds(60)) .WithTcpServer(settings.MQTTServerAddress) .Build()) .Build(); mlSend.StartAsync(optionsSend).Wait(); using (StreamReader r = new StreamReader(settings.SettingsFile)) { string json = r.ReadToEnd(); dynamic simulations = JsonConvert.DeserializeObject(json); foreach (var item in simulations.simulation) { string datastreamID = "99999999999"; OGCServiceCatalogue.ManageDataStreams mds = new OGCServiceCatalogue.ManageDataStreams(); if (mds.FindOrCreateOGCDatastream(item.thing, item.sensor, item.observedProperties, item.datastream, ref datastreamID)) { DatastreamControl sim = new DatastreamControl(); sim.Start(datastreamID, settings.DatabasePath + item.simulationFile, mlSend); dsc.Add(sim); } Console.WriteLine("{0} {1}", item.temp, item.vcc); } } CreateWebHostBuilder(args).Build().Run(); System.Console.ReadLine(); foreach (DatastreamControl sim in dsc) { sim.stopped = true; } }
public async Task Subscriptions_Are_Cleared_At_Logout() { using (var testEnvironment = new TestEnvironment(TestContext)) { await testEnvironment.StartServerAsync().ConfigureAwait(false); var sendingClient = await testEnvironment.ConnectClientAsync().ConfigureAwait(false); await sendingClient.PublishAsync(new MqttApplicationMessage { Topic = "topic", Payload = new byte[] { 1 }, Retain = true }); // Wait a bit for the retained message to be available await Task.Delay(500); await sendingClient.DisconnectAsync(); // Now use the managed client and check if subscriptions get cleared properly. var clientOptions = new MqttClientOptionsBuilder() .WithTcpServer("localhost", testEnvironment.ServerPort); var receivedManagedMessages = new List <MqttApplicationMessage>(); var managedClient = new ManagedMqttClient(testEnvironment.CreateClient(), new MqttNetLogger()); managedClient.ApplicationMessageReceivedHandler = new MqttApplicationMessageReceivedHandlerDelegate(c => { receivedManagedMessages.Add(c.ApplicationMessage); }); await managedClient.SubscribeAsync("topic"); await managedClient.StartAsync(new ManagedMqttClientOptionsBuilder() .WithClientOptions(clientOptions) .WithAutoReconnectDelay(TimeSpan.FromSeconds(1)) .Build()); await Task.Delay(500); Assert.AreEqual(1, receivedManagedMessages.Count); await managedClient.StopAsync(); await Task.Delay(500); await managedClient.StartAsync(new ManagedMqttClientOptionsBuilder() .WithClientOptions(clientOptions) .WithAutoReconnectDelay(TimeSpan.FromSeconds(1)) .Build()); await Task.Delay(1000); // After reconnect and then some delay, the retained message must not be received, // showing that the subscriptions were cleared Assert.AreEqual(1, receivedManagedMessages.Count); // Make sure that it gets received after subscribing again. await managedClient.SubscribeAsync("topic"); await Task.Delay(500); Assert.AreEqual(2, receivedManagedMessages.Count); } }