public static MqttClientOptionsBuilder WithConnectionUri(this MqttClientOptionsBuilder builder, Uri uri)
{
var port = uri.IsDefaultPort ? null : (int?)uri.Port;
switch (uri.Scheme.ToLower())
{
case "tcp":
case "mqtt":
builder.WithTcpServer(uri.Host, port);
break;
case "mqtts":
builder.WithTcpServer(uri.Host, port).WithTls();
break;
case "ws":
case "wss":
builder.WithWebSocketServer(uri.ToString());
break;
default:
throw new ArgumentException("Unexpected scheme in uri.");
}
if (!string.IsNullOrEmpty(uri.UserInfo))
{
var userInfo = uri.UserInfo.Split(':');
var username = userInfo[0];
var password = userInfo.Length > 1 ? userInfo[1] : "";
builder.WithCredentials(username, password);
}
return(builder);
}
private IMqttClientOptions CreateMqttClientOptions()
{
var options = new MqttClientOptionsBuilder()
.WithClientId(_settings.ClientId)
.WithCredentials(_settings.Username, _settings.Password);
if (_settings.TcpEndPoint.Enabled)
{
if (_settings.TcpEndPoint.Port > 0)
{
options.WithTcpServer(_settings.TcpEndPoint.Server, _settings.TcpEndPoint.Port);
}
else
{
options.WithTcpServer(_settings.TcpEndPoint.Server);
}
}
else
{
options.WithTcpServer("localhost");
}
if (_settings.CommunicationTimeout > 0)
{
options.WithCommunicationTimeout(TimeSpan.FromSeconds(_settings.CommunicationTimeout));
}
if (_settings.EnableCleanSessions)
{
options.WithCleanSession();
}
return(options.Build());
}
/// <inheritdoc cref="IMqttClientConfigBuilder.ConnectViaTcp(string,int?)" />
public IMqttClientConfigBuilder ConnectViaTcp(string server, int?port = null)
{
Check.NotNull(server, nameof(server));
_builder.WithTcpServer(server, port);
return(this);
}
private async Task ConnectToServer()
{
var clientOptions = new MqttClientOptionsBuilder().WithClientId($"Neon-Server-{EntitiesUtils.GenerateId()}");
if (_config.UseEmbeddedServer)
{
clientOptions = clientOptions.WithTcpServer("127.0.0.1", _config.EmbeddedServerPort);
}
else
{
clientOptions = clientOptions.WithTcpServer(_config.Client.Hostname, _config.Client.Port);
}
_mqttClient = new MqttFactory().CreateMqttClient();
var options = clientOptions.Build();
_logger.LogInformation($"Connecting to server ");
_mqttClient.UseDisconnectedHandler(async args =>
{
_logger.LogInformation($"Disconnected from server, will retry in 5 seconds");
await Task.Delay(5000);
if (_clientConnectionRetryNum <= 3)
{
if (_mqttClient != null)
{
await _mqttClient.ConnectAsync(options);
_logger.LogInformation($"Reconnected to server...");
_clientConnectionRetryNum++;
}
}
});
_mqttClient.UseApplicationMessageReceivedHandler(args =>
{
if (args.ApplicationMessage.Payload == null)
{
args.ApplicationMessage.Payload = Encoding.UTF8.GetBytes("");
}
OnMessageReceived(args.ApplicationMessage.Topic, Encoding.UTF8.GetString(args.ApplicationMessage.Payload));
});
await _mqttClient.ConnectAsync(options);
await SubscribeTopic("/neon");
_logger.LogInformation($"MQTT Client Connected");
}
public async Task <MqttClient> ConnectClient(MqttClientOptionsBuilder options, TimeSpan timeout = default)
{
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
options = options.WithTcpServer("127.0.0.1", ServerPort);
var client = CreateClient();
if (timeout == TimeSpan.Zero)
{
await client.ConnectAsync(options.Build()).ConfigureAwait(false);
}
else
{
using (var timeoutToken = new CancellationTokenSource(timeout))
{
await client.ConnectAsync(options.Build(), timeoutToken.Token).ConfigureAwait(false);
}
}
return(client);
}
private static IMqttClientOptions UnwrapOptions(IClientOptions wrappedOptions, IWillMessage willMessage)
{
var optionsBuilder = new MqttClientOptionsBuilder();
if (wrappedOptions.ConnectionType == ConnectionType.Tcp)
{
optionsBuilder.WithTcpServer(wrappedOptions.Uri.Host);
}
else
{
optionsBuilder.WithWebSocketServer(wrappedOptions.Uri.AbsoluteUri);
}
return(optionsBuilder
.WithWillMessage(WrapWillMessage(willMessage))
.WithCleanSession(wrappedOptions.CleanSession)
.WithClientId(wrappedOptions.ClientId ?? Guid.NewGuid().ToString().Replace("-", string.Empty))
.WithTls(wrappedOptions.AllowUntrustedCertificates, wrappedOptions.IgnoreCertificateChainErrors,
wrappedOptions.IgnoreCertificateChainErrors, UnwrapCertificates(wrappedOptions.Certificates))
.WithProtocolVersion(UnwrapProtocolVersion(wrappedOptions.ProtocolVersion))
.WithCommunicationTimeout(wrappedOptions.DefaultCommunicationTimeout == default(TimeSpan)
? TimeSpan.FromSeconds(10)
: wrappedOptions.DefaultCommunicationTimeout)
.WithKeepAlivePeriod(wrappedOptions.KeepAlivePeriod == default(TimeSpan)
? TimeSpan.FromSeconds(5)
: wrappedOptions.KeepAlivePeriod)
.WithCredentials(wrappedOptions.UserName, wrappedOptions.Password)
.Build());
}
private IMqttClientOptions GetMqttOption(string clientId)
{
var builder = new MqttClientOptionsBuilder()
.WithProtocolVersion(MqttProtocolVersion.V311)
.WithClientId(clientId);
/*
* .WithWillMessage(new MqttApplicationMessage()
* {
* Payload = Encoding.UTF8.GetBytes("Hello World!!!"),
* Topic = "/homegenie",
* Retain = true,
* QualityOfServiceLevel = MqttQualityOfServiceLevel.AtLeastOnce
* });
*/
// TODO: ...
//.WithKeepAlivePeriod(TimeSpan.FromSeconds(...))
//.WithCommunicationTimeout(TimeSpan.FromSeconds(...))
// .WithTls()
//.WithCleanSession();
if (usingWebSockets)
{
builder.WithWebSocketServer(endPoint.Address + ":" + endPoint.Port + "/mqtt");
}
else
{
builder.WithTcpServer(endPoint.Address, endPoint.Port);
}
if (networkCredential != null)
{
builder.WithCredentials(networkCredential.UserName, networkCredential.Password);
}
return(builder.Build());
}
public FedNetClient(ConnectorData MQTTConnectorData, IFedNetLogger newlogSystem = null)
{
_logSystem = newlogSystem;
if (_logSystem == null)
{
_logSystem = new DefaultLogger();
}
_MQTTHostAndPort = MQTTConnectorData.getHasSE();
_ClientConfiguration = new MqttClientOptionsBuilder();
_ClientConfiguration.WithClientId(String.Format("{0}-{1}_{2}", MQTTConnectorData.Username, DateTime.Now.ToString("ffffmmHHss"), FedNetWorker.getRandomString(10)));
if (MQTTConnectorData.useCreditential)
{
_ClientConfiguration.WithCredentials(MQTTConnectorData.Username, MQTTConnectorData.Password);
}
_ClientConfiguration.WithTcpServer(MQTTConnectorData.Host, MQTTConnectorData.Port);
_theGameClient = new MqttFactory().CreateMqttClient();
_theGameClient.UseDisconnectedHandler(e => {
_logSystem.Info("Disconnected (reason : " + (e.AuthenticateResult != null ? e.AuthenticateResult.ResultCode.ToString() : "unknow") + ")");
if (Disconnected != null)
{
Disconnected.Invoke(this, e);
}
if (reconnectOnDisco)
{
Task.Delay(1000).Wait();
Connect();
}
});
_theGameClient.UseConnectedHandler(e => {
_logSystem.Info("Connected !!");
_theGameClient.SubscribeAsync(FedNetConstante.SERVER_TO_CLIENT + FedNetConstante.DEFAULT_TOPIC_SEPARATOR + ClientId + FedNetConstante.DEFAULT_TOPIC_SEPARATOR + FedNetConstante.DEFAULT_TOPIC_JOKER, (MqttQualityOfServiceLevel)FedNetConstante.PRIORITY_SERVER_TO_CLIENT);
_theGameClient.SubscribeAsync(FedNetConstante.SERVER_BROADCAST + FedNetConstante.DEFAULT_TOPIC_SEPARATOR + FedNetConstante.DEFAULT_TOPIC_JOKER, (MqttQualityOfServiceLevel)FedNetConstante.PRIORITY_SERVER_BROADCAST);
if (Connected != null)
{
Connected.Invoke(this, e);
}
});
_theGameClient.UseApplicationMessageReceivedHandler(e => {
if (e.ClientId == "" || e.ClientId == " " || e.ClientId == null)
{
return;
}
if (MessageReceived != null)
{
MessageReceived.Invoke(this, Message.getMessage(e.ApplicationMessage));
}
});
reconnectOnDisco = true;
_logSystem.Info("Client initialized !");
}
private MqttClientOptionsBuilder BuildConnectionOptions()
{
var mqttClientOptionsBuilder = new MqttClientOptionsBuilder();
if (Uri != null && RequestHeaders != null && RequestHeaders.Any())
{
return(mqttClientOptionsBuilder.WithWebSocketServer(BuildWebSocketServerOptions));
}
return(mqttClientOptionsBuilder.WithTcpServer(BuildTcpServerOptions));
}
public async Task <IMqttClient> ConnectClientAsync(MqttClientOptionsBuilder options)
{
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
var client = CreateClient();
await client.ConnectAsync(options.WithTcpServer("localhost", ServerPort).Build());
return(client);
}
public async Task <IMqttClient> ConnectClientAsync(Action <MqttClientOptionsBuilder> optionsBuilder)
{
var options = new MqttClientOptionsBuilder();
options = options.WithTcpServer("localhost", ServerPort);
optionsBuilder?.Invoke(options);
var client = CreateClient();
await client.ConnectAsync(options.Build()).ConfigureAwait(false);
return(client);
}
public async Task <LowLevelMqttClient> ConnectLowLevelClient(Action <MqttClientOptionsBuilder> optionsBuilder = null)
{
var options = new MqttClientOptionsBuilder();
options = options.WithTcpServer("127.0.0.1", ServerPort);
optionsBuilder?.Invoke(options);
var client = CreateLowLevelClient();
await client.ConnectAsync(options.Build(), CancellationToken.None).ConfigureAwait(false);
return(client);
}
public Task StartAsync()
{
connectingFailedReason = null;
var mqttClientOptions = new MqttClientOptionsBuilder()
.WithClientId(clientId)
.WithCleanSession();
if (url.StartsWith("ws://"))
{
var subUrl = url.Substring("ws://".Length);
mqttClientOptions.WithWebSocketServer(subUrl);
}
else
{
var subUrl = url.StartsWith("tcp://") ? url.Substring("tcp://".Length) : url;
mqttClientOptions.WithTcpServer(subUrl);
}
var options = new ManagedMqttClientOptionsBuilder()
.WithAutoReconnectDelay(TimeSpan.FromSeconds(5))
.WithClientOptions(mqttClientOptions.Build())
.Build();
return(Task.Run(async() =>
{
if (this.mqttClient != null)
{
await this.mqttClient.StopAsync();
}
var mqttClient = new MqttFactory().CreateManagedMqttClient();
mqttClient.UseApplicationMessageReceivedHandler(e =>
{
var msg = Encoding.UTF8.GetString(e.ApplicationMessage.Payload);
var topic = e.ApplicationMessage.Topic;
OnReceivedMessage(topic, msg, e);
});
mqttClient.ConnectedHandler = this;
mqttClient.ConnectingFailedHandler = this;
mqttClient.DisconnectedHandler = this;
startWaitEvent.Reset();
await mqttClient.StartAsync(options);
startWaitEvent.WaitOne();
if (!string.IsNullOrEmpty(connectingFailedReason))
{
throw new LogMeException(connectingFailedReason);
}
this.mqttClient = mqttClient;
OnConnected();
}));
}
public async Task <IMqttClient> ConnectClient(MqttClientOptionsBuilder options)
{
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
options = options.WithTcpServer("127.0.0.1", ServerPort);
var client = CreateClient();
await client.ConnectAsync(options.Build()).ConfigureAwait(false);
return(client);
}
private IMqttClientOptions GetConnectOptions()
{
var mqttOptionsBuilder = new MqttClientOptionsBuilder()
.WithCleanSession()
.WithClientId(Guid.NewGuid().ToString());
if (!string.IsNullOrWhiteSpace(_mqttConfig.User))
{
mqttOptionsBuilder = mqttOptionsBuilder.WithCredentials(_mqttConfig.User, _mqttConfig.Password);
}
return(mqttOptionsBuilder.WithTcpServer(_mqttConfig.Host, _mqttConfig.Port)
.WithTls(tlsParameters =>
{
tlsParameters.UseTls = _mqttConfig.Tls;
}).Build());
}
public async Task Connect(string username, string server, int port)
{
var clientOptionsBuilder = new MqttClientOptionsBuilder();
clientOptionsBuilder.WithProtocolVersion((MqttProtocolVersion.V310));
if (!string.IsNullOrWhiteSpace(username))
{
MqttClientCredentials credentials = new MqttClientCredentials();
credentials.Username = username;
clientOptionsBuilder.WithCredentials(credentials);
}
clientOptionsBuilder.WithTcpServer(server, port);
await _mqttClient.ConnectAsync(clientOptionsBuilder.Build());
}
public async Task <ILowLevelMqttClient> ConnectLowLevelClientAsync(Action <MqttClientOptionsBuilder> optionsBuilder)
{
if (optionsBuilder == null)
{
throw new ArgumentNullException(nameof(optionsBuilder));
}
var options = new MqttClientOptionsBuilder();
options = options.WithTcpServer("127.0.0.1", ServerPort);
optionsBuilder.Invoke(options);
var client = new MqttFactory().CreateLowLevelMqttClient();
await client.ConnectAsync(options.Build(), CancellationToken.None).ConfigureAwait(false);
return(client);
}
public async Task <IMqttClient> ConnectClientAsync(Action <MqttClientOptionsBuilder> optionsBuilder)
{
if (optionsBuilder == null)
{
throw new ArgumentNullException(nameof(optionsBuilder));
}
var options = new MqttClientOptionsBuilder();
options = options.WithTcpServer("localhost", ServerPort);
optionsBuilder.Invoke(options);
var client = CreateClient();
await client.ConnectAsync(options.Build()).ConfigureAwait(false);
return(client);
}
public void changeClientConfig(ConnectorData MQTTConnectorData)
{
_MQTTHostAndPort = MQTTConnectorData.getHasSE();
_ClientConfiguration = new MqttClientOptionsBuilder();
_ClientConfiguration.WithClientId(String.Format("{0}-{1}_{2}", MQTTConnectorData.Username, DateTime.Now.ToString("ffffmmHHss"), FedNetWorker.getRandomString(10)));
if (MQTTConnectorData.useCreditential)
{
_ClientConfiguration.WithCredentials(MQTTConnectorData.Username, MQTTConnectorData.Password);
}
if (!MQTTConnectorData.useCreditential)
{
_ClientConfiguration.WithCredentials(MQTTConnectorData.Username, "");
}
_ClientConfiguration.WithTcpServer(MQTTConnectorData.Host, MQTTConnectorData.Port);
_logSystem.Info("MQTT Client reinitialized !");
}
/// <summary>
/// Connects the Sparkplug node to the MQTT broker.
/// </summary>
/// <param name="options">The configuration option.</param>
/// <returns>A <see cref="Task"/> representing any asynchronous operation.</returns>
private async Task ConnectInternal(SparkplugNodeOptions options)
{
options.CancellationToken ??= CancellationToken.None;
var builder = new MqttClientOptionsBuilder()
.WithClientId(options.ClientId)
.WithCredentials(options.UserName, options.Password)
.WithCleanSession(false)
.WithProtocolVersion(MqttProtocolVersion.V311);
if (options.UseTls)
{
builder.WithTls();
}
if (options.WebSocketParameters is null)
{
builder.WithTcpServer(options.BrokerAddress, options.Port);
}
else
{
builder.WithWebSocketServer(options.BrokerAddress, options.WebSocketParameters);
}
if (options.ProxyOptions != null)
{
builder.WithProxy(
options.ProxyOptions.Address,
options.ProxyOptions.Username,
options.ProxyOptions.Password,
options.ProxyOptions.Domain,
options.ProxyOptions.BypassOnLocal);
}
if (this.willMessage != null)
{
builder.WithWillMessage(this.willMessage);
}
this.ClientOptions = builder.Build();
await this.Client.ConnectAsync(this.ClientOptions, options.CancellationToken.Value);
}
private IMqttClientOptions GetMqttOption(string clientId)
{
var builder = new MqttClientOptionsBuilder()
.WithProtocolVersion(MqttProtocolVersion.V311)
.WithKeepAlivePeriod(TimeSpan.FromSeconds(5))
.WithCommunicationTimeout(TimeSpan.FromSeconds(15))
.WithClientId(clientId)
// this message will be sent to all clients
// subscribed to <clientId>/status topic
// if this client gets disconnected
.WithWillMessage(new MqttApplicationMessage
{
Payload = Encoding.UTF8.GetBytes("disconnected"),
Topic = String.Format("/{0}/status", clientId),
Retain = true,
QualityOfServiceLevel = MqttQualityOfServiceLevel.AtLeastOnce
});
// TODO: ?
// .WithCleanSession();
if (usingWebSockets)
{
builder.WithWebSocketServer(endPoint.Address + ":" + endPoint.Port + "/mqtt");
}
else
{
builder.WithTcpServer(endPoint.Address, endPoint.Port);
}
if (networkCredential != null)
{
builder.WithCredentials(networkCredential.UserName, networkCredential.Password);
}
if (useSsl)
{
var tlsParameters = new MqttClientOptionsBuilderTlsParameters {
UseTls = true
};
builder.WithTls(tlsParameters);
}
return(builder.Build());
}
public MqttWorker(EvoHomeSettings evoHomeSettings, ILogger <MqttWorker> logger)
{
_settings = evoHomeSettings;
_logger = logger;
if (evoHomeSettings.DisableMqtt)
{
_logger.LogInformation("Mqtt Disabled");
return;
}
var builder = new MqttClientOptionsBuilder()
.WithClientId(evoHomeSettings.MqttClientName);
if (!string.IsNullOrWhiteSpace(evoHomeSettings.MqttUser))
{
builder.WithCredentials(evoHomeSettings.MqttUser, evoHomeSettings.MqttPassword);
}
if (evoHomeSettings.MqttWebSockets)
{
builder.WithWebSocketServer($"{evoHomeSettings.MqttConnection}:{evoHomeSettings.MqttPort}");
}
else
{
builder.WithTcpServer(evoHomeSettings.MqttConnection, evoHomeSettings.MqttPort);
}
var options = builder.Build();
_managedOptions = new ManagedMqttClientOptionsBuilder()
.WithAutoReconnectDelay(TimeSpan.FromSeconds(5))
.WithClientOptions(options)
.Build();
var factory = new MqttFactory();
_mqttClient = factory.CreateManagedMqttClient();
}
public void Connect(out string errMsg)
{
errMsg = "";
if (this.mqttClient != null && this.mqttClient.IsConnected)
{
return;
}
if (this.param == null)
{
errMsg = "连接MQTT服务端失败,没有指明服务参数";
return;
}
try
{
mqttClient = new MqttFactory().CreateMqttClient() as MqttClient;
this.OnloadEvents();
MqttClientOptionsBuilder optionsBuilder = new MqttClientOptionsBuilder();
optionsBuilder.WithCommunicationTimeout(TimeSpan.FromSeconds(10));// 只连接等待10秒
optionsBuilder.WithTcpServer(this.param.ip, this.param.port);
optionsBuilder.WithCredentials(this.param.userName, this.param.password);
optionsBuilder.WithClientId(this.param.clientID);
optionsBuilder.WithCleanSession(true);// 临时会话
Task task = mqttClient.ConnectAsync(optionsBuilder.Build());
task.Wait(5000);
if (!this.IsConnected)
{
errMsg = "连接MQTT服务器失败";
}
}
catch (Exception ex)
{
errMsg = "连接到MQTT服务器失败！" + ex.Message;
}
}
private async Task <IManagedMqttClient> ConnectAsync(string clientId, string mqttServerAddress, int port, string username, string password, bool useTLS, CancellationToken token)
{
var mqttClientFactory = new MqttFactory();
var builder = new MqttClientOptionsBuilder();
builder.WithTcpServer(mqttServerAddress, port);
if (!string.IsNullOrWhiteSpace(clientId))
{
builder.WithClientId(clientId);
}
if (!string.IsNullOrEmpty(username) && !string.IsNullOrEmpty(password))
{
builder.WithCredentials(username, password);
}
if (useTLS)
{
builder.WithTls();
}
var options = builder.Build();
var managedOptions = new ManagedMqttClientOptionsBuilder()
.WithAutoReconnectDelay(TimeSpan.FromSeconds(5))
.WithClientOptions(options)
.Build();
//todo add a logger provided to the function CreateMqttClient
var client = mqttClientFactory.CreateManagedMqttClient(new MqttNetLogger(logger));
await client.StartAsync(managedOptions);
await client.WaitForConnectAsync(2000, token);
return(client);
}
private async void but_start_ClickAsync(object sender, EventArgs even)
{
try
{
but_Stop_Click(null, null);
var factory = new MqttFactory();
mqttClient = factory.CreateManagedMqttClient();
var mqttClientOptions = new MqttClientOptionsBuilder()
.WithClientId(txt_ClientID.Text?.Trim())
//.WithTcpServer(txt_Address.Text?.Trim(), int.Parse(txt_Port.Text?.Trim()))
.WithCredentials(txt_UserName.Text, txt_Password.Text);
if (checkBox1.Checked)
{
if (!File.Exists(txt_ca_file.Text))
{
MessageBox.Show($"没有找到文件:{txt_ca_file.Text}");
return;
}
if (!File.Exists(txt_pfx_file.Text))
{
MessageBox.Show($"没有找到文件:{txt_pfx_file.Text}");
return;
}
var caCert = X509Certificate.CreateFromCertFile(txt_ca_file.Text);
var clientCert = new X509Certificate2(txt_pfx_file.Text);
mqttClientOptions = mqttClientOptions.WithTls(new MqttClientOptionsBuilderTlsParameters()
{
UseTls = true,
SslProtocol = System.Security.Authentication.SslProtocols.Tls12,
CertificateValidationHandler = (o) =>
{
return(true);
},
Certificates = new List <X509Certificate>()
{
caCert, clientCert
}
});
}
if (comboBox1.SelectedIndex == 0)
{
mqttClientOptions = mqttClientOptions.WithTcpServer(txt_Address.Text?.Trim(), int.Parse(txt_Port.Text?.Trim()));
}
else if (comboBox1.SelectedIndex == 1)
{
mqttClientOptions = mqttClientOptions.WithWebSocketServer($"{txt_Address.Text?.Trim()}:{txt_Port.Text?.Trim()}/mqtt").WithTls();
}
else if (comboBox1.SelectedIndex == 2)
{
mqttClientOptions = mqttClientOptions.WithWebSocketServer($"{txt_Address.Text?.Trim()}:{txt_Port.Text?.Trim()}/mqtt");
}
var options = new ManagedMqttClientOptionsBuilder()
.WithAutoReconnectDelay(TimeSpan.FromSeconds(5))
.WithClientOptions(mqttClientOptions.Build())
.Build();
await mqttClient.StartAsync(options);
mqttClient.UseDisconnectedHandler(e =>
{
WriteLine_1("### 服务器断开连接 ###");
});
mqttClient.UseApplicationMessageReceivedHandler(e =>
{
WriteLine_1("### 收到消息 ###");
WriteLine_1($"+ Topic = {e.ApplicationMessage.Topic}");
try
{
WriteLine_1($"+ Payload = {Encoding.UTF8.GetString(e.ApplicationMessage.Payload)}");
}
catch { }
WriteLine_1($"+ QoS = {e.ApplicationMessage.QualityOfServiceLevel}");
WriteLine_1($"+ Retain = {e.ApplicationMessage.Retain}");
WriteLine_1();
});
mqttClient.UseConnectedHandler(e =>
{
WriteLine_1("### 连接到服务 ###");
but_Start.Enabled = false;
but_Subscribe.Enabled = true;
but_Publish.Enabled = true;
but_Stop.Enabled = true;
});
}
catch (Exception ex)
{
WriteLine_1($"err：{ex.Message}");
}
}
private MqttClientOptionsBuilder CreateOptionsBuilder(ClientCredentials credentials = null)
{
MqttClientOptionsBuilder clientOptionsBuilder = new MqttClientOptionsBuilder();
MqttClientOptionsBuilderTlsParameters tlsParameters = null;
string hostName = Settings.Client.BrokerHostname;
int portNum = Settings.Client.BrokerPort;
//check if broker endpoint for local connections is defined in environment, only possible for connections without credentials
if (credentials == null)
{
string brokerEndpoint = Environment.GetEnvironmentVariable("GE_BROKER_CONNECTION_ENDPOINT");
if (!string.IsNullOrEmpty(brokerEndpoint))
{
string[] tokens = brokerEndpoint.Split(':');
if (tokens.Length == 2)
{
hostName = tokens[0];
portNum = Convert.ToInt32(tokens[1], CultureInfo.InvariantCulture);
}
}
}
clientOptionsBuilder.WithCleanSession();
clientOptionsBuilder.WithClientId(ClientId);
if (portNum == 443)
{
clientOptionsBuilder.WithWebSocketServer(hostName);
}
else
{
clientOptionsBuilder.WithTcpServer(hostName, portNum);
}
if (credentials != null)
{
if (credentials.HasCertificates())
{
tlsParameters = new MqttClientOptionsBuilderTlsParameters
{
UseTls = true,
AllowUntrustedCertificates = Settings.Client.AllowUntrustedCertificates,
IgnoreCertificateChainErrors = Settings.Client.IgnoreCertificateChainErrors,
IgnoreCertificateRevocationErrors = Settings.Client.IgnoreCertificateRevocationErrors,
CertificateValidationHandler = CertificateValidationCallback,
Certificates = credentials.ClientCertAndCaChain,
SslProtocol = SslProtocols.Tls12
};
clientOptionsBuilder.WithTls(tlsParameters);
}
if (credentials.IsUserNameAndPasswordRequired())
{
credentials.GetUserNameAndPassword(ClientId, out string username, out string password);
clientOptionsBuilder.WithCredentials(username, password);
}
}
// settings for connection timeout and MQTT kepp alive interval, given in seconds
// (defaults in MQTTnet stack are CommunicationTimeout = 10 sec and KeepAlivePeriod = 15 sec.,
// see in MqttClientOptions.cs of MQTTnet)
clientOptionsBuilder.WithCommunicationTimeout(new TimeSpan(0, 0, Settings.Client.CommunicationTimeout));
clientOptionsBuilder.WithKeepAlivePeriod(new TimeSpan(0, 0, Settings.Client.MqttKeepAlivePeriod));
return(clientOptionsBuilder);
}
/// <summary>
/// Connects the Sparkplug node to the MQTT broker.
/// </summary>
/// <exception cref="ArgumentNullException">The options are null.</exception>
/// <returns>A <see cref="Task"/> representing any asynchronous operation.</returns>
private async Task ConnectInternal()
{
if (this.options is null)
{
throw new ArgumentNullException(nameof(this.options));
}
// Increment the session number.
this.IncrementLastSessionNumber();
// Reset the sequence number.
this.ResetLastSequenceNumber();
// Get the will message.
var willMessage = this.MessageGenerator.GetSparkPlugNodeDeathMessage(
this.NameSpace,
this.options.GroupIdentifier,
this.options.EdgeNodeIdentifier,
this.LastSessionNumber);
// Build up the MQTT client and connect.
this.options.CancellationToken ??= CancellationToken.None;
var builder = new MqttClientOptionsBuilder()
.WithClientId(this.options.ClientId)
.WithCredentials(this.options.UserName, this.options.Password)
.WithCleanSession(false)
.WithProtocolVersion(MqttProtocolVersion.V311);
if (this.options.UseTls)
{
builder.WithTls();
}
if (this.options.WebSocketParameters is null)
{
builder.WithTcpServer(this.options.BrokerAddress, this.options.Port);
}
else
{
builder.WithWebSocketServer(this.options.BrokerAddress, this.options.WebSocketParameters);
}
if (this.options.ProxyOptions != null)
{
builder.WithProxy(
this.options.ProxyOptions.Address,
this.options.ProxyOptions.Username,
this.options.ProxyOptions.Password,
this.options.ProxyOptions.Domain,
this.options.ProxyOptions.BypassOnLocal);
}
builder.WithWillMessage(willMessage);
this.ClientOptions = builder.Build();
// Debug output.
this.Logger?.Debug("CONNECT Message: {@ClientOptions}", this.ClientOptions);
await this.Client.ConnectAsync(this.ClientOptions, this.options.CancellationToken.Value);
}
/// <summary>
/// Opens the component.
/// </summary>
/// <param name="correlationId">(optional) transaction id to trace execution through call chain.</param>
public async Task OpenAsync(string correlationId)
{
var options = await _connectionResolver.ResolveAsync(correlationId);
var opts = new MqttClientOptionsBuilder()
.WithClientId(_clientId);
if (_keepAliveTimeout > 0)
{
opts.WithKeepAlivePeriod(TimeSpan.FromMilliseconds(_keepAliveTimeout));
}
else
{
opts.WithNoKeepAlive();
}
var uri = options.GetAsString("servers") ?? "";
var servers = uri.Split(',');
foreach (var server in servers)
{
var host = server;
var port = 1883;
var pos = server.IndexOf(":");
if (pos > 0)
{
host = server.Substring(0, pos);
Int32.TryParse(server.Substring(pos + 1), out port);
}
opts.WithTcpServer(host, port);
}
var username = options.GetAsString("username");
if (!string.IsNullOrEmpty(username))
{
var password = options.GetAsString("password");
opts.WithCredentials(username, password);
}
//opts.SetAutoReconnect(c.retryConnect)
//opts.SetConnectTimeout(time.Millisecond * time.Duration(c.connectTimeout))
//opts.SetConnectRetryInterval(time.Millisecond * time.Duration(c.reconnectTimeout))
var client = new MqttFactory().CreateMqttClient();
client.UseDisconnectedHandler(DisconnectedHandlerAsync);
client.UseApplicationMessageReceivedHandler(MessageReceiveHandlerAsync);
try
{
await client.ConnectAsync(opts.Build());
}
catch (Exception ex)
{
_logger.Error(correlationId, ex, "Failed to connect to MQTT broker at " + uri);
throw ex;
}
_connection = client;
_clientOptions = opts.Build();
_logger.Debug(correlationId, "Connected to MQTT broker at " + uri);
}
private async void Connect_Click(object sender, EventArgs e)
{
if (mqttClient == null)
{
mqttClient = new MqttFactory().CreateMqttClient();
mqttClient.UseApplicationMessageReceivedHandler(new
Action <MqttApplicationMessageReceivedEventArgs>(MqttClient_ApplicationMessageReceived));
mqttClient.UseDisconnectedHandler(new
Action <MqttClientDisconnectedEventArgs>(MqttClient_Disconnected));
mqttClient.UseConnectedHandler(new
Action <MqttClientConnectedEventArgs>(MqttClient_Connected));
}
if (mqttClient.IsConnected)
{
return;
}
status.Text = "Connecting...";
var clientOptionsBuilder = new MqttClientOptionsBuilder();
clientOptionsBuilder.WithProtocolVersion((MqttProtocolVersion)version.SelectedValue);
if (!string.IsNullOrWhiteSpace(username.Text))
{
if (!string.IsNullOrWhiteSpace(password.Text))
{
clientOptionsBuilder.WithCredentials(username.Text, password.Text);
}
else
{
clientOptionsBuilder.WithCredentials(username.Text);
}
}
if (!string.IsNullOrWhiteSpace(clientId.Text))
{
clientOptionsBuilder.WithClientId(clientId.Text);
}
if (useTls.Checked)
{
clientOptionsBuilder.WithTls();
}
if (useWebSocket.Checked)
{
clientOptionsBuilder.WithWebSocketServer(host.Text);
}
else
{
clientOptionsBuilder.WithTcpServer(host.Text, int.Parse(port.Text));
}
if (cleanSession.Checked)
{
clientOptionsBuilder.WithCleanSession(true);
}
else
{
clientOptionsBuilder.WithCleanSession(false);
}
if (setWill.Checked && !string.IsNullOrWhiteSpace(input.TextValue))
{
clientOptionsBuilder.WithWillMessage(BuildMessage());
}
try
{
await mqttClient.ConnectAsync(clientOptionsBuilder.Build());
clientId.Text = mqttClient.Options.ClientId;
}
catch (Exception ex)
{
MessageBox.Show(this, ex.Message);
}
}
private void _connect()
{
try
{
if (_mqttClient != null && _mqttClient.IsConnected)
{
return;
}
if (Options == null)
{
return;
}
LastWillMessage lastWillMsg = new LastWillMessage();
string payload = JsonConvert.SerializeObject(lastWillMsg);
MqttApplicationMessage msg = new MqttApplicationMessage()
{
Payload = Encoding.UTF8.GetBytes(payload),
QualityOfServiceLevel = MqttQualityOfServiceLevel.AtLeastOnce,
Retain = true,
Topic = string.Format(MQTTTopic.ScadaConnTopic, Options.ScadaId)
};
string clientId = "EdgeAgent_" + Guid.NewGuid().ToString("N");
var ob = new MqttClientOptionsBuilder();
ob.WithClientId(clientId)
.WithCredentials(Options.MQTT.Username, Options.MQTT.Password)
.WithCleanSession()
.WithWillMessage(msg);
switch (Options.MQTT.ProtocolType)
{
case Protocol.TCP:
ob.WithTcpServer(Options.MQTT.HostName, Options.MQTT.Port);
break;
case Protocol.WebSocket:
ob.WithWebSocketServer(Options.MQTT.HostName);
break;
default:
ob.WithTcpServer(Options.MQTT.HostName, Options.MQTT.Port);
break;
}
if (Options.UseSecure)
{
ob.WithTls();
}
var mob = new ManagedMqttClientOptionsBuilder()
.WithAutoReconnectDelay(TimeSpan.FromMilliseconds(Options.ReconnectInterval))
.WithClientOptions(ob.Build())
.Build();
_mqttClient.StartAsync(mob);
}
catch (Exception ex)
{
//_logger.Error( ex.ToString() );
}
}
