public void MetaMessageLastChunk()
{
if (Debugger.IsAttached)
{
MetaMessageFirstChunk();
}
string chunkFilePath = Path.Combine(TestDataFolder, "02.meta.chunk.bin");
byte[] rawMessage = File.ReadAllBytes(chunkFilePath);
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(MetaFrame)));
MetaFrame metaMessage = (MetaFrame)message;
Assert.That(metaMessage.DataSetWriterID, Is.EqualTo(1000));
Assert.That(metaMessage.FieldMetaDataList.Count, Is.EqualTo(138));
// Check Namespaces
// First entry must be null
Assert.That(metaMessage.Namespaces[0], Is.EqualTo(new String(string.Empty)));
Assert.That(metaMessage.Namespaces[1], Is.EqualTo(new String("http://siemens.com/energy/schema/opcua/ps/v2")));
Assert.That(metaMessage.Namespaces[2], Is.EqualTo(new String("https://mindsphere.io/OPCUAPubSub/v3")));
}
private static void CreateFieldMetaDataList(DataPointEntry entry, MetaFrame m_MetaFrame, EncodingOptions options)
{
if (m_MetaFrame.FieldMetaDataList == null)
{
m_MetaFrame.FieldMetaDataList = new List <FieldMetaData>();
}
FieldMetaData fieldMetaData = new FieldMetaData(options)
{
Index = entry.DataPoint.Index,
Name = new String(entry.DataPoint.Name),
Flags = new DataSetFieldFlags(options),
DataType = entry.DataPoint.NodeID,
FieldID = entry.DataPoint.FieldID
};
// all data points have a "Unit" and a "Prefix" key/value pair in the Properties
// list of the FieldMetaData; if it is null here, then create an empty entry
if (entry.DataPoint.Properties == null || entry.DataPoint.Properties.Count == 0)
{
fieldMetaData.Properties = new List <binary.Messages.Meta.KeyValuePair>
{
new binary.Messages.Meta.KeyValuePair("Prefix", new String("")),
new binary.Messages.Meta.KeyValuePair("Unit", new String(""))
};
}
else
{
fieldMetaData.Properties = entry.DataPoint.Properties;
}
// add the FieldMetaData for the given data object to the list of all FieldMetaData
m_MetaFrame.FieldMetaDataList.Add(fieldMetaData);
}
protected void CreateMeta(string name, EncodingOptions options, ushort sequenceNumber)
{
m_MetaFrame = new MetaFrame(options);
ExtendedFlags1 extendedFlags1 = new ExtendedFlags1
{
RawValue = 0x84
};
ExtendedFlags2 extendedFlags2 = new ExtendedFlags2
{
RawValue = 8
};
NetworkMessageHeader networkMessageHeader = new NetworkMessageHeader
{
VersionAndFlags = 0x91,
ExtendedFlags1 = extendedFlags1,
ExtendedFlags2 = extendedFlags2,
PublisherID = new String(PublisherId)
};
m_MetaFrame.NetworkMessageHeader = networkMessageHeader;
m_MetaFrame.SequenceNumber = sequenceNumber;
DateTime time = DateTime.UtcNow;
m_MetaFrame.ConfigurationVersion.Minor = (uint)(time.Ticks & uint.MaxValue);
m_MetaFrame.ConfigurationVersion.Major = (uint)(time.Ticks >> 32);
m_MetaFrame.Name = new String(name);
m_MetaFrame.DataSetWriterID = m_WriterId;
m_MetaFrame.Description = Description;
foreach (DataPointEntry entry in m_ProcessValues.Values)
{
CreateFieldMetaDataList(entry, m_MetaFrame, options);
AddDataPointMeta(entry.DataPoint);
}
}
protected override void CreateMeta()
{
m_MetaFrame = new MetaFrame();
ExtendedFlags1 extendedFlags1 = new ExtendedFlags1
{
RawValue = 0x84
};
ExtendedFlags2 extendedFlags2 = new ExtendedFlags2
{
RawValue = 0x08
};
m_MetaFrame.NetworkMessageHeader = new NetworkMessageHeader
{
VersionAndFlags = 0x91,
ExtendedFlags1 = extendedFlags1,
ExtendedFlags2 = extendedFlags2,
PublisherID = new String(m_PublisherID)
};
DateTime now = DateTime.UtcNow;
TimeSpan time = now - ConfigurationVersion.Base;
m_MetaFrame.ConfigurationVersion.Major = (uint)time.TotalSeconds;
m_MetaFrame.ConfigurationVersion.Minor = (uint)time.TotalSeconds;
m_MetaFrame.Name = new String("DataSet 002");
m_MetaFrame.DataSetWriterID = 2000;
AddFile("AssetFile.json");
if (m_MetaFrame.EnumDataTypes == null)
{
m_MetaFrame.EnumDataTypes = new Dictionary <NodeID, EnumDescription>();
}
}
public static DeltaFrame Decode(Stream inputStream, DataFrame dataFrame, MetaFrame meta)
{
if (inputStream == null || !inputStream.CanRead || meta == null)
{
return(null);
}
DeltaFrame instance = new DeltaFrame(dataFrame);
instance.MetaFrame = meta;
instance.Timestamp = dataFrame.Timestamp;
ushort?readuInt16 = BaseType.ReadUInt16(inputStream);
if (readuInt16 != null)
{
instance.FieldCount = readuInt16.Value;
}
instance.Items = new List <DataPointValue>(instance.FieldCount);
instance.FieldIndexList = new List <ushort>(instance.FieldCount);
for (int i = 0; i < instance.FieldCount; i++)
{
// Index
ushort?indexFromStream = BaseType.ReadUInt16(inputStream);
if (!indexFromStream.HasValue)
{
throw new Exception("Decode DeltaFrame: Could not parse field index.");
}
instance.FieldIndexList.Add(indexFromStream.Value);
DataPointValue item = ParseDataPoint(inputStream, meta, indexFromStream.Value);
if (item != null)
{
instance.Items.Add(item);
}
}
return(instance);
}
public static KeyFrame Decode(Stream inputStream, DataFrame dataFrame, MetaFrame meta)
{
if (inputStream == null || !inputStream.CanRead || meta == null)
{
return(null);
}
KeyFrame instance = new KeyFrame(dataFrame);
instance.MetaFrame = meta;
instance.Timestamp = dataFrame.Timestamp;
ushort fieldCount = (ushort)(meta.FieldMetaDataList?.Count ?? 0);
ushort?readUInt16 = BaseType.ReadUInt16(inputStream);
if (readUInt16 == null)
{
return(null);
}
if (readUInt16.Value != fieldCount)
{
Logger.Error($"Number of fields from Meta: {meta.FieldMetaDataList.Count} vs. FieldCount: {readUInt16.Value}");
return(null);
}
instance.Items = new List <DataPointValue>(fieldCount);
for (ushort index = 0; index < fieldCount; index++)
{
DataPointValue item = ParseDataPoint(inputStream, meta, index);
if (item != null)
{
instance.Items.Add(item);
}
}
return(instance);
}
protected static DataPointValue ParseDataPoint(Stream inputStream, MetaFrame meta, ushort index)
{
if (index > meta.FieldMetaDataList.Count - 1)
{
throw new Exception("Decode DeltaFrame: Could not parse field as corresponding meta data is not present");
}
// Value
FieldMetaData metaData = meta.FieldMetaDataList[index];
if (metaData.Index != index)
{
Logger.Error($"Index does not match: FieldMetaData.Index {metaData.Index} != {index} read from Stream.");
}
if (Logger.IsDebugEnabled)
{
Logger.Debug($"Decoding item at position {index} in Meta Frame. Using FieldMetaData:");
Logger.Debug(metaData);
}
DataPointValue item = null;
if (metaData.DataType == File.PreDefinedNodeID)
{
item = new File();
item.Decode(inputStream);
}
else
{
item = ProcessValueFactory.CreateValue(metaData.DataType);
item.Properties = metaData.Properties;
if (meta.StructureDataTypes.TryGetValue(metaData.DataType, out StructureDescription desc))
{
if (meta.EnumDataTypes != null &&
desc.Name.Name.ToString()
.Contains("EnumValue", StringComparison.InvariantCultureIgnoreCase))
{
string enumName = desc.Name.Name.Value
.Substring(10);
item.EnumDescription = meta.EnumDataTypes.First(s => s.Value.Name.Name.Value == enumName)
.Value;
}
item.Decode(inputStream);
}
}
// ReSharper disable once ConditionIsAlwaysTrueOrFalse
if (item == null)
{
Logger.Error($"Unable to decode value {metaData.DataType} at position {index} in message.");
return(null);
}
item.Name = metaData.Name.Value;
item.Properties = metaData.Properties;
item.Index = index;
return(item);
}
public ProcessDataSet(string publisherId, string name, ushort writerId, DataSetType dataSetType)
{
PublisherId = publisherId;
m_ProcessValues = new Dictionary <string, DataPointEntry>();
m_Name = name;
m_WriterId = writerId;
m_MetaFrame = null;
SetDataSetType(dataSetType);
Description = new LocalizedText();
}
internal static StructureDescription GetStructureDescription(MetaFrame meta, NodeID nodeID)
{
foreach (KeyValuePair <NodeID, StructureDescription> desc in meta.StructureDataTypes)
{
if (desc.Key == nodeID)
{
return(desc.Value);
}
}
return(null);
}
public void AddDataPoint(ProcessDataPointValue dataPoint)
{
if (!m_ProcessValues.ContainsKey(dataPoint.Name))
{
DataPointEntry entry = new DataPointEntry
{
DataPoint = dataPoint,
IsModified = true
};
m_ProcessValues.Add(dataPoint.Name, entry);
m_MetaFrame = null;
}
}
private MetaFrame ParseMetaFrame(Stream inputStream, NetworkMessageHeader networkMessageHeader, EncodingOptions options)
{
MetaFrame metaFrame = MetaFrame.Decode(inputStream, options);
if (metaFrame == null)
{
Logger.Error("Could not parse Meta Message.");
}
if (metaFrame != null)
{
metaFrame.NetworkMessageHeader = networkMessageHeader;
m_LocalMetaStorage.StoreMetaMessageLocally(metaFrame);
if (Logger.IsDebugEnabled)
{
Logger.Debug($"Meta Message decoded with Configuration Version: {metaFrame.ConfigurationVersion}");
Logger.Debug(metaFrame.ToString());
}
}
return(metaFrame);
}
public void StoreMetaMessageLocally(MetaFrame metaFrame)
{
string pubID = metaFrame.NetworkMessageHeader.PublisherID.Value;
ConfigurationVersion configVersion = metaFrame.ConfigurationVersion;
ushort writerID = metaFrame.DataSetWriterID;
if (IsMetaMessageAlreadyKnown(pubID, writerID, configVersion))
{
return;
}
if (Logger.IsInfoEnabled)
{
Logger.Info($"Storing meta message for {pubID} with version {configVersion}.");
}
if (!m_DeviceMetaMessages.TryGetValue(pubID, out ConcurrentDictionary <ushort, ConcurrentDictionary <ConfigurationVersion, MetaFrame> > publisherDictionary))
{
publisherDictionary = new ConcurrentDictionary <ushort, ConcurrentDictionary <ConfigurationVersion, MetaFrame> >();
m_DeviceMetaMessages.TryAdd(pubID, publisherDictionary);
}
if (!publisherDictionary.TryGetValue(writerID, out ConcurrentDictionary <ConfigurationVersion, MetaFrame> cfgDictionary))
{
cfgDictionary = new ConcurrentDictionary <ConfigurationVersion, MetaFrame>();
publisherDictionary.TryAdd(writerID, cfgDictionary);
}
if (cfgDictionary.Count > 10)
{
MetaFrame dummy;
cfgDictionary.TryRemove(cfgDictionary.Keys.OrderBy(a => a)
.First(),
out dummy
);
}
// Add the Meta Message if it doesn't exist yet or if it's already present, replace it.
cfgDictionary.AddOrUpdate(configVersion, metaFrame, (existingVersion, existingFrame) => metaFrame);
}
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);
}
private void InitDetailsFromMeta(MetaFrame metaMessage)
{
if (m_VisualizerForm.InvokeRequired)
{
m_VisualizerForm.Invoke(new Action <MetaFrame>(InitDetailsFromMeta), metaMessage);
}
else
{
try
{
string publisherID = metaMessage.NetworkMessageHeader.PublisherID.Value;
ushort writerID = metaMessage.DataSetWriterID;
ConcurrentDictionary <ushort, BindingSource> writerDictionary =
m_Bindings.GetOrAdd(publisherID, pubID => new ConcurrentDictionary <ushort, BindingSource>());
BindingSource bs = writerDictionary.GetOrAdd(writerID, s => new BindingSource());
bs.Clear();
m_VisualizerForm.ResetGroupedTypeIndex(publisherID, writerID);
if (metaMessage.FieldMetaDataList != null)
{
for (int i = 0; i < metaMessage.FieldMetaDataList.Count; i++)
{
FieldMetaData fieldMetaData = metaMessage.FieldMetaDataList[i];
bool isOldEnum = false,
isGroupedDataType = false;
if (metaMessage.StructureDataTypes.TryGetValue(fieldMetaData.DataType, out StructureDescription structDesc))
{
if (metaMessage.EnumDataTypes != null &&
structDesc.Name.Name.ToString()
.Contains("EnumValue"))
{
isOldEnum = true;
}
}
if (!isOldEnum)
{
isGroupedDataType = ProcessValueFactory.GetNodeIDType(fieldMetaData.DataType) == NodeIDType.GroupDataTypeTimeSeries;
}
DataPointBase dp = null;
if (fieldMetaData.DataType == File.PreDefinedNodeID)
{
dp = new FileDataPoint();
}
else
{
dp = new ProcessDataPoint();
}
dp.Index = fieldMetaData.Index;
dp.Name = dp.GetType()
.Name
== "FileDataPoint"
? Path.GetFileName(fieldMetaData.Name.Value)
: fieldMetaData.Name.Value;
bs.Add(dp);
if (isGroupedDataType)
{
m_VisualizerForm.AddGroupDataTypeIndex(publisherID, writerID, bs.Count - 1);
List <StructureField> fields = metaMessage.StructureDataTypes[fieldMetaData.DataType]
.Fields;
int count = fields.Count;
for (int k = 0; k < count; k++)
{
string name = fields[k]
.Name.Value;
if (name != "_time" && name.Contains("_qc") == false)
{
ProcessDataPoint dp1 = new ProcessDataPoint();
dp1.Index = fieldMetaData.Index;
dp1.Name = fields[k]
.Name.Value;
bs.Add(dp1);
}
}
}
}
}
}
catch (Exception e)
{
Console.WriteLine(e);
if (Debugger.IsAttached)
{
Debugger.Break();
}
else
{
throw;
}
}
}
}
