public void when_getting_client_flow_from_valid_packet_type_then_succeeds(MqttPacketType packetType, Type flowType)
{
ClientProtocolFlowProvider flowProvider = new ClientProtocolFlowProvider(Mock.Of <IMqttTopicEvaluator>(), Mock.Of <IRepositoryProvider>(), new MqttConfiguration());
IProtocolFlow flow = flowProvider.GetFlow(packetType);
flowType.Should().Be(flow.GetType());
}
IFormatter GetFormatter(MqttPacketType packetType, Type type)
{
var genericType = typeof(EmptyPacketFormatter <>);
var formatterType = genericType.MakeGenericType(type);
var formatter = Activator.CreateInstance(formatterType, packetType) as IFormatter;
return(formatter);
}
public void when_getting_server_flow_from_valid_packet_type_then_succeeds(MqttPacketType packetType, Type flowType)
{
IMqttAuthenticationProvider authenticationProvider = Mock.Of <IMqttAuthenticationProvider>(p => p.Authenticate(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>()) == true);
ServerProtocolFlowProvider flowProvider = new ServerProtocolFlowProvider(authenticationProvider, Mock.Of <IConnectionProvider>(), Mock.Of <IMqttTopicEvaluator>(),
Mock.Of <IRepositoryProvider>(), Mock.Of <IPacketIdProvider>(), Mock.Of <ISubject <MqttUndeliveredMessage> >(), new MqttConfiguration());
IProtocolFlow flow = flowProvider.GetFlow(packetType);
flowType.Should().Be(flow.GetType());
}
public void when_reading_invalid_empty_packet_then_fails(string packetPath, MqttPacketType packetType, Type type)
{
packetPath = Path.Combine(Environment.CurrentDirectory, packetPath);
var formatter = GetFormatter(packetType, type);
var packet = Packet.ReadAllBytes(packetPath);
var ex = Assert.Throws <AggregateException> (() => formatter.FormatAsync(packet).Wait());
Assert.True(ex.InnerException is MqttException);
}
public async Task when_writing_empty_packet_then_succeeds(string packetPath, MqttPacketType packetType, Type type)
{
packetPath = Path.Combine(Environment.CurrentDirectory, packetPath);
byte[] expectedPacket = Packet.ReadAllBytes(packetPath);
IFormatter formatter = GetFormatter(packetType, type);
IPacket packet = Activator.CreateInstance(type) as IPacket;
byte[] result = await formatter.FormatAsync(packet);
expectedPacket.Should().BeEquivalentTo(result);
}
public async Task when_reading_empty_packet_then_succeeds(string packetPath, MqttPacketType packetType, Type type)
{
packetPath = Path.Combine(Environment.CurrentDirectory, packetPath);
IFormatter formatter = GetFormatter(packetType, type);
byte[] packet = Packet.ReadAllBytes(packetPath);
IPacket result = await formatter.FormatAsync(packet);
Assert.NotNull(result);
}
protected override bool IsValidPacketType(MqttPacketType packetType)
{
return(packetType == MqttPacketType.ConnectAck ||
packetType == MqttPacketType.SubscribeAck ||
packetType == MqttPacketType.UnsubscribeAck ||
packetType == MqttPacketType.Publish ||
packetType == MqttPacketType.PublishAck ||
packetType == MqttPacketType.PublishComplete ||
packetType == MqttPacketType.PublishReceived ||
packetType == MqttPacketType.PublishRelease ||
packetType == MqttPacketType.PingResponse);
}
public async Task when_reading_empty_packet_then_succeeds(string packetPath, MqttPacketType packetType, Type type)
{
packetPath = Path.Combine(Environment.CurrentDirectory, packetPath);
var formatter = GetFormatter(packetType, type);
var packet = Packet.ReadAllBytes(packetPath);
var result = await formatter.FormatAsync(packet)
.ConfigureAwait(continueOnCapturedContext: false);
Assert.NotNull(result);
}
public async Task <IPacket> GetPacketAsync(byte[] bytes)
{
MqttPacketType packetType = (MqttPacketType)bytes.Byte(0).Bits(4);
if (!formatters.TryGetValue(packetType, out IFormatter formatter))
{
throw new MqttException(ClientProperties.PacketManager_PacketUnknown);
}
IPacket packet = await formatter.FormatAsync(bytes);
return(packet);
}
public async Task when_writing_empty_packet_then_succeeds(string packetPath, MqttPacketType packetType, Type type)
{
packetPath = Path.Combine(Environment.CurrentDirectory, packetPath);
var expectedPacket = Packet.ReadAllBytes(packetPath);
var formatter = GetFormatter(packetType, type);
var packet = Activator.CreateInstance(type) as IPacket;
var result = await formatter.FormatAsync(packet)
.ConfigureAwait(continueOnCapturedContext: false);
Assert.Equal(expectedPacket, result);
}
public async Task <IPacket> FormatAsync(byte[] bytes)
{
MqttPacketType actualType = (MqttPacketType)bytes.Byte(0).Bits(4);
if (PacketType != actualType)
{
throw new MqttException(ClientProperties.Formatter_InvalidPacket(typeof(T).Name));
}
T packet = await Task.Run(() => Read( bytes ));
return(packet);
}
byte[] GetFixedHeader( MqttPacketType packetType, byte[] remainingLength )
{
// MQTT 2.2.2: http://docs.oasis-open.org/mqtt/mqtt/v3.1.1/csprd02/mqtt-v3.1.1-csprd02.html#_Toc385349758
// The flags for PUBREL are different than for the other flow packets.
int flags = packetType == MqttPacketType.PublishRelease ? 0x02 : 0x00;
int type = Convert.ToInt32( packetType ) << 4;
byte fixedHeaderByte1 = Convert.ToByte( flags | type );
byte[] fixedHeader = new byte[1 + remainingLength.Length];
fixedHeader[0] = fixedHeaderByte1;
remainingLength.CopyTo( fixedHeader, 1 );
return fixedHeader;
}
public IProtocolFlow GetFlow(MqttPacketType packetType)
{
if (!IsValidPacketType(packetType))
{
throw new MqttException(ClientProperties.ProtocolFlowProvider_InvalidPacketType(packetType));
}
ProtocolFlowType flowType = packetType.ToFlowType();
if (!GetFlows().TryGetValue(flowType, out IProtocolFlow flow))
{
throw new MqttException(ClientProperties.ProtocolFlowProvider_UnknownPacketType(packetType));
}
return(flow);
}
internal static ProtocolFlowType ToFlowType(this MqttPacketType packetType)
{
var flowType = default(ProtocolFlowType);
switch (packetType)
{
case MqttPacketType.Connect:
case MqttPacketType.ConnectAck:
flowType = ProtocolFlowType.Connect;
break;
case MqttPacketType.Publish:
case MqttPacketType.PublishRelease:
flowType = ProtocolFlowType.PublishReceiver;
break;
case MqttPacketType.PublishAck:
case MqttPacketType.PublishReceived:
case MqttPacketType.PublishComplete:
flowType = ProtocolFlowType.PublishSender;
break;
case MqttPacketType.Subscribe:
case MqttPacketType.SubscribeAck:
flowType = ProtocolFlowType.Subscribe;
break;
case MqttPacketType.Unsubscribe:
case MqttPacketType.UnsubscribeAck:
flowType = ProtocolFlowType.Unsubscribe;
break;
case MqttPacketType.PingRequest:
case MqttPacketType.PingResponse:
flowType = ProtocolFlowType.Ping;
break;
case MqttPacketType.Disconnect:
flowType = ProtocolFlowType.Disconnect;
break;
}
return(flowType);
}
public IProtocolFlow GetFlow(MqttPacketType packetType)
{
if (!IsValidPacketType(packetType))
{
var error = string.Format(Properties.Resources.ProtocolFlowProvider_InvalidPacketType, packetType);
throw new MqttException(error);
}
var flow = default(IProtocolFlow);
var flowType = packetType.ToFlowType();
if (!GetFlows().TryGetValue(flowType, out flow))
{
var error = string.Format(Properties.Resources.ProtocolFlowProvider_UnknownPacketType, packetType);
throw new MqttException(error);
}
return(flow);
}
private static MqttPacket Acquire(MqttPacketType type, IClient client)
{
switch (type)
{
case MqttPacketType.Connect: return(MqttConnectPacket.Acquire());
case MqttPacketType.Subscribe: return(MqttSubscribePacket.Acquire());
case MqttPacketType.Unsubscribe: return(MqttUnsubscribePacket.Acquire());
case MqttPacketType.PingReq: return(MqttPingReqPacket.Acquire());
case MqttPacketType.Disconnect: return(MqttDisconnectPacket.Acquire());
case MqttPacketType.Publish: return(MqttPublishPacket.Acquire());
case MqttPacketType.PubAck: return(MqttPubackPacket.Acquire());
default:
Service.Logger.Log("Unknown MQTT Type: " + type);
return(null);
}
}
public static string ServerPacketListener_DispatchingMessage(MqttPacketType packetType, string flowName, string clientId) => $"Server - Dispatching {packetType} message to flow {flowName} for client {clientId}";
public static string ProtocolFlowProvider_UnknownPacketType(MqttPacketType packetType) => $"An error occured while trying to get a Flow Type based on Packet Type {packetType}";
protected void RemovePendingAcknowledgement(string clientId, ushort packetId, MqttPacketType type)
{
var session = sessionRepository.Get(s => s.ClientId == clientId);
if (session == null)
{
throw new MqttException(string.Format(Properties.Resources.SessionRepository_ClientSessionNotFound, clientId));
}
var pendingAcknowledgement = session
.GetPendingAcknowledgements()
.FirstOrDefault(u => u.Type == type && u.PacketId == packetId);
session.RemovePendingAcknowledgement(pendingAcknowledgement);
sessionRepository.Update(session);
}
public EmptyPacketFormatter(MqttPacketType packetType)
{
this.packetType = packetType;
}
public static string ClientPacketListener_DispatchingMessage(string clientId, MqttPacketType packetType, string flowTypeName) => $"Client {clientId} - Dispatching {packetType} message to flow {flowTypeName}";
public static string ClientPacketListener_FirstPacketReceived(string clientId, MqttPacketType packetType) => $"Client {clientId} - First packet from Server has been received. Type: {packetType}";
public static string PublishFlow_RetryingQoSFlow(MqttPacketType type, string clientId) => $"The ack for message {type} has not been received. Re sending message for client {clientId}";
public static string ProtocolFlowProvider_InvalidPacketType(MqttPacketType packetType) => $"The packet type {packetType} cannot be handled by this flow provider";
protected abstract bool IsValidPacketType(MqttPacketType packetType);
public FlowPacketFormatter( MqttPacketType packetType, Func<ushort, T> packetFactory )
{
_packetType = packetType;
_packetFactory = packetFactory;
}
public async Task when_managing_packet_from_source_then_succeeds(string packetPath, string jsonPath, Type packetType, MqttPacketType type)
{
jsonPath = Path.Combine(Environment.CurrentDirectory, jsonPath);
IPacket packet = Packet.ReadPacket(jsonPath, packetType) as IPacket;
packetPath = Path.Combine(Environment.CurrentDirectory, packetPath);
byte[] bytes = Packet.ReadAllBytes(packetPath);
Mock <IFormatter> formatter = new Mock <IFormatter>();
formatter.Setup(f => f.PacketType).Returns(type);
formatter
.Setup(f => f.FormatAsync(It.Is <IPacket>(p => Convert.ChangeType(p, packetType) == packet)))
.Returns(Task.FromResult(bytes));
PacketManager packetManager = new PacketManager(formatter.Object);
byte[] result = await packetManager.GetBytesAsync(packet);
bytes.Should().BeEquivalentTo(result);
}
protected void RemovePendingAcknowledgement(string clientId, ushort packetId, MqttPacketType type)
{
ClientSession session = sessionRepository.Read(clientId);
if (session == null)
{
throw new MqttException(ClientProperties.SessionRepository_ClientSessionNotFound(clientId));
}
PendingAcknowledgement pendingAcknowledgement = session
.GetPendingAcknowledgements()
.FirstOrDefault(u => u.Type == type && u.PacketId == packetId);
session.RemovePendingAcknowledgement(pendingAcknowledgement);
sessionRepository.Update(session);
}
public async Task when_managing_packet_bytes_then_succeeds(string packetPath, string jsonPath, Type packetType, MqttPacketType type)
{
packetPath = Path.Combine(Environment.CurrentDirectory, packetPath);
byte[] bytes = Packet.ReadAllBytes(packetPath);
jsonPath = Path.Combine(Environment.CurrentDirectory, jsonPath);
object packet = Packet.ReadPacket(jsonPath, packetType);
Mock <IFormatter> formatter = new Mock <IFormatter>();
formatter.Setup(f => f.PacketType).Returns(type);
formatter
.Setup(f => f.FormatAsync(It.Is <byte[]>(b => b.ToList().SequenceEqual(bytes))))
.Returns(Task.FromResult <IPacket>((IPacket)packet));
PacketManager packetManager = new PacketManager(formatter.Object);
IPacket result = await packetManager.GetPacketAsync(bytes);
packet.Should().Be(result);
}
public async Task when_managing_packet_from_source_then_succeeds(string packetPath, string jsonPath, Type packetType, MqttPacketType type)
{
jsonPath = Path.Combine(Environment.CurrentDirectory, jsonPath);
var packet = Packet.ReadPacket(jsonPath, packetType) as IPacket;
packetPath = Path.Combine(Environment.CurrentDirectory, packetPath);
var bytes = Packet.ReadAllBytes(packetPath);
var formatter = new Mock <IFormatter> ();
formatter.Setup(f => f.PacketType).Returns(type);
formatter
.Setup(f => f.FormatAsync(It.Is <IPacket> (p => Convert.ChangeType(p, packetType) == packet)))
.Returns(Task.FromResult(bytes));
var packetManager = new PacketManager(formatter.Object);
var result = await packetManager.GetBytesAsync(packet)
.ConfigureAwait(continueOnCapturedContext: false);
Assert.Equal(bytes, result);
}
