public async Task Execute_Success_MQTT_V5_Mixed_Clients()
{
using (var testEnvironment = CreateTestEnvironment())
{
await testEnvironment.StartServer();
var responseSender = await testEnvironment.ConnectClient();
await responseSender.SubscribeAsync("MQTTnet.RPC/+/ping", MqttQualityOfServiceLevel.AtMostOnce);
responseSender.ApplicationMessageReceivedAsync += async e =>
{
Assert.IsNull(e.ApplicationMessage.ResponseTopic);
await responseSender.PublishStringAsync(e.ApplicationMessage.Topic + "/response", "pong");
};
var requestSender = await testEnvironment.ConnectClient(new MqttClientOptionsBuilder().WithProtocolVersion(MqttProtocolVersion.V500));
using (var rpcClient = new MqttRpcClient(requestSender, new MqttRpcClientOptionsBuilder().Build()))
{
var response = await rpcClient.ExecuteAsync(TimeSpan.FromSeconds(5), "ping", "", MqttQualityOfServiceLevel.AtMostOnce);
Assert.AreEqual("pong", Encoding.UTF8.GetString(response));
}
}
}
public IEnumerable <string> Get()
{
var factory = new MqttFactory();
var mqttClient = factory.CreateMqttClient();
var rpcClient = new MqttRpcClient(mqttClient);
var options = new MqttClientOptionsBuilder()
.WithWebSocketServer("10.195.97.228:1883/mqtt")
.Build();
mqttClient.ConnectAsync(options);
var message = new MqttApplicationMessageBuilder()
.WithTopic("MyTopic")
.WithPayload("Hello World")
.WithExactlyOnceQoS()
.WithRetainFlag()
.Build();
var timeout = TimeSpan.FromSeconds(5);
var qos = MqttQualityOfServiceLevel.AtMostOnce;
var response = rpcClient.ExecuteAsync(timeout, "myMethod", "Hello World", qos);
return(new string[] { "value1", "value2" });
}
async Task Execute_Success(MqttQualityOfServiceLevel qosLevel, MqttProtocolVersion protocolVersion)
{
using (var testEnvironment = new TestEnvironment(TestContext))
{
await testEnvironment.StartServer();
var responseSender = await testEnvironment.ConnectClient(new MqttClientOptionsBuilder().WithProtocolVersion(protocolVersion));
await responseSender.SubscribeAsync("MQTTnet.RPC/+/ping", qosLevel);
responseSender.ApplicationMessageReceivedHandler = new MqttApplicationMessageReceivedHandlerDelegate(async e =>
{
await responseSender.PublishAsync(e.ApplicationMessage.Topic + "/response", "pong");
});
var requestSender = await testEnvironment.ConnectClient();
using (var rpcClient = new MqttRpcClient(requestSender, new MqttRpcClientOptionsBuilder().Build()))
{
var response = await rpcClient.ExecuteAsync(TimeSpan.FromSeconds(5), "ping", "", qosLevel);
Assert.AreEqual("pong", Encoding.UTF8.GetString(response));
}
}
}
/// <summary>
/// methodName : xxx.yyy
/// </summary>
/// <param name="methodName"></param>
/// <param name="msg"></param>
/// <param name="timeoutSeconds"></param>
/// <returns></returns>
public async Task <string> RpcPub(string methodName, string msg, int timeoutSeconds = 15)
{
var rpcClient = new MqttRpcClient(_client.InternalClient.InternalClient, new MqttRpcClientOptions());
var response = await rpcClient
.ExecuteAsync(TimeSpan.FromSeconds(timeoutSeconds), methodName, msg,
MqttQualityOfServiceLevel.ExactlyOnce)
.ConfigureAwait(false);
return(Encoding.UTF8.GetString(response));
}
public async Task Execute_Timeout()
{
using (var testEnvironment = new TestEnvironment())
{
await testEnvironment.StartServerAsync();
var requestSender = await testEnvironment.ConnectClientAsync();
var rpcClient = new MqttRpcClient(requestSender);
await rpcClient.ExecuteAsync(TimeSpan.FromSeconds(2), "ping", "", MqttQualityOfServiceLevel.AtMostOnce);
}
}
public async Task Execute_With_Custom_Topic_Names()
{
using (var testEnvironment = new TestEnvironment(TestContext))
{
await testEnvironment.StartServerAsync();
var requestSender = await testEnvironment.ConnectClientAsync();
var rpcClient = new MqttRpcClient(requestSender, new MqttRpcClientOptionsBuilder().WithTopicGenerationStrategy(new TestTopicStrategy()).Build());
await rpcClient.ExecuteAsync(TimeSpan.FromSeconds(2), "ping", "", MqttQualityOfServiceLevel.AtMostOnce);
}
}
private async void ExecuteRpc(object sender, RoutedEventArgs e)
{
var qos = MqttQualityOfServiceLevel.AtMostOnce;
if (RpcQoS1.IsChecked == true)
{
qos = MqttQualityOfServiceLevel.AtLeastOnce;
}
if (RpcQoS2.IsChecked == true)
{
qos = MqttQualityOfServiceLevel.ExactlyOnce;
}
var payload = new byte[0];
if (RpcText.IsChecked == true)
{
payload = Encoding.UTF8.GetBytes(RpcPayload.Text);
}
if (RpcBase64.IsChecked == true)
{
payload = Convert.FromBase64String(RpcPayload.Text);
}
try
{
var rpcClient = new MqttRpcClient(_mqttClient);
await rpcClient.EnableAsync();
var response = await rpcClient.ExecuteAsync(TimeSpan.FromSeconds(5), RpcMethod.Text, payload, qos);
await rpcClient.DisableAsync();
RpcResponses.Items.Add(RpcMethod.Text + " >>> " + Encoding.UTF8.GetString(response));
}
catch (MqttCommunicationTimedOutException)
{
RpcResponses.Items.Add(RpcMethod.Text + " >>> [TIMEOUT]");
}
}
public async Task InitializePublisher(ClientConfiguration configuration)
{
var options = new MqttClientOptionsBuilder()
.WithClientId(configuration.ClientId)
.WithCleanSession(false)
.WithTcpServer(configuration.Host, configuration.Port)
.WithCredentials(configuration.Username, configuration.Password)
.WithKeepAlivePeriod(TimeSpan.FromMilliseconds(configuration.KeepAlivePeriod))
.WithCommunicationTimeout(TimeSpan.FromMilliseconds(configuration.CommunicationTimeout)).Build();
var mqttClient = new MqttFactory().CreateMqttClient();
var connectResult = await mqttClient.ConnectAsync(options);
Console.WriteLine($"Publisher connection result : {connectResult.ResultCode}");
var rpcOptions = new MqttRpcClientOptions()
{
TopicGenerationStrategy = new DefaultMqttRpcClientTopicGenerationStrategy()
};
var rpcClient = new MqttRpcClient(mqttClient, rpcOptions);
var command = new CommandDto
{
Id = 1,
Message = "Say Hello world!"
};
var payload = JsonConvert.SerializeObject(command);
Console.WriteLine($"Publisher requesting work \"DoWork\" with Id : 1");
var responseMqtt = await rpcClient.ExecuteAsync(TimeSpan.FromSeconds(50), "DoWork", payload, MqttQualityOfServiceLevel.AtLeastOnce);
var response = Encoding.Default.GetString(responseMqtt);
Console.WriteLine($"Publisher got response : {response}");
}
public async Task Execute_Success()
{
using (var testEnvironment = new TestEnvironment())
{
await testEnvironment.StartServerAsync();
var responseSender = await testEnvironment.ConnectClientAsync();
await responseSender.SubscribeAsync("MQTTnet.RPC/+/ping");
responseSender.ApplicationMessageReceivedHandler = new MqttApplicationMessageReceivedHandlerDelegate(async e =>
{
await responseSender.PublishAsync(e.ApplicationMessage.Topic + "/response", "pong");
});
var requestSender = await testEnvironment.ConnectClientAsync();
var rpcClient = new MqttRpcClient(requestSender);
var response = await rpcClient.ExecuteAsync(TimeSpan.FromSeconds(5), "ping", "", MqttQualityOfServiceLevel.AtMostOnce);
Assert.AreEqual("pong", Encoding.UTF8.GetString(response));
}
}
public async Task Execute_Timeout_MQTT_V5_Mixed_Clients()
{
using (var testEnvironment = new TestEnvironment(TestContext))
{
await testEnvironment.StartServer();
var responseSender = await testEnvironment.ConnectClient();
await responseSender.SubscribeAsync("MQTTnet.RPC/+/ping", MqttQualityOfServiceLevel.AtMostOnce);
responseSender.ApplicationMessageReceivedAsync += async e =>
{
Assert.IsNull(e.ApplicationMessage.ResponseTopic);
await PlatformAbstractionLayer.CompletedTask;
};
var requestSender = await testEnvironment.ConnectClient(new MqttClientOptionsBuilder().WithProtocolVersion(MqttProtocolVersion.V500));
using (var rpcClient = new MqttRpcClient(requestSender, new MqttRpcClientOptionsBuilder().Build()))
{
var response = await rpcClient.ExecuteAsync(TimeSpan.FromSeconds(2), "ping", "", MqttQualityOfServiceLevel.AtMostOnce);
}
}
}
//void mqtt_Callback(string topic, string payload, int payloadLength)
//{
// string topicString = topic;
// if (topicString.StartsWith("MQTTnet.RPC/"))
// {
// string responseTopic = topicString + ("/response");
// if (topicString.EndsWith("/deviceA.ping"))
// {
// mqtt_publish(responseTopic, "pong", false);
// return;
// }
// }
//}
private async void Button_ClickAsync(object sender, RoutedEventArgs e)
{
// Use WebSocket connection.
var options = new MqttClientOptionsBuilder()
//.WithWebSocketServer("192.168.1.106:1883/mqtt")
.WithClientId("123")
.WithTcpServer("localhost", 60000)
.WithTls(new MqttClientOptionsBuilderTlsParameters
{
CertificateValidationCallback = (X509Certificate x, X509Chain y, SslPolicyErrors z, IMqttClientOptions o) =>
{
// TODO: Check conditions of certificate by using above parameters.
return(true);
}
})
.Build();
mqttClient.UseDisconnectedHandler(async c =>
{
Console.WriteLine("### DISCONNECTED FROM SERVER ###");
await Task.Delay(TimeSpan.FromSeconds(5));
try
{
//if (retryConnect > 3)
//{
// await mqttClient.DisconnectAsync();
//}
//else
//{
// Console.WriteLine("IsConnected:" + mqttClient.IsConnected);
// //if (retryConnect > 3)
// //{
// // Console.WriteLine("Exiting Program");
// //}
// //else
// //{
// // Console.WriteLine("Retry");
// await mqttClient.ConnectAsync(options);
// //}
// //retryConnect++;
// //Console.WriteLine("asda:"+c.Exception.ToString());
//}
}
catch
{
Console.WriteLine("### RECONNECTING FAILED ###");
retryConnect++;
//Console.WriteLine("asda:" + c.Exception.ToString());
}
});
try
{
await mqttClient.ConnectAsync(options);
//await mqttClient.SubscribeAsync(new TopicFilterBuilder().WithTopic("MQTTnet.RPC/+/Reply").Build());
rpcClient = new MqttRpcClient(mqttClient);
}
catch (Exception ex) {
Console.WriteLine("Error When Connecting:" + ex);
}
}
