public async Task StartAsyncSubscribesToTopics()
{
// Arrange
var mockManagedMqttClient = new Mock <IManagedMqttClient>();
var mockManagedMqttClientOptions = new Mock <IManagedMqttClientOptions>();
var mqttConfiguration = new MqttConfiguration(mockManagedMqttClientOptions.Object, new[] { new TopicFilter("test/topic", MqttQualityOfServiceLevel.AtLeastOnce) });
var mockMqttClientFactory = new Mock <IMqttClientFactory>();
var mockTriggeredFunctionExecutor = new Mock <ITriggeredFunctionExecutor>();
mockManagedMqttClient
.Setup(m => m.SubscribeAsync(It.Is <TopicFilter[]>(y => y == mqttConfiguration.Topics)))
.Returns(Task.CompletedTask);
mockManagedMqttClient
.Setup(m => m.StartAsync(It.Is <IManagedMqttClientOptions>(y => y == mqttConfiguration.Options)))
.Returns(Task.CompletedTask);
mockMqttClientFactory
.Setup(m => m.CreateManagedMqttClient())
.Returns(mockManagedMqttClient.Object);
var mqttListener = new MqttListener(mockMqttClientFactory.Object, mqttConfiguration, mockTriggeredFunctionExecutor.Object, _mockLogger.Object);
// Act
await mqttListener.StartAsync(_cancellationToken).ConfigureAwait(false);
// Assert
mockMqttClientFactory.Verify(x => x.CreateManagedMqttClient(), Times.Once());
mockManagedMqttClient.VerifyAll();
}
public async Task StartAsyncSubscribesToTopics()
{
// Arrange
var mockManagedMqttClient = new Mock <IManagedMqttClient>();
var mockManagedMqttClientOptions = new Mock <IManagedMqttClientOptions>();
var mockMqttClientFactory = new Mock <IManagedMqttClientFactory>();
var messageProcessor = new Mock <IProcesMqttMessage>();
mockMqttClientFactory
.Setup(m => m.CreateManagedMqttClient())
.Returns(mockManagedMqttClient.Object);
mockManagedMqttClient
.Setup(m => m.StartAsync(It.Is <IManagedMqttClientOptions>(y => y == mockManagedMqttClientOptions.Object)))
.Returns(Task.CompletedTask);
messageProcessor.Setup(x => x.OnMessage(It.IsAny <MqttMessageReceivedEventArgs>())).Returns(Task.CompletedTask);
var config = new MqttConfiguration("CustomConfig", mockManagedMqttClientOptions.Object);
var mqttConnection = new MqttConnection(mockMqttClientFactory.Object, config, _mockLogger.Object);
// Act
await mqttConnection.StartAsync(messageProcessor.Object);
await mqttConnection.HandleConnectedAsync(new MqttClientConnectedEventArgs(new MqttClientAuthenticateResult {
IsSessionPresent = true,
ResultCode = MqttClientConnectResultCode.Success
}));
// Assert
Assert.Equal(ConnectionState.Connected, mqttConnection.ConnectionState);
mockMqttClientFactory.VerifyAll();
mockManagedMqttClient.VerifyAll();
}
public async Task NewMessageIsProcessed()
{
// Arrange
var mockManagedMqttClient = new Mock <IManagedMqttClient>();
var mockManagedMqttClientOptions = new Mock <IManagedMqttClientOptions>();
var mockMqttClientFactory = new Mock <IManagedMqttClientFactory>();
var messageProcessor = new Mock <IProcesMqttMessage>();
mockMqttClientFactory
.Setup(m => m.CreateManagedMqttClient())
.Returns(mockManagedMqttClient.Object);
messageProcessor.Setup(x => x.OnMessage(It.IsAny <MqttMessageReceivedEventArgs>())).Returns(Task.CompletedTask);
var config = new MqttConfiguration("CustomConfig", mockManagedMqttClientOptions.Object);
var mqttConnection = new MqttConnection(mockMqttClientFactory.Object, config, _mockLogger.Object);
// Act
await mqttConnection.StartAsync(messageProcessor.Object);
await mqttConnection.HandleApplicationMessageReceivedAsync(new MqttApplicationMessageReceivedEventArgs("ClientId", DefaultMessage));
// Assert
messageProcessor.Verify(x => x.OnMessage(It.Is <MqttMessageReceivedEventArgs>(y => y.Message.Topic == DefaultMessage.Topic)));
messageProcessor.Verify(x => x.OnMessage(It.Is <MqttMessageReceivedEventArgs>(y => y.Message.Retain == DefaultMessage.Retain)));
messageProcessor.Verify(x => x.OnMessage(It.Is <MqttMessageReceivedEventArgs>(y => y.Message.QosLevel.ToString() == DefaultMessage.QualityOfServiceLevel.ToString())));
messageProcessor.Verify(x => x.OnMessage(It.Is <MqttMessageReceivedEventArgs>(y => y.Message.GetMessage() == DefaultMessage.Payload)));
}
public void when_packet_channel_error_then_notifies()
{
MqttConfiguration configuration = new MqttConfiguration {
WaitTimeoutSecs = 1
};
Subject <byte[]> receiver = new Subject <byte[]>();
Mock <IMqttChannel <byte[]> > innerChannel = new Mock <IMqttChannel <byte[]> >();
innerChannel.Setup(x => x.ReceiverStream).Returns(receiver);
Mock <IPacketManager> manager = new Mock <IPacketManager>();
PacketChannel channel = new PacketChannel(innerChannel.Object, manager.Object, configuration);
string errorMessage = "Packet Exception";
receiver.OnError(new MqttException(errorMessage));
Exception errorReceived = default;
channel.ReceiverStream.Subscribe(_ => { }, ex =>
{
errorReceived = ex;
});
Assert.NotNull(errorReceived);
Assert.True(errorReceived is MqttException);
errorMessage.Should().Be((errorReceived as MqttException).Message);
}
public void when_reading_bytes_then_notifies_packet(string packetPath, Type packetType)
{
MqttConfiguration configuration = new MqttConfiguration {
WaitTimeoutSecs = 1
};
Subject <byte[]> receiver = new Subject <byte[]>();
Mock <IMqttChannel <byte[]> > innerChannel = new Mock <IMqttChannel <byte[]> >();
innerChannel.Setup(x => x.ReceiverStream).Returns(receiver);
object expectedPacket = Activator.CreateInstance(packetType);
Mock <IPacketManager> manager = new Mock <IPacketManager>();
manager.Setup(x => x.GetPacketAsync(It.IsAny <byte[]>()))
.Returns(Task.FromResult <IPacket>((IPacket)expectedPacket));
PacketChannel channel = new PacketChannel(innerChannel.Object, manager.Object, configuration);
IPacket receivedPacket = default;
channel.ReceiverStream.Subscribe(packet =>
{
receivedPacket = packet;
});
packetPath = Path.Combine(Environment.CurrentDirectory, packetPath);
byte[] readPacket = Packet.ReadAllBytes(packetPath);
receiver.OnNext(readPacket);
Assert.NotNull(receivedPacket);
packetType.Should().Be(receivedPacket.GetType());
}
protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{
var configuration = new MqttConfiguration()
{
Port = port,
AllowWildcardsInTopicFilters = true,
KeepAliveSecs = 30,
ConnectionTimeoutSecs = 30,
WaitTimeoutSecs = 30
};
client = await MqttClient.CreateAsync(broker, configuration);
clientId = Guid.NewGuid().ToString().Replace("-", "");
client.Disconnected += Client_Disconnected;
do
{
try
{
if (!client.IsConnected)
{
await Connect();
}
await Task.Delay(5000, stoppingToken);
}
catch (Exception ex)
{
_logger.LogError(ex.GetType().ToString());
_logger.LogError(ex.Message);
}
}while (!stoppingToken.IsCancellationRequested);
}
public async Task when_writing_packet_then_inner_channel_is_notified(string packetPath, Type packetType)
{
MqttConfiguration configuration = new MqttConfiguration {
WaitTimeoutSecs = 1
};
packetPath = Path.Combine(Environment.CurrentDirectory, packetPath);
byte[] bytes = Packet.ReadAllBytes(packetPath);
Subject <byte[]> receiver = new Subject <byte[]>();
Mock <IMqttChannel <byte[]> > innerChannel = new Mock <IMqttChannel <byte[]> >();
innerChannel.Setup(x => x.ReceiverStream).Returns(receiver);
innerChannel.Setup(x => x.SendAsync(It.IsAny <byte[]>()))
.Returns(Task.Delay(0));
IPacket packet = Activator.CreateInstance(packetType) as IPacket;
Mock <IPacketManager> manager = new Mock <IPacketManager>();
manager.Setup(x => x.GetBytesAsync(It.IsAny <IPacket>()))
.Returns(Task.FromResult(bytes));
PacketChannel channel = new PacketChannel(innerChannel.Object, manager.Object, configuration);
await channel.SendAsync(packet);
innerChannel.Verify(x => x.SendAsync(It.Is <byte[]>(b => b.ToList().SequenceEqual(bytes))));
manager.Verify(x => x.GetBytesAsync(It.Is <IPacket>(p => Convert.ChangeType(p, packetType) == packet)));
}
public async static void SetupClient()
{
localClient = new MqttClientLocal();
var configuration = new MqttConfiguration()
{
Port = 12393,
KeepAliveSecs = 60,
WaitTimeoutSecs = 5,
BufferSize = 128 * 1024,
AllowWildcardsInTopicFilters = true,
MaximumQualityOfService = MqttQualityOfService.AtLeastOnce
};
string topicSubscribe = "song/#";
string topicSubscribe2 = "status";
remoteClient = await MqttClient.CreateAsync("broker.busk.cf", configuration);
await remoteClient.ConnectAsync(new MqttClientCredentials(clientId : "Frontend", "front", "frontpass"));
await remoteClient.SubscribeAsync(topicSubscribe, MqttQualityOfService.AtLeastOnce); //subscribe on cloud mqtt
await remoteClient.SubscribeAsync(topicSubscribe2, MqttQualityOfService.AtLeastOnce); //subscribe on cloud mqtt
localClient.Subscribe(remoteClient.MessageStream); // subscribe to the iobservable (the response message stream)
}
public static async Task setup_template()
{
MqttClientLocal localClient = new MqttClientLocal();
var configuration = new MqttConfiguration()
{
Port = 12393,
KeepAliveSecs = 0,
WaitTimeoutSecs = 5,
BufferSize = 128 * 1024,
AllowWildcardsInTopicFilters = true,
MaximumQualityOfService = MqttQualityOfService.AtLeastOnce
};
string topicSubscribe = "my/topic";
string topicPost = "my/other/topic";
var remoteClient = await MqttClient.CreateAsync("localhost", configuration);
await remoteClient.ConnectAsync(new MqttClientCredentials(clientId : "Frontend", "front", "frontpass"));
await remoteClient.SubscribeAsync(topicSubscribe, MqttQualityOfService.AtLeastOnce);
localClient.Subscribe(remoteClient.MessageStream);
string payloadToSend = "MY MESSAGE TO BE SENT";
var mymessage = new MqttApplicationMessage(topicPost, Encoding.UTF8.GetBytes(payloadToSend));
remoteClient.PublishAsync(mymessage, MqttQualityOfService.AtLeastOnce).Wait();
}
public async Task when_writing_packet_from_source_then_inner_channel_is_notified(string packetPath, string jsonPath, Type packetType)
{
var configuration = new MqttConfiguration {
WaitTimeoutSecs = 1
};
packetPath = Path.Combine(Environment.CurrentDirectory, packetPath);
var bytes = Packet.ReadAllBytes(packetPath);
var receiver = new Subject <byte[]> ();
var innerChannel = new Mock <IMqttChannel <byte[]> >();
innerChannel.Setup(x => x.ReceiverStream).Returns(receiver);
innerChannel.Setup(x => x.SendAsync(It.IsAny <byte[]> ()))
.Returns(Task.Delay(0));
jsonPath = Path.Combine(Environment.CurrentDirectory, jsonPath);
var packet = Packet.ReadPacket(jsonPath, packetType) as IPacket;
var manager = new Mock <IPacketManager> ();
manager.Setup(x => x.GetBytesAsync(It.IsAny <IPacket>()))
.Returns(Task.FromResult(bytes));
var channel = new PacketChannel(innerChannel.Object, manager.Object, configuration);
await channel.SendAsync(packet)
.ConfigureAwait(continueOnCapturedContext: false);
innerChannel.Verify(x => x.SendAsync(It.Is <byte[]> (b => b.ToList().SequenceEqual(bytes))));
manager.Verify(x => x.GetBytesAsync(It.Is <IPacket> (p => Convert.ChangeType(p, packetType) == packet)));
}
public async void Start()
{
var configuration = new MqttConfiguration
{
BufferSize = 128 * 1024,
Port = 55555,
KeepAliveSecs = 10,
WaitTimeoutSecs = 2,
MaximumQualityOfService = MqttQualityOfService.AtMostOnce,
AllowWildcardsInTopicFilters = true
};
var client = await MqttClient.CreateAsync("127.0.0.1", configuration);
var sessionState = await client.ConnectAsync(new MqttClientCredentials(clientId : int.MaxValue.ToString()), cleanSession : true);
await client.SubscribeAsync("foo/bar/topic1", MqttQualityOfService.AtMostOnce); //QoS0
await client.SubscribeAsync("foo/bar/topic2", MqttQualityOfService.AtLeastOnce); //QoS1
await client.SubscribeAsync("foo/bar/topic3", MqttQualityOfService.ExactlyOnce); //QoS2
//client.MessageStream.Subscribe(msg => Console.WriteLine($"Message received in topic {msg.Topic}"));
var message3 = new MqttApplicationMessage("foo/bar/topic4", Encoding.UTF8.GetBytes("Foo Message 4"));
await client.PublishAsync(message3, MqttQualityOfService.AtMostOnce); //QoS0
client.MessageStream.Where(msg => msg.Topic == "foo/bar/topic2").Subscribe(msg => Console.WriteLine($"Message received in topic {msg.Topic}"));
}
/// <summary>
/// Initializes a new instance of the <see cref="MqttTriggerAttribute"/> class.
/// </summary>
/// <param name="parameter">The parameter to bind to.</param>
/// <param name="mqttClientFactory">The MQTT client factory.</param>
/// <param name="config">The MQTT configuration.</param>
/// <param name="logger">The logger.</param>
public MqttTriggerBinding(ParameterInfo parameter, IMqttClientFactory mqttClientFactory, MqttConfiguration config, ILogger logger)
{
_parameter = parameter;
_mqttClientFactory = mqttClientFactory;
_config = config;
_logger = logger;
}
public async Task <IMqttConnectedClient> CreateClientAsync(MqttConfiguration configuration)
{
try
{
//Adding this to not break backwards compatibility related to the method signature
//Yielding at this point will cause the method to return immediately after it's called,
//running the rest of the logic acynchronously
await Task.Yield();
PrivateBinding binding = new PrivateBinding(_privateStreamListener, EndpointIdentifier.Client);
MqttTopicEvaluator topicEvaluator = new MqttTopicEvaluator(configuration);
IMqttChannelFactory innerChannelFactory = binding.GetChannelFactory(IPAddress.Loopback.ToString(), configuration);
PacketChannelFactory channelFactory = new PacketChannelFactory(innerChannelFactory, topicEvaluator, configuration);
PacketIdProvider packetIdProvider = new PacketIdProvider();
InMemoryRepositoryProvider repositoryProvider = new InMemoryRepositoryProvider();
ClientProtocolFlowProvider flowProvider = new ClientProtocolFlowProvider(topicEvaluator, repositoryProvider, configuration);
return(new MqttConnectedClient(channelFactory, flowProvider, repositoryProvider, packetIdProvider, configuration));
}
catch (Exception ex)
{
_tracer.Error(ex, ClientProperties.Client_InitializeError);
throw new MqttClientException(ClientProperties.Client_InitializeError, ex);
}
}
public void Connect()
{
try
{
var config = new MqttConfiguration {
Port = 1883
};
var client = MqttClient.CreateAsync(host, config).Result;
var clientId = "XamarinClient";
client.ConnectAsync(new MqttClientCredentials(clientId)).Wait();
client.SubscribeAsync(topic, MqttQualityOfService.AtLeastOnce).Wait();
client.MessageStream.Subscribe(message =>
{
var data = Encoding.UTF8.GetString(message.Payload);
Debug.WriteLine($"Message Received; {data}");
var msg = new MqttMessage
{
Topic = message.Topic,
Payload = data
};
//MessagingCenter.Send<XamFormsSample.ViewModels.MainPageViewModel>(this, "Hi");
// TODO get nuget fixed....
Messenger.Default.Send <MqttMessage>(msg);
});
}
catch (Exception e)
{
Debug.WriteLine("_________________ Begin e _________________");
Debug.WriteLine(e);
Debug.WriteLine("_________________ End e _________________");
}
}
public void when_creating_stream_then_becomes_ready()
{
MqttConfiguration configuration = new MqttConfiguration();
PrivateStream stream = new PrivateStream(configuration);
Assert.True(!stream.IsDisposed);
}
public async void publishMQTT(MqttCon mqtt)
{
if (string.IsNullOrEmpty(mqtt.topic) ||
string.IsNullOrEmpty(mqtt.msg))
{
Console.WriteLine("Debe contener Topic y Message");
}
else
{
Console.WriteLine(mqtt.topic);
Console.WriteLine(mqtt.msg);
var configuration = new MqttConfiguration {
BufferSize = 128 * 1024,
Port = 1883,
KeepAliveSecs = 10,
WaitTimeoutSecs = 2,
MaximumQualityOfService = MqttQualityOfService.AtMostOnce,
AllowWildcardsInTopicFilters = true
};
var client = await MqttClient.CreateAsync("iot02.qaingenieros.com", configuration);
var sessionState = await client.ConnectAsync(new MqttClientCredentials(clientId : "foo"));
var message1 = new MqttApplicationMessage(mqtt.topic, Encoding.UTF8.GetBytes(mqtt.msg));
await client.PublishAsync(message1, MqttQualityOfService.AtMostOnce); //QoS0
await client.DisconnectAsync();
}
}
static void Main(string[] args)
{
Console.WriteLine("Started Program to start broker...");
var mqttOptions = new MqttConfiguration {
BufferSize = 128 * 1024,
Port = 1883,
KeepAliveSecs = 10,
WaitTimeoutSecs = 2,
MaximumQualityOfService = MqttQualityOfService.AtMostOnce,
AllowWildcardsInTopicFilters = true,
AllowLocationSubscription = true
};
var broker = MqttServer.Create(mqttOptions);
try {
broker.Start();
Console.WriteLine("Press CTRL + C exit.");
while (true)
{
System.Threading.Thread.Sleep(1000);
}
}
catch (Exception ex) {
Console.WriteLine(ex);
}
}
public async Task when_sending_packet_then_stream_receives_successfully()
{
var configuration = new MqttConfiguration();
var stream = new PrivateStream(configuration);
var channel = new PrivateChannel(stream, EndpointIdentifier.Client, configuration);
var packetsReceived = 0;
stream
.Receive(EndpointIdentifier.Client)
.Subscribe(packet => {
packetsReceived++;
});
await channel.SendAsync(new byte[255]);
await channel.SendAsync(new byte[10]);
await channel.SendAsync(new byte[34]);
await channel.SendAsync(new byte[100]);
await channel.SendAsync(new byte[50]);
await Task.Delay(TimeSpan.FromMilliseconds(1000));
Assert.Equal(5, packetsReceived);
}
public IObservable <uint> Create()
{
return(Observable.Create <uint>(
async observer =>
{
var config = new MqttConfiguration
{
Port = _configuration.Value.Port,
MaximumQualityOfService = MqttQualityOfService.ExactlyOnce,
AllowWildcardsInTopicFilters = true
};
var client = await MqttClient.CreateAsync(_configuration.Value.Broker, config);
_ = await client.ConnectAsync();
await client.SubscribeAsync(_configuration.Value.Topic, MqttQualityOfService.AtLeastOnce);
var subscription = client
.MessageStream
.Where(message => message.Payload.Length == 4)
.Select(message => BitConverter.ToUInt32(message.Payload))
.Subscribe(observer);
return new CompositeDisposable(
subscription,
client
);
}
));
}
static void Main(string[] args)
{
Debug.WriteLine("Configuring Server...");
var stopSignal = new ManualResetEventSlim();
var config = new MqttConfiguration
{
Port = port,
MaximumQualityOfService = MqttQualityOfService.AtLeastOnce,
AllowWildcardsInTopicFilters = true,
WaitTimeoutSecs = 10,
KeepAliveSecs = 15
};
var server = MqttServer.Create(config);
Debug.WriteLine("Starting Server...");
server.Stopped += (sender, e) =>
{
Debug.WriteLine("Server stopped. Finishing app...");
stopSignal.Set();
};
server.ClientConnected += (sender, e) => Debug.WriteLine($"New player connected: {e}");
server.ClientDisconnected += (sender, e) => Debug.WriteLine($"Player disconnected: {e}");
server.Start();
Debug.WriteLine("Server started...");
Debug.WriteLine("Listening for new players...");
stopSignal.Wait();
}
/// <summary>
/// Запуск задачи соединения с облаком
/// </summary>
/// <param name="connection_string"></param>
/// <param name="client_id"></param>
private async Task <bool> Start(MQTTClient client)
{
return(await Task.Run(() =>
{
try
{
var configuration = new MqttConfiguration
{
//BufferSize = 128 * 1024,
Port = client.Port
//KeepAliveSecs = 10,
//WaitTimeoutSecs = 12,
//MaximumQualityOfService = MqttQualityOfService.AtMostOnce
//AllowWildcardsInTopicFilters = true
};
//System.Net.Sockets.Socket.
CloudConnectionResult.Message = "В ожидании соединения";
_client = MqttClient.CreateAsync(client.Server, configuration).Result;
_client.Disconnected += _client_Disconnected;
var sessionState = _client.ConnectAsync(new MqttClientCredentials(clientId: client.ClientId, userName: client.UserName, password: client.Password), cleanSession: false).Result;
CloudConnectionResult.Message = "Соединение установлено";
return true;
}
catch (System.Exception ex)
{
CloudConnectionResult.Message = ex.Message;
Log.Debug(MQTT_TAG, ex.Message);
Toast.MakeText(_context, ex.Message, ToastLength.Long);
return false;
}
}));
}
public void when_packet_is_received_then_it_is_dispatched_to_proper_flow()
{
Mock <IConnectionProvider> connectionProvider = new Mock <IConnectionProvider>();
Mock <IProtocolFlowProvider> flowProvider = new Mock <IProtocolFlowProvider>();
IRepositoryProvider repositoryProvider = Mock.Of <IRepositoryProvider>();
Mock <IProtocolFlow> flow = new Mock <IProtocolFlow>();
flowProvider.Setup(p => p.GetFlow(It.IsAny <MqttPacketType>())).Returns(flow.Object);
MqttConfiguration configuration = new MqttConfiguration {
WaitTimeoutSecs = 10
};
Subject <IPacket> receiver = new Subject <IPacket>();
Mock <IMqttChannel <IPacket> > packetChannel = new Mock <IMqttChannel <IPacket> >();
packetChannel.Setup(c => c.ReceiverStream).Returns(receiver);
packetChannel.Setup(c => c.SenderStream).Returns(new Subject <IPacket>());
ServerPacketListener listener = new ServerPacketListener(packetChannel.Object, connectionProvider.Object, flowProvider.Object, configuration);
listener.Listen();
string clientId = Guid.NewGuid().ToString();
Connect connect = new Connect(clientId, cleanSession: true, MqttProtocol.SupportedLevel);
Publish publish = new Publish(Guid.NewGuid().ToString(), MqttQualityOfService.AtMostOnce, false, false);
receiver.OnNext(connect);
receiver.OnNext(publish);
bool connectReceived = false;
bool publishReceived = false;
ManualResetEventSlim signal = new ManualResetEventSlim();
listener.PacketStream.Subscribe(p =>
{
if (p is Connect)
{
connectReceived = true;
}
else if (p is Publish)
{
publishReceived = true;
}
if (connectReceived && publishReceived)
{
signal.Set();
}
});
bool signalSet = signal.Wait(1000);
Assert.True(signalSet);
flowProvider.Verify(p => p.GetFlow(It.Is <MqttPacketType>(t => t == MqttPacketType.Publish)));
flow.Verify(f => f.ExecuteAsync(It.Is <string>(s => s == clientId), It.Is <IPacket>(p => p is Connect), It.Is <IMqttChannel <IPacket> >(c => c == packetChannel.Object)));
flow.Verify(f => f.ExecuteAsync(It.Is <string>(s => s == clientId), It.Is <IPacket>(p => p is Publish), It.Is <IMqttChannel <IPacket> >(c => c == packetChannel.Object)));
}
public async Task when_subscribing_new_topics_then_subscriptions_are_created_and_ack_is_sent()
{
var configuration = new MqttConfiguration {
MaximumQualityOfService = MqttQualityOfService.AtLeastOnce
};
var topicEvaluator = new Mock <IMqttTopicEvaluator> ();
var sessionRepository = new Mock <IRepository <ClientSession> > ();
var packetIdProvider = Mock.Of <IPacketIdProvider> ();
var retainedMessageRepository = Mock.Of <IRepository <RetainedMessage> > ();
var senderFlow = Mock.Of <IPublishSenderFlow> ();
var clientId = Guid.NewGuid().ToString();
var session = new ClientSession(clientId, clean: false);
topicEvaluator.Setup(e => e.IsValidTopicFilter(It.IsAny <string> ())).Returns(true);
sessionRepository.Setup(r => r.Read(It.IsAny <string> ())).Returns(session);
var fooQoS = MqttQualityOfService.AtLeastOnce;
var fooTopic = "test/foo/1";
var fooSubscription = new Subscription(fooTopic, fooQoS);
var barQoS = MqttQualityOfService.AtMostOnce;
var barTopic = "test/bar/1";
var barSubscription = new Subscription(barTopic, barQoS);
var packetId = (ushort)new Random().Next(0, ushort.MaxValue);
var subscribe = new Subscribe(packetId, fooSubscription, barSubscription);
var channel = new Mock <IMqttChannel <IPacket> > ();
var response = default(IPacket);
channel.Setup(c => c.SendAsync(It.IsAny <IPacket> ()))
.Callback <IPacket> (p => response = p)
.Returns(Task.Delay(0));
var connectionProvider = new Mock <IConnectionProvider> ();
connectionProvider
.Setup(p => p.GetConnection(It.Is <string> (c => c == clientId)))
.Returns(channel.Object);
var flow = new ServerSubscribeFlow(topicEvaluator.Object, sessionRepository.Object,
retainedMessageRepository, packetIdProvider, senderFlow, configuration);
await flow.ExecuteAsync(clientId, subscribe, channel.Object)
.ConfigureAwait(continueOnCapturedContext: false);
sessionRepository.Verify(r => r.Update(It.Is <ClientSession> (s => s.Id == clientId && s.Subscriptions.Count == 2 &&
s.Subscriptions.All(x => x.TopicFilter == fooTopic || x.TopicFilter == barTopic))));
Assert.NotNull(response);
var subscribeAck = response as SubscribeAck;
Assert.NotNull(subscribeAck);
Assert.Equal(packetId, subscribeAck.PacketId);
Assert.Equal(2, subscribeAck.ReturnCodes.Count());
Assert.Contains(subscribeAck.ReturnCodes, c => c == SubscribeReturnCode.MaximumQoS0);
Assert.Contains(subscribeAck.ReturnCodes, c => c == SubscribeReturnCode.MaximumQoS1);
}
/// <summary>
/// Inititalizes a new instance of the <see cref="MqttListener"/> class.
/// </summary>
/// <param name="mqttClientFactory">The factory for <see cref="IManagedMqttClient"/>s.</param>
/// <param name="config">The MQTT configuration.</param>
/// <param name="executor">Allows the function to be executed.</param>
/// <param name="logger">The logger.</param>
public MqttListener(IMqttClientFactory mqttClientFactory, MqttConfiguration config, ITriggeredFunctionExecutor executor, ILogger logger)
{
_config = config;
_mqttClientFactory = mqttClientFactory;
_executor = executor;
_logger = logger;
_cancellationTokenSource = new CancellationTokenSource();
}
internal MqttConnectedClient(IMqttChannel <IPacket> packetChannel,
IProtocolFlowProvider flowProvider,
IRepositoryProvider repositoryProvider,
IPacketIdProvider packetIdProvider,
MqttConfiguration configuration)
: base(packetChannel, flowProvider, repositoryProvider, packetIdProvider, configuration)
{
}
public MessageMonitor(IOptions <MqttConfiguration> mqttOptions, ILogger <MessageMonitor> logger, DeviceRepository deviceRepository, IMqttClient messageClient, MasterService masterService)
{
_mqttOptions = mqttOptions.Value;
_logger = logger;
_deviceRepository = deviceRepository;
_messageClient = messageClient;
_masterService = masterService;
}
private async Task <IMqttClient> CreateClient()
{
Logger.LogInfo($"Connecting to MQTT broker '{_conf.Host}'");
var mqttConf = new MqttConfiguration();
return(await MqttClient.CreateAsync(_conf.Host, mqttConf));
}
public PrivateChannel(PrivateStream stream, EndpointIdentifier identifier, MqttConfiguration configuration)
{
this.stream = stream;
this.identifier = identifier;
receiver = new ReplaySubject <byte[]> (window: TimeSpan.FromSeconds(configuration.WaitTimeoutSecs));
sender = new ReplaySubject <byte[]> (window: TimeSpan.FromSeconds(configuration.WaitTimeoutSecs));
streamSubscription = SubscribeStream();
}
protected ProtocolFlowProvider(IMqttTopicEvaluator topicEvaluator,
IRepositoryProvider repositoryProvider,
MqttConfiguration configuration)
{
this.topicEvaluator = topicEvaluator;
this.repositoryProvider = repositoryProvider;
this.configuration = configuration;
}
public Publisher(string broker, int port)
{
var configuration = new MqttConfiguration {
Port = port
};
this.client = MqttClient.CreateAsync(broker, configuration).Result;
}
