public void Start()
{
_storageService.TryReadOrCreate(out MqttServiceOptions options, MqttServiceOptions.Filename);
var mqttFactory = new MqttFactory();
_enableMqttLogging = options.EnableLogging;
if (_enableMqttLogging)
{
_mqttServer = mqttFactory.CreateMqttServer(new LoggerAdapter(_logger));
}
else
{
_mqttServer = mqttFactory.CreateMqttServer();
}
_mqttServer.UseApplicationMessageReceivedHandler(new MqttApplicationMessageReceivedHandlerDelegate(e => OnApplicationMessageReceived(e)));
var serverOptions = new MqttServerOptionsBuilder()
.WithDefaultEndpointPort(options.ServerPort)
.WithPersistentSessions();
if (options.PersistRetainedMessages)
{
var storage = new MqttServerStorage(_storageService, _logger);
storage.Start();
serverOptions.WithStorage(storage);
}
_mqttServer.StartAsync(serverOptions.Build()).GetAwaiter().GetResult();
Task.Factory.StartNew(() => ProcessIncomingMqttMessages(_systemCancellationToken.Token), _systemCancellationToken.Token, TaskCreationOptions.LongRunning, TaskScheduler.Default);
}
private async Task StartMqttServer()
{
MqttTcpChannel.CustomCertificateValidationCallback = RemoteValidation;
var logger = new MqttLogger(_logger);
var factory = new MqttFactory();
_mqttServer = factory.CreateMqttServer(new List <IMqttServerAdapter> {
new MqttTcpServerAdapter(logger)
}, logger);
_mqttServer.Started += Started;
_mqttServer.ClientConnected += ClientConnected;
_mqttServer.ClientDisconnected += ClientDisconnected;
await _mqttServer.StartAsync(_options);
// wait for 5 seconds for server to be started
for (var i = 0; i < 100; i++)
{
if (serverStarted)
{
return;
}
await Task.Delay(50);
}
throw new Exception("Mqtt Server did not start?");
}
private async Task StartMqttServer()
{
var logger = new MqttLogger(_logger);
var factory = new MqttFactory();
_mqttServer = factory.CreateMqttServer(new List <IMqttServerAdapter> {
new MqttTcpServerAdapter(logger.CreateChildLogger())
}, logger);
_mqttServer.StartedHandler = this;
_mqttServer.ClientConnectedHandler = this;
_mqttServer.ClientDisconnectedHandler = this;
await _mqttServer.StartAsync(_options);
// wait for 5 seconds for server to be started
for (var i = 0; i < 100; i++)
{
if (serverStarted)
{
_logger.LogDebug($"Waited for {i * 50} milliseconds for server to be started");
return;
}
await Task.Delay(50);
}
throw new Exception("Mqtt Server did not start?");
}
private IMqttServerOptions Initialize(IConfiguration settings)
{
//if (mqttServer != null) throw new Exception($"{name} Duplicate start");
var config = new MQTTConfig();
settings.GetSection("MQTT").Bind(config);
var factory = new MqttFactory();
mqttServer = factory.CreateMqttServer();
return(new MqttServerOptionsBuilder()
.WithConnectionBacklog(100)
.WithConnectionValidator(c => { if (c.Username != config.User)
{
return;
}
if (c.Password != config.Pass)
{
return;
}
c.ReasonCode = MqttConnectReasonCode.Success; })
.WithDefaultEndpointPort(config.Port).Build());
}
public void Setup()
{
TopicGenerator.Generate(NumPublishers, NumTopicsPerPublisher, out var topicsByPublisher, out var singleWildcardTopicsByPublisher, out var multiWildcardTopicsByPublisher);
_topics = topicsByPublisher.Values.First();
var serverOptions = new MqttServerOptionsBuilder().WithDefaultEndpoint().Build();
var factory = new MqttFactory();
_mqttServer = factory.CreateMqttServer(serverOptions);
_mqttClient = factory.CreateMqttClient();
_mqttServer.StartAsync().GetAwaiter().GetResult();
var clientOptions = new MqttClientOptionsBuilder()
.WithTcpServer("localhost").Build();
_mqttClient.ConnectAsync(clientOptions).GetAwaiter().GetResult();
foreach (var topic in _topics)
{
var subscribeOptions = new MqttClientSubscribeOptionsBuilder()
.WithTopicFilter(topic)
.Build();
_mqttClient.SubscribeAsync(subscribeOptions).GetAwaiter().GetResult();
}
}
public async Task RunAsync()
{
if (bool.Parse(_configuration.GetSection("MQTT").GetSection("EnableDebugLogging").Value))
{
var mqttNetLogger = new MqttNetLoggerWrapper(_logger);
_mqttFactory = new MqttFactory(mqttNetLogger);
_logger.LogWarning("Debug logging is enabled. Performance of MQTTnet Server is decreased!");
}
else
{
_mqttFactory = new MqttFactory();
}
var server = _mqttFactory.CreateMqttServer();
var serverOptions = new MqttServerOptionsBuilder()
.WithDefaultEndpointBoundIPAddress(IPAddress.Parse(_configuration.GetSection("MQTT").GetSection("IP").Value))
.WithDefaultEndpointBoundIPV6Address(IPAddress.None)
.WithDefaultEndpointPort(int.Parse(_configuration.GetSection("MQTT").GetSection("Port").Value))
.Build();
server.ApplicationMessageReceivedHandler = _messageReceivedHandler;
server.ClientConnectedHandler = _clientConnectedHandler;
server.ClientDisconnectedHandler = _clientDisconnectedHandler;
await server.StartAsync(serverOptions);
}
/// <summary>
/// 6
/// </summary>
/// <returns></returns>
static async Task ServerAndClientTestRunAsync()
{
MqttNetConsoleLogger.ForwardToConsole();
var factory = new MqttFactory();
var server = factory.CreateMqttServer();
var client = factory.CreateMqttClient();
var serverOptions = new MqttServerOptionsBuilder().Build();
server.ApplicationMessageReceived += Server_ApplicationMessageReceived;
await server.StartAsync(serverOptions);
var clientOptions = new MqttClientOptionsBuilder().WithTcpServer("127.0.0.1").Build();
client.ApplicationMessageReceived += Client_ApplicationMessageReceived;
await client.ConnectAsync(clientOptions);
Task.Run(() =>
{
while (client.IsConnected)
{
client.PublishAsync("test/topic", "hello").GetAwaiter().GetResult();
Thread.Sleep(500);
}
});
client.SubscribeAsync("test/topic");
}
public void Setup()
{
var factory = new MqttFactory();
var tcpServer = new MqttTcpServerAdapter(new MqttNetEventLogger());
tcpServer.ClientHandler += args =>
{
_serverChannel =
(IMqttChannel)args.GetType().GetField("_channel",
System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance)
.GetValue(args);
return(Task.CompletedTask);
};
_mqttServer = factory.CreateMqttServer(new[] { tcpServer }, new MqttNetEventLogger());
var serverOptions = new MqttServerOptionsBuilder().Build();
_mqttServer.StartAsync(serverOptions).GetAwaiter().GetResult();
var clientOptions = new MqttClientOptionsBuilder()
.WithTcpServer("localhost").Build();
var tcpOptions = (MqttClientTcpOptions)clientOptions.ChannelOptions;
_clientChannel = new MqttTcpChannel(new MqttClientOptions {
ChannelOptions = tcpOptions
});
_clientChannel.ConnectAsync(CancellationToken.None).GetAwaiter().GetResult();
}
public async Task InitializeAsync()
{
var factory = new MqttFactory();
MqttServer = factory.CreateMqttServer();
MqttClient1 = factory.CreateMqttClient();
MqttClient2 = factory.CreateMqttClient();
MqttClient1.ApplicationMessageReceivedHandler = new MqttApplicationMessageReceivedHandlerDelegate(args => Client1MessageReceived?.Invoke(this, args));
MqttClient2.ApplicationMessageReceivedHandler = new MqttApplicationMessageReceivedHandlerDelegate(args => Client2MessageReceived?.Invoke(this, args));
var brokerIpAddress = IPAddress.Loopback;
var brokerPort = 1885;
var mqttServerOptions = new MqttServerOptionsBuilder()
.WithClientId("broker")
.WithDefaultEndpointBoundIPAddress(brokerIpAddress)
.WithDefaultEndpointPort(brokerPort)
.Build();
var mqttClient1Options = new MqttClientOptionsBuilder()
.WithClientId("client1")
.WithTcpServer(brokerIpAddress.ToString(), brokerPort)
.Build();
var mqttClient2Options = new MqttClientOptionsBuilder()
.WithClientId("client2")
.WithTcpServer(brokerIpAddress.ToString(), brokerPort)
.Build();
await MqttServer.StartAsync(mqttServerOptions).ConfigureAwait(false);
var connectClient1Result = await MqttClient1.ConnectAsync(mqttClient1Options).ConfigureAwait(false);
var connectClient2Result = await MqttClient2.ConnectAsync(mqttClient2Options).ConfigureAwait(false);
}
public static async Task Run_Minimal_Server()
{
/*
* This sample starts a simple MQTT server which will accept any TCP connection.
*/
var mqttFactory = new MqttFactory();
// The port for the default endpoint is 1883.
// The default endpoint is NOT encrypted!
// Use the builder classes where possible.
var mqttServerOptions = new MqttServerOptionsBuilder().WithDefaultEndpoint().Build();
// The port can be changed using the following API (not used in this example).
// new MqttServerOptionsBuilder()
// .WithDefaultEndpoint()
// .WithDefaultEndpointPort(1234)
// .Build();
using (var mqttServer = mqttFactory.CreateMqttServer(mqttServerOptions))
{
await mqttServer.StartAsync();
Console.WriteLine("Press Enter to exit.");
Console.ReadLine();
// Stop and dispose the MQTT server if it is no longer needed!
await mqttServer.StopAsync();
}
}
public void Create_MqttServer()
{
var factory = new MqttFactory();
var server = factory.CreateMqttServer(new MqttServerOptionsBuilder().Build());
Assert.IsNotNull(server);
}
public void Create_MqttServer()
{
var factory = new MqttFactory();
var server = factory.CreateMqttServer();
Assert.IsNotNull(server);
}
public static async Task Run_Server_With_Logging()
{
/*
* This sample starts a simple MQTT server and prints the logs to the output.
*
* IMPORTANT! Do not enable logging in live environment. It will decrease performance.
*
* See sample "Run_Minimal_Server" for more details.
*/
var mqttFactory = new MqttFactory(new ConsoleLogger());
var mqttServerOptions = new MqttServerOptionsBuilder().WithDefaultEndpoint().Build();
using (var mqttServer = mqttFactory.CreateMqttServer(mqttServerOptions))
{
await mqttServer.StartAsync();
Console.WriteLine("Press Enter to exit.");
Console.ReadLine();
// Stop and dispose the MQTT server if it is no longer needed!
await mqttServer.StopAsync();
}
}
public IMqttServer CreateMqttServer(List <IMqttServerAdapter> adapters)
{
if (adapters == null)
{
throw new ArgumentNullException(nameof(adapters));
}
return(_mqttFactory.CreateMqttServer(adapters));
}
public MqttServer(System.Net.IPAddress iPAddress, int port)
{
server = factory.CreateMqttServer();
options = new MqttServerOptionsBuilder()
.WithDefaultEndpointBoundIPAddress(iPAddress)
.WithDefaultEndpointPort(port)
.WithApplicationMessageInterceptor(OnMessage)
.Build();
}
public void InitialServer()
{
factory = new MqttFactory();
this.Server = factory.CreateMqttServer();
Options = new MqttServerOptionsBuilder()
.WithDefaultEndpointBoundIPAddress(IPAddress.Any)
.WithDefaultEndpointPort(23000)
.WithClientId("Server")
.WithConnectionBacklog(100);
}
static async Task <MqttServer> StartMqttServer()
{
var mqttFactory = new MqttFactory();
// Due to security reasons the "default" endpoint (which is unencrypted) is not enabled by default!
var mqttServerOptions = mqttFactory.CreateServerOptionsBuilder().WithDefaultEndpoint().Build();
var server = mqttFactory.CreateMqttServer(mqttServerOptions);
await server.StartAsync();
return(server);
}
public async Task <IMqttServer> StartServerAsync(MqttServerOptionsBuilder options)
{
if (Server != null)
{
throw new InvalidOperationException("Server already started.");
}
Server = new TestServerWrapper(_mqttFactory.CreateMqttServer(_serverLogger), TestContext, this);
await Server.StartAsync(options.WithDefaultEndpointPort(ServerPort).Build());
return(Server);
}
public void Start()
{
_storageService.TryReadOrCreate(out _options, DefaultDirectoryNames.Configuration, MqttServiceOptions.Filename);
var mqttFactory = new MqttFactory();
IsLowLevelMqttLoggingEnabled = _options.EnableLogging;
if (IsLowLevelMqttLoggingEnabled)
{
_mqttServer = mqttFactory.CreateMqttServer(new LoggerAdapter(_logger));
}
else
{
_mqttServer = mqttFactory.CreateMqttServer();
}
_mqttServer.UseApplicationMessageReceivedHandler(new MqttApplicationMessageReceivedHandlerDelegate(e => OnApplicationMessageReceived(e)));
var serverOptions = new MqttServerOptionsBuilder()
.WithDefaultEndpointPort(_options.ServerPort)
.WithConnectionValidator(ValidateClientConnection)
.WithPersistentSessions();
if (_options.PersistRetainedMessages)
{
var storage = new MqttServerStorage(_storageService, _logger);
storage.Start();
serverOptions.WithStorage(storage);
}
_mqttServer.StartAsync(serverOptions.Build()).GetAwaiter().GetResult();
_workerThread = new Thread(ProcessIncomingMqttMessages)
{
Name = nameof(MqttService),
IsBackground = true
};
_workerThread.Start();
}
public void Start()
{
_storageService.TryReadOrCreate(out MqttServiceOptions options, MqttServiceOptions.Filename);
var mqttFactory = new MqttFactory();
IsLowLevelMqttLoggingEnabled = options.EnableLogging;
if (IsLowLevelMqttLoggingEnabled)
{
_mqttServer = mqttFactory.CreateMqttServer(new LoggerAdapter(_logger));
}
else
{
_mqttServer = mqttFactory.CreateMqttServer();
}
_mqttServer.UseApplicationMessageReceivedHandler(new MqttApplicationMessageReceivedHandlerDelegate(e => OnApplicationMessageReceived(e)));
var serverOptions = new MqttServerOptionsBuilder()
.WithDefaultEndpointPort(options.ServerPort)
.WithPersistentSessions();
if (options.PersistRetainedMessages)
{
var storage = new MqttServerStorage(_storageService, _logger);
storage.Start();
serverOptions.WithStorage(storage);
}
_mqttServer.StartAsync(serverOptions.Build()).GetAwaiter().GetResult();
_workerThread = new Thread(ProcessIncomingMqttMessages)
{
Priority = ThreadPriority.AboveNormal,
IsBackground = true
};
_workerThread.Start();
}
protected override void OnStart()
{
_storageService.SafeReadSerializedValue(out _options, DefaultDirectoryNames.Configuration, MqttServiceOptions.Filename);
IsLowLevelMqttLoggingEnabled = _options.EnableLogging;
var mqttFactory = new MqttFactory();
IMqttNetLogger mqttNetLogger;
if (IsLowLevelMqttLoggingEnabled)
{
mqttNetLogger = new LoggerAdapter(_logger);
}
else
{
mqttNetLogger = new MqttNetLogger();
}
_webSocketServerAdapter = new MqttWebSocketServerAdapter(mqttNetLogger);
var serverAdapters = new List <IMqttServerAdapter>
{
new MqttTcpServerAdapter(mqttNetLogger),
_webSocketServerAdapter
};
_mqttServer = mqttFactory.CreateMqttServer(serverAdapters, mqttNetLogger);
_mqttServer.UseApplicationMessageReceivedHandler(new MqttApplicationMessageReceivedHandlerDelegate(e => OnApplicationMessageReceived(e)));
var serverOptions = new MqttServerOptionsBuilder()
.WithDefaultEndpointPort(_options.ServerPort)
.WithConnectionValidator(ValidateClientConnection)
.WithPersistentSessions();
if (_options.PersistRetainedMessages)
{
var storage = new MqttServerStorage(_storageService, _systemCancellationToken, _logger);
storage.Start();
serverOptions.WithStorage(storage);
}
_mqttServer.StartAsync(serverOptions.Build()).GetAwaiter().GetResult();
_systemCancellationToken.Token.Register(() =>
{
_mqttServer.StopAsync().GetAwaiter().GetResult();
});
ParallelTask.StartLongRunning(ProcessIncomingMqttMessages, _systemCancellationToken.Token, _logger);
}
static async Task Main(string[] args)
{
var serverLogger = new MqttLoggerFactory().Create("Server");
var clientLogger = new MqttLoggerFactory().Create("Client");
IMqttFactory mqttFactory = new MqttFactory();
//STARTING SERVER
var mqttServer = mqttFactory.CreateMqttServer(serverLogger);
await mqttServer.StartAsync(new MqttServerOptionsBuilder().Build());
//STARTING CLIENT
var mqttClient = mqttFactory.CreateMqttClient(clientLogger);
var options = new MqttClientOptionsBuilder()
.WithClientId("Client1")
.WithTcpServer("localhost")
.WithCleanSession(false).Build();
await mqttClient.ConnectAsync(options);
await mqttClient.SubscribeAsync("testtopic/1", MqttQualityOfServiceLevel.AtLeastOnce);
await mqttClient.SubscribeAsync("testtopic/2", MqttQualityOfServiceLevel.AtLeastOnce);
mqttClient.UseApplicationMessageReceivedHandler(async e =>
{
if (e.ApplicationMessage.Topic == "testtopic/1")
{
var messageMqtt2 = new MqttApplicationMessageBuilder()
.WithTopic("testtopic/2")
.WithPayload("Hello2")
.WithQualityOfServiceLevel(MqttQualityOfServiceLevel.AtLeastOnce)
.WithRetainFlag(false)
.Build();
await mqttClient.PublishAsync(messageMqtt2);
}
});
var messageMqtt1 = new MqttApplicationMessageBuilder()
.WithTopic("testtopic/1")
.WithPayload("Hello1")
.WithQualityOfServiceLevel(MqttQualityOfServiceLevel.AtLeastOnce)
.WithRetainFlag(false)
.Build();
await mqttClient.PublishAsync(messageMqtt1);
Console.WriteLine("Finish!");
Console.ReadKey();
}
public static void RunEmptyServerWithLogging()
{
var logger = new MqttNetEventLogger();
MqttNetConsoleLogger.ForwardToConsole(logger);
var mqttFactory = new MqttFactory(logger);
var mqttServer = mqttFactory.CreateMqttServer(new MqttServerOptions());
mqttServer.StartAsync().GetAwaiter().GetResult();
Console.WriteLine("Press any key to exit.");
Console.ReadLine();
}
/// <summary>
/// IotService OnStart
/// </summary>
/// <param name="args"></param>
protected override void OnStart(string[] args)
{
// todo: 引入记录服务的 nlogger file
nlogger.Trace("IotService OnStart..");
try
{
// get local ip address
foreach (IPAddress _ipaddress in Dns.GetHostEntry(Dns.GetHostName()).AddressList)
{
if (_ipaddress.AddressFamily.ToString() == "InterNetwork")
{
nlogger.Debug("get the local ip address: " + _ipaddress.ToString());
mqttServerUrl = _ipaddress;
}
}
if (mqttServer == null)
{
nlogger.Trace("create new mqttServer. IP:" + mqttServerUrl.ToString() + " port:" + mqttPort.ToString());
var factory = new MqttFactory();
mqttServer = factory.CreateMqttServer() as MqttServer;
options = new MqttServerOptionsBuilder()
.WithConnectionBacklog(1000)
.WithDefaultEndpointPort(mqttPort)
.WithDefaultEndpointBoundIPAddress(mqttServerUrl)
.Build();
(options as MqttServerOptions).ConnectionValidator = new MqttServerConnectionValidatorDelegate(new Func <MqttConnectionValidatorContext, Task>(ConnectionValidation));
mqttServer.ClientConnectedHandler = new MqttServerClientConnectedHandlerDelegate(new Func <MqttServerClientConnectedEventArgs, Task>(Connected));
mqttServer.ClientDisconnectedHandler = new MqttServerClientDisconnectedHandlerDelegate(new Func <MqttServerClientDisconnectedEventArgs, Task>(DisConnected));
mqttServer.ApplicationMessageReceivedHandler = new MqttApplicationMessageReceivedHandlerDelegate(new Action <MqttApplicationMessageReceivedEventArgs>(MqttApplicationMessageReceived));
mqttServer.ClientSubscribedTopicHandler = new MqttServerClientSubscribedHandlerDelegate(new Func <MqttServerClientSubscribedTopicEventArgs, Task>(SubscribeTopic));
mqttServer.ClientUnsubscribedTopicHandler = new MqttServerClientUnsubscribedTopicHandlerDelegate(new Func <MqttServerClientUnsubscribedTopicEventArgs, Task>(UnSubscribeTopic));
mqttServer.StartedHandler = new MqttServerStartedHandlerDelegate(new Action <EventArgs>(Started));
mqttServer.StoppedHandler = new MqttServerStoppedHandlerDelegate(new Action <EventArgs>(Stopped));
}
// 启动 Mqtt 服务
mqttServer.StartAsync(options);
}
catch (Exception ex)
{
nlogger.Error("Exception occur in OnStart, stop this IotService.");
this.Stop();
}
}
public async Task Setup()
{
new TopicGenerator().Generate(NumPublishers, NumTopicsPerPublisher, out _topicsByPublisher, out _singleWildcardTopicsByPublisher, out _multiWildcardTopicsByPublisher);
var serverOptions = new MqttServerOptionsBuilder().WithDefaultEndpoint().Build();
var factory = new MqttFactory();
_mqttServer = factory.CreateMqttServer(serverOptions);
await _mqttServer.StartAsync();
Console.WriteLine();
Console.WriteLine("Begin connect " + NumPublishers + " publisher(s)...");
var stopWatch = new System.Diagnostics.Stopwatch();
stopWatch.Start();
_mqttPublisherClientsByPublisherName = new Dictionary <string, IMqttClient>();
foreach (var pt in _topicsByPublisher)
{
var publisherName = pt.Key;
var mqttClient = factory.CreateMqttClient();
var publisherOptions = new MqttClientOptionsBuilder()
.WithTcpServer("localhost")
.WithClientId(publisherName)
.Build();
await mqttClient.ConnectAsync(publisherOptions);
_mqttPublisherClientsByPublisherName.Add(publisherName, mqttClient);
}
stopWatch.Stop();
Console.Write($"{NumPublishers} publisher(s) connected in {stopWatch.ElapsedMilliseconds / 1000.0:0.000} seconds, ");
Console.WriteLine($"connections per second: {NumPublishers / (stopWatch.ElapsedMilliseconds / 1000.0):0.000}");
_mqttSubscriberClients = new List <IMqttClient>();
for (var i = 0; i < NumSubscribers; ++i)
{
var mqttClient = factory.CreateMqttClient();
var subsriberOptions = new MqttClientOptionsBuilder()
.WithTcpServer("localhost")
.WithClientId("sub" + i)
.Build();
await mqttClient.ConnectAsync(subsriberOptions);
mqttClient.ApplicationMessageReceivedAsync += HandleApplicationMessageReceivedAsync;
_mqttSubscriberClients.Add(mqttClient);
}
}
public static async Task RunAsync()
{
MqttNetConsoleLogger.ForwardToConsole();
var factory = new MqttFactory();
var server = factory.CreateMqttServer();
var client = factory.CreateMqttClient();
var serverOptions = new MqttServerOptionsBuilder().Build();
await server.StartAsync(serverOptions);
var clientOptions = new MqttClientOptionsBuilder().WithTcpServer("localhost").Build();
await client.ConnectAsync(clientOptions);
await Task.Delay(Timeout.Infinite);
}
public static async Task Validating_Connections()
{
/*
* This sample starts a simple MQTT server which will check for valid credentials and client ID.
*
* See _Run_Minimal_Server_ for more information.
*/
var mqttFactory = new MqttFactory();
var mqttServerOptions = new MqttServerOptionsBuilder()
.WithDefaultEndpoint()
.Build();
using (var mqttServer = mqttFactory.CreateMqttServer(mqttServerOptions))
{
// Setup connection validation before starting the server so that there is
// no change to connect without valid credentials.
mqttServer.ValidatingConnectionAsync += e =>
{
if (e.ClientId != "ValidClientId")
{
e.ReasonCode = MqttConnectReasonCode.ClientIdentifierNotValid;
}
if (e.Username != "ValidUser")
{
e.ReasonCode = MqttConnectReasonCode.BadUserNameOrPassword;
}
if (e.Password != "SecretPassword")
{
e.ReasonCode = MqttConnectReasonCode.BadUserNameOrPassword;
}
return(Task.CompletedTask);
};
await mqttServer.StartAsync();
Console.WriteLine("Press Enter to exit.");
Console.ReadLine();
await mqttServer.StopAsync();
}
}
public static async Task RunClientAndServer()
{
try
{
var mqttFactory = new MqttFactory();
var mqttServerOptions = new MqttServerOptionsBuilder().WithDefaultEndpoint().Build();
var mqttServer = mqttFactory.CreateMqttServer(mqttServerOptions);
await mqttServer.StartAsync().ConfigureAwait(false);
var options = new MqttClientOptions
{
ChannelOptions = new MqttClientTcpOptions
{
Server = "127.0.0.1"
}
};
var client = mqttFactory.CreateMqttClient();
await client.ConnectAsync(options).ConfigureAwait(false);
var message = new MqttApplicationMessageBuilder().WithTopic("t")
.Build();
var stopwatch = new Stopwatch();
for (var i = 0; i < 10; i++)
{
stopwatch.Restart();
var sentMessagesCount = 0;
while (stopwatch.ElapsedMilliseconds < 1000)
{
await client.PublishAsync(message, CancellationToken.None).ConfigureAwait(false);
sentMessagesCount++;
}
Console.WriteLine($"Sending {sentMessagesCount} messages per second. #" + (i + 1));
}
}
catch (Exception exception)
{
Console.WriteLine(exception);
}
}
public async Task Publish_Special_Content()
{
var factory = new MqttFactory();
var server = factory.CreateMqttServer();
var serverOptions = new MqttServerOptionsBuilder().Build();
var receivedMessages = new List <MqttApplicationMessage>();
var client = factory.CreateMqttClient();
try
{
await server.StartAsync(serverOptions);
client.Connected += async(s, e) =>
{
await client.SubscribeAsync("RCU/P1/H0001/R0003");
var msg = new MqttApplicationMessageBuilder()
.WithPayload("DA|18RS00SC00XI0000RV00R100R200R300R400L100L200L300L400Y100Y200AC0102031800BELK0000BM0000|")
.WithTopic("RCU/P1/H0001/R0003");
await client.PublishAsync(msg.Build());
};
client.ApplicationMessageReceived += (s, e) =>
{
lock (receivedMessages)
{
receivedMessages.Add(e.ApplicationMessage);
}
};
await client.ConnectAsync(new MqttClientOptionsBuilder().WithTcpServer("localhost").Build());
await Task.Delay(500);
Assert.AreEqual(1, receivedMessages.Count);
Assert.AreEqual("DA|18RS00SC00XI0000RV00R100R200R300R400L100L200L300L400Y100Y200AC0102031800BELK0000BM0000|", receivedMessages.First().ConvertPayloadToString());
}
finally
{
await server.StopAsync();
}
}
private async void StartMqttServer()
{
ClientDispatcher = Dispatcher.CurrentDispatcher;
SetStatus("Configuring");
MqttFactory factory = new MqttFactory();
MqttServerOptionsBuilder optionsBuilder = new MqttServerOptionsBuilder()
.WithDefaultCommunicationTimeout(new TimeSpan(0, 0, 0, 60, 0))
.WithDefaultEndpoint()
.WithDefaultEndpointPort(PlainPort)
.WithMaxPendingMessagesPerClient(2000)
;
Server = factory.CreateMqttServer();
Server.ApplicationMessageReceived += Server_ApplicationMessageReceived;
Server.ClientConnected += Server_ClientConnected;
Server.ClientDisconnected += Server_ClientDisconnected;
Server.ClientSubscribedTopic += Server_ClientSubscribedTopic;
Server.ClientUnsubscribedTopic += Server_ClientUnsubscribedTopic;
Server.Started += Server_Started;
#if HAVE_SYNC
if (IsSync)
{
Server.Start(optionsBuilder.Build());
}
else
#endif
await Server.StartAsync(optionsBuilder.Build());
SetStatus("Started");
// This will run the event queue forever, until we stop it
Dispatcher.Run();
#if HAVE_SYNC
if (IsSync)
{
Server.Stop();
}
else
#endif
Server.StopAsync().Wait();
await Dispatcher.BeginInvoke((Action)(() => OnServerThreadStopped()));
}
