protected AbstractChannelHandlerContext(IChannelPipeline pipeline, IChannelHandlerInvoker invoker, string name, PropagationDirections skipPropagationDirections) { Contract.Requires(pipeline != null); Contract.Requires(name != null); this.Channel = pipeline.Channel(); this.invoker = invoker; this.skipPropagationFlags = skipPropagationDirections; this.Name = name; }
public Task HandshakeAsync(IChannel channel, IHttpRequest req, HttpHeaders responseHeaders) { if (req is IFullHttpRequest request) { return(this.HandshakeAsync(channel, request, responseHeaders)); } if (Logger.IsDebugEnabled) { Logger.DebugFormat("{} WebSocket version {} server handshake", channel, this.version); } IChannelPipeline p = channel.Pipeline; IChannelHandlerContext ctx = p.Context <HttpRequestDecoder>(); if (ctx == null) { // this means the user use a HttpServerCodec ctx = p.Context <HttpServerCodec>(); if (ctx == null) { return(TaskEx.FromException(new InvalidOperationException("No HttpDecoder and no HttpServerCodec in the pipeline"))); } } // Add aggregator and ensure we feed the HttpRequest so it is aggregated. A limit o 8192 should be more then // enough for the websockets handshake payload. // // TODO: Make handshake work without HttpObjectAggregator at all. string aggregatorName = "httpAggregator"; p.AddAfter(ctx.Name, aggregatorName, new HttpObjectAggregator(8192)); var completion = new TaskCompletionSource(); p.AddAfter(aggregatorName, "handshaker", new Handshaker(this, channel, responseHeaders, completion)); try { ctx.FireChannelRead(ReferenceCountUtil.Retain(req)); } catch (Exception cause) { completion.TrySetException(cause); } return(completion.Task); }
public async override Task <ITcpSocketClient> BuildAsync() { TcpSocketClient tcpClient = new TcpSocketClient(_ip, _port, _event); var clientChannel = await new Bootstrap() .Group(new MultithreadEventLoopGroup()) .Channel <TcpSocketChannel>() .Option(ChannelOption.TcpNodelay, true) .Handler(new ActionChannelInitializer <IChannel>(channel => { IChannelPipeline pipeline = channel.Pipeline; _setEncoder?.Invoke(pipeline); pipeline.AddLast(new CommonChannelHandler(tcpClient)); })).ConnectAsync($"{_ip}:{_port}".ToIPEndPoint()); tcpClient.SetChannel(clientChannel); return(await Task.FromResult(tcpClient)); }
public Context() { _channel = Substitute.For <IChannel>(); _channelHandlerContext = Substitute.For <IChannelHandlerContext>(); _pipeline = Substitute.For <IChannelPipeline>(); _channelHandlerContext.Channel.Returns(_channel); _channel.Pipeline.Returns(_pipeline); _pipeline.Get <ZeroPacketSplitter>().Returns(new ZeroPacketSplitter(LimboLogs.Instance)); _packetSender = Substitute.For <IPacketSender>(); _syncServer = Substitute.For <ISyncServer>(); _syncServer = Substitute.For <ISyncServer>(); _syncServer.Genesis.Returns(Build.A.Block.Genesis.TestObject.Header); _syncServer.Head.Returns(Build.A.BlockHeader.TestObject); _txPool = Substitute.For <ITxPool>(); _discoveryApp = Substitute.For <IDiscoveryApp>(); _serializer = new MessageSerializationService(); _localPeer = Substitute.For <IRlpxPeer>(); _localPeer.LocalPort.Returns(_localPort); _localPeer.LocalNodeId.Returns(TestItem.PublicKeyA); _nodeStatsManager = new NodeStatsManager(new StatsConfig(), LimboLogs.Instance); _blockTree = Substitute.For <IBlockTree>(); _blockTree.ChainId.Returns(1); _blockTree.Genesis.Returns(Build.A.Block.Genesis.TestObject.Header); _protocolValidator = new ProtocolValidator(_nodeStatsManager, _blockTree, LimboLogs.Instance); _peerStorage = Substitute.For <INetworkStorage>(); _syncPeerPool = Substitute.For <ISyncPeerPool>(); _manager = new ProtocolsManager( _syncPeerPool, _syncServer, _txPool, _discoveryApp, _serializer, _localPeer, _nodeStatsManager, _protocolValidator, _peerStorage, MainnetSpecProvider.Instance, LimboLogs.Instance); _serializer.Register(new HelloMessageSerializer()); _serializer.Register(new StatusMessageSerializer()); _serializer.Register(new DisconnectMessageSerializer()); }
public async Task WebIMServer() { IEventLoopGroup bossGroup = new MultithreadEventLoopGroup(1); IEventLoopGroup workerGroup = new MultithreadEventLoopGroup(); var isSsl = Convert.ToBoolean(_configuration["SSL:IsSsl"]); X509Certificate2 tlsCertificate = null; if (isSsl) { var path = _configuration["SSL:Path"]; var password = _configuration["SSL:Password"]; tlsCertificate = string.IsNullOrWhiteSpace(password) ? new X509Certificate2(path) : new X509Certificate2(path, password); } var bootstrap = new ServerBootstrap() .Group(bossGroup, workerGroup) .Channel <TcpServerSocketChannel>() .Option(ChannelOption.SoBacklog, 8192) .ChildHandler(new ActionChannelInitializer <IChannel>(channel => { IChannelPipeline pipeline = channel.Pipeline; if (isSsl) { pipeline.AddLast(TlsHandler.Server(tlsCertificate)); } pipeline .AddLast(new IdleStateHandler(_heartBeatTime, 0, 0)) .AddLast(new HttpServerCodec()) .AddLast(new HttpObjectAggregator(65536)) .AddLast(new WebSocketDecoder()) .AddLast(new ProtobufDecoder(CatMessage.Parser)) .AddLast(new WebSocketEncoder()) .AddLast(new WebSocketServerProtocolHandler("/ws", null, true)) .AddLast(new ServerHandler(_logger, _messageController)); })); await bootstrap.BindAsync(_port); }
static async Task RunServerAsync() { IEventLoopGroup bossGroup = new MultithreadEventLoopGroup(1); IEventLoopGroup workerGroup = new MultithreadEventLoopGroup(); Console.WriteLine("NLog server starting..."); try { var bootstrap = new ServerBootstrap(); bootstrap.Group(bossGroup, workerGroup); bootstrap.Channel <TcpServerSocketChannel>(); bootstrap .Option(ChannelOption.SoBacklog, 100) .Handler(new LoggingHandler("SRV-LSTN")) .ChildHandler(new ActionChannelInitializer <IChannel>(channel => { IChannelPipeline pipeline = channel.Pipeline; pipeline.AddLast(new LoggingHandler("SRV-CONN")); pipeline.AddLast("framing-enc", new LengthFieldPrepender(2)); pipeline.AddLast("framing-dec", new LengthFieldBasedFrameDecoder(ushort.MaxValue, 0, 2, 0, 2)); pipeline.AddLast("nlog", new NLogHandler()); })); IChannel boundChannel = await bootstrap.BindAsync(port); Console.WriteLine($"listening on port : {port}"); while (Console.ReadLine() != "exit") { Console.WriteLine("type 'exit' to close this app."); } await boundChannel.CloseAsync(); } finally { await Task.WhenAll( bossGroup.ShutdownGracefullyAsync(TimeSpan.FromMilliseconds(100), TimeSpan.FromSeconds(1)), workerGroup.ShutdownGracefullyAsync(TimeSpan.FromMilliseconds(100), TimeSpan.FromSeconds(1))); } }
async Task RunServerAsync() { if (commSetting.useConsoleLoger) { commSetting.SetConsoleLogger(); } bossGroup = new MultithreadEventLoopGroup(1); workerGroup = new MultithreadEventLoopGroup(); var SERVER_HANDLER = new RpcServerHandler(this); X509Certificate2 tlsCertificate = null; if (useSSl) { tlsCertificate = new X509Certificate2(Path.Combine(commSetting.ProcessDirectory, sslFile), sslPassword); } try { var bootstrap = new ServerBootstrap(); bootstrap .Group(bossGroup, workerGroup) .Channel <CustTcpServerSocketChannel>() .Option(ChannelOption.SoBacklog, backLength) // .Handler(new LoggingHandler(LogLevel.INFO)) .ChildHandler(new ActionChannelInitializer <ISocketChannel>(channel => { IChannelPipeline pipeline = channel.Pipeline; if (tlsCertificate != null) { pipeline.AddLast(TlsHandler.Server(tlsCertificate)); } pipeline.AddLast(new IdleStateHandler(commSetting.IdleStateTime, 0, 0)); pipeline.AddLast(new FastPacketDecode(commSetting.MAX_FRAME_LENGTH, commSetting.LENGTH_FIELD_OFFSET, commSetting.LENGTH_FIELD_LENGTH, commSetting.LENGTH_ADJUSTMENT, commSetting.INITIAL_BYTES_TO_STRIP, false)); pipeline.AddLast(new FastPacketEncoder(), SERVER_HANDLER); })); rpcServerChannel = AsyncHelpers.RunSync <IChannel>(() => bootstrap.BindAsync(port)); } finally { } }
/// <summary> /// Write messages to the inbound of this <see cref="IChannel" /> /// </summary> /// <param name="msgs">The messages to be written.</param> /// <returns><c>true</c> if the write operation did add something to the inbound buffer</returns> public bool WriteInbound(params object[] msgs) { this.EnsureOpen(); if (msgs.Length == 0) { return(IsNotEmpty(this.inboundMessages)); } IChannelPipeline p = this.Pipeline; foreach (object m in msgs) { p.FireChannelRead(m); } p.FireChannelReadComplete(); this.RunPendingTasks(); this.CheckException(); return(IsNotEmpty(this.inboundMessages)); }
public static IServiceHostClientBuilder UseRpcForTransfer(this IServiceHostClientBuilder serviceHostBuilder) { serviceHostBuilder.AddInitializer(container => { ITransportClientFactory factory = container.Resolve <ITransportClientFactory>(); ILogger logger = container.Resolve <ILogger>(); ISerializer serializer = container.Resolve <ISerializer>(); Bootstrap bootstrap = new Bootstrap(); logger.Info($"启动rpc客户端"); bootstrap .Group(new MultithreadEventLoopGroup()) .Channel <TcpSocketChannel>() .Option(ChannelOption.TcpNodelay, true) .Handler(new ActionChannelInitializer <IChannel>(channel => { IChannelPipeline pipeline = channel.Pipeline; pipeline.AddLast(new LengthFieldPrepender(4)); pipeline.AddLast(new LengthFieldBasedFrameDecoder(int.MaxValue, 0, 4, 0, 4)); pipeline.AddLast(new ReadClientMessageChannelHandler(serializer)); pipeline.AddLast(new RpcClientHandler(factory)); })); AttributeKey <IClientSender> clientSenderKey = AttributeKey <IClientSender> .ValueOf(typeof(DefaultTransportClientFactory), nameof(IClientSender)); AttributeKey <IClientListener> clientListenerKey = AttributeKey <IClientListener> .ValueOf(typeof(DefaultTransportClientFactory), nameof(IClientListener)); factory.ClientCreatorDelegate += (ServerAddress address, ref ITransportClient client) => { if (client == null && address.ServerFlag == ServerFlag.Rpc) { EndPoint ep = address.CreateEndPoint(); IChannel channel = bootstrap.ConnectAsync(ep).Result; RpcClientListener listener = new RpcClientListener(); channel.GetAttribute(clientListenerKey).Set(listener); RpcClientSender sender = new RpcClientSender(channel, serializer); channel.GetAttribute(clientSenderKey).Set(sender); client = new DefaultTransportClient(listener, sender, serializer, logger); } }; }); return(serviceHostBuilder); }
public Task StartAsync(CancellationToken cancellationToken) { bossGroup = new DispatcherEventLoopGroup(); workerGroup = new WorkerEventLoopGroup(bossGroup, configuration.EventLoopCount); serverBufferAllocator = new PooledByteBufferAllocator(); //serverBufferAllocator = new UnpooledByteBufferAllocator(); ServerBootstrap bootstrap = new ServerBootstrap(); bootstrap.Group(bossGroup, workerGroup); bootstrap.Channel <TcpServerChannel>(); if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux) || RuntimeInformation.IsOSPlatform(OSPlatform.OSX)) { bootstrap .Option(ChannelOption.SoReuseport, true) .ChildOption(ChannelOption.SoReuseaddr, true); } bootstrap .Option(ChannelOption.SoBacklog, configuration.SoBacklog) .ChildOption(ChannelOption.Allocator, serverBufferAllocator) .ChildHandler(new ActionChannelInitializer <IChannel>(channel => { IChannelPipeline pipeline = channel.Pipeline; using (var scope = serviceProvider.CreateScope()) { channel.Pipeline.AddLast("jt808TcpBuffer", new DelimiterBasedFrameDecoder(int.MaxValue, Unpooled.CopiedBuffer(new byte[] { JT808.Protocol.JT808Package.BeginFlag }), Unpooled.CopiedBuffer(new byte[] { JT808.Protocol.JT808Package.EndFlag }))); channel.Pipeline.AddLast("jt808TcpDecode", scope.ServiceProvider.GetRequiredService <JT808TcpDecoder>()); channel.Pipeline.AddLast("jt808TcpEncode", scope.ServiceProvider.GetRequiredService <JT808TcpEncoder>()); channel.Pipeline.AddLast("systemIdleState", new IdleStateHandler( configuration.ReaderIdleTimeSeconds, configuration.WriterIdleTimeSeconds, configuration.AllIdleTimeSeconds)); channel.Pipeline.AddLast("jt808TcpConnection", scope.ServiceProvider.GetRequiredService <JT808TcpConnectionHandler>()); channel.Pipeline.AddLast("jt808TcpService", scope.ServiceProvider.GetRequiredService <JT808TcpServerHandler>()); } })); logger.LogInformation($"JT808 TCP Server start at {IPAddress.Any}:{configuration.TcpPort}."); return(bootstrap.BindAsync(configuration.TcpPort) .ContinueWith(i => bootstrapChannel = i.Result)); }
static async Task RunServer() { var eventListener = new ObservableEventListener(); eventListener.LogToConsole(); eventListener.EnableEvents(DefaultEventSource.Log, EventLevel.Verbose); var bossGroup = new MultithreadEventLoopGroup(1); var workerGroup = new MultithreadEventLoopGroup(); try { var bootstrap = new ServerBootstrap(); bootstrap .Group(bossGroup, workerGroup) .Channel <TcpServerSocketChannel>() .Option(ChannelOption.SoBacklog, 100) .Handler(new LoggingHandler(LogLevel.INFO)) .ChildHandler(new ActionChannelInitializer <ISocketChannel>(channel => { IChannelPipeline pipeline = channel.Pipeline; if (EchoServerSettings.IsSsl) { pipeline.AddLast(TlsHandler.Server(new X509Certificate2("dotnetty.com.pfx", "password"))); } pipeline.AddLast(new EchoServerHandler()); })); IChannel bootstrapChannel = await bootstrap.BindAsync(EchoServerSettings.Port); Console.ReadLine(); await bootstrapChannel.CloseAsync(); } finally { Task.WaitAll(bossGroup.ShutdownGracefullyAsync(), workerGroup.ShutdownGracefullyAsync()); eventListener.Dispose(); } }
protected override void Init(IChannel channel) { foreach (ChannelOptionValue e in this.Options) { try { if (!e.Set(channel.Configuration)) { Logger.Warn("Unknown channel option: " + e); } } catch (Exception ex) { Logger.Warn("Failed to set a channel option: " + channel, ex); } } foreach (AttributeValue e in this.Attributes) { e.Set(channel); } IChannelPipeline p = channel.Pipeline; IChannelHandler channelHandler = this.Handler(); if (channelHandler != null) { p.AddLast((string)null, channelHandler); } IEventLoopGroup currentChildGroup = this.childGroup; IChannelHandler currentChildHandler = this.childHandler; ChannelOptionValue[] currentChildOptions = this.childOptions.Values.ToArray(); AttributeValue[] currentChildAttrs = this.childAttrs.Values.ToArray(); p.AddLast(new ActionChannelInitializer <IChannel>(ch => { ch.Pipeline.AddLast(new ServerBootstrapAcceptor(currentChildGroup, currentChildHandler, currentChildOptions, currentChildAttrs)); })); }
static async Task Main(string[] args) { ExampleHelper.SetConsoleLogger(); var bossGroup = new MultithreadEventLoopGroup(1); var workerGroup = new MultithreadEventLoopGroup(); X509Certificate2 tlsCertificate = null; if (ServerSettings.IsSsl) { tlsCertificate = new X509Certificate2(Path.Combine(ExampleHelper.ProcessDirectory, "dotnetty.com.pfx"), "password"); } try { var bootstrap = new ServerBootstrap(); bootstrap .Group(bossGroup, workerGroup) .Channel <TcpServerSocketChannel>() .Option(ChannelOption.SoBacklog, 100) .Handler(new LoggingHandler("LSTN")) .ChildHandler(new ActionChannelInitializer <IChannel>(channel => { IChannelPipeline pipeline = channel.Pipeline; if (tlsCertificate != null) { pipeline.AddLast(TlsHandler.Server(tlsCertificate)); } pipeline.AddLast(new LoggingHandler("CONN")); pipeline.AddLast(new DiscardServerHandler()); })); IChannel bootstrapChannel = await bootstrap.BindAsync(ServerSettings.Port); Console.ReadLine(); await bootstrapChannel.CloseAsync(); } finally { Task.WaitAll(bossGroup.ShutdownGracefullyAsync(), workerGroup.ShutdownGracefullyAsync()); } }
static async Task RunClientAsync() { var group = new MultithreadEventLoopGroup(); try { var bootstrap = new Bootstrap(); bootstrap .Group(group) .Channel <TcpSocketChannel>() .Option(ChannelOption.TcpNodelay, true) .Handler(new ActionChannelInitializer <ISocketChannel>(channel => { IChannelPipeline pipeline = channel.Pipeline; pipeline.AddLast(new DelimiterBasedFrameDecoder(8192, Delimiters.LineDelimiter())); pipeline.AddLast(new StringEncoder(), new StringDecoder(), new ProxyClientHandler()); })); bootstrapChannel = await bootstrap.ConnectAsync(IPAddress.Parse(ConfigHelper.GetValue <string>("server")), ConfigHelper.GetValue <int>("port")); Console.WriteLine("Success Connect"); for (; ;) { string line = Console.ReadLine(); if (string.IsNullOrEmpty(line)) { continue; } if (string.Equals(line, "bye", StringComparison.OrdinalIgnoreCase)) { await bootstrapChannel.CloseAsync(); break; } } await bootstrapChannel.CloseAsync(); } finally { group.ShutdownGracefullyAsync().Wait(1000); } }
private void InitDotNetty() { group = new MultithreadEventLoopGroup(); bootstrap = new Bootstrap(); bootstrap .Group(group) .Channel <TcpSocketChannel>() .Option(ChannelOption.TcpNodelay, true) .Option(ChannelOption.ConnectTimeout, TimeSpan.FromSeconds(3)) .Handler(new ActionChannelInitializer <ISocketChannel>(channel => { IChannelPipeline pipeline = channel.Pipeline; // Tcp粘包处理,添加一个LengthFieldBasedFrameDecoder解码器,它会在解码时按照消息头的长度来进行解码。 pipeline.AddLast("frameDecoder", new LengthFieldBasedFrameDecoder(ushort.MaxValue, 0, 4, 0, 4)); // MessagePack解码器,消息进来后先由frameDecoder处理,再给msgPackDecoder处理 pipeline.AddLast("msgPackDecoder", new MessagePackDecoder()); // Tcp粘包处理,添加一个 // LengthFieldPrepender编码器,它会在ByteBuf之前增加4个字节的字段,用于记录消息长度。 pipeline.AddLast("frameEncoder", new LengthFieldPrepender(4)); // MessagePack编码器,消息发出之前先由frameEncoder处理,再给msgPackEncoder处理 pipeline.AddLast("msgPackEncoder", new MessagePackEncoder()); // IdleStateHandler 心跳 //客户端为写IDLE pipeline.AddLast(new IdleStateHandler(0, 0, 0)); // 消息处理handler if (DotNettyClientHandler != null) { DotNettyClientHandler.ReceiveEventFromClientEvent -= ReceiveMessage; DotNettyClientHandler.ReconnectServer -= () => ConnectToServer().Wait(); DotNettyClientHandler.RecordLogEvent -= this.RecordLogEvent; } DotNettyClientHandler = new EchoClientHandler(); DotNettyClientHandler.ReceiveEventFromClientEvent += ReceiveMessage; DotNettyClientHandler.ReconnectServer += () => ConnectToServer().Wait(); DotNettyClientHandler.RecordLogEvent += this.RecordLogEvent; pipeline.AddLast("handler", DotNettyClientHandler); })); bootstrap.RemoteAddress(new IPEndPoint(IPAddress.Parse(this.ServerIP), this.ServerPort)); CheckConnectServer(); }
static async Task RunClient() { var eventListener = new ObservableEventListener(); eventListener.LogToConsole(); eventListener.EnableEvents(DefaultEventSource.Log, EventLevel.Verbose); var group = new MultithreadEventLoopGroup(); try { var bootstrap = new Bootstrap(); bootstrap .Group(group) .Channel <TcpSocketChannel>() .Option(ChannelOption.TcpNodelay, true) .Handler(new ActionChannelInitializer <ISocketChannel>(channel => { IChannelPipeline pipeline = channel.Pipeline; if (EchoClientSettings.IsSsl) { var cert = new X509Certificate2("dotnetty.com.pfx", "password"); string targetHost = cert.GetNameInfo(X509NameType.DnsName, false); pipeline.AddLast(TlsHandler.Client(targetHost, null, (sender, certificate, chain, errors) => true)); } pipeline.AddLast(new EchoClientHandler()); })); IChannel bootstrapChannel = await bootstrap.ConnectAsync(new IPEndPoint(EchoClientSettings.Host, EchoClientSettings.Port)); Console.ReadLine(); await bootstrapChannel.CloseAsync(); } finally { group.ShutdownGracefullyAsync().Wait(1000); eventListener.Dispose(); } }
/// <summary> /// /// </summary> /// <param name="ip"></param> /// <param name="port"></param> public async void Connect(string ip, int port) { group = new MultithreadEventLoopGroup(); X509Certificate2 cert = null; string targetHost = null; if (IsSsl) { // cert = new X509Certificate2(Path.Combine(ExampleHelper.ProcessDirectory, "dotnetty.com.pfx"), "password"); targetHost = cert.GetNameInfo(X509NameType.DnsName, false); } try { var bootstrap = new Bootstrap(); bootstrap .Group(group) .Channel <TcpSocketChannel>() .Option(ChannelOption.TcpNodelay, true) .Handler(new ActionChannelInitializer <ISocketChannel>(channel => { IChannelPipeline pipeline = channel.Pipeline; if (cert != null) { pipeline.AddLast("tls", new TlsHandler(stream => new SslStream(stream, true, (sender, certificate, chain, errors) => true), new ClientTlsSettings(targetHost))); } pipeline.AddLast("framing-enc", new LengthFieldPrepender(4)); pipeline.AddLast("framing-dec", new LengthFieldBasedFrameDecoder(Int32.MaxValue, 0, 4, 0, 4)); mChannelHandler = new ClientChannelHandler(this); mChannelHandler.DataArrivedEvent += ProcessData; pipeline.AddLast(mChannelHandler); })); clientChannel = await bootstrap.ConnectAsync(new IPEndPoint(IPAddress.Parse(ip), port)); } catch { Close(); NeedReConnected = true; } }
/// <summary>运行 /// </summary> public override async ValueTask ConnectAsync() { if (_channel != null && _channel.Registered) { Logger.LogInformation($"Client is running! Don't run again! ChannelId:{_channel.Id.AsLongText()}"); return; } try { _group = new MultithreadEventLoopGroup(); _bootStrap = new Bootstrap(); _bootStrap .Group(_group) .Channel <TcpSocketChannel>() .Option(ChannelOption.TcpNodelay, _dotNettyOption.TcpNodelay) .Option(ChannelOption.WriteBufferHighWaterMark, _dotNettyOption.WriteBufferHighWaterMark) .Option(ChannelOption.WriteBufferLowWaterMark, _dotNettyOption.WriteBufferLowWaterMark) .Option(ChannelOption.SoReuseaddr, _dotNettyOption.SoReuseaddr) .Option(ChannelOption.AutoRead, true) .Handler(new ActionChannelInitializer <ISocketChannel>(channel => { IChannelPipeline pipeline = channel.Pipeline; pipeline.AddLast(new LoggingHandler(typeof(DotNettyConnection))); pipeline.AddLast("fdfs-write", new ChunkedWriteHandler <IByteBuffer>()); pipeline.AddLast("fdfs-decoder", ServiceProvider.CreateInstance <FastDFSDecoder>(new Func <TransportContext>(() => _context))); pipeline.AddLast("fdfs-handler", ServiceProvider.CreateInstance <FastDFSHandler>(new Action <ReceivedPackage>(HandleReceivedPack), new Func <Exception, Task>(HandleExceptionCaught))); })); _channel = await _bootStrap.ConnectAsync(new IPEndPoint(IPAddress.Parse(ConnectionAddress.IPAddress), ConnectionAddress.Port)); IsConnected = true; Logger.LogInformation($"Client connect! serverEndPoint:{_channel.RemoteAddress.ToStringAddress()},localAddress:{_channel.LocalAddress.ToStringAddress()}"); } catch (Exception ex) { Logger.LogError(ex.Message); IsConnected = false; await _group.ShutdownGracefullyAsync(TimeSpan.FromMilliseconds(100), TimeSpan.FromSeconds(1)); } }
/// <summary> /// Performs the opening handshake /// When call this method you <c>MUST NOT</c> retain the <see cref="IHttpRequest"/> which is passed in. /// </summary> /// <param name="channel">Channel</param> /// <param name="req">HTTP Request</param> /// <param name="responseHeaders">Extra headers to add to the handshake response or <code>null</code> if no extra headers should be added</param> /// <returns></returns> public Task HandshakeAsync(IChannel channel, IHttpRequest req, HttpHeaders responseHeaders) { if (req is IFullHttpRequest request) { return(HandshakeAsync(channel, request, responseHeaders)); } #if DEBUG if (Logger.DebugEnabled) { Logger.WebSocketVersionServerHandshake(channel, _version); } #endif IChannelPipeline p = channel.Pipeline; IChannelHandlerContext ctx = p.Context <HttpRequestDecoder>(); if (ctx is null) { // this means the user use an HttpServerCodec ctx = p.Context <HttpServerCodec>(); if (ctx is null) { return(ThrowHelper.ThrowInvalidOperationException_NoHttpDecoderAndServerCodec()); } } // Add aggregator and ensure we feed the HttpRequest so it is aggregated. A limit o 8192 should be more then // enough for the websockets handshake payload. // // TODO: Make handshake work without HttpObjectAggregator at all. string aggregatorName = "httpAggregator"; _ = p.AddAfter(ctx.Name, aggregatorName, new HttpObjectAggregator(8192)); var completion = channel.NewPromise(); _ = p.AddAfter(aggregatorName, "handshaker", new Handshaker(this, channel, responseHeaders, completion)); try { _ = ctx.FireChannelRead(ReferenceCountUtil.Retain(req)); } catch (Exception cause) { _ = completion.TrySetException(cause); } return(completion.Task); }
public async Task Run() { MultithreadEventLoopGroup bossGroup = new MultithreadEventLoopGroup(); MultithreadEventLoopGroup workerGroup = new MultithreadEventLoopGroup(); try { ServerBootstrap b = new ServerBootstrap(); b.Group(bossGroup, workerGroup) .Channel <TcpServerSocketChannel>() .ChildHandler(new ActionChannelInitializer <IChannel>(channel => { IChannelPipeline pipeline = channel.Pipeline; pipeline.AddLast("decoder", new StringDecoder()); pipeline.AddLast("encoder", new StringEncoder()); pipeline.AddLast("handler", new StringHandler()); Log.Info("initChannel:" + channel.RemoteAddress); })) .Option(ChannelOption.SoBacklog, 128) .ChildOption(ChannelOption.SoKeepalive, true); Log.Info("tcp server start......"); IChannel f = await b.BindAsync(port); await f.CloseCompletion; } catch (Exception ex) { Log.Error("tcp server start error."); } finally { await workerGroup.ShutdownGracefullyAsync(); await bossGroup.ShutdownGracefullyAsync(); Log.Info("tcp server close"); } }
public async Task RunEngineAsync(int port, IBasicHandler basicHandler, ICustomizeHandler handler) { bossGroup = new MultithreadEventLoopGroup(1); workerGroup = new MultithreadEventLoopGroup(); MessageDispatcher dispatcher = new MessageDispatcher(this.BasicController, basicHandler, handler); List <ChannelServerHandler> handlers = new List <ChannelServerHandler>(); RingObject <ChannelServerHandler> ringHandlers = null; if (!useDefaultThread)//此处相比默认handler增加了工作线程,默认工作线程为cpu核心*2 { for (int i = 0; i < workThreadCount; i++) { WorkerEngine <RequestInfo> workerEngine = new WorkerEngine <RequestInfo>(3000, 1, dispatcher.Process); workerEngine.Start(); handlers.Add(new ChannelServerHandler(this.userManager, workerEngine)); } ringHandlers = new RingObject <ChannelServerHandler>(handlers); } else { var cChannelHandlers = new List <ChannelServerHandler>() { new ChannelServerHandler(this.userManager, dispatcher) }; ringHandlers = new RingObject <ChannelServerHandler>(cChannelHandlers); } var bootstrap = new ServerBootstrap(); bootstrap .Group(bossGroup, workerGroup) .Channel <TcpServerSocketChannel>() //.Option(ChannelOption.SoBacklog, 100) //.Handler(new LoggingHandler(LogLevel.INFO)) .ChildHandler(new ActionChannelInitializer <ISocketChannel>(channel => { IChannelPipeline pipeline = channel.Pipeline; pipeline.AddLast(OFrameDecoder.NewOFrameDecoder()); pipeline.AddLast(ringHandlers.GetNext()); })); IChannel bootstrapChannel = await bootstrap.BindAsync(port); }
public async Task <IChannel> startHttpPortAsync(string lport) { //X509Certificate2 tlsCertificate = null; //if (ServerSettings.IsSsl) //{ // tlsCertificate = new X509Certificate2(Path.Combine(commSetting.ProcessDirectory, "dotnetty.com.pfx"), "password"); //} if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) { GCSettings.LatencyMode = GCLatencyMode.SustainedLowLatency; } try { httpbootstrap.Group(httpbossGroup, httpworkerGroup); httpbootstrap.Channel <CustHttpServerSocketChannel>(); httpbootstrap .Option(ChannelOption.SoBacklog, 8192) .ChildHandler(new ActionChannelInitializer <IChannel>(channel => { IChannelPipeline pipeline = channel.Pipeline; // pipeline.AddLast("encoder", new HttpResponseEncoder()); pipeline.AddLast("decoder", new HttpRequestDecoder(maxInitialLineLength, maxHeaderSize, maxChunkSize, true)); pipeline.AddLast("decoder2", new HttpObjectAggregator(maxContentLength)); pipeline.AddLast("handler", new HttpProxyServerHandler()); })) .ChildOption(ChannelOption.SoKeepalive, true); httpbootstrapChannel = await httpbootstrap.BindAsync(IPAddress.IPv6Any, int.Parse(lport)); Console.WriteLine($"Httpd started. Listening on {httpbootstrapChannel.LocalAddress}"); return(httpbootstrapChannel); } catch (Exception ex) { Task.WaitAll(httpbossGroup.ShutdownGracefullyAsync(), httpworkerGroup.ShutdownGracefullyAsync()); throw new Exception("服务启动失败"); } }
public async Task StartAsync(CancellationToken cancellationToken) { workerGroup = new MultithreadEventLoopGroup(configuration.EventLoopCount); var bootstrap = new Bootstrap(); bootstrap.Group(workerGroup) .Channel <SocketDatagramChannel>() .Option(ChannelOption.SoBroadcast, true) .Handler(new ActionChannelInitializer <IChannel>(channel => { IChannelPipeline pipeline = channel.Pipeline; pipeline.AddLast(new UdpHandler(Provider.GetRequiredService <ILogger <UdpHandler> >())); var lengthFieldLength = configuration.LengthFieldLength; pipeline.AddLast(new LengthFieldBasedFrameDecoder(ByteOrder.BigEndian, configuration.MaxFrameLength, 0, lengthFieldLength, 0, lengthFieldLength, true)); pipeline.AddLast(new RequestDecoder(decoder), new UdpLengthFieldPrepender(lengthFieldLength), new ResponseEncoder(encoder), handler); })); logger.LogInformation($"Server start at {IPAddress.Any}:{configuration.Port}."); bootstrapChannel = await bootstrap.BindAsync(configuration.Port); }
Task <IChannel> NewServer(bool autoRead, params IChannelHandler[] handlers) { Assert.True(handlers.Length >= 1); var serverBootstrap = new ServerBootstrap(); serverBootstrap.Group(this.group) .Channel <TcpServerSocketChannel>() .ChildOption(ChannelOption.AutoRead, autoRead) .ChildHandler( new ActionChannelInitializer <IChannel>( ch => { IChannelPipeline pipeline = ch.Pipeline; pipeline.AddLast(new OneByteToThreeStringsDecoder()); pipeline.AddLast(handlers); })); return(serverBootstrap.BindAsync(IPAddress.Loopback, 0)); }
private Bootstrap CreateBootstrap(IEventLoopGroup group) { ClientHandler handler = new ClientHandler(_clientInvoker, _config.RpcSerializer); Bootstrap bootstrap = new Bootstrap() .Group(group) .Channel <TcpSocketChannel>() .Option(ChannelOption.SoSndbuf, _config.SoSndbuf) .Option(ChannelOption.SoRcvbuf, _config.SoRcvbuf) .Option(ChannelOption.SoReuseaddr, true) .Handler(new ActionChannelInitializer <ISocketChannel>(channel => { IChannelPipeline pipeline = channel.Pipeline; //pipeline.AddLast(new IdleStateHandler(0, 0, _config.AllIdleTimeSeconds)); pipeline.AddLast("framing-enc", new LengthFieldPrepender(4)); pipeline.AddLast("framing-dec", new LengthFieldBasedFrameDecoder(int.MaxValue, 0, 4, 0, 4)); pipeline.AddLast(handler); })); return(bootstrap); }
public TcpClient(IServiceProvider serviceProvider, ITcpClientSessionManager sessionManager, ILogger <TcpClient> logger, IOptions <GatewayConfiguration> configuration) { this.logger = logger; this.sessionManager = sessionManager; this.configuration = configuration.Value; eventLoopGroup = new MultithreadEventLoopGroup(); bootstrap = new Bootstrap().Group(eventLoopGroup) .Channel <TcpSocketChannel>() .Option(ChannelOption.TcpNodelay, true) .Option(ChannelOption.ConnectTimeout, TimeSpan.FromSeconds(30)) .Handler(new ActionChannelInitializer <ISocketChannel>(channel => { var scope = serviceProvider.CreateScope().ServiceProvider; IChannelPipeline pipeline = channel.Pipeline; pipeline.AddLast(new IdleStateHandler(this.configuration.BrabchServerReaderIdleTimeSeconds, this.configuration.BrabchServerWriterIdleTimeSeconds, this.configuration.BrabchServerAllIdleTimeSeconds)); pipeline.AddLast(scope.GetRequiredService <TcpMetadataDecoder>()); pipeline.AddLast(scope.GetRequiredService <TcpMetadataEncoder>()); pipeline.AddLast(scope.GetRequiredService <TcpClientHandler>()); })); }
public ServerChannel(IContainer container, IChannelPipeline pipeline, IByteBuffer buffer, IFramer framer, ConfigurationSetting setting) : base(buffer, framer) { Ensure.IsNotNull(container); Ensure.IsNotNull(pipeline); Ensure.IsNotNull(buffer); Ensure.IsNotNull(framer); SendingBufferSize = setting.SocketSendBufferSize; ReceivingBufferSize = setting.SocketReceiveBufferSize; _container = container; _setting = setting; this.pipeline = pipeline; _channelPipelineFactory?.Invoke(pipeline); SetSocket(SocketUtils.CreateSocket()); }
/// <summary> /// 构造函数 /// </summary> /// <param name="clientStub"></param> /// <param name="serviceType"></param> internal TCPClient(ClientStub clientStub, Type serviceType) : base(clientStub, serviceType) { _responseWaits = new ResponseWaits(RequestTimeoutSeconds); _bootstrap = new Bootstrap() .Group(new MultithreadEventLoopGroup()) .Channel <TcpSocketChannel>() .Option(ChannelOption.TcpNodelay, true) .Handler(new ActionChannelInitializer <ISocketChannel>(channel => { IChannelPipeline pipeline = channel.Pipeline; pipeline.AddLast("framing-enc", new LengthFieldPrepender(2)); //数据包最大长度 pipeline.AddLast("framing-dec", new LengthFieldBasedFrameDecoder(ushort.MaxValue, 0, 2, 0, 2)); ClientHandler clientHandler = new ClientHandler(_responseWaits) { OnDeserializeMessage = DeserializeMessage }; pipeline.AddLast(clientHandler); })); }
/// <summary> /// Starts the network. /// </summary> static async Task Bootstrap() { var boss = new MultithreadEventLoopGroup(1); var worker = new MultithreadEventLoopGroup(); var bootstrap = new ServerBootstrap(); bootstrap.Group(boss, worker); bootstrap.Option(ChannelOption.SoKeepalive, true); bootstrap.Channel <TcpServerSocketChannel>(); bootstrap.ChildHandler(new ActionChannelInitializer <ISocketChannel>((ch) => { IChannelPipeline pipeline = ch.Pipeline; pipeline.AddLast("decoder", new ConnectionDecoder()); pipeline.AddLast("encoder", new ConnectionEncoder()); pipeline.AddLast("handler", new NetworkHandler(ch)); })); await bootstrap.BindAsync(IPAddress.Any, Constants.HOST_PORT); }
public async Task Run() { var bossGroup = new MultithreadEventLoopGroup(1); var workerGroup = new MultithreadEventLoopGroup(5); var bootstrap = new ServerBootstrap(); bootstrap .Group(bossGroup, workerGroup) .Channel <TcpServerSocketChannel>() .Option(ChannelOption.SoBacklog, 100) .ChildHandler(new ActionChannelInitializer <ISocketChannel>(channel => { IChannelPipeline pipeline = channel.Pipeline; pipeline.AddLast(new DeCoder()); pipeline.AddLast(new EnCoder()); pipeline.AddLast(new EnCoder2()); pipeline.AddLast(new EchoServerHandler()); })); bootstrapChannel = await bootstrap.BindAsync(2012); }
private void Init() { receiveGroup = new MultithreadEventLoopGroup(); workGroup = new MultithreadEventLoopGroup(); bootstrap = new ServerBootstrap(); bootstrap.Group(receiveGroup, workGroup); bootstrap.Channel <TcpServerSocketChannel>(); bootstrap.ChildHandler(new ActionChannelInitializer <IChannel>(channel => { IChannelPipeline pipeline = channel.Pipeline; pipeline.AddLast(new ProtobufVarint32FrameDecoder()); pipeline.AddLast(new ProtobufDecoder(ImMessageContext.Parser)); pipeline.AddLast(new ProtobufVarint32LengthFieldPrepender()); pipeline.AddLast(new ProtobufEncoder()); pipeline.AddLast(new IdleStateHandler(IMConstants.READERIDLE_TIMEOUT_SECONDS, IMConstants.WRITERIDLE_TIMEOUT_SECONDS, 0)); pipeline.AddLast(new ServerChannelHandler(this.ServerEngineOption, this.Receivers)); })); }
void HandleReadException(IChannelPipeline pipeline, IByteBuffer byteBuf, Exception cause, bool close) { if (byteBuf != null) { if (byteBuf.IsReadable()) { this.Channel.ReadPending = false; pipeline.FireChannelRead(byteBuf); } else { byteBuf.Release(); } } pipeline.FireChannelReadComplete(); pipeline.FireExceptionCaught(cause); if (close || cause is SocketException) { this.CloseOnRead(); } }