public ClientMessageHandler(IClientSocket clientSocket, IMessageDecoder messageDecoder,ThreadSafeBuffer buffer) { _clientSocket = clientSocket; _messageDecoder = messageDecoder; _buffer = buffer; _clientSocket.BeginReceive(ReceiveMessage); }
public MessageReceiver(WebSocket client, IMessageDecoder decoder, IMessageDecompressor decompressor) { mDecoder = decoder; mDecompressor = decompressor; mClient = client; mClient.OnMessage += OnMessage; }
public UdpConnection(Socket client, IMessageEncoder encoder, IMessageDecoder decoder, IByteBufAllocator allocator) { InitClient(client); Encoder = encoder; Decoder = decoder; Allocator = allocator; }
public ClientHandler(Socket clientSock) { _socket = clientSock; _encoder = new GeneralMessageEncoder(); _decoder = new GeneralMessageDecoder(); }
/// <summary> /// Create a new channel /// </summary> /// <param name="readBuffer">Buffer which should be used when reading from the socket</param> /// <param name="encoder">Used to encode outgoing data</param> /// <param name="decoder">Used to decode incoming data</param> /// <returns>Created channel</returns> public ITcpChannel Create(IBufferSlice readBuffer, IMessageEncoder encoder, IMessageDecoder decoder) { var channel = new TcpChannel(readBuffer, encoder, decoder); if (OutboundMessageQueueFactory != null) channel.OutboundMessageQueue = OutboundMessageQueueFactory(); return channel; }
public MulticastUdpConnection(NetworkEventLoop eventLoop, INode binding, INode multicastAddress, TimeSpan timeout, IMessageEncoder encoder, IMessageDecoder decoder, IByteBufAllocator allocator) : base(eventLoop, binding, timeout, encoder, decoder, allocator) { MulticastAddress = multicastAddress; InitMulticastClient(); }
public MulticastUdpConnection(NetworkEventLoop eventLoop, INode binding, INode multicastAddress, IMessageEncoder encoder, IMessageDecoder decoder, IByteBufAllocator allocator) : this( eventLoop, binding, multicastAddress, NetworkConstants.DefaultConnectivityTimeout, encoder, decoder, allocator) { }
/// <summary> /// Initializes a new instance of the <see cref="TcpChannel" /> class. /// </summary> /// <param name="readBuffer">Buffer used for our reading.</param> /// <param name="encoder">Used to encode messages before they are put in the MicroMessage body of outbound messages.</param> /// <param name="decoder"> /// Used to decode the body of incoming MicroMessages. The <c>MessageReceived</c> delegate will be /// overridden by this class. /// </param> public TcpChannel(IBufferSlice readBuffer, IMessageEncoder encoder, IMessageDecoder decoder) { if (readBuffer == null) throw new ArgumentNullException("readBuffer"); if (encoder == null) throw new ArgumentNullException("encoder"); if (decoder == null) throw new ArgumentNullException("decoder"); _readArgs = new SocketAsyncEventArgs(); _readArgs.SetBuffer(readBuffer.Buffer, readBuffer.Offset, readBuffer.Capacity); _readArgs.Completed += OnReadCompleted; _readArgsWrapper = new SocketAsyncEventArgsWrapper(_readArgs); _encoder = encoder; _decoder = decoder; _decoder.MessageReceived = OnMessageReceived; _writeArgs = new SocketAsyncEventArgs(); _writeArgs.Completed += OnSendCompleted; _writeArgsWrapper = new SocketAsyncEventArgsWrapper(_writeArgs); _sendCompleteAction = (channel, message) => { }; _disconnectAction = (channel, exception) => { }; ChannelFailure = (channel, error) => HandleDisconnect(SocketError.ProtocolNotSupported); RemoteEndpoint = EmptyEndpoint.Instance; ChannelId = GuidFactory.Create().ToString(); Data = new ChannelData(); }
protected SingleReceiveLoopProxyReactor(IPAddress localAddress, int localPort, NetworkEventLoop eventLoop, IMessageEncoder encoder, IMessageDecoder decoder, IByteBufAllocator allocator, SocketType socketType = SocketType.Stream, ProtocolType protocol = ProtocolType.Tcp, int bufferSize = NetworkConstants.DEFAULT_BUFFER_SIZE) : base(localAddress, localPort, eventLoop, encoder, decoder, allocator, socketType, protocol, bufferSize) { }
private SecureTcpChannel CreateServerChannel(IBufferSlice slice, IMessageEncoder encoder, IMessageDecoder decoder) { var streamBuilder = new ServerSideSslStreamBuilder(_certificate); var channel = new SecureTcpChannel(slice, encoder, decoder, streamBuilder); return channel; }
protected UnstreamedConnectionBase(NetworkEventLoop eventLoop, INode binding, IMessageEncoder encoder, IMessageDecoder decoder, IByteBufAllocator allocator, int bufferSize = NetworkConstants.DEFAULT_BUFFER_SIZE) : this( eventLoop, binding, NetworkConstants.DefaultConnectivityTimeout, encoder, decoder, allocator, bufferSize ) { }
public MulticastUdpConnection(Socket client, IMessageEncoder encoder, IMessageDecoder decoder, IByteBufAllocator allocator) : base(client) { InitMulticastClient(); Encoder = encoder; Decoder = decoder; Allocator = allocator; }
public TcpConnection(Socket client, IMessageEncoder encoder, IMessageDecoder decoder, IByteBufAllocator allocator, int bufferSize = NetworkConstants.DEFAULT_BUFFER_SIZE) : base(bufferSize) { InitClient(client); Encoder = encoder; Decoder = decoder; Allocator = allocator; }
public UdpProxyReactor(IPAddress localAddress, int localPort, NetworkEventLoop eventLoop, IMessageEncoder encoder, IMessageDecoder decoder, IByteBufAllocator allocator, int bufferSize = NetworkConstants.DEFAULT_BUFFER_SIZE) : base( localAddress, localPort, eventLoop, encoder, decoder, allocator, SocketType.Dgram, ProtocolType.Udp, bufferSize) { LocalEndpoint = new IPEndPoint(localAddress, localPort); RemoteEndPoint = new IPEndPoint(IPAddress.Any, 0); }
public TcpProxyReactor(IPAddress localAddress, int localPort, NetworkEventLoop eventLoop, IMessageEncoder encoder, IMessageDecoder decoder, IByteBufAllocator allocator, int bufferSize = NetworkConstants.DEFAULT_BUFFER_SIZE) : base( localAddress, localPort, eventLoop, encoder, decoder, allocator, SocketType.Stream, ProtocolType.Tcp, bufferSize) { LocalEndpoint = new IPEndPoint(localAddress, localPort); Listener = new Socket(LocalEndpoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp); }
public MessageProcessor(IMessageSource source, IMessageDecoder decoders, IEnumerable<IMessageHandler> handlers, ILogger logger) { MessageSource = source; MessageDecoder = decoders; MessageHandlers = handlers; Logger = logger; }
/// <summary> /// Initializes a new instance of the <see cref="HttpService" /> class. /// </summary> public HttpService(IModuleManager moduleManager) { ApplicationInfo = new MemoryItemStorage(); BodyDecoder = new CompositeSerializer(); _service = this; _moduleManager = moduleManager; _encoder = new HttpMessageEncoder(); _decoder = new HttpMessageDecoder(BodyDecoder); _decoder.MessageReceived = OnMessageReceived; }
protected UnstreamedConnectionBase(NetworkEventLoop eventLoop, INode binding, TimeSpan timeout, IMessageEncoder encoder, IMessageDecoder decoder, IByteBufAllocator allocator, int bufferSize = NetworkConstants.DEFAULT_BUFFER_SIZE) : base() { Decoder = decoder; Encoder = encoder; Allocator = allocator; Created = DateTimeOffset.UtcNow; Binding = binding; Timeout = timeout; BufferSize = bufferSize; NetworkEventLoop = eventLoop; }
/// <summary> /// Helper method which sends the websocket upgrade request /// </summary> /// <param name="decoder"></param> private static void sendWebSocketUpgradeRequest(IMessageDecoder decoder) { var buffer = new SocketBufferFake(); buffer.Buffer = Encoding.ASCII.GetBytes(@"GET / HTTP/1.1 host: localhost connection: upgrade upgrade: websocket "); buffer.BytesTransferred = buffer.Buffer.Length; decoder.ProcessReadBytes(buffer); }
protected ReactorBase(IPAddress localAddress, int localPort, NetworkEventLoop eventLoop, IMessageEncoder encoder, IMessageDecoder decoder, IByteBufAllocator allocator, SocketType socketType = SocketType.Stream, ProtocolType protocol = ProtocolType.Tcp, int bufferSize = NetworkConstants.DEFAULT_BUFFER_SIZE) { Decoder = decoder; Encoder = encoder; Allocator = allocator; LocalEndpoint = new IPEndPoint(localAddress, localPort); Listener = new Socket(AddressFamily.InterNetwork, socketType, protocol); if (protocol == ProtocolType.Tcp) { Transport = TransportType.Tcp; } else if (protocol == ProtocolType.Udp) { Transport = TransportType.Udp; } Backlog = NetworkConstants.DefaultBacklog; EventLoop = eventLoop; ConnectionAdapter = new ReactorConnectionAdapter(this); BufferSize = bufferSize; }
/// <summary> /// This constructor sets user defined values to connect to FreeSwitch. /// </summary> /// <param name="address">FreeSwitch mod_event_socket IP address or hostname</param> /// <param name="port">FreeSwitch mod_event_socket Port number</param> /// <param name="messageEncoder">FreeSwitch message encoder</param> /// <param name="messageDecoder">FreeSwitch message decoder</param> /// <param name="freeSwitchEventFilter">FreeSwitch event filters</param> /// <param name="connectionTimeout">Connection Timeout</param> /// <param name="password">FreeSwitch mod_event_socket Password</param> public OutboundChannelSession(string address, int port, IMessageEncoder messageEncoder, IMessageDecoder messageDecoder, string freeSwitchEventFilter, TimeSpan connectionTimeout, string password) { Address = address; Port = port; MessageEncoder = messageEncoder; MessageDecoder = messageDecoder; FreeSwitchEventFilter = freeSwitchEventFilter; ConnectionTimeout = connectionTimeout; Password = password; _authenticated = false; _requestsQueue = new ConcurrentQueue<CommandAsyncEvent>(); _channel = new TcpChannel(new BufferSlice(new byte[65535], 0, 65535), MessageEncoder, MessageDecoder); _channel.MessageReceived += OnMessageReceived; _channel.Disconnected += OnDisconnect; _channel.MessageSent += OnSendCompleted; _args.Completed += OnConnect; OnAuthentication += SendAuthentication; }
/// <summary> /// </summary> /// <param name="readBuffer"></param> /// <param name="encoder"></param> /// <param name="decoder"></param> /// <param name="sslStreamBuilder">Used to wrap the socket with a SSL stream</param> public SecureTcpChannel(IBufferSlice readBuffer, IMessageEncoder encoder, IMessageDecoder decoder, ISslStreamBuilder sslStreamBuilder) { if (readBuffer == null) throw new ArgumentNullException("readBuffer"); if (encoder == null) throw new ArgumentNullException("encoder"); if (decoder == null) throw new ArgumentNullException("decoder"); if (sslStreamBuilder == null) throw new ArgumentNullException("sslStreamBuilder"); _encoder = encoder; _decoder = decoder; _sslStreamBuilder = sslStreamBuilder; _decoder.MessageReceived = OnMessageReceived; _sendCompleteAction = (channel, message) => { }; _disconnectAction = (channel, exception) => { }; ChannelFailure = (channel, error) => HandleDisconnect(SocketError.ProtocolNotSupported); RemoteEndpoint = EmptyEndpoint.Instance; _readBuffer = new SocketBuffer(readBuffer); _writeBuffer = new SocketBuffer(); ChannelId = GuidFactory.Create().ToString(); Data = new ChannelData(); }
public static MessageEnvelope <T> Instantiate <T>(this MessageEnvelope envelope, IMessageDecoder decoder) { var message = envelope.ConvertTo <T>(); message.Message = decoder.DecodeMessage <T>(envelope.Body); return(message); }
public TcpSingleEventLoopProxyReactor(IPAddress localAddress, int localPort, NetworkEventLoop eventLoop, IMessageEncoder encoder, IMessageDecoder decoder, IByteBufAllocator allocator, int bufferSize = NetworkConstants.DEFAULT_BUFFER_SIZE) : base(localAddress, localPort, eventLoop, encoder, decoder, allocator, bufferSize) { }
/// <summary> /// Initializes a new instance of the <see cref="ChannelTcpClient" /> class. /// </summary> /// <param name="encoder">Used to encode outbound messages.</param> /// <param name="decoder">Used to decode inbound messages.</param> public ChannelTcpClient(IMessageEncoder encoder, IMessageDecoder decoder) : this(encoder, decoder, new BufferSlice(new byte[65535], 0, 65535)) { }
public new ServerBootstrap SetDecoder(IMessageDecoder decoder) { base.SetDecoder(decoder); return(this); }
public TcpConnection(NetworkEventLoop eventLoop, INode node, IMessageEncoder encoder, IMessageDecoder decoder, IByteBufAllocator allocator, int bufferSize = NetworkConstants.DEFAULT_BUFFER_SIZE) : base(eventLoop, node, encoder, decoder, allocator, bufferSize) { InitClient(); }
public ProcessorBase(IMessageDecoder <T> messageDecoder) { _messageDecoder = messageDecoder; }
public static HttpStatusCode Decode <T>(Request request, IBufferManager bufferManager, IMessageDecoder decoder, out T result) { result = default(T); var buffer = bufferManager.BorrowBuffer(); int count = request.Body.Read(buffer, 0, buffer.Length); if (count == 0 || count == buffer.Length) { bufferManager.ReturnBuffer(buffer); return(HttpStatusCode.RequestEntityTooLarge); } result = decoder.DecodeMessage <T>(buffer, 0, count); bufferManager.ReturnBuffer(buffer); if (result == null) { return(HttpStatusCode.InternalServerError); } return(HttpStatusCode.OK); }
/// <summary> 解码 </summary> /// <typeparam name="T"></typeparam> /// <param name="decoder"></param> /// <param name="data"></param> /// <param name="gzip"></param> /// <returns></returns> public static async Task <T> DecodeAsync <T>(this IMessageDecoder decoder, byte[] data, bool gzip = true) { var obj = await decoder.DecodeAsync(data, typeof(T), gzip); return(obj.CastTo <T>()); }
public TcpProxyReactor(IPAddress localAddress, int localPort, NetworkEventLoop eventLoop, IMessageEncoder encoder, IMessageDecoder decoder, IByteBufAllocator allocator, int bufferSize = NetworkConstants.DEFAULT_BUFFER_SIZE) : base(localAddress, localPort, eventLoop, encoder, decoder, allocator, SocketType.Stream, ProtocolType.Tcp, bufferSize) { LocalEndpoint = new IPEndPoint(localAddress, localPort); Listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); }
/// <summary> /// Create a new channel /// </summary> /// <param name="readBuffer">Buffer which should be used when reading from the socket</param> /// <param name="encoder">Used to encode outgoing data</param> /// <param name="decoder">Used to decode incoming data</param> /// <returns>Created channel</returns> public ITcpChannel Create(IBufferSlice readBuffer, IMessageEncoder encoder, IMessageDecoder decoder) { return new SecureTcpChannel(readBuffer, encoder, decoder, _sslStreamBuilder); }
/// <summary> /// Initializes a new instance of the <see cref="DeviceManager" /> class. /// </summary> /// <param name="deviceAccessLayer">The device access layer.</param> /// <param name="messageDecoder">The message decoder.</param> public DeviceManager(IDeviceAccessLayer deviceAccessLayer, IMessageDecoder messageDecoder, ILog logger) { this.deviceAccessLayer = deviceAccessLayer; this.messageDecoder = messageDecoder; this.logger = logger; }
/// <summary> 解码 </summary> /// <typeparam name="T"></typeparam> /// <param name="decoder"></param> /// <param name="data"></param> /// <param name="gzip"></param> /// <returns></returns> public static T Decode <T>(this IMessageDecoder decoder, byte[] data, bool gzip = true) { var obj = decoder.Decode(data, typeof(T), gzip); return(obj.CastTo <T>()); }
private SecureTcpChannel CreateClientChannel(IBufferSlice slice, IMessageEncoder encoder, IMessageDecoder decoder) { var streamBuilder = new ClientSideSslStreamBuilder("mamma"); var channel = new SecureTcpChannel(slice, encoder, decoder, streamBuilder); return(channel); }
public XmlActorControlFrameDataDecoder(IMessageDecoder decoder) { _decoder = decoder; }
public LengthFieldEncodingTests() { Encoder = new LengthFieldPrepender(LengthFieldLength); Decoder = new LengthFieldFrameBasedDecoder(2000, 0, LengthFieldLength, 0, LengthFieldLength); //stip headers }
public MicroMessageHandler(IMessageDecoder messageDecoder) { _messageDecoder = messageDecoder; }
public HL7MessageProcessor(IMessageDecoder <Message> messageDecoder) : base(messageDecoder) { }
private SecureTcpChannel CreateServerChannel(IBufferSlice slice, IMessageEncoder encoder, IMessageDecoder decoder) { var streamBuilder = new ServerSideSslStreamBuilder(_certificate); var channel = new SecureTcpChannel(slice, encoder, decoder, streamBuilder); return(channel); }
public ClientNetwork(IMessageEncoder encoder, IMessageDecoder decoder) { messageEncoder = encoder; messageDecoder = decoder; }
public UdpProxyReactor(IPAddress localAddress, int localPort, NetworkEventLoop eventLoop, IMessageEncoder encoder, IMessageDecoder decoder, IByteBufAllocator allocator, int bufferSize = NetworkConstants.DEFAULT_BUFFER_SIZE) : base(localAddress, localPort, eventLoop, encoder, decoder, allocator, SocketType.Dgram, ProtocolType.Udp, bufferSize) { LocalEndpoint = new IPEndPoint(localAddress, localPort); RemoteEndPoint = new IPEndPoint(IPAddress.Any, 0); }
public TcpChannel(IMessageDecoder <IMessage> decoder, IMessageEncoder <IMessage> encoder, IHandshakeHandler handshakeHandler) : base(decoder, encoder, handshakeHandler) { }
public new ClientBootstrap SetDecoder(IMessageDecoder decoder) { base.SetDecoder(decoder); return this; }
private void ReceiveData(DataReceivedEventArgs e) { IMessageDecoder decoder = Spec.NewMessageDecoder(e.Data); if (decoder.IsRequest) { Request request; try { request = decoder.DecodeRequest(); } catch (Exception) { if (decoder.IsReply) { if (log.IsWarnEnabled) { log.Warn("Message format error caused by " + e.EndPoint); } } else { // manually build RST from raw information EmptyMessage rst = new EmptyMessage(MessageType.RST); rst.Destination = e.EndPoint; rst.ID = decoder.ID; Fire(SendingEmptyMessage, rst); _channel.Send(Serialize(rst), rst.Destination); if (log.IsWarnEnabled) { log.Warn("Message format error caused by " + e.EndPoint + " and reseted."); } } return; } request.Source = e.EndPoint; Fire(ReceivingRequest, request); if (!request.IsCancelled) { Exchange exchange = _matcher.ReceiveRequest(request); if (exchange != null) { exchange.EndPoint = this; _coapStack.ReceiveRequest(exchange, request); } } } else if (decoder.IsResponse) { Response response = decoder.DecodeResponse(); response.Source = e.EndPoint; Fire(ReceivingResponse, response); if (!response.IsCancelled) { Exchange exchange = _matcher.ReceiveResponse(response); if (exchange != null) { response.RTT = (DateTime.Now - exchange.Timestamp).TotalMilliseconds; exchange.EndPoint = this; _coapStack.ReceiveResponse(exchange, response); } else if (response.Type != MessageType.ACK) { if (log.IsDebugEnabled) { log.Debug("Rejecting unmatchable response from " + e.EndPoint); } Reject(response); } } } else if (decoder.IsEmpty) { EmptyMessage message = decoder.DecodeEmptyMessage(); message.Source = e.EndPoint; Fire(ReceivingEmptyMessage, message); if (!message.IsCancelled) { // CoAP Ping if (message.Type == MessageType.CON || message.Type == MessageType.NON) { if (log.IsDebugEnabled) { log.Debug("Responding to ping by " + e.EndPoint); } Reject(message); } else { Exchange exchange = _matcher.ReceiveEmptyMessage(message); if (exchange != null) { exchange.EndPoint = this; _coapStack.ReceiveEmptyMessage(exchange, message); } } } } else if (log.IsDebugEnabled) { log.Debug("Silently ignoring non-CoAP message from " + e.EndPoint); } }
public virtual AbstractBootstrap SetDecoder(IMessageDecoder decoder) { Decoder = decoder; return(this); }
public void SetUp() { Encoder = MLLP.MLLPEncoder.Default; Decoder = SimpleMLLPDecoder.Default; }
public MulticastUdpConnection(NetworkEventLoop eventLoop, INode binding, INode multicastAddress, IMessageEncoder encoder, IMessageDecoder decoder, IByteBufAllocator allocator) : this(eventLoop, binding, multicastAddress, NetworkConstants.DefaultConnectivityTimeout, encoder, decoder, allocator) { }
/// <summary> /// Create a new channel /// </summary> /// <param name="readBuffer">Buffer which should be used when reading from the socket</param> /// <param name="encoder">Used to encode outgoing data</param> /// <param name="decoder">Used to decode incoming data</param> /// <returns>Created channel</returns> public ITcpChannel Create(IBufferSlice readBuffer, IMessageEncoder encoder, IMessageDecoder decoder) { var channel = new TcpChannel(readBuffer, encoder, decoder); return(channel); }
public MicroMessageHandler(IMessageDecoder messageDecoder, bool gzip) { _messageDecoder = messageDecoder; _gzip = gzip; }
/// <summary> 解码 </summary> /// <param name="decoder"></param> /// <param name="data"></param> /// <param name="type"></param> /// <param name="gzip"></param> /// <returns></returns> public static object Decode(this IMessageDecoder decoder, byte[] data, Type type, bool gzip = true) { return(decoder.DecodeAsync(data, type, gzip).ConfigureAwait(false).GetAwaiter().GetResult()); }
public UdpConnection(NetworkEventLoop eventLoop, INode binding, IMessageEncoder encoder, IMessageDecoder decoder, IByteBufAllocator allocator) : base(eventLoop, binding, encoder, decoder, allocator) { InitClient(); }
public ActorMessageDecoder(IMessageDecoder decoder) { _decoder = decoder; }
public ServerNetwork(IMessageEncoder encoder, IMessageDecoder decoder) { messageEncoder = encoder; messageDecoder = decoder; }
/// <summary> /// Create a new channel /// </summary> /// <param name="readBuffer">Buffer which should be used when reading from the socket</param> /// <param name="encoder">Used to encode outgoing data</param> /// <param name="decoder">Used to decode incoming data</param> /// <returns>Created channel</returns> public ITcpChannel Create(IBufferSlice readBuffer, IMessageEncoder encoder, IMessageDecoder decoder) { return new TcpChannel(readBuffer, encoder, decoder); }
public new ServerBootstrap SetDecoder(IMessageDecoder decoder) { base.SetDecoder(decoder); return this; }