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);
}
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>
/// 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);
}
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;
}
public void SetUp()
{
Encoder = MLLP.MLLPEncoder.Default;
Decoder = SimpleMLLPDecoder.Default;
}
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 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;
}
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();
}
/// <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;
}
