public void TestDeltaFrame(ProcessDataPointValue dataPoint)
{
ProcessDataSet dataSet = new ProcessDataSet("test-publisher", "test001", 123, ProcessDataSet.DataSetType.TimeSeries);
dataSet.AddDataPoint(dataPoint);
DecodeMessage decoder = new DecodeMessage();
byte[] encodedMeta = dataSet.GetEncodedMetaFrame(new EncodingOptions(), 1, true);
byte[] encodedKey = dataSet.GetEncodedDeltaFrame(2);
NetworkMessage metaNetworkMessage = decoder.ParseBinaryMessage(encodedMeta);
Assert.That(metaNetworkMessage, Is.Not.Null);
Assert.That(metaNetworkMessage, Is.InstanceOf(typeof(MetaFrame)));
Assert.That(metaNetworkMessage.NetworkMessageHeader.UADPFlags.HasFlag(UADPFlags.PayloadHeaderEnabled), Is.False);
NetworkMessage deltaNetworkMessage = decoder.ParseBinaryMessage(encodedKey);
Assert.That(deltaNetworkMessage, Is.Not.Null);
Assert.That(deltaNetworkMessage, Is.InstanceOf(typeof(DeltaFrame)));
Assert.That(deltaNetworkMessage.NetworkMessageHeader.UADPFlags.HasFlag(UADPFlags.PayloadHeaderEnabled), Is.True);
DeltaFrame decodedDeltaMessage = (DeltaFrame)deltaNetworkMessage;
Assert.That(decodedDeltaMessage, Is.Not.Null);
Assert.That(decodedDeltaMessage.Items, Is.Not.Empty);
Assert.That(decodedDeltaMessage.Items.Count, Is.EqualTo(1));
Assert.That(decodedDeltaMessage.NetworkMessageHeader.UADPFlags.HasFlag(UADPFlags.PayloadHeaderEnabled), Is.True);
ProcessDataPointValue decodedDataPoint = (ProcessDataPointValue)decodedDeltaMessage.Items[0];
Common.AssertDataPointsAreEqual(dataPoint, decodedDataPoint);
}
public void DeltaFrame(List <ProcessDataPointValue> dataPoints)
{
ProcessDataSet dataSet = new ProcessDataSet("test-publisher", "test001", 123, ProcessDataSet.DataSetType.TimeSeries);
foreach (ProcessDataPointValue dataPoint in dataPoints)
{
dataSet.AddDataPoint(dataPoint);
}
DecodeMessage decoder = new DecodeMessage();
byte[] encodedMeta = dataSet.GetEncodedMetaFrame(new EncodingOptions(), 1, true);
byte[] encodedDelta = dataSet.GetEncodedDeltaFrame(2);
NetworkMessage metaNetworkMessage = decoder.ParseBinaryMessage(encodedMeta);
Assert.That(metaNetworkMessage, Is.Not.Null);
Assert.That(metaNetworkMessage, Is.InstanceOf(typeof(MetaFrame)));
NetworkMessage deltaNetworkMessage = decoder.ParseBinaryMessage(encodedDelta);
Assert.That(deltaNetworkMessage, Is.Not.Null);
Assert.That(deltaNetworkMessage, Is.InstanceOf(typeof(DeltaFrame)));
DeltaFrame decodedDeltaMessage = (DeltaFrame)deltaNetworkMessage;
Assert.That(decodedDeltaMessage, Is.Not.Null);
Assert.That(decodedDeltaMessage.Items, Is.Not.Empty);
Assert.That(decodedDeltaMessage.Items.Count, Is.EqualTo(dataPoints.Count));
Assert.That(decodedDeltaMessage.Items, Is.EqualTo(dataPoints));
}
public byte[] GetEncodedDeltaFrame(ushort sequenceNumber)
{
DeltaFrame delta = new DeltaFrame();
delta.ConfigurationVersion = m_MetaFrame.ConfigurationVersion;
delta.MetaFrame = m_MetaFrame;
delta.NetworkMessageHeader = new NetworkMessageHeader
{
PublisherID = new String(PublisherId),
VersionAndFlags = 0xD1,
ExtendedFlags1 = new ExtendedFlags1
{
RawValue = 0x04
}
};
delta.Flags1 = new DataSetFlags1
{
RawValue = 0xEB
};
delta.Flags2 = new DataSetFlags2
{
RawValue = 0x11
};
delta.FieldIndexList = new List <ushort>();
delta.PayloadHeader = new DataSetPayloadHeader
{
Count = 1,
DataSetWriterID = new[] { m_MetaFrame.DataSetWriterID }
};
delta.Items = new List <DataPointValue>();
delta.FieldIndexList = new List <ushort>();
for (int i = 0; i < m_ProcessValues.Values.Count; i++)
{
if (m_ProcessValues.Values.ElementAt(i)
.IsModified)
{
DataPointValue dataPoint = m_ProcessValues.Values.ElementAt(i)
.DataPoint;
dataPoint.Index = i;
delta.Items.Add(dataPoint);
m_ProcessValues.Values.ElementAt(i)
.IsModified = false;
delta.FieldIndexList.Add((ushort)i);
}
}
delta.FieldCount = (ushort)delta.Items.Count;
delta.DataSetMessageSequenceNumber = sequenceNumber;
delta.Timestamp = DateTime.Now;
using (MemoryStream outputStream = new MemoryStream())
{
delta.Encode(outputStream);
return(outputStream.ToArray());
}
}
public override byte[] GetEncodedDeltaFrame()
{
FileInfo assetInfo = GetFileInfo();
DeltaFrame delta = new DeltaFrame();
delta.ConfigurationVersion = m_MetaFrame.ConfigurationVersion;
delta.NetworkMessageHeader = new NetworkMessageHeader
{
PublisherID = new String(m_PublisherID),
VersionAndFlags = 0xD1,
ExtendedFlags1 = new ExtendedFlags1
{
RawValue = 0x04
}
};
delta.Flags1.RawValue = 0xEB;
delta.Flags2.RawValue = 0x01;
delta.Items = new List <DataPointValue>
{
new File
{
Path = new String(assetInfo.FullName),
Content = GetContent(),
Time = assetInfo.LastWriteTimeUtc.ToFileTimeUtc(),
FileType = new String("asset")
}
};
delta.MetaFrame = m_MetaFrame;
delta.PayloadHeader = new DataSetPayloadHeader
{
Count = 1,
DataSetWriterID = new ushort[] { 2000 }
};
delta.FieldCount = (ushort)delta.Items.Count;
delta.FieldIndexList = new List <ushort>
{
0
};
byte[] result = null;
using (MemoryStream outputStream = new MemoryStream())
{
delta.Encode(outputStream);
result = outputStream.ToArray();
}
return(result);
}
public int DeltaMessages(string fileName)
{
if (Debugger.IsAttached)
{
MetaMessage();
}
string filePath = Path.Combine(TestDataFolder, fileName);
byte[] rawMessage = File.ReadAllBytes(filePath);
NetworkMessage message = null;
Assert.DoesNotThrow(() => message = Decoder.ParseBinaryMessage(rawMessage));
Assert.That(message, Is.Not.Null);
Assert.That(message.NetworkMessageHeader.PublisherID.Value, Is.EqualTo(PublisherID));
Assert.That(message, Is.InstanceOf(typeof(DeltaFrame)));
DeltaFrame deltaMessage = (DeltaFrame)message;
Assert.That(deltaMessage.DataSetMessageSequenceNumber, Is.EqualTo(0));
return(deltaMessage.FieldIndexList.Count);
}
private DataFrame ParseDataSetFrame(Stream inputStream, DataFrame dataFrame)
{
if (dataFrame == null)
{
return(null);
}
ushort writerID = dataFrame.PayloadHeader.DataSetWriterID[0];
MetaFrame metaFrame = null;
if (dataFrame.Flags2.DataSetMessageType != DataSetMessageTypeEnum.KeepAlive)
{
metaFrame = m_LocalMetaStorage.RetrieveMetaMessageLocally(dataFrame.NetworkMessageHeader.PublisherID.Value, writerID, dataFrame.ConfigurationVersion);
if (metaFrame == null)
{
Logger.Warn($"Could not find MetaMessage for {dataFrame.NetworkMessageHeader.PublisherID.Value} [{dataFrame.ConfigurationVersion}]");
return(dataFrame);
}
}
switch (dataFrame.Flags2.DataSetMessageType)
{
case DataSetMessageTypeEnum.DataKeyFrame:
if (Logger.IsDebugEnabled)
{
Logger.Debug("Starting decoding KeyFrame");
}
KeyFrame keyFrame = KeyFrame.Decode(inputStream, dataFrame, metaFrame);
if (keyFrame == null)
{
Logger.Error("Unable to decode KeyFrame");
}
if (Logger.IsDebugEnabled && keyFrame != null)
{
Logger.Debug(keyFrame.ToString());
}
return(keyFrame);
case DataSetMessageTypeEnum.DataDeltaFrame:
if (Logger.IsDebugEnabled)
{
Logger.Debug("Starting decoding DeltaFrame");
}
DeltaFrame deltaFrame = DeltaFrame.Decode(inputStream, dataFrame, metaFrame);
if (deltaFrame == null)
{
Logger.Error("Unable to decode DeltaFrame");
}
if (Logger.IsDebugEnabled && deltaFrame != null)
{
Logger.Debug(deltaFrame.ToString());
}
return(deltaFrame);
case DataSetMessageTypeEnum.KeepAlive:
if (dataFrame.NetworkMessageHeader?.PublisherID != null)
{
if (Logger.IsInfoEnabled)
{
Logger.Info($"KeepAlive from {dataFrame.NetworkMessageHeader.PublisherID}");
}
KeepAliveFrame keepAliveFrame = KeepAliveFrame.Decode(inputStream, dataFrame);
if (keepAliveFrame == null)
{
Logger.Error("Unable to decode keep alive frame");
}
if (Logger.IsDebugEnabled && keepAliveFrame != null)
{
Logger.Debug(keepAliveFrame.ToString());
}
}
return(dataFrame);
}
return(null);
}
