private byte[] GetMessagesRequestBody(IEnumerable <Message> payloads, ChannelOptions options)
{
EncodePayloads(options, payloads);
if (_protocol == Protocol.MsgPack)
{
return(MsgPackHelper.Serialise(payloads));
}
return(JsonHelper.Serialize(payloads).GetBytes());
}
private byte[] GetMessagesRequestBody(IEnumerable <Message> payloads, ChannelOptions options)
{
EncodePayloads(new DecodingContext(options), payloads);
#if MSGPACK
if (_protocol == Protocol.MsgPack)
{
return(MsgPackHelper.Serialise(payloads));
}
#endif
return(JsonHelper.Serialize(payloads).GetBytes());
}
public void CanDeserialiseConnectionDetailsMessages()
{
var connectionDetails = new ConnectionDetails()
{
ClientId = "123", ConnectionStateTtl = TimeSpan.FromSeconds(60)
};
var serialized = MsgPackHelper.Serialise(connectionDetails);
var deserialized = MsgPackHelper.Deserialise(serialized, typeof(ConnectionDetails));
deserialized.ShouldBeEquivalentTo(connectionDetails);
}
public void CanSerialiseAndDeserializeProtocolMessage()
{
var message = new ProtocolMessage(ProtocolMessage.MessageAction.Presence, "boo");
message.Presence = new[] { new PresenceMessage(PresenceAction.Enter, "123", "my data") };
var data = MsgPackHelper.Serialise(message);
var result = MsgPackHelper.Deserialise(data, typeof(ProtocolMessage)) as ProtocolMessage;
result.Action.Should().Be(message.Action);
result.Presence.First().Data.Should().Be(message.Presence[0].Data);
}
public T ParseResponse <T>(AblyRequest request, AblyResponse response) where T : class
{
LogResponse(response);
var responseText = response.TextResponse;
if (_protocol == Protocol.MsgPack)
{
return((T)MsgPackHelper.Deserialise(response.Body, typeof(T)));
}
return(JsonHelper.Deserialize <T>(responseText));
}
public void FromStream(int iteration)
{
#pragma warning disable CS0618
var binaryStream = BinaryHelper.ToStream(_testModel);
#pragma warning restore CS0618
var dataContractStream = DataContractHelper.ToStream(_testModel);
var jilStream = JilHelper.ToStream(_testModel);
var messagePackStream = MessagePackHelper.ToStream(_testModel);
var msgPackStream = MsgPackHelper.ToStream(_testModel);
var newtonsoftJsonStream = NewtonsoftJsonHelper.ToStream(_testModel);
var protobufStream = ProtobufHelper.ToStream(_testModel);
var sharpYamlStream = SharpYamlHelper.ToStream(_testModel);
var systemTextJsonStream = SystemTextJsonHelper.ToStream(_testModel);
var utf8JsonStream = Utf8JsonHelper.ToStream(_testModel);
var xmlStream = XmlHelper.ToStream(_testModel);
var yamlDotNetStream = YamlDotNetHelper.ToStream(_testModel);
var zeroFormatterStream = ZeroFormatterHelper.ToStream(_testModel);
Console.WriteLine("FromStream go!");
Runner.Initialize();
Console.WriteLine(Runner.Time("BinaryHelper FromStream", iteration,
#pragma warning disable CS0618
() => BinaryHelper.FromStream <TestModel>(binaryStream)));
#pragma warning restore CS0618
Console.WriteLine(Runner.Time("DataContractHelper FromStream", iteration,
() => DataContractHelper.FromStream <TestModel>(dataContractStream)));
Console.WriteLine(Runner.Time("JilHelper FromStream", iteration,
() => JilHelper.FromStream <TestModel>(jilStream)));
Console.WriteLine(Runner.Time("MessagePackHelper FromStream", iteration,
() => MessagePackHelper.FromStream <TestModel>(messagePackStream)));
Console.WriteLine(Runner.Time("MsgPackHelper FromStream", iteration,
() => MsgPackHelper.FromStream <TestModel>(msgPackStream)));
Console.WriteLine(Runner.Time("NewtonsoftJsonHelper FromStream", iteration,
() => NewtonsoftJsonHelper.FromStream <TestModel>(newtonsoftJsonStream)));
Console.WriteLine(Runner.Time("ProtobufHelper FromStream", iteration,
() => ProtobufHelper.FromStream <TestModel>(protobufStream)));
Console.WriteLine(Runner.Time("SharpYamlHelper FromStream", iteration,
() => SharpYamlHelper.FromStream <TestModel>(sharpYamlStream)));
Console.WriteLine(Runner.Time("SystemTextJsonHelper FromStream", iteration,
() => SystemTextJsonHelper.FromStream <TestModel>(systemTextJsonStream)));
Console.WriteLine(Runner.Time("Utf8JsonHelper FromStream", iteration,
() => Utf8JsonHelper.FromStream <TestModel>(utf8JsonStream)));
Console.WriteLine(Runner.Time("XmlHelper FromStream", iteration,
() => XmlHelper.FromStream <TestModel>(xmlStream)));
Console.WriteLine(Runner.Time("YamlDotNetHelper FromStream", iteration,
() => YamlDotNetHelper.FromStream <TestModel>(yamlDotNetStream)));
Console.WriteLine(Runner.Time("ZeroFormatterHelper FromStream", iteration,
() => ZeroFormatterHelper.FromStream <TestModel>(zeroFormatterStream)));
Console.WriteLine("\r\nFromStream complete!\r\n");
}
public void CanSerialiseAndDeserialiseStatsCorrectly()
{
var bytes =
"kYqqaW50ZXJ2YWxJZLAyMDE1LTAyLTAzOjE1OjA1pHVuaXSmbWludXRlo2FsbIKjYWxsgqVjb3VudG6kZGF0Yc0q+KhtZXNzYWdlc4KlY291bnRupGRhdGHNKvinaW5ib3VuZIKjYWxsgqNhbGyCpWNvdW50RqRkYXRhzRtYqG1lc3NhZ2VzgqVjb3VudEakZGF0Yc0bWKhyZWFsdGltZYKjYWxsgqVjb3VudEakZGF0Yc0bWKhtZXNzYWdlc4KlY291bnRGpGRhdGHNG1iob3V0Ym91bmSCo2FsbIKjYWxsgqVjb3VudCikZGF0Yc0PoKhtZXNzYWdlc4KlY291bnQopGRhdGHND6CocmVhbHRpbWWCo2FsbIKlY291bnQopGRhdGHND6CobWVzc2FnZXOCpWNvdW50KKRkYXRhzQ+gqXBlcnNpc3RlZIKjYWxsgqVjb3VudBSkZGF0Yc0H0KhwcmVzZW5jZYKlY291bnQUpGRhdGHNB9CrY29ubmVjdGlvbnOCo2FsbIOkcGVhaxSjbWluAKZvcGVuZWQKo3Rsc4KkcGVhaxSmb3BlbmVkCqhjaGFubmVsc4KkcGVhazKmb3BlbmVkHqthcGlSZXF1ZXN0c4Kpc3VjY2VlZGVkMqZmYWlsZWQKrXRva2VuUmVxdWVzdHOCqXN1Y2NlZWRlZDymZmFpbGVkFA=="
.FromBase64();
var expected = JsonHelper.Deserialize <List <Stats> >(ResourceHelper.GetResource("MsgPackStatsTest.json"));
var unpacked = (List <Stats>)MsgPackHelper.Deserialise(bytes, typeof(List <Stats>));
unpacked.ShouldBeEquivalentTo(expected);
}
private IEnumerable <Stats> ParseStatsResponse(AblyResponse response)
{
var body = response.TextResponse;
#if MSGPACK
if (_protocol == Protocol.MsgPack)
{
return((List <Stats>)MsgPackHelper.Deserialise(response.Body, typeof(List <Stats>)));
}
#endif
return(JsonHelper.Deserialize <List <Stats> >(body));
}
private void LogRequestBody(byte[] requestBody)
{
try
{
var body = MsgPackHelper.DeserialiseMsgPackObject(requestBody)?.ToString();
Logger.Debug("RequestBody: " + (body ?? "No body present"));
}
catch (Exception ex)
{
Logger.Error("Error while logging request body.", ex);
}
}
public void CanSerialiseListOfMessagesAndDeserialiseThem()
{
var message = new Message("example", "The quick brown fox jumped over the lazy dog");
var serialised = MsgPackHelper.Serialise(new List <Message> {
message
});
var result = MsgPackHelper.Deserialise(serialised, typeof(List <Message>)) as List <Message>;
var resultMessage = result.First();
resultMessage.Data.Should().Be(message.Data);
resultMessage.Name.Should().Be(message.Name);
}
private void LogRequestBody(byte[] requestBody)
{
try
{
var body = MsgPackHelper.Deserialise(requestBody, typeof(MessagePackObject)).ToString();
Logger.Debug("RequestBody: " + body);
}
catch (Exception ex)
{
Logger.Error("Error while logging request body.", ex);
}
}
/// <summary>
/// 设备解析数据标准接口
/// </summary>
/// <param name="strSource">需要解析的数据流</param>
/// <param name="strCmd">回写数据流</param>
/// <param name="eventId">事件ID</param>
/// <param name="isDisconnect">是否断开连接，True：断开 False：不断开</param>
/// <param name="isMass">是否群发</param>
/// <param name="strAdvance">扩展参数</param>
/// <param name="connId">客户端Id</param>
/// <param name="spreadObject">客户端附加参数</param>
public void ParseResult(byte[] strSource, ref byte[] strCmd, string eventId, ref bool isDisconnect, ref bool isMass, ref string strAdvance, string connId, ref ConcurrentDictionary <string, SpreadModel> spreadObject, ref bool IsUpdater, ref byte[] 扩展参数)
{
try
{
IsUpdater = true;
byte[] len = new byte[4];
Array.Copy(strSource, 2, len, 0, 4);
int lens = BitConverter.ToInt32(len, 0);
byte[] realDatas = new byte[lens]; //真实数据大小
//去掉包头
Array.Copy(strSource, 11, realDatas, 0, lens);
FileInformation sendUpdateContents = new FileInformation();
请求文件信息 updateList = MsgPackHelper <请求文件信息> .UnPack(realDatas);
WriteDeviceLog.WriteLog("Log\\" + _DeviceName + "\\解析日志", $@"收到文件ID：{updateList.FileId}", Guid.NewGuid().ToString());
//sendUpdateContents = FileByteContents.Where(x => x.FileId==updateList).ToList().First();//获取文件id对应的文件
sendUpdateContents = FileListFileInformation.Where(x => x.FileId == updateList.FileId).ToList().First();
WriteDeviceLog.WriteLog("Log\\" + _DeviceName + "\\解析日志", $@"whereId：{sendUpdateContents.FileId}", Guid.NewGuid().ToString());
//包头7字节
//2048长度来存放文件路径
//剩下的放文件内容
byte[] filePath = new byte[2048];
byte[] basePath = Encoding.Default.GetBytes(sendUpdateContents.BaseFilePath);//文件路径
Array.Copy(basePath, 0, filePath, 0, basePath.Length);
扩展参数 = filePath;
strAdvance = sendUpdateContents.FilePath + "|" + sendUpdateContents.FileId + "|" + updateList.文件读取开始位置 + "|" + updateList.文件读取长度;
WriteDeviceLog.WriteLog("Log\\" + _DeviceName + "\\解析日志", $@"返回：{strAdvance}", Guid.NewGuid().ToString());
//strCmd = CopyByte(filePath,FileHelper.GetFileBytes(sendUpdateContents.FilePath));
//strCmd = ByteHelper.PackByte(strCmd, Command.UpdateDatasList);//封包
//WriteDeviceLog.WriteLog("Log\\" + _DeviceName + "\\解析日志", $@"发送文件ID：{updateList} 大小：{strCmd.Length}字节", Guid.NewGuid().ToString());
if (connId != null)
{
if (spreadObject.ContainsKey(connId))
{
//更新客户端对象扩展信息
spreadObject[connId].connId = connId;
spreadObject[connId].DeviceCode = "AutoUpdaterService";
spreadObject[connId].AccessAddress = strAdvance;
spreadObject[connId].LastTimeHandleTime = DateTime.Now;
spreadObject[connId].OnlineTime = TimeHelper.GetTimeLong(spreadObject[connId].FirstTimeConnectTime, DateTime.Now, 1);
}
}
}
catch (Exception ex)
{
WriteDeviceLog.WriteLog("Log\\" + _DeviceName + "\\解析日志", $@"{strAdvance} {ex}", eventId);
}
}
public IEnumerable <PresenceMessage> ParsePresenceMessages(AblyResponse response, ChannelOptions options)
{
if (response.Type == ResponseType.Json)
{
var messages = JsonHelper.Deserialize <List <PresenceMessage> >(response.TextResponse);
ProcessMessages(messages, options);
return(messages);
}
var payloads = MsgPackHelper.Deserialise(response.Body, typeof(List <PresenceMessage>)) as List <PresenceMessage>;
ProcessMessages(payloads, options);
return(payloads);
}
public void CanSerialiseAndDeserialiseTokenDetailsWithEmptyCapability()
{
var details = new TokenDetails()
{
Token = "DaC_fA.DzqwNZFHNIl_GpUR6ENpeqewYnzf5LtI2L2RCP0eDSs597_6OXEW5vumSHiBn2pdxP7ge420UNbrqpKaS_W4aWE5oc15OriGL_8hELLGpgDEoNsnUixWIizGvhsnKVFYT",
KeyName = "DaC_fA.ChPHsQ",
Issued = 1462827574141.FromUnixTimeInMilliseconds(),
Capability = new Capability(),
};
var packed = MsgPackHelper.Serialise(details);
var unpacked = (TokenDetails)MsgPackHelper.Deserialise(packed, typeof(TokenDetails));
unpacked.ShouldBeEquivalentTo(details);
}
public void DeserializesMessageCorrectly_Count(int count)
{
// Arrange
byte[] expectedMessage = MsgPackHelper.Serialise(new ProtocolMessage()
{
Count = count
}) as byte[];
// Act
ProtocolMessage target = MsgPackHelper.Deserialise <ProtocolMessage>(expectedMessage);
// Assert
Assert.NotNull(target);
Assert.Equal(count, target.Count.Value);
}
public void CanSerialiseAndDeserialiseBase64ByteArray()
{
var message = new Message()
{
Name = "example", Data = "AAECAwQFBgcICQoLDA0ODw==".FromBase64()
};
var serialised = MsgPackHelper.Serialise(new List <Message> {
message
});
var resultMessage = MsgPackHelper.Deserialise(serialised, typeof(List <Message>)) as List <Message>;
var data = resultMessage.First().Data as byte[];
data.Should().BeEquivalentTo(message.Data as byte[]);
resultMessage.First().Name.Should().Be(message.Name);
}
public void DeserializesMessageCorrectly_ConnectionSerial(long connectionSerial)
{
// Arrange
List <byte> expectedMessage = new List <byte>();
expectedMessage.Add(0x81);
expectedMessage.AddRange(SerializeString("connectionSerial"));
expectedMessage.Add(BitConverter.GetBytes(connectionSerial).First());
// Act
ProtocolMessage target = MsgPackHelper.Deserialise <ProtocolMessage>(expectedMessage.ToArray());
// Assert
target.Should().NotBeNull();
Assert.Equal <long>(connectionSerial, target.ConnectionSerial.Value);
}
public void CanDeserialiseTokenResponse()
{
var value =
"gaxhY2Nlc3NfdG9rZW6GpXRva2Vu2YhnNFg2UVEuRHlCYzlMZUdvdy1saWVEcG4zTXRsd09uUEhoN2VtN3MyQ3JTZ1pLM2NUNkRvZUo1dlQxWXRwNDFvaTVWUUtNUkxuSVdDckFadHVOb3F5Q0lvVFphQjFfb1FFX0Utb3c2Y3hKX1EwcFUyZ3lpb2xRNGp1VDM1TjI0Qzgzd0p6aUI5p2tleU5hbWWtZzRYNlFRLnV0ekdsZ6Zpc3N1ZWTOVMEP1qdleHBpcmVzzlTBHeaqY2FwYWJpbGl0eYGhKpGhKqhjbGllbnRJZKMxMjM=";
var decodedMessagePack = MsgPackHelper.Deserialise(value.FromBase64(), typeof(MessagePackObject)).ToString();
var response = JsonHelper.Deserialize <TokenResponse>(decodedMessagePack);
response.AccessToken.Should().NotBeNull();
response.AccessToken.Capability.ToJson().Should().Be("{\"*\":[\"*\"]}");
response.AccessToken.ClientId.Should().Be("123");
response.AccessToken.Token.Should().Be("g4X6QQ.DyBc9LeGow-lieDpn3MtlwOnPHh7em7s2CrSgZK3cT6DoeJ5vT1Ytp41oi5VQKMRLnIWCrAZtuNoqyCIoTZaB1_oQE_E-ow6cxJ_Q0pU2gyiolQ4juT35N24C83wJziB9");
response.AccessToken.Issued.Should().Be(((long)1421938646).FromUnixTimeInMilliseconds());
response.AccessToken.Expires.Should().Be(((long)1421942246).FromUnixTimeInMilliseconds());
}
public void DeserializesMessageCorrectly_Action(ProtocolMessage.MessageAction action)
{
// Arrange
List <byte> expectedMessage = new List <byte>();
expectedMessage.Add(0x81);
expectedMessage.AddRange(SerializeString("action"));
expectedMessage.Add((byte)action);
// Act
ProtocolMessage target = MsgPackHelper.Deserialise <ProtocolMessage>(expectedMessage.ToArray());
// Assert
Assert.NotNull(target);
Assert.Equal(action, target.Action);
}
public void DeserializesMessageCorrectly_ConnectionKey(string connectionKey)
{
// Arrange
List <byte> expectedMessage = new List <byte>();
expectedMessage.Add(0x81);
expectedMessage.AddRange(SerializeString("connectionKey"));
expectedMessage.AddRange(SerializeString(connectionKey));
// Act
ProtocolMessage target = MsgPackHelper.Deserialise <ProtocolMessage>(expectedMessage.ToArray());
// Assert
Assert.NotNull(target);
Assert.Equal <string>(connectionKey, target.ConnectionKey);
}
public void DeserializesMessageCorrectly_ConnectionId(string connectionId)
{
// Arrange
List <byte> expectedMessage = new List <byte>();
expectedMessage.Add(0x81);
expectedMessage.AddRange(SerializeString("connectionId"));
expectedMessage.AddRange(SerializeString(connectionId));
// Act
ProtocolMessage target = MsgPackHelper.Deserialise <ProtocolMessage>(expectedMessage.ToArray());
// Assert
target.Should().NotBeNull();
Assert.Equal(connectionId, target.ConnectionId);
}
/// <summary>
/// 设备初始化规则
/// </summary>
/// <param name="strDevice"></param>
/// <param name="dbType"></param>
public void GetRules(string strDevice, string dbType, ref string param1)
{
_DeviceID = strDevice;
_DeviceName = strDevice;
//加载客户端缓存文件
var fileHelper = new FileHelper();
//测试手动获取文件位置
FileListFileInformation = fileHelper.GetAllFiles(new System.IO.DirectoryInfo($@"{_baseDir}\UpdateTempFile"));
//FileByteContents = FileHelper.FileByteContentsList;
datas = MsgPackHelper <List <FileInformation> > .Pack(FileListFileInformation);
//datas = SerializableHelper.ObjectToBytes(FileListFileInformation);
WriteDeviceLog.WriteLog("Log\\" + _DeviceName + "\\解析日志", $@"加载内存：文件列表{FileListFileInformation.Count}个", Guid.NewGuid().ToString());
}
public IEnumerable <PresenceMessage> ParsePresenceMessages(AblyResponse response, ChannelOptions options)
{
if (response.Type == ResponseType.Json)
{
var messages = JsonHelper.Deserialize <List <PresenceMessage> >(response.TextResponse);
ProcessMessages(messages, options);
return(messages);
}
#if MSGPACK
var payloads = MsgPackHelper.Deserialise(response.Body, typeof(List <PresenceMessage>)) as List <PresenceMessage>;
ProcessMessages(payloads, options);
return(payloads);
#else
throw new AblyException($"Response of type '{response.Type}' is invalid because MsgPack support was not enabled for this build.");
#endif
}
private void LogRequestBody(byte[] requestBody)
{
try
{
#if MSGPACK
var body = MsgPackHelper.DeserialiseMsgPackObject(requestBody)?.ToString();
Logger.Debug("RequestBody: " + (body ?? "No body present"));
#else
Logger.Debug("RequestBody: MsgPack disabled, cannot log request");
#endif
}
catch (Exception ex)
{
Logger.Error("Error while logging request body.", ex);
}
}
public void DeserializesMessageCorrectly_MsgSerial(long serial)
{
// Arrange
List <byte> expectedMessage = new List <byte>();
expectedMessage.Add(0x81);
expectedMessage.AddRange(SerializeString("msgSerial"));
expectedMessage.Add(BitConverter.GetBytes(serial).First());
// Act
ProtocolMessage target = MsgPackHelper.Deserialise <ProtocolMessage>(expectedMessage.ToArray());
// Assert
Assert.NotNull(target);
Assert.Equal <long>(serial, target.MsgSerial);
}
public void DeserializesMessageCorrectly_Id(string id)
{
// Arrange
List <byte> expectedMessage = new List <byte>();
expectedMessage.Add(0x81);
expectedMessage.AddRange(SerializeString("id"));
expectedMessage.AddRange(SerializeString(id));
// Act
ProtocolMessage target = MsgPackHelper.Deserialise <ProtocolMessage>(expectedMessage.ToArray());
// Assert
Assert.NotNull(target);
Assert.Equal <string>(id, target.Id);
}
private void LogResponse(AblyResponse response)
{
Logger.Info("Protocol:" + _protocol);
try
{
var responseBody = response.TextResponse;
if (_protocol == Protocol.MsgPack && response.Body != null)
{
responseBody = MsgPackHelper.DeSerialise(response.Body, typeof(MessagePackObject)).ToString();
}
Logger.Debug("Response: " + responseBody);
}
catch (Exception ex)
{
Logger.Error("Error while logging response body.", ex);
}
}
public void DeserializesMessageCorrectly_Flags(int flags)
{
// Arrange
List <byte> expectedMessage = new List <byte>();
expectedMessage.Add(0x81);
expectedMessage.AddRange(SerializeString("flags"));
expectedMessage.Add((byte)flags);
// Act
ProtocolMessage target = MsgPackHelper.Deserialise <ProtocolMessage>(expectedMessage.ToArray());
// Assert
Assert.NotNull(target);
Assert.Equal <byte>((byte)flags, (byte)target.Flags);
}
private void socket_DataReceived(object sender, DataReceivedEventArgs e)
{
if (Logger.IsDebug)
{
try
{
var message = MsgPackHelper.Deserialise(e.Data, typeof(MessagePackObject)).ToString();
Logger.Debug("Websocket data message received. Raw: " + message);
}
catch (Exception)
{
Logger.Debug("Error parsing message as MsgPack.");
}
}
Listener?.OnTransportDataReceived(new RealtimeTransportData(e.Data));
}
public void WithMsgPackEncoding_CanSerialiseAndDeserializeProtocolMessage()
{
#if MSGPACK
if (!Defaults.MsgPackEnabled)
{
return;
}
var message = new ProtocolMessage(ProtocolMessage.MessageAction.Presence, "boo");
message.Presence = new[] { new PresenceMessage(PresenceAction.Enter, "123", "my data") };
var data = MsgPackHelper.Serialise(message);
var result = MsgPackHelper.Deserialise(data, typeof(ProtocolMessage)) as ProtocolMessage;
result.Action.Should().Be(message.Action);
result.Presence.First().Data.Should().Be(message.Presence[0].Data);
#endif
}
