private async void SimulateButton_Click(object sender, RoutedEventArgs e)
{
try
{
if (m_ProducerHandler == null)
{
await DisplayError("Use connect button to connect first");
return;
}
List <ChannelMetadataRecord> timeRecords = new List <ChannelMetadataRecord>();
List <ChannelMetadataRecord> depthRecords = new List <ChannelMetadataRecord>();
List <ChannelMetadataRecord> timeAndDepthRecords = new List <ChannelMetadataRecord>();
ChannelStreamingInfo channelStreamingInfo = new ChannelStreamingInfo();
List <ChannelStreamingInfo> lstChannelStreamingInfo = new List <ChannelStreamingInfo>();
m_ProducerHandler.ChannelInfoReceived += ChannelStreamingInfo;
foreach (var item in m_ChannelItems)
{
if (item.Selected)
{
if (item.HasDepthIndex && item.HasTimeIndex)
{
timeAndDepthRecords.Add(item.ChannelMetadataRecord);
}
else if (item.HasTimeIndex)
{
///??Only for time??
channelStreamingInfo = new ChannelStreamingInfo()
{
ChannelId = item.ChannelMetadataRecord.ChannelId,
StartIndex = new StreamingStartIndex()
{
Item = null
},
ReceiveChangeNotification = true
};
timeRecords.Add(item.ChannelMetadataRecord);
}
else if (item.HasDepthIndex)
{
depthRecords.Add(item.ChannelMetadataRecord);
}
lstChannelStreamingInfo.Add(channelStreamingInfo);
}
}
if (timeRecords.Count > 0)
{
//string message = $"\nRequest: [Protocol {} MessageType {}]";
//Message?.Invoke("", 0, TraceLevel.Info);
//await m_ProducerHandler.Connect(EtpUrl .Text , UserName .Text , UserPassword .Password , protocols, m_Token);
await m_ProducerHandler.SendChannelData(lstChannelStreamingInfo);
}
}
catch (Exception ex)
{
await DisplayError(ex.Message);
}
}
protected void HandleChannelMetadata(object sender, ProtocolEventArgs <ChannelMetadata> e)
{
var receivedTime = DateTime.UtcNow;
if (e.Header.Protocol == 1 && e.Header.MessageType == 2)
{
var timediff = receivedTime - m_Time;
string message = "Channels received: [";
ChannelMetadata metadata = new ChannelMetadata();
metadata.Channels = new List <ChannelMetadataRecord>();
foreach (var channel in e.Message.Channels)
{
metadata.Channels.Add(channel);
ChannelStreamingInfo channelStreamingInfo = new ChannelStreamingInfo()
{
ChannelId = channel.ChannelId,
StartIndex = new StreamingStartIndex()
{
Item = null
},
ReceiveChangeNotification = true
};
}
ChannelInfoReceived?.Invoke(metadata);
message = $"\nResponse : [Protocol {e.Header.Protocol} MessageType {e.Header.MessageType}]";
Message?.Invoke(message, timediff.TotalMilliseconds, TraceLevel.Info);
}
}
private object ToChannelIndexValue(ChannelMetadataRecord channel, IndexMetadataRecord index, DateTimeOffset indexDateTimeOffset)
{
if (index.IndexKind == ChannelIndexKind.Time)
{
return(indexDateTimeOffset.ToUnixTimeMicroseconds());
}
object indexValue;
if (ChannelStreamingInfo.ContainsKey(channel.Id))
{
indexValue = ChannelStreamingInfo[channel.Id];
if (indexValue is double)
{
indexValue = (double)indexValue + Math.Pow(10, index.Scale) * 0.1;
}
}
else
{
indexValue = 0d;
}
ChannelStreamingInfo[channel.Id] = indexValue;
return(indexValue);
}
protected virtual void OnStart(object sender, ProtocolEventArgs <Start> e)
{
TaskRunner = new TaskRunner(e.Message.MaxMessageRate)
{
OnExecute = StreamChannelData,
OnError = LogStreamingError
};
if (Client.Handler <IChannelStreamingProducer>().IsSimpleStreamer)
{
var channelMetadata = Simulator.GetChannelMetadata(e.Header)
.Cast <ChannelMetadataRecord>()
.ToList();
Channels.Clear();
Channels.AddRange(channelMetadata);
Client.Handler <IChannelStreamingProducer>()
.ChannelMetadata(e.Header, channelMetadata);
foreach (var channel in channelMetadata.Select(ToChannelStreamingInfo))
{
ChannelStreamingInfo.Add(channel);
}
TaskRunner.Start();
}
}
/// <summary>
/// 生成数据项，包含索引值（深度、时间）以及具体数值。
/// </summary>
/// <param name="streamingInfo"></param>
/// <returns></returns>
private DataItem ToChannelDataItem(ChannelStreamingInfo streamingInfo)
{
var channel = Channels.FirstOrDefault(x => x.ChannelId == streamingInfo.ChannelId);
if (channel == null)
{
return(null);
}
var indexDateTimeOffset = DateTimeOffset.UtcNow;
///<summary>
///两个关键函数：toChannelIndexValue(为什么总是返回零）toChannelDataValue返回模拟值；
/// </summary>
return(new DataItem()
{
ChannelId = channel.ChannelId,
Indexes = channel.Indexes
.Select(x => ToChannelIndexValue(streamingInfo, x, indexDateTimeOffset))
.ToList(),
ValueAttributes = new DataAttribute[0],
Value = new DataValue()
{
Item = ToChannelDataValue(channel, indexDateTimeOffset)
}
});
}
/// <summary>
/// Receive Channel Metadata
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
///
protected void HandleChannelMetadata(object sender, ProtocolEventArgs <ChannelMetadata> e)
{
var receivedTime = DateTime.UtcNow;
if (e.Header.Protocol == 1 && e.Header.MessageType == 2)
{
var timediff = receivedTime - m_Time;
string message = "Channels received: [";
ChannelMetadata metadata = new ChannelMetadata();
metadata.Channels = new List <ChannelMetadataRecord>();
lock (m_ChannelStreamingInfo)
{
foreach (var channel in e.Message.Channels)
{
//if (m_LogCurveEml.Contains(channel.ChannelUri, StringComparer.InvariantCultureIgnoreCase))
{
metadata.Channels.Add(channel);
ChannelStreamingInfo channelStreamingInfo = new ChannelStreamingInfo()
{
ChannelId = channel.ChannelId,
StartIndex = new StreamingStartIndex()
{
Item = null
},
ReceiveChangeNotification = true
};
m_ChannelStreamingInfo.Add(channelStreamingInfo);
message = message + $"\n{channel.ChannelId} {channel.ChannelName} {channel.ChannelUri}";
//ChannelMetaDataVM channelMetaData_VM = ETPMapper.Instance().Map<ChannelMetaDataVM>(channel);
//string json = JsonConvert.SerializeObject(channelMetaData_VM, Formatting.Indented);
//Message?.Invoke(json, timediff.TotalMilliseconds, TraceLevel.Info);
}
}
Metadata = metadata;
ChannelInfoReceived?.Invoke(metadata);
}
message = message + "\n]";
message = $"\nResponse : [Protocol {e.Header.Protocol} MessageType {e.Header.MessageType}]\n{message}";
Message?.Invoke(message, timediff.TotalMilliseconds, TraceLevel.Info);
HasDescribing = false;
}
}
private void StreamChannelData()
{
if (!Client.IsOpen)
{
return;
}
var dataItems = ChannelStreamingInfo
.Select(ToChannelDataItem)
.ToList();
Client.Handler <IChannelStreamingProducer>()
.ChannelData(null, dataItems);
}
private long ToChannelIndexValue(ChannelStreamingInfo streamingInfo, IndexMetadataRecord index, DateTimeOffset indexDateTimeOffset)
{
if (index.IndexType == ChannelIndexTypes.Time)
{
return(indexDateTimeOffset.ToUnixTimeMicroseconds());
}
var value = 0d;
if (streamingInfo.StartIndex.Item is double)
{
value = (double)streamingInfo.StartIndex.Item
+ Math.Pow(10, index.Scale) * 0.1;
}
streamingInfo.StartIndex.Item = value;
return((long)value);
}
private DataItem ToChannelDataItem(ChannelStreamingInfo streamingInfo)
{
var channel = Channels.FirstOrDefault(x => x.ChannelId == streamingInfo.ChannelId);
if (channel == null)
{
return(null);
}
var indexDateTimeOffset = DateTimeOffset.UtcNow;
return(new DataItem
{
ChannelId = channel.ChannelId,
Indexes = channel.Indexes
.Select(x => ToChannelIndexValue(streamingInfo, x, indexDateTimeOffset))
.ToList(),
ValueAttributes = new DataAttribute[0],
Value = new DataValue
{
Item = ToChannelDataValue(channel, indexDateTimeOffset)
}
});
}
protected void Decode(byte[] data)
{
var receivedTime = DateTime.UtcNow;
using (var inputStream = new MemoryStream(data))
{
// create avro binary decoder to read from memory stream
var decoder = new BinaryDecoder(inputStream);
var record = Activator.CreateInstance <MessageHeader>();
var reader = new SpecificReader <MessageHeader>(new EtpSpecificReader(record.Schema, record.Schema));
MessageHeader header = reader.Read(record, decoder);
// string message = Encoding.UTF8.GetString(inputStream.ToArray());
if (header.Protocol == 0 && header.MessageType == 2)
{
lock (m_ConnectionLock)
{
m_HasConnected = true;
}
var recordSession = Activator.CreateInstance <OpenSession>();
var readerSession = new SpecificReader <OpenSession>(new EtpSpecificReader(recordSession.Schema, recordSession.Schema));
readerSession.Read(recordSession, decoder);
string message = ToString(recordSession);
var timediff = receivedTime - m_Time;
Message?.Invoke(message, timediff.TotalMilliseconds, TraceLevel.Info);
}
else if (header.Protocol == 3 && header.MessageType == 2)
{
var responce = Activator.CreateInstance <GetResourcesResponse>();
var bodyreader = new SpecificReader <GetResourcesResponse>(new EtpSpecificReader(responce.Schema, responce.Schema));
GetResourcesResponse bodyheader = bodyreader.Read(responce, decoder);
RequestInformation parent;
lock (m_RequestInformation)
{
parent = m_RequestInformation[header.CorrelationId];
}
var timediff = receivedTime - parent.RequestTime;
string message = ToString(responce);
Message?.Invoke(message, timediff.TotalMilliseconds, TraceLevel.Info);
if (parent.ChannelItem == null)
{
ChannelItem channelItem = new ChannelItem()
{
Name = responce.Resource.Name,
Uid = responce.Resource.Uuid,
Eml = responce.Resource.Uri,
Level = 0,
ChildrensCount = responce.Resource.HasChildren
};
ChannelItemsReceived?.Invoke(channelItem);
}
else
{
ChannelItem channelItem = new ChannelItem()
{
Name = responce.Resource.Name,
Uid = responce.Resource.Uuid,
Eml = responce.Resource.Uri,
Level = parent.ChannelItem.Level + 1,
ChildrensCount = responce.Resource.HasChildren
};
ChannelChildrensReceived?.Invoke(channelItem, parent.ChannelItem);
}
}
else if (header.Protocol == 1 && header.MessageType == 2)
{
var timediff = receivedTime - m_Time;
string message = "Channels received: [";
var recordMetadata = Activator.CreateInstance <ChannelMetadata>();
var readerMetadata = new SpecificReader <ChannelMetadata>(new EtpSpecificReader(recordMetadata.Schema, recordMetadata.Schema));
readerMetadata.Read(recordMetadata, decoder);
ChannelMetadata metadata = new ChannelMetadata();
metadata.Channels = new List <ChannelMetadataRecord>();
lock (m_ChannelStreamingInfo)
{
foreach (var channel in recordMetadata.Channels)
{
if (m_LogCurveEml.Contains(channel.ChannelUri, StringComparer.InvariantCultureIgnoreCase))
{
metadata.Channels.Add(channel);
ChannelStreamingInfo channelStreamingInfo = new ChannelStreamingInfo()
{
ChannelId = channel.ChannelId,
StartIndex = new StreamingStartIndex()
{
Item = null
},
ReceiveChangeNotification = true
};
m_ChannelStreamingInfo.Add(channelStreamingInfo);
message = message + $"\n{channel.ChannelId} {channel.ChannelName}";
ChannelMetaDataVM channelMetaData_VM = ETPMapper.Instance().Map <ChannelMetaDataVM>(channel);
string json = JsonConvert.SerializeObject(channelMetaData_VM, Formatting.Indented);
Message?.Invoke(json, timediff.TotalMilliseconds, TraceLevel.Info);
}
}
ChannelInfoReceived?.Invoke(metadata);
}
message = message + "\n]";
Message?.Invoke(message, timediff.TotalMilliseconds, TraceLevel.Info);
HasDescribing = false;
}
else if (header.Protocol == 1 && header.MessageType == 3)
{
var recordData = Activator.CreateInstance <ChannelData>();
var readerdata = new SpecificReader <ChannelData>(new EtpSpecificReader(recordData.Schema, recordData.Schema));
readerdata.Read(recordData, decoder);
ChannelDataReceived?.Invoke(recordData.Data);
}
else if (header.MessageType == 1000)
{
var timediff = receivedTime - m_Time;
var bodyrecord = Activator.CreateInstance <ProtocolException>();
var bodyreader = new SpecificReader <ProtocolException>(new EtpSpecificReader(bodyrecord.Schema, bodyrecord.Schema));
ProtocolException bodyheader = bodyreader.Read(bodyrecord, decoder);
string message = $"Error Received ({bodyrecord.ErrorCode}): {bodyrecord.ErrorMessage}";
Message?.Invoke(message, timediff.TotalMilliseconds, TraceLevel.Error);
HasDescribing = false;
}
else
{
HasDescribing = false;
}
}
}
