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; } } }