static EmbeddedChannel()
{
LOCAL_ADDRESS = new EmbeddedSocketAddress();
REMOTE_ADDRESS = new EmbeddedSocketAddress();
EMPTY_HANDLERS = EmptyArray <IChannelHandler> .Instance;
s_logger = InternalLoggerFactory.GetInstance <EmbeddedChannel>();
METADATA_NO_DISCONNECT = new ChannelMetadata(false);
METADATA_DISCONNECT = new ChannelMetadata(true);
}
public ClientWebSocketChannel(IChannel parent, ClientWebSocket webSocket)
: base(parent)
{
_webSocket = webSocket;
_isActive = true;
Metadata = new ChannelMetadata(false, 16);
Configuration = new ClientWebSocketChannelConfig();
_writeCancellationTokenSource = new CancellationTokenSource();
}
public ServerWebSocketChannel(IChannel parent, WebSocket webSocket, EndPoint remoteEndPoint)
: base(parent)
{
_webSocket = webSocket;
RemoteAddressInternal = remoteEndPoint;
_active = true;
Metadata = new ChannelMetadata(false, 16);
Configuration = new ServerWebSocketChannelConfig();
_writeCancellationTokenSource = new CancellationTokenSource();
}
public async Task SendChannelMetadata(ChannelMetadata metadata)
{
MessageHeader header = new MessageHeader();
header.Protocol = (int)Protocols.ChannelStreaming;
header.MessageType = 2;
header.MessageId = EtpHelper.NextMessageId;
header.MessageFlags = 0;
header.CorrelationId = 0;
var result = m_client.Handler <IChannelStreamingProducer>().ChannelMetadata(header, metadata.Channels);
}
// Shamelessly copy pasted from XDAWaveFormDataParser
ChannelMetadata ConvertToChannelMetadata(ParsedChannel parsedChannel)
{
ChannelMetadata channelRecord = new ChannelMetadata
{
Name = parsedChannel.Name,
// Remove these assumptions at a later stage
IsDigital = false,
SignalType = GSF.Units.EE.SignalType.ALOG
};
return(channelRecord);
}
/// <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;
}
}
public async Task SendChannelMetadata(ChannelMetadata metadata)
{
MessageHeader header = new MessageHeader();
header.Protocol = (int)Protocols.ChannelStreaming;
header.MessageType = 2;
header.MessageId = EtpHelper.NextMessageId;
header.MessageFlags = 0;
header.CorrelationId = 0;
var result = m_client.Handler <IChannelStreamingProducer>().ChannelMetadata(header, metadata.Channels);
string message = $"\nRequest: [Protocol {header.Protocol} MessageType {header.MessageType}]";
Message?.Invoke(message + "\nChannel Data processed " + message.ToString(), 0, TraceLevel.Info);
}
private void ChannelMeta(ChannelMetadata metadata)
{
m_ConsumerHandler.Metadata = metadata;
Channels.Dispatcher.InvokeAsync(() =>
{
try
{
m_ChannelItems.Clear();
foreach (var c in metadata.Channels)
{
bool hasDepth = false;
bool hasTime = false;
foreach (var index in c.Indexes)
{
if (index.IndexType == Energistics.Etp.v11.Datatypes.ChannelData.ChannelIndexTypes.Depth)
{
hasDepth = true;
}
if (index.IndexType == Energistics.Etp.v11.Datatypes.ChannelData.ChannelIndexTypes.Time)
{
hasTime = true;
}
}
ChannelItem item = new ChannelItem()
{
Eml = c.ChannelUri,
Name = c.ChannelName,
Description = c.Description,
Uid = c.ChannelId.ToString(),
HasDepthIndex = hasDepth,
HasTimeIndex = hasTime,
Selected = true,
ChannelMetadataRecord = c
};
m_ChannelItems.Add(item);
}
}
catch (Exception ex)
{
DisplayError(ex.Message).ConfigureAwait(true);
}
});
}
public Message()
{
MessageKey = Guid.NewGuid().GetHash();
Metadata = new ChannelMetadata();
DateCreated = DateTime.Now;
To = new SourceAddressCollection();
CC = new SourceAddressCollection();
BCC = new SourceAddressCollection();
SourceChannelId = 0;
TargetChannelId = 0;
Documents = new AdvancedObservableCollection <Document>();
LabelsList = new AdvancedObservableCollection <Label>();
ReceiveLabels = new List <Label>();
PostLabels = new List <Label>();
ContentSynced = true;
}
/// <summary>
/// Handles the channel metadata.
/// </summary>
/// <param name="header">The header.</param>
/// <param name="channelMetadata">The channel metadata.</param>
protected override void HandleChannelMetadata(MessageHeader header, ChannelMetadata channelMetadata)
{
// Base implementation caches ChannelMetadataRecord items sent from the producer
base.HandleChannelMetadata(header, channelMetadata);
// Remove invalid channels
EvaluateChannelMetadata(header.MessageId, channelMetadata);
// Ensure there are still channels to stream
if (channelMetadata.Channels.Count < 1)
{
return;
}
InitializeDataBlocks(header.MessageId, channelMetadata.Channels);
var infos = channelMetadata.Channels
.Select(ToChannelStreamingInfo)
.ToList();
// Send ChannelStreamingStart message
ChannelStreamingStart(infos);
}
private void ChannelStreamingInfo(ChannelMetadata Channel)
{
string a = "";
}
/// <summary>
/// Handles the ChannelMetadata message from a producer.
/// </summary>
/// <param name="header">The message header.</param>
/// <param name="channelMetadata">The ChannelMetadata message.</param>
protected override void HandleChannelMetadata(IMessageHeader header, ChannelMetadata channelMetadata)
{
Console.WriteLine(string.Join(Environment.NewLine, channelMetadata.Channels.Select(d => EtpExtensions.Serialize(d))));
}
public StreamBufferingEncoderTest()
{
_writer = new Mock <IHttp2FrameWriter>();
_ctx = new Mock <IChannelHandlerContext>();
_channel = new Mock <IChannel>();
_channelUnsafe = new Mock <IChannelUnsafe>();
_config = new Mock <IChannelConfiguration>();
_executor = new Mock <IEventExecutor>();
var configuration = new Mock <IHttp2FrameWriterConfiguration>();
var frameSizePolicy = new Mock <IHttp2FrameSizePolicy>();
_writer.SetupGet(x => x.Configuration).Returns(() => configuration.Object);
configuration.SetupGet(x => x.FrameSizePolicy).Returns(() => frameSizePolicy.Object);
frameSizePolicy.SetupGet(x => x.MaxFrameSize).Returns(Http2CodecUtil.DefaultMaxFrameSize);
_writer
.Setup(x => x.WriteDataAsync(
It.IsAny <IChannelHandlerContext>(),
It.IsAny <int>(),
It.IsAny <IByteBuffer>(),
It.IsAny <int>(),
It.IsAny <bool>(),
It.IsAny <IPromise>()))
.Returns <IChannelHandlerContext, int, IByteBuffer, int, bool, IPromise>((c, i, buf, x, y, p) => SuccessAnswer(buf));
_writer
.Setup(x => x.WriteRstStreamAsync(
It.Is <IChannelHandlerContext>(v => v == _ctx.Object),
It.IsAny <int>(),
It.IsAny <Http2Error>(),
It.IsAny <IPromise>()))
.Returns <IChannelHandlerContext, int, Http2Error, IPromise>((x, y, z, p) => SuccessAnswer());
_writer
.Setup(x => x.WriteGoAwayAsync(
It.IsAny <IChannelHandlerContext>(),
It.IsAny <int>(),
It.IsAny <Http2Error>(),
It.IsAny <IByteBuffer>(),
It.IsAny <IPromise>()))
.Returns <IChannelHandlerContext, int, Http2Error, IByteBuffer, IPromise>((c, i, e, buf, p) => SuccessAnswer(buf));
_connection = new DefaultHttp2Connection(false);
_connection.Remote.FlowController = new DefaultHttp2RemoteFlowController(_connection);
_connection.Local.FlowController = new DefaultHttp2LocalFlowController(_connection).FrameWriter(_writer.Object);
var defaultEncoder = new DefaultHttp2ConnectionEncoder(_connection, _writer.Object);
_encoder = new StreamBufferingEncoder(defaultEncoder);
var decoder = new DefaultHttp2ConnectionDecoder(_connection, _encoder, new Mock <IHttp2FrameReader>().Object);
var builder = new Http2ConnectionHandlerBuilder()
{
FrameListener = new Mock <IHttp2FrameListener>().Object
};
var handler = builder.Codec(decoder, _encoder).Build();
// Set LifeCycleManager on encoder and decoder
_ctx.SetupGet(x => x.Channel).Returns(_channel.Object);
_ctx.SetupGet(x => x.Allocator).Returns(UnpooledByteBufferAllocator.Default);
_channel.SetupGet(x => x.Allocator).Returns(UnpooledByteBufferAllocator.Default);
_executor.SetupGet(x => x.InEventLoop).Returns(true);
_ctx.Setup(x => x.NewPromise()).Returns(() => NewPromise());
_ctx.SetupGet(x => x.Executor).Returns(() => _executor.Object);
_channel.SetupGet(x => x.IsActive).Returns(false);
_channel.SetupGet(x => x.Configuration).Returns(() => _config.Object);
_channel.SetupGet(x => x.IsWritable).Returns(true);
_channel.SetupGet(x => x.BytesBeforeUnwritable).Returns(long.MaxValue);
_config.SetupGet(x => x.WriteBufferHighWaterMark).Returns(int.MaxValue);
_config.SetupGet(x => x.MessageSizeEstimator).Returns(DefaultMessageSizeEstimator.Default);
ChannelMetadata metadata = new ChannelMetadata(false, 16);
_channel.SetupGet(x => x.Metadata).Returns(metadata);
_channel.SetupGet(x => x.Unsafe).Returns(() => _channelUnsafe.Object);
handler.HandlerAdded(_ctx.Object);
}
public Http2ControlFrameLimitEncoderTest()
{
_writer = new Mock <IHttp2FrameWriter>();
_ctx = new Mock <IChannelHandlerContext>();
_channel = new Mock <IChannel>();
_unsafe = new Mock <IChannelUnsafe>();
_config = new Mock <IChannelConfiguration>();
_executor = new Mock <IEventExecutor>();
_numWrites = 0;
var configuration = new Mock <IHttp2FrameWriterConfiguration>();
var frameSizePolicy = new Mock <IHttp2FrameSizePolicy>();
_writer.SetupGet(x => x.Configuration).Returns(configuration.Object);
configuration.SetupGet(x => x.FrameSizePolicy).Returns(frameSizePolicy.Object);
frameSizePolicy.SetupGet(x => x.MaxFrameSize).Returns(Http2CodecUtil.DefaultMaxFrameSize);
_writer
.Setup(x => x.WriteRstStreamAsync(
It.IsAny <IChannelHandlerContext>(),
It.IsAny <int>(),
It.IsAny <Http2Error>(),
It.IsAny <IPromise>()))
.Returns <IChannelHandlerContext, int, Http2Error, IPromise>((ctx, streamId, errorCode, p) =>
{
return(HandlePromise(p, 3).Task);
});
_writer
.Setup(x => x.WriteSettingsAckAsync(
It.IsAny <IChannelHandlerContext>(),
It.IsAny <IPromise>()))
.Returns <IChannelHandlerContext, IPromise>((ctx, p) =>
{
return(HandlePromise(p, 1).Task);
});
_writer
.Setup(x => x.WritePingAsync(
It.IsAny <IChannelHandlerContext>(),
It.IsAny <bool>(),
It.IsAny <long>(),
It.IsAny <IPromise>()))
.Returns <IChannelHandlerContext, bool, long, IPromise>((ctx, ack, data, p) =>
{
var promise = HandlePromise(p, 3);
if (ack == false)
{
promise.TryComplete();
}
return(promise.Task);
});
_writer
.Setup(x => x.WriteGoAwayAsync(
It.IsAny <IChannelHandlerContext>(),
It.IsAny <int>(),
It.IsAny <Http2Error>(),
It.IsAny <IByteBuffer>(),
It.IsAny <IPromise>()))
.Returns <IChannelHandlerContext, int, Http2Error, IByteBuffer, IPromise>((ctx, streamId, errCode, debugData, p) =>
{
ReferenceCountUtil.Release(debugData);
_goAwayPromises.AddLast(p);
return(p.Task);
});
IHttp2Connection connection = new DefaultHttp2Connection(false);
connection.Remote.FlowController = new DefaultHttp2RemoteFlowController(connection);
connection.Local.FlowController = new DefaultHttp2LocalFlowController(connection).FrameWriter(_writer.Object);
DefaultHttp2ConnectionEncoder defaultEncoder =
new DefaultHttp2ConnectionEncoder(connection, _writer.Object);
_encoder = new Http2ControlFrameLimitEncoder(defaultEncoder, 2);
DefaultHttp2ConnectionDecoder decoder =
new DefaultHttp2ConnectionDecoder(connection, _encoder, (new Mock <IHttp2FrameReader>()).Object);
var builder = new Http2ConnectionHandlerBuilder();
builder.FrameListener = (new Mock <IHttp2FrameListener>()).Object;
Http2ConnectionHandler handler = builder.Codec(decoder, _encoder).Build();
// Set LifeCycleManager on _encoder and decoder
_ctx.SetupGet(x => x.Channel).Returns(_channel.Object);
_ctx.SetupGet(x => x.Allocator).Returns(UnpooledByteBufferAllocator.Default);
_channel.SetupGet(x => x.Allocator).Returns(UnpooledByteBufferAllocator.Default);
_executor.SetupGet(x => x.InEventLoop).Returns(true);
_ctx.Setup(x => x.NewPromise()).Returns(() => NewPromise());
_ctx.SetupGet(x => x.Executor).Returns(_executor.Object);
_channel.SetupGet(x => x.IsActive).Returns(false);
_channel.SetupGet(x => x.Configuration).Returns(_config.Object);
_channel.SetupGet(x => x.IsWritable).Returns(true);
_channel.SetupGet(x => x.BytesBeforeUnwritable).Returns(long.MaxValue);
_config.SetupGet(x => x.WriteBufferHighWaterMark).Returns(int.MaxValue);
_config.SetupGet(x => x.MessageSizeEstimator).Returns(DefaultMessageSizeEstimator.Default);
ChannelMetadata metadata = new ChannelMetadata(false, 16);
_channel.SetupGet(x => x.Metadata).Returns(metadata);
_channel.SetupGet(x => x.Unsafe).Returns(_unsafe.Object);
handler.HandlerAdded(_ctx.Object);
}
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;
}
}
}
