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);
}
static void Main(string[] args)
{
var optionsBuilder = new MqttServerOptionsBuilder()
.WithConnectionValidator(c =>
{
Console.WriteLine($"{c.ClientId} connection validator for c.Endpoint: {c.Endpoint}");
c.ReasonCode = MqttConnectReasonCode.Success;
})
.WithApplicationMessageInterceptor(context =>
{
Console.WriteLine("WithApplicationMessageInterceptor block merging data");
var newData = Encoding.UTF8.GetBytes(DateTime.Now.ToString("O"));
var oldData = context.ApplicationMessage.Payload;
var mergedData = newData.Concat(oldData).ToArray();
context.ApplicationMessage.Payload = mergedData;
})
.WithDefaultEndpointBoundIPAddress(IPAddress.Loopback) // Set IP address
.WithConnectionBacklog(100)
.WithDefaultEndpointPort(1884);
//start server
var mqttServer = new MqttFactory().CreateMqttServer();
mqttServer.StartAsync(optionsBuilder.Build());
Console.WriteLine($"Broker is Running: Host: {mqttServer.Options.DefaultEndpointOptions.BoundInterNetworkAddress} Port: {mqttServer.Options.DefaultEndpointOptions.Port}");
Console.WriteLine("Press any key to exit.");
Console.ReadLine();
Task.Run(() => Thread.Sleep(Timeout.Infinite)).Wait();
mqttServer.StopAsync().Wait();
}
static async Task Main(string[] args)
{
var optionsBuilder = new MqttServerOptionsBuilder()
.WithConnectionBacklog(100)
.WithDefaultEndpointPort(1884);
var mqttServer = new MqttFactory().CreateMqttServer();
await mqttServer.StartAsync(optionsBuilder.Build());
mqttServer.ApplicationMessageReceived += (s, e) =>
{
Console.WriteLine();
Console.WriteLine("### Mensagem Recebida ###");
Console.WriteLine($"+ ClientId = {e.ClientId}");
Console.WriteLine($"+ Topico = {e.ApplicationMessage.Topic}");
Console.WriteLine($"+ Mensagem = {Encoding.UTF8.GetString(e.ApplicationMessage.Payload)}");
Console.WriteLine($"+ QoS = {e.ApplicationMessage.QualityOfServiceLevel}");
Console.WriteLine($"+ Retain = {e.ApplicationMessage.Retain}");
Console.WriteLine();
};
Console.WriteLine("Server Mqtt iniciado...");
Console.WriteLine("Pressione qualquer tecla para fechar");
Console.ReadLine();
await mqttServer.StopAsync();
}
static void Main(string[] args)
{
//Console.WriteLine("Hello World1!");
//configure options
var optionsBuilder = new MqttServerOptionsBuilder()
.WithConnectionValidator(c =>
{
Console.WriteLine($"{c.ClientId} connection validator for c.Endpoint: {c.Endpoint}");
c.ReasonCode = MqttConnectReasonCode.Success;
})
.WithConnectionBacklog(100)
.WithDefaultEndpointPort(1884);
//start server
var mqttServer = new MqttFactory().CreateMqttServer();
mqttServer.StartAsync(optionsBuilder.Build()).Wait();
Console.WriteLine($"Broker is Running: Host: {mqttServer.Options.DefaultEndpointOptions.BoundInterNetworkAddress} Port: {mqttServer.Options.DefaultEndpointOptions.Port}");
Console.WriteLine("Press any key to exit.");
Console.ReadLine();
mqttServer.StopAsync().Wait();
}
private static async Task StartServer()
{
var optionsBuilder = new MqttServerOptionsBuilder()
.WithConnectionBacklog(100)
.WithDefaultEndpointPort(1883);
var mqttServer = new MqttFactory().CreateMqttServer();
await mqttServer.StartAsync(optionsBuilder.Build());
var ct = new CancellationTokenSource();
var heartbeatTask = Task.Run(async() => await ServerHeartbeat(ct.Token, mqttServer));
Console.WriteLine("Type 'quit' to exit");
while (true)
{
string input = Console.ReadLine();
if (input != null && input.Contains("quit"))
{
break;
}
}
ct.Cancel();
await heartbeatTask;
await mqttServer.StopAsync();
}
//static DeviceContext db = new DeviceContext();
public static void ConfigureAndStart()
{
DeviceContext db = new DeviceContext();
var optionsBuilder = new MqttServerOptionsBuilder()
.WithDefaultEndpointPort(1884);
var mqttServer = new MqttFactory().CreateMqttServer();
// mqttServer.UseApplicationMessageReceivedHandler(new MqttMessageReceivedHandler());
mqttServer.UseApplicationMessageReceivedHandler(e =>
{
string payload = Encoding.UTF8.GetString(e.ApplicationMessage.Payload);
//Console.WriteLine(payload);
Device device = new Device {
Temperature = payload
};
db.devices.Add(device);
db.SaveChanges();
//db.devices.Add(new Device { Id = 2, Temperature = payload });
//db.devices.Add(new Device {Id =4, Temperature= 3.ToString() });
});
mqttServer.StartAsync(optionsBuilder.Build()).GetAwaiter().GetResult();
}
public async Task StartAsync(CancellationToken cancellationToken)
{
_logger.LogInformation("Starting MQTT Daemon on port " + _config.Value.Port);
//Building the config
var optionsBuilder = new MqttServerOptionsBuilder()
.WithConnectionBacklog(1000)
.WithDefaultEndpointPort(_config.Value.Port);
//Getting an MQTT Instance
_mqttServer = new MqttFactory().CreateMqttServer();
//Wiring up all the events...
_mqttServer.ClientSubscribedTopic += _mqttServer_ClientSubscribedTopic;
_mqttServer.ClientUnsubscribedTopic += _mqttServer_ClientUnsubscribedTopic;
_mqttServer.ClientConnected += _mqttServer_ClientConnected;
_mqttServer.ClientDisconnected += _mqttServer_ClientDisconnected;
_mqttServer.ApplicationMessageReceived += _mqttServer_ApplicationMessageReceived;
//Now, start the server -- Notice this is resturning the MQTT Server's StartAsync, which is a task.
await _mqttServer.StartAsync(optionsBuilder.Build());
return;
}
public void Start(ConnectionOptions options)
{
//configure options
var optionsBuilder = new MqttServerOptionsBuilder()
.WithConnectionValidator(context =>
{
_logger?.Log(nameof(Broker), $"{context.ClientId} connection validator for c.Endpoint: {context.Endpoint}");
context.ReasonCode = MqttConnectReasonCode.Success;
})
.WithApplicationMessageInterceptor(context =>
{
_logger?.Log(nameof(Broker), $"Intercept data");
//var newData = Encoding.UTF8.GetBytes(DateTime.Now.ToString("O"));
//var oldData = context.ApplicationMessage.Payload;
//var mergedData = newData.Concat(oldData).ToArray();
//context.ApplicationMessage.Payload = mergedData;
})
.WithConnectionBacklog(100)
.WithDefaultEndpointBoundIPAddress(IPAddress.Parse(options.IpAddress))
.WithDefaultEndpointPort(options.Port)
;
//start server
_mqttServer = new MqttFactory().CreateMqttServer();
_mqttServer.StartAsync(optionsBuilder.Build()).Wait();
}
static void Main(string[] args)
{
var optionsBuilder = new MqttServerOptionsBuilder()
.WithDefaultEndpoint().WithDefaultEndpointPort(1883) // For testing purposes only
//.WithEncryptedEndpoint().WithEncryptedEndpointPort(config.Port)
//.WithEncryptionCertificate(certificate.Export(X509ContentType.Pfx))
//.WithEncryptionSslProtocol(SslProtocols.Tls12)
.WithConnectionValidator(
c =>
{
Console.WriteLine(c.Username);
c.ReasonCode = MqttConnectReasonCode.Success;
}).WithSubscriptionInterceptor(
c =>
{
c.AcceptSubscription = false;
}).WithApplicationMessageInterceptor(
c =>
{
c.AcceptPublish = false;
});
var mqttServer = new MqttFactory().CreateMqttServer();
mqttServer.StartAsync(optionsBuilder.Build());
Console.ReadLine();
}
public async Task <ReuquestResult> StartMQServer()
{
try
{
if (mqttServer != null && mqOptionsBuilder != null)
{
await mqttServer.StartAsync(mqOptionsBuilder.Build());
mqOptionsBuilder = null;
return(new ReuquestResult {
Successful = true
});
}
else
{
LMLogs.NLog.Logger.Log(LMLogs.LogLevel.Exception, "MqttService", $"开启成功");
}
return(new ReuquestResult {
Successful = false
});
}
catch (Exception e)
{
LMLogs.NLog.Logger.Log(LMLogs.LogLevel.Exception, "MqttService", $"开启异常:{e.Message}");
return(new ReuquestResult {
Successful = false, Code = 500
});
}
}
public async Task StartAsync(CancellationToken cancellationToken)
{
var optionsBuilder = new MqttServerOptionsBuilder()
.WithDefaultEndpoint().WithDefaultEndpointPort(1883).WithConnectionValidator(
c =>
{
c.ReasonCode = MqttConnectReasonCode.Success;
}).WithSubscriptionInterceptor(
c =>
{
c.AcceptSubscription = true;
}).WithApplicationMessageInterceptor(
c =>
{
string s = string.Empty;
foreach (byte b in c.ApplicationMessage.Payload)
{
s += Convert.ToChar(b);
}
Console.WriteLine($"Sender: {c.ClientId} - Topic: {c.ApplicationMessage.Topic} - Message: {s}");
c.AcceptPublish = true;
});
await _mqttServer.StartAsync(optionsBuilder.Build());
}
private async Task StartMqttServer()
{
// Start a MQTT server.
Logger.LogInfo(LogCategory.Processor, this.Name, "Starting MQTT Server..");
_mqttServer = new MqttFactory().CreateMqttServer();
var optionsBuilder = new MqttServerOptionsBuilder()
.WithConnectionBacklog(100)
.WithDefaultEndpointPort(BrokerPort)
.WithConnectionValidator(AuthenticateUser)
.WithStorage(new RetainedMqttMessageHandler());
if (!string.IsNullOrEmpty(SecureCommunicationCertLocation))
{
optionsBuilder.WithEncryptedEndpoint().WithEncryptedEndpointPort(EncryptedBrokerPort);
}
var options = optionsBuilder.Build();
if (!string.IsNullOrEmpty(SecureCommunicationCertLocation))
{
var certificate = new X509Certificate(SecureCommunicationCertLocation, "");
options.TlsEndpointOptions.Certificate = certificate.Export(X509ContentType.Cert);
}
await _mqttServer.StartAsync(options);
}
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\SimpleMqttServer_.txt"), rollingInterval: RollingInterval.Day)
.WriteTo.Console()
.CreateLogger();
var config = ReadConfiguration(currentPath);
var optionsBuilder = new MqttServerOptionsBuilder()
.WithDefaultEndpoint().WithDefaultEndpointPort(config.Port).WithConnectionValidator(
c =>
{
var currentUser = config.Users.FirstOrDefault(u => u.UserName == c.Username);
if (currentUser == null)
{
c.ReasonCode = MqttConnectReasonCode.BadUserNameOrPassword;
LogMessage(c, true);
return;
}
if (c.Username != currentUser.UserName)
{
c.ReasonCode = MqttConnectReasonCode.BadUserNameOrPassword;
LogMessage(c, true);
return;
}
if (c.Password != currentUser.Password)
{
c.ReasonCode = MqttConnectReasonCode.BadUserNameOrPassword;
LogMessage(c, true);
return;
}
c.ReasonCode = MqttConnectReasonCode.Success;
LogMessage(c, false);
}).WithSubscriptionInterceptor(
c =>
{
c.AcceptSubscription = true;
LogMessage(c, true);
}).WithApplicationMessageInterceptor(
c =>
{
c.AcceptPublish = true;
LogMessage(c);
});
var mqttServer = new MqttFactory().CreateMqttServer();
mqttServer.StartAsync(optionsBuilder.Build());
Console.ReadLine();
}
static void Main(string[] args)
{
Console.WriteLine("Hello World!");
var currentPath = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
Log.Logger = new LoggerConfiguration()
.MinimumLevel.Debug()
// ReSharper disable once AssignNullToNotNullAttribute
.WriteTo.File(Path.Combine(currentPath,
@"log\SimpleMqttServer_.txt"), rollingInterval: RollingInterval.Day)
.WriteTo.Console()
.CreateLogger();
var optionsBuilder = new MqttServerOptionsBuilder().WithDefaultEndpoint().WithApplicationMessageInterceptor(
c =>
{
c.AcceptPublish = true;
LogMessage(c);
}).WithSubscriptionInterceptor(
c =>
{
c.AcceptSubscription = true;
LogMessage(c, true);
});
var mqttServer = new MqttFactory().CreateMqttServer();
mqttServer.StartAsync(optionsBuilder.Build());
Console.ReadLine();
}
static async void StartServer()
{
var optionsBuilder = new MqttServerOptionsBuilder()
.WithConnectionBacklog(int.Parse(_configuration["backlog"]))
.WithDefaultEndpointPort(int.Parse(_configuration["portNumber"]));
var mqttServer = new MqttFactory().CreateMqttServer();
var isEchoOn = bool.Parse(_configuration["echo"]);
_topicsFilter = _configuration["echoTopicFilters"].Split(",");
Console.WriteLine($"Mqtt broker listening on port {_configuration["portNumber"]} - press enter to exit.");
if (isEchoOn)
{
Console.WriteLine($"echoing messages using topicFilter of {_configuration["echoTopicFilters"]}");
mqttServer.UseClientConnectedHandler(ClientConnectedHandler);
mqttServer.UseClientDisconnectedHandler(ClientDisconnectedHandler);
mqttServer.UseApplicationMessageReceivedHandler(MessageReceivedHandler);
}
await mqttServer.StartAsync(optionsBuilder.Build());
Console.ReadLine();
await mqttServer.StopAsync();
}
public async Task ServerRun(SignalRService signalRService)
{
Debug.WriteLine("TestMQTTServer");
var optionsBuilder = new MqttServerOptionsBuilder()
.WithConnectionBacklog(100)
.WithDefaultEndpointPort(8081);
mqttServer = new MqttFactory().CreateMqttServer();
mqttServer.ApplicationMessageReceived += async(s, e) =>
{
Debug.WriteLine("### RECEIVED APPLICATION MESSAGE ###");
Debug.WriteLine($"+ Topic = {e.ApplicationMessage.Topic}");
Debug.WriteLine($"+ Payload = {Encoding.UTF8.GetString(e.ApplicationMessage.Payload)}");
Debug.WriteLine($"+ QoS = {e.ApplicationMessage.QualityOfServiceLevel}");
Debug.WriteLine($"+ Retain = {e.ApplicationMessage.Retain}");
Debug.WriteLine($"+ Retain = {e.ClientId}");
var payload = Encoding.UTF8.GetString(e.ApplicationMessage.Payload);
var splitedPayload = payload.Split('/');
var isOn = splitedPayload[2] == "on" ? true : false;
await signalRService.InvokeSendStatusMethod(int.Parse(splitedPayload[1]), isOn);
};
await mqttServer.StartAsync(optionsBuilder.Build());
// Console.WriteLine("Press any key to exit.");
// Console.ReadLine();
// await mqttServer.StopAsync();
}
public override async Task StartAsync(CancellationToken cancellationToken)
{
// Server
_logger.LogInformation($"Start MQTT-Broker (Port:{_brokerConfig.Port})");
var optionsBuilder = new MqttServerOptionsBuilder()
.WithDefaultEndpoint()
.WithDefaultEndpointPort(_brokerConfig.Port)
.WithSubscriptionInterceptor(
c =>
{
c.AcceptSubscription = true;
_logger.LogInformation($"New subscription: ClientId = {c.ClientId}, TopicFilter = {c.TopicFilter}");
})
.WithApplicationMessageInterceptor(
c =>
{
c.ApplicationMessage.Payload =
Encoding.UTF8.GetBytes(
Encoding.UTF8.GetString(c.ApplicationMessage.Payload).Trim());
//c.ApplicationMessage.Payload = Encoding.UTF8.GetBytes(payload);
});
_mqttServer = new MqttFactory().CreateMqttServer();
_mqttServer.ClientConnectedHandler = this;
_mqttServer.ClientDisconnectedHandler = this;
_mqttServer.ApplicationMessageReceivedHandler = this;
await _mqttServer.StartAsync(optionsBuilder.Build());
await base.StartAsync(cancellationToken);
}
// 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);
#region MQTT配置
string hostIp = Configuration["MqttOption:HostIp"]; //IP地址
int hostPort = int.Parse(Configuration["MqttOption:HostPort"]); //端口号
int timeout = int.Parse(Configuration["MqttOption:Timeout"]); //超时时间
string username = Configuration["MqttOption:UserName"]; //用户名
string password = Configuration["MqttOption:Password"]; //密码
var optionBuilder = new MqttServerOptionsBuilder()
.WithDefaultEndpointBoundIPAddress(System.Net.IPAddress.Parse(hostIp))
.WithDefaultEndpointPort(hostPort)
.WithDefaultCommunicationTimeout(TimeSpan.FromMilliseconds(timeout))
.WithConnectionValidator(t =>
{
if (t.Username != username || t.Password != password)
{
t.ReturnCode = MqttConnectReturnCode.ConnectionRefusedBadUsernameOrPassword;
}
t.ReturnCode = MqttConnectReturnCode.ConnectionAccepted;
});
var option = optionBuilder.Build();
services
.AddHostedMqttServer(option)
.AddMqttConnectionHandler()
.AddConnections();
#endregion
}
public override async Task StartAsync(CancellationToken cancellationToken)
{
this.CancellationToken = cancellationToken;
await LoadConfigurationAsync();
Log.Information("[{where}] Broker is starting v {version} on port {port}...", nameof(MQTTServer), Program.Version, port);
mqttServer = new MqttFactory().CreateMqttServer();
var optionsBuilder = new MqttServerOptionsBuilder()
.WithConnectionValidator(c =>
{
if (c.Username == username && c.Password == password)
{
c.ReasonCode = MqttConnectReasonCode.Success;
}
else
{
c.ReasonCode = MqttConnectReasonCode.BadUserNameOrPassword;
}
})
.WithConnectionBacklog(100)
.WithDefaultEndpointPort(port)
.WithApplicationMessageInterceptor(async context =>
{
Log.Verbose("[{where}] Message Received...\r\n[{client}] - {topic} - {msg}", nameof(MQTTServer), context.ClientId ?? "n/a", context.ApplicationMessage.Topic, context.ApplicationMessage.ConvertPayloadToString());
if (context?.ClientId != null)
{
// handle multiple devices mapped to the same payload
var clients = devices.Where(x => x.ClientId == context.ClientId || x.ClientId == "*");
Parallel.ForEach(clients, async(device) =>
{
if (device.TopicName.Equals(context.ApplicationMessage.Topic, StringComparison.InvariantCultureIgnoreCase) ||
device.AlternateTopicName?.Equals(context.ApplicationMessage.Topic, StringComparison.InvariantCultureIgnoreCase) == true)
{
await ProcessMessageAsync(device, context.ApplicationMessage);
}
});
}
CancelIfNeeded();
await Task.CompletedTask;
});
var options = optionsBuilder.Build() as MqttServerOptions;
try
{
await mqttServer.StartAsync(options);
}
catch (Exception ex)
{
Log.Error(ex, $"[{nameof(MqttServer)}].{nameof(StartAsync)}");
}
}
public async void StartServer()
{
optionsBuilder = new MqttServerOptionsBuilder()
.WithConnectionBacklog(100)
//.WithConnectionValidator(connValidator)
.WithDefaultEndpointPort(1884);
await mqttServer.StartAsync(optionsBuilder.Build());
}
public async Task ConfigBrocerAsync()
{
var optionsBuilder = new MqttServerOptionsBuilder()
.WithDefaultEndpointPort(1889);
var mqttServer = new MqttFactory().CreateMqttServer();
await mqttServer.StartAsync(optionsBuilder.Build());
}
// Use this for initialization
async void Start()
{
// Start a MQTT server.
mqttServer = new MqttFactory().CreateMqttServer();
var ipAddress = new byte[] { 0, 0, 0, 0 };
var ipObject = new System.Net.IPAddress(ipAddress);
var options = new MqttServerOptionsBuilder()
.WithDefaultEndpointBoundIPAddress(ipObject)
.WithDefaultEndpointPort(1883);
// Write all trace messages to the console window.
MqttNetGlobalLogger.LogMessagePublished += (s, e) =>
{
var trace = $">> [{e.TraceMessage.Timestamp:O}] [{e.TraceMessage.ThreadId}] [{e.TraceMessage.Source}] [{e.TraceMessage.Level}]: {e.TraceMessage.Message}";
if (e.TraceMessage.Exception != null)
{
trace += Environment.NewLine + e.TraceMessage.Exception.ToString();
}
Debug.Log(trace);
};
try
{
await mqttServer.StartAsync(options.Build());
} catch (Exception e)
{
// testing...
Debug.Log("exception!");
Debug.Log(e.Message);
}
mqttServer.ClientConnected += (s, e) =>
{
Debug.Log("Client connected " + e.ClientId);
};
mqttServer.Started += (s, e) =>
{
Debug.Log("Server was started");
};
mqttServer.Stopped += (s, e) =>
{
Debug.Log("Server was stopped");
};
mqttServer.ApplicationMessageReceived += (s, e) =>
{
// TODO split values up! & find out what is what.
// -> parse values like in the code from Ricky.
Debug.Log("application message received");
var payload = string.Concat(e.ApplicationMessage.Payload);
Debug.Log(payload);
};
Debug.Log(mqttServer.Options.DefaultEndpointOptions.Port);
Debug.Log(mqttServer.Options.DefaultEndpointOptions.BoundInterNetworkAddress);
}
public async Task <bool> Start()
{
if (_neonConfig.Mqtt.RunEmbedded)
{
var mqttOptionBuilder = new MqttServerOptionsBuilder()
.WithConnectionBacklog(100)
.WithDefaultEndpointBoundIPAddress(IPAddress.Parse("0.0.0.0"))
.WithDefaultEndpointPort(1883);
_mqttServer = new MqttFactory().CreateMqttServer();
_logger.LogInformation($"Starting embedded MQTT Server");
await _mqttServer.StartAsync(mqttOptionBuilder.Build());
_logger.LogInformation($"Embedded MQTT Server started");
_neonConfig.Mqtt.Host = "127.0.0.1";
}
_logger.LogInformation($"Connecting to {_neonConfig.Mqtt.Host} with clientId: {_neonConfig.Mqtt.ClientId}");
var options = new MqttClientOptionsBuilder()
.WithClientId(_neonConfig.Mqtt.ClientId)
.WithTcpServer(_neonConfig.Mqtt.Host)
.WithCleanSession()
.Build();
_mqttClient = new MqttFactory().CreateMqttClient();
_mqttClient.UseDisconnectedHandler(async e =>
{
if (_reconnectTry <= 5)
{
_logger.LogWarning("Disconnected from MQTT Server, reconnecting in 10 seconds");
await Task.Delay(10000);
await Start();
_reconnectTry++;
}
else
{
_logger.LogWarning("Max number reconnect try to MQTT Server, abort");
}
});
_mqttClient.UseConnectedHandler(async e =>
{
await _mqttClient.SubscribeAsync(new TopicFilterBuilder().WithTopic("Neon.iot").Build());
await _mqttClient.PublishAsync(new MqttApplicationMessageBuilder().WithTopic("Neon.iot")
.WithPayload("connected!").WithExactlyOnceQoS().WithRetainFlag().Build());
});
_mqttClient.UseApplicationMessageReceivedHandler(args => { OnMessageReceived(args.ApplicationMessage); });
await _mqttClient.ConnectAsync(options);
_logger.LogInformation("Connected");
ConnectMirror();
return(true);
}
private async Task StartMqttServer()
{
// Start a MQTT server.
Logger.LogInfo(LogCategory.Processor, this.Name, "Starting MQTT Server..");
_mqttServer = new MqttFactory().CreateMqttServer();
var optionsBuilder = new MqttServerOptionsBuilder()
.WithConnectionBacklog(100)
.WithDefaultEndpointPort(BrokerPort)
.WithConnectionValidator(AuthenticateUser)
.WithStorage(new RetainedMqttMessageHandler());
if (!string.IsNullOrEmpty(SecureCommunicationCertLocation))
{
optionsBuilder.WithEncryptedEndpoint().WithEncryptedEndpointPort(EncryptedBrokerPort);
}
var options = optionsBuilder.Build();
if (!string.IsNullOrEmpty(SecureCommunicationCertLocation))
{
var certificate = new X509Certificate(SecureCommunicationCertLocation, "");
options.TlsEndpointOptions.Certificate = certificate.Export(X509ContentType.Cert);
}
_mqttServer.Started += (s, a) =>
{
//Logger.LogTrace(LogCategory.Processor, this.Name, "MQTT Started", a.ToJSON());
};
_mqttServer.ApplicationMessageReceived += async(s, a) =>
{
Logger.LogTrace(LogCategory.Processor, this.Name, "MQTT Server Received Message", a.ToJSON());
};
_mqttServer.ClientSubscribedTopic += async(s, a) =>
{
//Logger.LogTrace(LogCategory.Processor, this.Name, "MQTT Client Subscribed to Topic", a.ToJSON());
};
_mqttServer.ClientUnsubscribedTopic += async(s, a) =>
{
//Logger.LogTrace(LogCategory.Processor, this.Name, "MQTT Client Unsubscribed to Topic", a.ToJSON());
};
_mqttServer.ClientConnected += async(s, a) =>
{
//Logger.LogTrace(LogCategory.Processor, this.Name, "MQTT Client Connected", a.ToJSON());
};
_mqttServer.ClientDisconnected += async(s, a) =>
{
//Logger.LogTrace(LogCategory.Processor, this.Name, "MQTT Client Disconnected", a.ToJSON());
};
await _mqttServer.StartAsync(options);
}
static void Main(string[] args)
{
var optionsServer = new MqttServerOptionsBuilder()
.WithDefaultEndpointBoundIPAddress(new System.Net.IPAddress(new byte[] { 192, 168, 10, 254 }))
.WithDefaultEndpointPort(1883);
IMqttServer _mqttBroker = new MqttFactory().CreateMqttServer();
//IMqttClient mqttClient = new MqttFactory().CreateMqttClient();
//var optionsClient = new MqttClientOptionsBuilder().WithClientId("9999").WithTcpServer("192.168.10.254", 1883);
var receivedEvents = new List <string>();
_mqttBroker.ClientConnected += delegate(object sender, MQTTnet.Server.MqttClientConnectedEventArgs e)
{
//receivedEvents.Add(args.ClientId);
Console.WriteLine($"Client {e.ClientId} has connected");
};
_mqttBroker.ApplicationMessageReceived += delegate(object sender, MqttApplicationMessageReceivedEventArgs e)
{
//receivedEvents.Add(args.ClientId);
Console.WriteLine($"Client {e.ClientId} Published ({e.ApplicationMessage.ConvertPayloadToString()})");
};
//** Start broker
Task _brokerStart = Task.Run(() => _mqttBroker.StartAsync(optionsServer.Build()));
_brokerStart.Wait();
Console.WriteLine("Broker Started");
//Task taskClientStart = Task.Run(() => mqttClient.ConnectAsync(optionsClient.Build()));
//taskClientStart.Wait();
Console.WriteLine("Waiting to exit, Press Any Key");
var pause = new ManualResetEvent(false);
Console.ReadKey();
//pause.WaitOne();
Console.WriteLine("Goodbye");
//var taskClientStop = Task.Run(() => mqttClient.DisconnectAsync());
//taskClientStop.Wait();
//** Stop Broker
Task _brokerTaskStop = Task.Run(() => _mqttBroker.StopAsync());
_brokerTaskStop.Wait();
Console.WriteLine("Broker Stopped");
}
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()));
}
async private static void CreateServer()
{
string ipAddress = config["mqttSettings:ipaddress"];
int port = Convert.ToInt32(config["mqttSettings:port"]);
bool useSSL = Convert.ToBoolean(config["mqttSettings:useSSL"]);
// Setup client validator.
var optionsBuilder = new MqttServerOptionsBuilder()
.WithConnectionBacklog(100)
// .WithDefaultEndpointBoundIPAddress(IPAddress.Parse(ipAddress))
.WithDefaultEndpointPort(port);
var options = optionsBuilder.Build() as MqttServerOptions;
//options.ConnectionValidator = c =>
//{
// ConnectionValidator.ValidateConnection(c);
//};
if (useSSL)
{
string certificateName = config["mqttSettings:certificateName"];
X509Certificate cert = null;
X509Store store = new X509Store(StoreLocation.LocalMachine);
X509Certificate2Collection cers = store.Certificates.Find(X509FindType.FindBySubjectName, certificateName, true);
if (cers.Count > 0)
{
cert = cers[0];
}
;
options.TlsEndpointOptions.Certificate = cert.Export(X509ContentType.Cert);
}
mqttServer = new MqttFactory().CreateMqttServer();
mqttServer.ClientConnected += OnConnected;
mqttServer.ClientDisconnected += OnDisonnected;
mqttServer.ClientSubscribedTopic += OnSubscribe;
mqttServer.ClientUnsubscribedTopic += OnUnsubscribe;
mqttServer.ApplicationMessageReceived += OnMessage;
MqttNetGlobalLogger.LogMessagePublished += (s, e) =>
{
var trace = $">> [{e.TraceMessage.Timestamp:O}] [{e.TraceMessage.ThreadId}] [{e.TraceMessage.Source}] [{e.TraceMessage.Level}]: {e.TraceMessage.Message}";
if (e.TraceMessage.Exception != null)
{
trace += Environment.NewLine + e.TraceMessage.Exception.ToString();
}
Console.WriteLine(trace);
};
await mqttServer.StartAsync(options);
Console.WriteLine("Press any key to exit.");
Console.ReadLine();
//await mqttServer.StopAsync();
}
