public async Task Subscribe()
{
var server = new MqttFactory().CreateMqttServer();
var client = new MqttFactory().CreateMqttClient();
try
{
await server.StartAsync(new MqttServerOptions());
await client.ConnectAsync(new MqttClientOptionsBuilder().WithTcpServer("127.0.0.1").WithProtocolVersion(MqttProtocolVersion.V500).Build());
var result = await client.SubscribeAsync(new MqttClientSubscribeOptions()
{
SubscriptionIdentifier = 1,
TopicFilters = new List <TopicFilter>
{
new TopicFilter {
Topic = "a", QualityOfServiceLevel = MqttQualityOfServiceLevel.AtLeastOnce
}
}
});
await client.DisconnectAsync();
Assert.AreEqual(1, result.Items.Count);
Assert.AreEqual(MqttClientSubscribeResultCode.GrantedQoS1, result.Items[0].ResultCode);
}
finally
{
await server.StopAsync();
}
}
public async Task MqttServer_HandleCleanDisconnect()
{
var serverAdapter = new MqttTcpServerAdapter(new MqttNetLogger().CreateChildLogger());
var s = new MqttFactory().CreateMqttServer(new[] { serverAdapter }, new MqttNetLogger());
var clientConnectedCalled = 0;
var clientDisconnectedCalled = 0;
s.ClientConnected += (_, __) => clientConnectedCalled++;
s.ClientDisconnected += (_, __) => clientDisconnectedCalled++;
var clientOptions = new MqttClientOptionsBuilder()
.WithTcpServer("localhost")
.Build();
await s.StartAsync(new MqttServerOptions());
var c1 = new MqttFactory().CreateMqttClient();
await c1.ConnectAsync(clientOptions);
await Task.Delay(100);
await c1.DisconnectAsync();
await Task.Delay(100);
await s.StopAsync();
await Task.Delay(100);
Assert.AreEqual(clientConnectedCalled, clientDisconnectedCalled);
}
public async Task Publish_With_Properties()
{
var server = new MqttFactory().CreateMqttServer();
var client = new MqttFactory().CreateMqttClient();
try
{
await server.StartAsync(new MqttServerOptions());
var applicationMessage = new MqttApplicationMessageBuilder()
.WithTopic("Hello")
.WithPayload("World")
.WithAtMostOnceQoS()
.WithUserProperty("x", "1")
.WithUserProperty("y", "2")
.WithResponseTopic("response")
.WithContentType("text")
.WithMessageExpiryInterval(50)
.WithCorrelationData(new byte[12])
.WithTopicAlias(2)
.Build();
await client.ConnectAsync(new MqttClientOptionsBuilder().WithTcpServer("127.0.0.1").WithProtocolVersion(MqttProtocolVersion.V500).Build());
var result = await client.PublishAsync(applicationMessage);
await client.DisconnectAsync();
Assert.AreEqual(MqttClientPublishReasonCode.Success, result.ReasonCode);
}
finally
{
await server.StopAsync();
}
}
public async Task Unsubscribe()
{
var server = new MqttFactory().CreateMqttServer();
var client = new MqttFactory().CreateMqttClient();
try
{
await server.StartAsync(new MqttServerOptions());
await client.ConnectAsync(new MqttClientOptionsBuilder().WithTcpServer("127.0.0.1").WithProtocolVersion(MqttProtocolVersion.V500).Build());
await client.SubscribeAsync("a");
var result = await client.UnsubscribeAsync("a");
await client.DisconnectAsync();
Assert.AreEqual(1, result.Items.Count);
Assert.AreEqual(MqttClientUnsubscribeResultCode.Success, result.Items[0].ReasonCode);
}
finally
{
await server.StopAsync();
}
}
public async Task <bool> PublishLockCommand(Guid moduleId, bool isLocked)
{
var dlm = await _repository.GetDLMByGuid(moduleId);
if (dlm == null)
{
return(false);
}
dlm.IsLocked = isLocked;
await _repository.Commit();
var mqttOptions = new MqttClientOptionsBuilder()
.WithClientId("LiveboltServer")
.WithTcpServer("localhost")
.WithCredentials("livebolt", "livebolt")
.Build();
var mqttClient = new MqttFactory().CreateMqttClient();
await mqttClient.ConnectAsync(mqttOptions);
var message = new MqttApplicationMessageBuilder()
.WithTopic($"dlm/lock/{moduleId}")
.WithPayload((isLocked ? 1 : 0).ToString())
.WithExactlyOnceQoS()
.Build();
await mqttClient.PublishAsync(message);
await mqttClient.DisconnectAsync();
return(true);
}
public static PythonDictionary publish_external(PythonDictionary parameters)
{
if (parameters is null)
{
throw new ArgumentNullException(nameof(parameters));
}
var server = Convert.ToString(parameters.get("server"));
var port = Convert.ToInt32(parameters.get("port", 1883));
var username = Convert.ToString(parameters.get("username"));
var password = Convert.ToString(parameters.get("password"));
var clientId = Convert.ToString(parameters.get("client_id", Guid.NewGuid().ToString("N")));
var topic = Convert.ToString(parameters.get("topic"));
var qos = Convert.ToInt32(parameters.get("qos", 0));
var retain = Convert.ToBoolean(parameters.get("retain", false));
var tls = Convert.ToBoolean(parameters.get("tls", false));
var timeout = Convert.ToInt32(parameters.get("timeout", 5000));
var payload = parameters.get("payload", null);
var mqttClient = new MqttFactory().CreateMqttClient();
try
{
var options = new MqttClientOptionsBuilder().WithTcpServer(server, port).WithCredentials(username, password).WithClientId(clientId)
.WithTimeout(TimeSpan.FromMilliseconds(timeout)).WithTls(new MqttClientOptionsBuilderTlsParameters
{
UseTls = tls
}).Build();
mqttClient.ConnectAsync(options).GetAwaiter().GetResult();
var message = new MqttApplicationMessageBuilder().WithTopic(topic).WithPayload(PythonConvert.ToPayload(payload))
.WithQualityOfServiceLevel((MqttQualityOfServiceLevel)qos).WithRetainFlag(retain).Build();
mqttClient.PublishAsync(message).GetAwaiter().GetResult();
return(new PythonDictionary
{
["type"] = "success"
});
}
catch (MqttConnectingFailedException)
{
return(new PythonDictionary
{
["type"] = "exception.connecting_failed"
});
}
catch (Exception exception)
{
return(PythonConvert.ToPythonDictionary(new ExceptionPythonModel(exception).ToDictionary()));
}
finally
{
mqttClient?.DisconnectAsync().GetAwaiter().GetResult();
mqttClient?.Dispose();
}
}
public static void Main()
{
var currentPath = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
Log.Logger = new LoggerConfiguration()
.MinimumLevel.Debug()
// ReSharper disable once AssignNullToNotNullAttribute
.WriteTo.File(Path.Combine(currentPath,
@"log\MqttBridge_.txt"), rollingInterval: RollingInterval.Day)
.WriteTo.Console()
.CreateLogger();
var config = ReadConfiguration(currentPath);
var optionsBuilder = new MqttServerOptionsBuilder()
.WithDefaultEndpoint().WithApplicationMessageInterceptor(
async c =>
{
IMqttClientOptions options;
if (config.UseSsl)
{
options = new MqttClientOptionsBuilder()
.WithClientId(config.BridgeUser.ClientId)
.WithTcpServer(config.BridgeUrl, config.BridgePort)
.WithCredentials(config.BridgeUser.UserName, config.BridgeUser.Password)
.WithTls()
.WithCleanSession()
.Build();
}
else
{
options = new MqttClientOptionsBuilder()
.WithClientId(config.BridgeUser.ClientId)
.WithTcpServer(config.BridgeUrl, config.BridgePort)
.WithCredentials(config.BridgeUser.UserName, config.BridgeUser.Password)
.WithCleanSession()
.Build();
}
var mqttClient = new MqttFactory().CreateMqttClient();
await mqttClient.ConnectAsync(options, CancellationToken.None);
await mqttClient.PublishAsync(c.ApplicationMessage, CancellationToken.None);
await mqttClient.DisconnectAsync(null, CancellationToken.None);
c.AcceptPublish = true;
LogMessage(c);
});
var mqttServer = new MqttFactory().CreateMqttServer();
mqttServer.StartAsync(optionsBuilder.Build());
Console.ReadLine();
}
public async Task MqttServer_SameClientIdConnectDisconnectEventOrder()
{
var s = new MqttFactory().CreateMqttServer();
var events = new List <string>();
s.ClientConnected += (_, __) =>
{
lock (events)
{
events.Add("c");
}
};
s.ClientDisconnected += (_, __) =>
{
lock (events)
{
events.Add("d");
}
};
var clientOptions = new MqttClientOptionsBuilder()
.WithTcpServer("localhost")
.WithClientId("same_id")
.Build();
await s.StartAsync(new MqttServerOptions());
var c1 = new MqttFactory().CreateMqttClient();
var c2 = new MqttFactory().CreateMqttClient();
await c1.ConnectAsync(clientOptions);
await Task.Delay(250);
await c2.ConnectAsync(clientOptions);
await Task.Delay(250);
await c1.DisconnectAsync();
await Task.Delay(250);
await c2.DisconnectAsync();
await Task.Delay(250);
await s.StopAsync();
var flow = string.Join(string.Empty, events);
Assert.AreEqual("cdcd", flow);
}
public async Task MqttServer_LotsOfRetainedMessages()
{
const int ClientCount = 100;
var server = new MqttFactory().CreateMqttServer();
try
{
await server.StartAsync(new MqttServerOptionsBuilder().Build());
Parallel.For(
0,
ClientCount,
new ParallelOptions {
MaxDegreeOfParallelism = 10
},
i =>
{
using (var client = new MqttFactory().CreateMqttClient())
{
client.ConnectAsync(new MqttClientOptionsBuilder().WithTcpServer("localhost").Build())
.GetAwaiter().GetResult();
for (var j = 0; j < 10; j++)
{
// Clear retained message.
client.PublishAsync(new MqttApplicationMessageBuilder().WithTopic("r" + i)
.WithPayload(new byte[0]).WithRetainFlag().Build()).GetAwaiter().GetResult();
// Set retained message.
client.PublishAsync(new MqttApplicationMessageBuilder().WithTopic("r" + i)
.WithPayload("value" + j).WithRetainFlag().Build()).GetAwaiter().GetResult();
}
client.DisconnectAsync().GetAwaiter().GetResult();
}
});
await Task.Delay(100);
var retainedMessages = server.GetRetainedMessages();
Assert.AreEqual(ClientCount, retainedMessages.Count);
for (var i = 0; i < ClientCount; i++)
{
Assert.IsTrue(retainedMessages.Any(m => m.Topic == "r" + i));
}
}
finally
{
await server.StopAsync();
}
}
public async Task PublishAsync(MqttApplicationMessage message)
{
var options = new MqttClientOptionsBuilder()
.WithClientId(_configuration.GetSection("MQTT").GetSection("MqttClientEnactorName").Value)
.WithTcpServer(_configuration.GetSection("MQTT").GetSection("IP").Value, int.Parse(_configuration.GetSection("MQTT").GetSection("Port").Value))
.Build();
var client = new MqttFactory().CreateMqttClient();
await client.ConnectAsync(options);
await client.PublishAsync(message.Topic, Encoding.UTF8.GetString(message.Payload), MqttQualityOfServiceLevel.AtMostOnce);
await client.DisconnectAsync();
}
public async Task MqttServer_SameClientIdConnectDisconnectEventOrder()
{
var serverAdapter = new MqttTcpServerAdapter(new MqttNetLogger().CreateChildLogger());
var s = new MqttFactory().CreateMqttServer(new[] { serverAdapter }, new MqttNetLogger());
var connectedClient = false;
var connecteCalledBeforeConnectedClients = false;
s.ClientConnected += (_, __) =>
{
connecteCalledBeforeConnectedClients |= connectedClient;
connectedClient = true;
};
s.ClientDisconnected += (_, __) =>
{
connectedClient = false;
};
var clientOptions = new MqttClientOptionsBuilder()
.WithTcpServer("localhost")
.WithClientId(Guid.NewGuid().ToString())
.Build();
await s.StartAsync(new MqttServerOptions());
var c1 = new MqttFactory().CreateMqttClient();
var c2 = new MqttFactory().CreateMqttClient();
await c1.ConnectAsync(clientOptions);
await Task.Delay(100);
await c2.ConnectAsync(clientOptions);
await Task.Delay(100);
await c1.DisconnectAsync();
await c2.DisconnectAsync();
await s.StopAsync();
await Task.Delay(100);
Assert.IsFalse(connecteCalledBeforeConnectedClients, "ClientConnected was called before ClientDisconnect was called");
}
public async Task Connect_And_Disconnect()
{
var server = new MqttFactory().CreateMqttServer();
var client = new MqttFactory().CreateMqttClient();
try
{
await server.StartAsync(new MqttServerOptions());
await client.ConnectAsync(new MqttClientOptionsBuilder().WithTcpServer("127.0.0.1").WithProtocolVersion(MqttProtocolVersion.V500).Build());
await client.DisconnectAsync();
}
finally
{
await server.StopAsync();
}
}
static void Main(string[] args)
{
Console.WriteLine("Hello World!");
var options = new MqttClientOptionsBuilder()
.WithTcpServer("localhost", 5002) // Port is optional
.Build();
var client = new MqttFactory().CreateMqttClient();
Console.WriteLine("Ready to Connect");
Console.ReadLine();
Console.WriteLine("Connecting");
var task = client.ConnectAsync(options);
task.ContinueWith(t =>
{
Console.WriteLine("Subscribing");
client.SubscribeAsync("my/amazing/topic");
client.SubscribeAsync("my/+/stuff");
return(true);
})
.ContinueWith(t =>
{
if (t.Result)
{
Task.Delay(10000).Wait();
Console.WriteLine("Sending Data");
client.PublishAsync("my/dance/stuff", "{ \"DanceMove\":\"Break Dancing\" }");
}
});
Console.WriteLine("Hit Enter to Disconnect");
Console.ReadLine();
client.DisconnectAsync().Wait();
Console.WriteLine("Disconnected");
Console.WriteLine("Hit Enter to Shutdown");
Console.ReadLine();
}
public async Task MqttServer_Client_Disconnect_Without_Errors()
{
var errors = 0;
MqttNetGlobalLogger.LogMessagePublished += (_, e) =>
{
System.Diagnostics.Debug.WriteLine($"[{e.TraceMessage.Timestamp:s}] {e.TraceMessage.Source} {e.TraceMessage.Message}");
if (e.TraceMessage.Level == MqttNetLogLevel.Error)
{
errors++;
}
};
bool clientWasConnected;
var server = new MqttFactory().CreateMqttServer();
try
{
var options = new MqttServerOptionsBuilder().Build();
await server.StartAsync(options);
var client = new MqttFactory().CreateMqttClient();
var clientOptions = new MqttClientOptionsBuilder()
.WithTcpServer("localhost")
.Build();
await client.ConnectAsync(clientOptions);
clientWasConnected = true;
await client.DisconnectAsync();
await Task.Delay(500);
}
finally
{
await server.StopAsync();
}
Assert.IsTrue(clientWasConnected);
Assert.AreEqual(0, errors);
}
public async Task MqttServer_ConnectionDenied()
{
var server = new MqttFactory().CreateMqttServer();
var client = new MqttFactory().CreateMqttClient();
try
{
var options = new MqttServerOptionsBuilder().WithConnectionValidator(context =>
{
context.ReturnCode = MqttConnectReturnCode.ConnectionRefusedNotAuthorized;
}).Build();
await server.StartAsync(options);
var clientOptions = new MqttClientOptionsBuilder()
.WithTcpServer("localhost").Build();
try
{
await client.ConnectAsync(clientOptions);
Assert.Fail("An exception should be raised.");
}
catch (Exception exception)
{
if (exception is MqttConnectingFailedException)
{
}
else
{
Assert.Fail("Wrong exception.");
}
}
}
finally
{
await client.DisconnectAsync();
await server.StopAsync();
client.Dispose();
}
}
public async Task Subscribe_And_Publish()
{
var server = new MqttFactory().CreateMqttServer();
var client1 = new MqttFactory().CreateMqttClient();
var client2 = new MqttFactory().CreateMqttClient();
try
{
await server.StartAsync(new MqttServerOptions());
var receivedMessages = new List <MqttApplicationMessageReceivedEventArgs>();
await client1.ConnectAsync(new MqttClientOptionsBuilder().WithTcpServer("127.0.0.1").WithClientId("client1").WithProtocolVersion(MqttProtocolVersion.V500).Build());
client1.ApplicationMessageReceivedHandler = new MqttApplicationMessageReceivedHandlerDelegate(e =>
{
lock (receivedMessages)
{
receivedMessages.Add(e);
}
});
await client1.SubscribeAsync("a");
await client2.ConnectAsync(new MqttClientOptionsBuilder().WithTcpServer("127.0.0.1").WithClientId("client2").WithProtocolVersion(MqttProtocolVersion.V500).Build());
await client2.PublishAsync("a", "b");
await Task.Delay(500);
await client2.DisconnectAsync();
await client1.DisconnectAsync();
Assert.AreEqual(1, receivedMessages.Count);
Assert.AreEqual("client1", receivedMessages[0].ClientId);
Assert.AreEqual("a", receivedMessages[0].ApplicationMessage.Topic);
Assert.AreEqual("b", receivedMessages[0].ApplicationMessage.ConvertPayloadToString());
}
finally
{
await server.StopAsync();
}
}
public async Task Publish_QoS_2()
{
var server = new MqttFactory().CreateMqttServer();
var client = new MqttFactory().CreateMqttClient();
try
{
await server.StartAsync(new MqttServerOptions());
await client.ConnectAsync(new MqttClientOptionsBuilder().WithTcpServer("127.0.0.1").WithProtocolVersion(MqttProtocolVersion.V500).Build());
var result = await client.PublishAsync("a", "b", MqttQualityOfServiceLevel.ExactlyOnce);
await client.DisconnectAsync();
Assert.AreEqual(MqttClientPublishReasonCode.Success, result.ReasonCode);
}
finally
{
await server.StopAsync();
}
}
public async Task PublishRemoveIDMCommand(Guid moduleId)
{
var mqttOptions = new MqttClientOptionsBuilder()
.WithClientId("LiveboltServer")
.WithTcpServer("localhost")
.WithCredentials("livebolt", "livebolt")
.Build();
var mqttClient = new MqttFactory().CreateMqttClient();
await mqttClient.ConnectAsync(mqttOptions);
var message = new MqttApplicationMessageBuilder()
.WithTopic($"idm/remove/{moduleId}")
.WithPayload(1.ToString())
.WithExactlyOnceQoS()
.Build();
await mqttClient.PublishAsync(message);
await mqttClient.DisconnectAsync();
}
public async Task MqttServer_HandleCleanDisconnect()
{
MqttNetGlobalLogger.LogMessagePublished += (_, e) =>
{
System.Diagnostics.Debug.WriteLine($"[{e.TraceMessage.Timestamp:s}] {e.TraceMessage.Source} {e.TraceMessage.Message}");
};
var serverAdapter = new MqttTcpServerAdapter(new MqttNetLogger().CreateChildLogger());
var s = new MqttFactory().CreateMqttServer(new[] { serverAdapter }, new MqttNetLogger());
var clientConnectedCalled = 0;
var clientDisconnectedCalled = 0;
s.ClientConnected += (_, __) => clientConnectedCalled++;
s.ClientDisconnected += (_, __) => clientDisconnectedCalled++;
var clientOptions = new MqttClientOptionsBuilder()
.WithTcpServer("localhost")
.Build();
await s.StartAsync(new MqttServerOptions());
var c1 = new MqttFactory().CreateMqttClient();
await c1.ConnectAsync(clientOptions);
await Task.Delay(100);
await c1.DisconnectAsync();
await Task.Delay(100);
await s.StopAsync();
await Task.Delay(100);
Assert.AreEqual(clientConnectedCalled, clientDisconnectedCalled);
}
static async Task Main(string[] args)
{
// Set up mqttClient
var mqttClient = new MqttFactory().CreateMqttClient();
var options = new MqttClientOptionsBuilder()
.WithClientId(mqttClientId)
.WithWebSocketServer(mqttBrokerAddress)
//.WithTcpServer(mqttBrokerAddress)
.WithCredentials(mqttUser, mqttPassword)
.WithTls()
//.WithCleanSession()
.Build();
mqttClient.UseApplicationMessageReceivedHandler(async e =>
{
var parsedMessage = parseMqttMessage(e.ApplicationMessage.Payload);
await sendDeviceMessage(parsedMessage);
/*Console.WriteLine($"+ Topic = {e.ApplicationMessage.Topic}");
* Console.WriteLine($"+ Payload = {Encoding.UTF8.GetString(e.ApplicationMessage.Payload)}");
* Console.WriteLine($"+ QoS = {e.ApplicationMessage.QualityOfServiceLevel}");
* Console.WriteLine($"+ Retain = {e.ApplicationMessage.Retain}"); */
});
mqttClient.UseConnectedHandler(async e =>
{
Console.WriteLine("Connected to MQTT Server");
// Subscribe to a topic
await mqttClient.SubscribeAsync(new MqttTopicFilterBuilder().WithTopic(mqttTopic).Build());
});
await mqttClient.ConnectAsync(options, CancellationToken.None);
Console.WriteLine("Press any key to close MQTT - HTTP bridge");
Console.ReadKey();
await mqttClient.DisconnectAsync();
}
public static async Task Run(CancellationToken cancelToken)
{
Console.Write("MIC Hostname: ");
var hostname = await ConsoleUtils.ReadLineAsync(cancelToken);
Console.WriteLine("Getting MIC manifest . . .");
using (var micClient = await CreateMicClient(hostname, cancelToken))
{
var micClientConfig = micClient.Config;
micClientConfig.LogMetrics = true;
Console.Write("Username: "******"Password: "******"Logging in . . . ");
var login = await micClient.AuthLogin(
username, password, cancelToken);
((IMicModel)(login.User)).AdditionalData.TryGetValue("domainPath", out object domainPath);
Console.WriteLine("Successful!");
Console.WriteLine();
var awsCredentials = ((IMicClient)micClient).AwsCredentials;
Console.WriteLine($"Cognito Identity pool: {awsCredentials.IdentityPoolId}");
Console.WriteLine($" Identity Id: {login.Credentials.IdentityId}");
Console.WriteLine($" Login provider: {micClient.Manifest.GetCognitoProviderName()}");
Console.WriteLine($" Token: {login.Credentials.Token}");
Console.WriteLine();
var immutableCredentials = await awsCredentials.GetCredentialsAsync();
Console.WriteLine("AWS Immutable Credentials:");
Console.WriteLine($" Access key: {immutableCredentials.AccessKey}");
Console.WriteLine($" Secret key: {immutableCredentials.SecretKey}");
if (immutableCredentials.UseToken)
{
Console.WriteLine($" Token: {immutableCredentials.Token}");
}
Console.WriteLine();
var userInfo = await micClient.UserGet(login.User.Username, cancelToken);
Console.WriteLine(JsonConvert.SerializeObject(userInfo, Formatting.Indented));
Console.WriteLine();
Console.WriteLine($"IoT Endpoint: {micClient.Manifest.IotEndpoint}");
Console.Write("Connecting MQTT Client . . . ");
var iotConfig = micClientConfig.Create <AmazonIoTDeviceGatewayConfig>();
using (var iotClient = new AmazonIoTDeviceGatewayClient(awsCredentials, iotConfig))
{
var mqttOptionsTask = iotClient.CreateMqttWebSocketClientOptionsAsync(micClient.Manifest.IotEndpoint, cancelToken);
using (var mqttClient = new MqttFactory().CreateMqttClient())
{
var mqttConsoleSync = new object();
mqttClient.ApplicationMessageReceived += (sender, e) =>
{
Task.Run(() =>
{
lock (mqttConsoleSync)
{
Console.WriteLine($"Application Message received by client {e.ClientId}");
Console.WriteLine($"Topic: {e.ApplicationMessage.Topic}, QoS: {e.ApplicationMessage.QualityOfServiceLevel}");
if (e.ApplicationMessage.Retain)
{
Console.WriteLine(" Message should be retained");
}
int payloadLength = e.ApplicationMessage.Payload?.Length ?? 0;
Console.WriteLine($" Message Payload: ({payloadLength} byte{(payloadLength == 1 ? "" : "s")})");
Console.WriteLine();
string payload = e.ApplicationMessage.ConvertPayloadToString();
try
{
var jtoken = JToken.Parse(payload);
payload = jtoken.ToString(Formatting.Indented);
}
catch { }
Console.WriteLine(payload);
Console.WriteLine();
Console.WriteLine(new string('-', count: 20));
Console.WriteLine();
}
}, cancelToken);
};
var mqttOptions = await mqttOptionsTask;
var connectInfo = await mqttClient.ConnectAsync(mqttOptions);
try
{
cancelToken.ThrowIfCancellationRequested();
Console.WriteLine("Successful!");
Console.Write($"Subscribing to events . . . ");
var subscriptions = await mqttClient.SubscribeAsync($"event{domainPath}");
cancelToken.ThrowIfCancellationRequested();
var subscriptionsWild = await mqttClient.SubscribeAsync($"event{domainPath}#");
cancelToken.ThrowIfCancellationRequested();
var thingUpdateSubs = await mqttClient.SubscribeAsync($"thing-update{domainPath}#");
cancelToken.ThrowIfCancellationRequested();
int subCount = subscriptions.Count + subscriptionsWild.Count + thingUpdateSubs.Count;
Console.WriteLine($"{subCount} subscription{(subCount == 1 ? "" : "s")}.");
foreach (var sub in subscriptions.Concat(subscriptionsWild).Concat(thingUpdateSubs))
{
var tf = sub.TopicFilter;
Console.WriteLine($"{tf.Topic} (QoS: {tf.QualityOfServiceLevel}): {sub.ReturnCode}");
}
Console.WriteLine();
cancelToken.ThrowIfCancellationRequested();
var resetEvent = new ManualResetEventSlim();
resetEvent.Wait(cancelToken);
}
finally
{
await mqttClient.DisconnectAsync();
}
}
}
}
}
public override async Task SendAsync(PayloadRoot payload, HostChannel channel)
{
if (channel == HostChannel.Undefined || payload.Row.Count == 0)
{
return;
}
string clientId = null, topic = null;
switch (channel)
{
case HostChannel.Status:
clientId = payload.MachineNo + "#" + nameof(HostChannel.Status);
topic = $"/{nameof(HostTransaction.Smmp).ToLower()}/{payload.MachineNo}/{nameof(WorkTasks.Collection).ToLower()}/{nameof(HostChannel.Status).ToLower()}";
break;
case HostChannel.Parameter:
clientId = payload.MachineNo + "#" + nameof(HostChannel.Parameter);
topic = $"/{nameof(HostTransaction.Smmp).ToLower()}/{payload.MachineNo}/{nameof(WorkTasks.Collection).ToLower()}/{nameof(HostChannel.Parameter).ToLower()}";
break;
case HostChannel.Production:
clientId = payload.MachineNo + "#" + nameof(HostChannel.Production);
topic = $"/{nameof(HostTransaction.Smmp).ToLower()}/{payload.MachineNo}/{nameof(WorkTasks.Collection).ToLower()}/{nameof(HostChannel.Production).ToLower()}";
break;
}
payload.Row.ForEach(c =>
{
if (YamlBase.Propertie.Debug)
{
Console.WriteLine($"[{DateTime.Now:MM/dd HH:mm ss}] ModbusTCP => NO.{payload.MachineNo} - {c.AttribNo}:{c.AttribValue}");
}
});
try
{
FoundationProvider box = new();
IConfigurationBuilder builder = new ConfigurationBuilder().SetBasePath(Directory.GetCurrentDirectory()).AddJsonFile("appsettings.json");
IConfigurationRoot config = builder.Build();
IMqttClient client = new MqttFactory().CreateMqttClient();
await client.ConnectAsync(new MqttClientOptionsBuilder()
.WithTcpServer(box.FoundationBasic.Server.Address.Split('/')[2].Split(':')[0], box.FoundationBasic.Server.MqttPort)
.WithCredentials(config.GetValue <string>("Server:Account"), config.GetValue <string>("Server:Password"))
.WithClientId(clientId)
.Build());
await client.PublishAsync(new MqttApplicationMessageBuilder()
.WithTopic(topic)
.WithPayload(JsonConvert.SerializeObject(payload))
.WithExactlyOnceQoS()
.WithRetainFlag()
.Build());
await client.DisconnectAsync();
client.Dispose();
}
catch (Exception e)
{
LogBuilder.WriteLog(LogEventLevel.Error, "MQTT Server => " + e.Message);
}
}
public async Task Loading1000PublishClient()
{
//Create 1000 publish client
var publishServers = 1000;
//send tries
var sendTries = 10;
//Add extra message
var extraMessage = "oiservtionseopteoprvtwetnuioertrptuiweptprovirtuoeriopvtwuipertnoweuioertuvpert" +
"uwpoerutvipetnwueiroprtuipwueotuweioprtuowpetuioueroptuwvoenutwewepvtornutoivweweirvtuepr";
//Run a MQTT Server
var server = new MqttFactory().CreateMqttServer();
await server.StartAsync(new MqttServerOptions());
//Create publish client(s)
var publishers = new List <IMqttClient>();
for (int i = 0; i < publishServers; i++)
{
var publishClient = new MqttFactory().CreateMqttClient();
await publishClient.ConnectAsync(new MqttClientOptionsBuilder().WithTcpServer(ServerAddress).Build());
publishers.Add(publishClient);
}
var receiveIndexes = new List <int>();
//Run a MQTT receive client
var receniveClient = new MqttFactory().CreateMqttClient();
await receniveClient.ConnectAsync(new MqttClientOptionsBuilder().WithTcpServer(ServerAddress).Build());
receniveClient.ApplicationMessageReceived += (object o, MqttApplicationMessageReceivedEventArgs e) =>
{
var receiveMessage = Encoding.UTF8.GetString(e.ApplicationMessage.Payload);
var receiveIndex = int.Parse(receiveMessage.Replace(extraMessage, ""));
receiveIndexes.Add(receiveIndex);
};
//Receive client subscribe a topic
await receniveClient.SubscribeAsync(new TopicFilterBuilder().WithTopic(Topic).WithQualityOfServiceLevel(ConnectQuality).Build());
//Sending message
for (int i = 0; i < sendTries; i++)
{
for (int j = 0; j < publishServers; j++)
{
var index = j + i * publishServers;
//Publish Client send a message
await publishers[j].PublishAsync(new MqttApplicationMessage()
{
Topic = Topic,
QualityOfServiceLevel = ConnectQuality,
Payload = Encoding.UTF8.GetBytes(index.ToString() + extraMessage),
});
}
}
//Wait
await Task.Delay(1000);
//check receive message
for (int i = 0; i < sendTries * publishServers; i++)
{
if (!receiveIndexes.Contains(i))
{
Assert.AreEqual(-1, i);
}
}
Console.WriteLine($"Total receive : {receiveIndexes.Count}");
//Success
Assert.IsTrue(true);
//stop server
await receniveClient.DisconnectAsync();
foreach (var publisher in publishers)
{
await publisher.DisconnectAsync();
}
await server.StopAsync();
}