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);
}
}
