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, Client.MqttClient>();
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(string.Format("{0} publisher(s) connected in {1:0.000} seconds, ", NumPublishers, stopWatch.ElapsedMilliseconds / 1000.0));
Console.WriteLine(string.Format("connections per second: {0:0.000}", NumPublishers / (stopWatch.ElapsedMilliseconds / 1000.0)));
_mqttSubscriberClients = new List <Client.MqttClient>();
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 async void startServer()
{
var optionsBuilder = new MqttServerOptionsBuilder()
.WithConnectionBacklog(100)
.WithDefaultEndpointPort(1883)
.WithDefaultEndpointBoundIPAddress(IPAddress.Parse("172.22.111.55"))
;
mqttServer = new MqttFactory().CreateMqttServer();
await mqttServer.StartAsync(optionsBuilder.Build());
mqttServer.ClientConnected += (s, e) =>
{
Console.WriteLine(e.ClientId);
};
}
public async Task MqttServerOnOtherPortReceivesMessage()
{
var options = new MqttServerOptionsBuilder()
.WithDefaultEndpointPort(1337)
.Build();
using (var mqttServer = await MqttServerHelper.Get(_logger, options))
using (var jobHost = await JobHostHelper <SimpleMessageAnotherPortTestFunction> .RunFor(_testLoggerProvider))
{
await mqttServer.PublishAsync(DefaultMessage);
await WaitFor(() => SimpleMessageAnotherPortTestFunction.CallCount >= 1);
}
Assert.Equal(1, SimpleMessageAnotherPortTestFunction.CallCount);
}
static async void InitMqtt()
{
// Start a MQTT server.
Console.WriteLine("Starting MQTT Server at: localhost:1883");
// Configure MQTT server.
var optionsBuilder = new MqttServerOptionsBuilder()
.WithConnectionBacklog(100)
.WithDefaultEndpointPort(1883);
var mqttServer = new MqttFactory().CreateMqttServer();
await mqttServer.StartAsync(optionsBuilder.Build());
Console.WriteLine("Press any key to exit.");
Console.ReadLine();
await mqttServer.StopAsync();
}
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 void Init()
{
Server = new MqttFactory().CreateMqttServer();
IMqttServerOptions SrvOpt = new MqttServerOptionsBuilder().WithDefaultEndpointPort(1883).Build();
Server.StartAsync(SrvOpt);
Client = new MqttFactory().CreateMqttClient();
Client.UseApplicationMessageReceivedHandler(OnMessageReceived);
Client.UseConnectedHandler(OnConnected);
IMqttClientOptions CliOpt = new MqttClientOptionsBuilder().WithClientId("SquidHome").WithTcpServer("127.0.0.1", 1883).WithCleanSession().Build();
Client.ConnectAsync(CliOpt, CancellationToken.None);
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
var mqttServerOptions = new MqttServerOptionsBuilder()
.WithoutDefaultEndpoint()
.WithConnectionValidator(new Authenticators.HubAuthenticatorService(Configuration).Validate)
.WithApplicationMessageInterceptor(c => { })
.Build();
services
.AddHostedMqttServer(mqttServerOptions)
.AddMqttConnectionHandler()
.AddConnections();
services.AddDbContext <HubDbContext>(options => options.UseSqlServer(
Configuration.GetConnectionString("HubDatabase")));
}
public async Task TriggerAndOutputReuseConnection()
{
var mqttApplicationMessages = new List <MqttApplicationMessage>();
var counnections = 0;
var options = new MqttServerOptionsBuilder()
.WithConnectionValidator(x =>
{
counnections += (x.ClientId != "IntegrationTest") ? 1 : 0;
})
.Build();
using (var mqttServer = await MqttServerHelper.Get(_logger, options))
using (var mqttClient = await MqttClientHelper.Get(_logger))
using (var jobHost = await JobHostHelper <TriggerAndOutputWithSameConnectionTestFunction> .RunFor(_testLoggerProvider))
{
await mqttClient.SubscribeAsync("test/outtopic");
await mqttClient.SubscribeAsync("test/outtopic2");
await mqttServer.PublishAsync(DefaultMessage);
var firstMessage = await mqttClient.WaitForMessage();
if (firstMessage != null)
{
mqttApplicationMessages.Add(firstMessage);
var secondMessage = await mqttClient.WaitForMessage();
if (secondMessage != null)
{
mqttApplicationMessages.Add(secondMessage);
}
}
await WaitFor(() => TriggerAndOutputWithSameConnectionTestFunction.CallCount >= 1);
}
Assert.Equal(1, TriggerAndOutputWithSameConnectionTestFunction.CallCount);
Assert.Equal(1, counnections);
Assert.Equal(2, mqttApplicationMessages.Count);
Assert.Contains(mqttApplicationMessages, x => x.Topic == "test/outtopic");
Assert.Contains(mqttApplicationMessages, x => x.Topic == "test/outtopic2");
var bodyString = Encoding.UTF8.GetString(mqttApplicationMessages.First().Payload);
Assert.Equal("{\"test\":\"message\"}", bodyString);
}
public async Task Set_Session_Item()
{
using (var testEnvironment = new TestEnvironment(TestContext))
{
var serverOptions = new MqttServerOptionsBuilder()
.WithConnectionValidator(delegate(MqttConnectionValidatorContext context)
{
// Don't validate anything. Just set some session items.
context.SessionItems["can_subscribe_x"] = true;
context.SessionItems["default_payload"] = "Hello World";
})
.WithSubscriptionInterceptor(delegate(MqttSubscriptionInterceptorContext context)
{
if (context.TopicFilter.Topic == "x")
{
context.AcceptSubscription = context.SessionItems["can_subscribe_x"] as bool? == true;
}
})
.WithApplicationMessageInterceptor(delegate(MqttApplicationMessageInterceptorContext context)
{
context.ApplicationMessage.Payload = Encoding.UTF8.GetBytes(context.SessionItems["default_payload"] as string);
});
await testEnvironment.StartServer(serverOptions);
string receivedPayload = null;
var client = await testEnvironment.ConnectClient();
client.UseApplicationMessageReceivedHandler(delegate(MqttApplicationMessageReceivedEventArgs args)
{
receivedPayload = args.ApplicationMessage.ConvertPayloadToString();
});
var subscribeResult = await client.SubscribeAsync("x");
Assert.AreEqual(MqttClientSubscribeResultCode.GrantedQoS0, subscribeResult.Items[0].ResultCode);
var client2 = await testEnvironment.ConnectClient();
await client2.PublishAsync("x");
await Task.Delay(1000);
Assert.AreEqual("Hello World", receivedPayload);
}
}
private void InitServer()
{
IMqttNetLogger logger = new MqttNetLogger();
serverOptionsBuilder = new MqttServerOptionsBuilder()
.WithDefaultEndpointBoundIPAddress(IPAddress.Parse(ip))
.WithDefaultEndpointPort(port)
.WithDefaultCommunicationTimeout(TimeSpan.FromSeconds(communicationTimeout))
.WithEncryptionSslProtocol(sslProtocols);
// connect verfication
serverOptionsBuilder.WithConnectionValidator(valid =>
{
if (valid.ClientId.Length < 10)
{
valid.ReasonCode = MqttConnectReasonCode.ClientIdentifierNotValid;
return;
}
if (!valid.Username.Equals(this.username))
{
valid.ReasonCode = MqttConnectReasonCode.BadUserNameOrPassword;
return;
}
if (!valid.Password.Equals(password))
{
valid.ReasonCode = MqttConnectReasonCode.BadUserNameOrPassword;
return;
}
valid.ReasonCode = MqttConnectReasonCode.Success;
});
serverOptions = serverOptionsBuilder.Build();
mqttServer = (new MqttFactory()).CreateMqttServer(logger) as MqttServer;
mqttServer.ClientConnectedHandler = new MqttServerClientConnectedHandlerDelegate(e =>
{
ClientIds.Add(e.ClientId);
Logger.Info($"clientID:{e.ClientId} connect success!");
});
mqttServer.ClientDisconnectedHandler = new MqttServerClientDisconnectedHandlerDelegate(e =>
{
ClientIds.RemoveWhere(s => s.Equals(e.ClientId));
Logger.Info($"clientID:{e.ClientId} disconnect!");
});
mqttServer.UseApplicationMessageReceivedHandler(e =>
{
AppMsgReceivedHandler?.Invoke(e.ClientId, e.ApplicationMessage);
});
}
public async Task Manage_Session_MaxParallel()
{
using (var testEnvironment = CreateTestEnvironment())
{
testEnvironment.IgnoreClientLogErrors = true;
var serverOptions = new MqttServerOptionsBuilder();
await testEnvironment.StartServer(serverOptions);
var options = new MqttClientOptionsBuilder().WithClientId("1");
var clients = await Task.WhenAll(Enumerable.Range(0, 10).Select(i => TryConnect(testEnvironment, options)));
var connectedClients = clients.Where(c => c?.IsConnected ?? false).ToList();
Assert.AreEqual(1, connectedClients.Count);
}
}
public async Task StartServerAsync()
{
try
{
var optionsBuilder = new MqttServerOptionsBuilder()
.WithConnectionBacklog(100)
.WithDefaultEndpointPort(1883);
_mqttServer = new MqttFactory().CreateMqttServer();
await _mqttServer.StartAsync(optionsBuilder.Build());
}
catch (Exception ex)
{
_logger.LogError("StartServerAsync error:\n" + ex.ToString());
Console.ReadLine();
}
}
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 void StartListening()
{
MqttServerOptionsBuilder optionsBuilder = new MqttServerOptionsBuilder()
.WithConnectionBacklog(100)
.WithDefaultEndpointPort(5656)
.WithApplicationMessageInterceptor(context =>
{
Console.WriteLine(Encoding.UTF8.GetString(context.ApplicationMessage.Payload, 0, context.ApplicationMessage.Payload.Length));
Clients.All.notifyMessage(context.ApplicationMessage.Payload, 0, context.ApplicationMessage.Payload.Length);
context.ApplicationMessage.Payload = null;
});
IMqttServer mqttServer = new MqttFactory().CreateMqttServer();
mqttServer.StartAsync(optionsBuilder.Build());
Console.WriteLine("Press any key to exit.");
Console.ReadLine();
}
/// <summary>
/// 开启服务
/// </summary>
private async Task <string> CreateMQTTServer(int port)
{
var optionsBuilder = new MqttServerOptionsBuilder();
try
{
//在 MqttServerOptions 选项中，你可以使用 ConnectionValidator 来对客户端连接进行验证。比如客户端ID标识 ClientId，用户名 Username 和密码 Password 等。
optionsBuilder.WithConnectionValidator(c =>
{
try
{
if (LoginEvent != null)
{
LoginEvent?.Invoke(c);
}
else
{
c.ReturnCode = MqttConnectReturnCode.ConnectionAccepted;
}
}
catch
{
c.ReturnCode = MqttConnectReturnCode.ConnectionRefusedBadUsernameOrPassword;
return;
}
});
//指定端口
optionsBuilder.WithDefaultEndpointPort(port);
//连接记录数，默认 一般为2000
//optionsBuilder.WithConnectionBacklog(2000);
mqttServer = new MqttFactory().CreateMqttServer();
// 客户端支持 Connected、Disconnected 和 ApplicationMessageReceived 事件，用来处理客户端与服务端连接、客户端从服务端断开以及客户端收到消息的事情。
//其中 ClientConnected 和 ClientDisconnected 事件的事件参数一个客户端连接对象 ConnectedMqttClient，通过该对象可以获取客户端ID标识 ClientId 和 MQTT 版本 ProtocolVersion。
mqttServer.ClientConnected += MqttServer_ClientConnected;
mqttServer.ClientDisconnected += MqttServer_ClientDisconnected;
//ApplicationMessageReceived 的事件参数包含了客户端ID标识 ClientId 和 MQTT 应用消息 MqttApplicationMessage 对象，通过该对象可以获取主题 Topic、QoS QualityOfServiceLevel 和消息内容 Payload 等信息。
mqttServer.ApplicationMessageReceived += MqttServer_ApplicationMessageReceived;
}
catch (Exception ex)
{
return("MQTT服务创建失败>" + ex.Message);
}
await mqttServer.StartAsync(optionsBuilder.Build());
return("MQTT服务<0.0.0.0:" + port + ">已启动");
}
public async Task StartAsync(CancellationToken cancellationToken)
{
using (var db = _serviceProvider.CreateScope().ServiceProvider.GetService <SmartServerContext>())
{
await db.Database.MigrateAsync(cancellationToken : cancellationToken);
}
_logger.LogInformation("Starting MqttBrokerService");
var optionsBuilder = new MqttServerOptionsBuilder().WithDefaultEndpoint();
await _mqttServer.StartAsync(optionsBuilder.Build());
await _mqttTemperatureClientService.StartAsync();
await _autodiscoverService.StartAsync();
_mqttServer.ClientConnectedHandler = new MqttServerClientConnectedHandlerDelegate(args => _logger.LogDebug("Client {0} connected.", args.ClientId));
_mqttServer.ClientDisconnectedHandler = new MqttServerClientDisconnectedHandlerDelegate(args => _logger.LogDebug("Client {0} disconnected ({1}).", args.ClientId, args.DisconnectType));
}
private IMqttServerOptions ConfigBroker(int port = 1889)
{
var optionsBuilder = new MqttServerOptionsBuilder()
.WithConnectionBacklog(100)
.WithDefaultEndpointPort(port)
.WithConnectionValidator(c =>
{
c.ReasonCode = MqttConnectReasonCode.BadUserNameOrPassword;
var userAccount = (_accountManager.Login(c.Username, c.Password))?.Result;
if (userAccount != null)
{
c.ReasonCode = MqttConnectReasonCode.Success;
}
});
return(optionsBuilder.Build());
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.Configure <CookiePolicyOptions>(options =>
{
// This lambda determines whether user consent for non-essential cookies is needed for a given request.
options.CheckConsentNeeded = context => true;
options.MinimumSameSitePolicy = SameSiteMode.None;
});
#if ENABLE_MQTT_BROKER
var mqttServerOptions = new MqttServerOptionsBuilder()
.WithoutDefaultEndpoint()
.Build();
services
.AddHostedMqttServer(mqttServerOptions)
.AddMqttConnectionHandler()
.AddConnections();
#endif
MongoDB.Driver.MongoClient client = new MongoDB.Driver.MongoClient(Configuration.GetConnectionString("mongodb"));
var redisConfiguration = Configuration.GetSection("redis").Get <RedisConfiguration>();
var mqttOptions = Configuration.GetSection("MQTT").Get <MqttSubscribeConfig>();
services.AddSingleton(mqttOptions);
services.AddSingleton(redisConfiguration);
services.AddSingleton <IRedisConnectionFactory, RedisConnectionFactory>();
services.AddSingleton(client);
queue_service = new MongoBackgroundTaskQueue(client);
services.AddSingleton(queue_service);
//IServiceCollection cols = services.AddSingleton<IBackgroundMongoTaskQueue, MongoBackgroundTaskQueue>();
//services.AddHostedService<MongoBackgroundHostService>();
//byte[] file_array = File.ReadAllBytes("output.txt");
//byte[] new_fileArray = new byte[file_array.Length + 8];
//Array.Copy(file_array, new_fileArray, file_array.Length);
//DaegunPacket packet = PacketParser.ByteToStruct<DaegunPacket>(new_fileArray);
//packet.timestamp = DateTime.Now;
//queue_service.QueueBackgroundWorkItem(packet);
services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_1);
}
private static async Task StartMqttServer()
{
if (mqttServer == null)
{
// Configure MQTT server.
var optionsBuilder = new MqttServerOptionsBuilder()
.WithConnectionBacklog(100)
.WithDefaultEndpointPort(8222)
.WithConnectionValidator(c =>
{
Dictionary <string, string> c_u = new Dictionary <string, string>();
c_u.Add("client001", "username001");
c_u.Add("client002", "username002");
Dictionary <string, string> u_psw = new Dictionary <string, string>();
u_psw.Add("username001", "psw001");
u_psw.Add("username002", "psw002");
if (c_u.ContainsKey(c.ClientId) && c_u[c.ClientId] == c.Username)
{
if (u_psw.ContainsKey(c.Username) && u_psw[c.Username] == c.Password)
{
c.ReasonCode = MqttConnectReasonCode.Success;
}
else
{
c.ReasonCode = MqttConnectReasonCode.BadUserNameOrPassword;
}
}
else
{
c.ReasonCode = MqttConnectReasonCode.ClientIdentifierNotValid;
}
});
// Start a MQTT server.
mqttServer = new MqttFactory().CreateMqttServer();
mqttServer.UseApplicationMessageReceivedHandler(MqttServer_ApplicationMessageReceived);
mqttServer.UseClientConnectedHandler(MqttServer_ClientConnected);
mqttServer.UseClientDisconnectedHandler(MqttServer_ClientDisconnected);
await mqttServer.StartAsync(optionsBuilder.Build());
Console.WriteLine("MQTT服务启动成功！");
}
}
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();
}
}
public async Task <bool> StartAsync(int port)
{
if (server.IsStarted)
{
return(true);
}
Port = port;
IMqttServerOptions options = new MqttServerOptionsBuilder()
.WithApplicationMessageInterceptor(cv => { cv.AcceptPublish = true; })
.WithConnectionValidator(cv =>
{
if (cv.ClientId.Length < 10)
{
cv.ReasonCode = MqttConnectReasonCode.ClientIdentifierNotValid;
return;
}
if (!users.ContainsKey(cv.Username) ||
users[cv.Username] != cv.Password)
{
cv.ReasonCode = MqttConnectReasonCode.BadUserNameOrPassword;
return;
}
cv.ReasonCode = MqttConnectReasonCode.Success;
})
.WithEncryptionSslProtocol(System.Security.Authentication.SslProtocols.Tls12)
.WithDefaultEndpointPort(port)
.WithSubscriptionInterceptor(cv => { cv.AcceptSubscription = true; })
.Build();
try
{
await server.StartAsync(options);
logger.Debug("Mqtt server is running at: {0}", port);
return(true);
}
catch (Exception ex)
{
logger.Error(ex);
return(false);
}
}
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()));
}
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 TriggerAndOutputUseDifferentConnection()
{
MqttApplicationMessage mqttApplicationMessage = null;
var connectionsCountServer1 = 0;
var optionsServer1 = new MqttServerOptionsBuilder()
.WithDefaultEndpointPort(1337)
.WithConnectionValidator(x =>
{
connectionsCountServer1 += (x.ClientId != "IntegrationTest") ? 1 : 0;
})
.Build();
var connectionsCountServer2 = 0;
var optionsServer2 = new MqttServerOptionsBuilder()
.WithConnectionValidator(x =>
{
connectionsCountServer2 += (x.ClientId != "IntegrationTest") ? 1 : 0;
})
.Build();
using (var mqttServer1 = await MqttServerHelper.Get(_logger, optionsServer1))
using (var mqttServer2 = await MqttServerHelper.Get(_logger, optionsServer2))
using (var mqttClientForServer2 = await MqttClientHelper.Get(_logger))
using (var jobHost = await JobHostHelper <TriggerAndOutputWithDifferentConnectionTestFunction> .RunFor(_testLoggerProvider))
{
await mqttClientForServer2.SubscribeAsync("test/outtopic");
await mqttServer1.PublishAsync(DefaultMessage);
mqttApplicationMessage = await mqttClientForServer2.WaitForMessage();
await WaitFor(() => TriggerAndOutputWithDifferentConnectionTestFunction.CallCount >= 1);
}
Assert.Equal(1, TriggerAndOutputWithDifferentConnectionTestFunction.CallCount);
Assert.Equal(1, connectionsCountServer1);
Assert.Equal(1, connectionsCountServer2);
Assert.NotNull(mqttApplicationMessage);
Assert.Equal("test/outtopic", mqttApplicationMessage.Topic);
var bodyString = Encoding.UTF8.GetString(mqttApplicationMessage.Payload);
Assert.Equal("{\"test\":\"message\"}", bodyString);
}
public async Task WhenTlsIsSetToTrueASecureConnectionIsMade()
{
var options = new MqttServerOptionsBuilder()
.WithEncryptedEndpoint()
.WithEncryptionCertificate(new X509Certificate2(@"Certificates/myRootCA.pfx", "12345", X509KeyStorageFlags.Exportable))
.WithoutDefaultEndpoint()
.Build();
using (var mqttServer = await MqttServerHelper.Get(_logger, options))
using (var jobHost = await JobHostHelper <FunctionConnectingWithTlsEnabledTestFunction> .RunFor(_testLoggerProvider))
{
await mqttServer.PublishAsync(DefaultMessage);
await WaitFor(() => FunctionConnectingWithTlsEnabledTestFunction.CallCount >= 1, 20);
}
Assert.Equal(1, FunctionConnectingWithTlsEnabledTestFunction.CallCount);
}
public async Task Deny_Connection()
{
var serverOptions = new MqttServerOptionsBuilder().WithConnectionValidator(context =>
{
context.ReasonCode = MqttConnectReasonCode.NotAuthorized;
});
using (var testEnvironment = new TestEnvironment(TestContext))
{
testEnvironment.IgnoreClientLogErrors = true;
await testEnvironment.StartServerAsync(serverOptions);
var connectingFailedException = await Assert.ThrowsExceptionAsync <MqttConnectingFailedException>(() => testEnvironment.ConnectClientAsync());
Assert.AreEqual(MqttClientConnectResultCode.NotAuthorized, connectingFailedException.ResultCode);
}
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_1);
var mqttOptions = new MqttServerOptionsBuilder()
.WithSubscriptionInterceptor(c => {
// This callback area is not fired regardless tested using breakpoint and Console.WriteLine
Console.WriteLine($"WithSubscriptionInterceptor: client id = {c.ClientId}");
c.AcceptSubscription = false;
c.CloseConnection = true;
})
// Other validation + interceptor
.Build();
services.AddHostedMqttServer(mqttOptions);
services.AddMqttTcpServerAdapter();
services.AddMqttWebSocketServerAdapter();
}
public async Task CustomConnectionWithClientIdIsReceived()
{
string clientId = string.Empty;
var options = new MqttServerOptionsBuilder()
.WithConnectionValidator(x => clientId = x.ClientId)
.Build();
using (var mqttServer = await MqttServerHelper.Get(_logger, options))
using (var jobHost = await JobHostHelper <CustomConnectionStringWithClientIdTestFunction> .RunFor(_testLoggerProvider))
{
await mqttServer.PublishAsync(DefaultMessage);
await WaitFor(() => CustomConnectionStringWithClientIdTestFunction.CallCount >= 1);
}
Assert.Equal(1, CustomConnectionStringWithClientIdTestFunction.CallCount);
Assert.Equal("Custom", clientId);
}
public static IServiceCollection AddColtSmartMQTT(this IServiceCollection services, IConfiguration configuration)
{
var mqttOption = configuration.GetSection("MqttOption").Get <MqttOption>();
var optionBuilder = new MqttServerOptionsBuilder().WithDefaultEndpointBoundIPAddress(System.Net.IPAddress.Parse(mqttOption.HostIp))
.WithDefaultEndpointPort(mqttOption.HostPort)
.WithDefaultCommunicationTimeout(TimeSpan.FromMilliseconds(mqttOption.Timeout))
.WithEncryptedEndpoint()
.WithConnectionValidator(t =>
{
if (!string.IsNullOrWhiteSpace(t.Username) && !string.IsNullOrWhiteSpace(t.Password))
{
var userService = EnjoyGlobals.ServiceProvider.GetService <IUserService>();
if (userService != null && userService.VerifyUser(t.Username, t.Password))
{
t.ReturnCode = MqttConnectReturnCode.ConnectionAccepted;
}
else
{
t.ReturnCode = MqttConnectReturnCode.ConnectionRefusedBadUsernameOrPassword;
}
}
else
{
t.ReturnCode = MqttConnectReturnCode.ConnectionRefusedNotAuthorized;
}
});
var options = optionBuilder.Build();
//var certificate = new X509Certificate2(@"C:\certs\test\test.cer", "", X509KeyStorageFlags.Exportable);
//options.TlsEndpointOptions.Certificate = certificate.Export(X509ContentType.Pfx);
//options.TlsEndpointOptions.IsEnabled = true;
services.AddHostedMqttServer(options)
.AddMqttConnectionHandler()
.AddConnections();
return(services);
}
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();
}
}
