public async Task RunAsync(X509Certificate2 certificate, int threadCount, CancellationToken cancellationToken) { Contract.Requires(certificate != null); Contract.Requires(threadCount > 0); try { BootstrapperEventSource.Log.Info("Starting", null); PerformanceCounters.ConnectionsEstablishedTotal.RawValue = 0; PerformanceCounters.ConnectionsCurrent.RawValue = 0; this.tlsCertificate = certificate; this.parentEventLoopGroup = new MultithreadEventLoopGroup(1); this.eventLoopGroup = new MultithreadEventLoopGroup(threadCount); this.bufferAllocator = new PooledByteBufferAllocator(16 * 1024, 300 * 1024 * 1024 / threadCount); // reserve up to 300 MB of 16 KB buffers ServerBootstrap bootstrap = this.SetupBootstrap(); BootstrapperEventSource.Log.Info(string.Format("Initializing TLS endpoint on port {0} with certificate {1}.", MqttsPort, this.tlsCertificate.Thumbprint), null); this.serverChannel = await bootstrap.BindAsync(IPAddress.Any, MqttsPort); cancellationToken.Register(this.CloseAsync); BootstrapperEventSource.Log.Info("Started", null); } catch (Exception ex) { BootstrapperEventSource.Log.Error("Failed to start", ex); this.CloseAsync(); } }
private static IEventLoopGroup GetServerPool(int poolSize) { if (_serverPool == null) { _serverPool = new MultithreadEventLoopGroup(poolSize); } return _serverPool; }
private static IEventLoopGroup GetClientWorkerPool(int poolSize) { if (_clientPool == null) { _clientPool = new MultithreadEventLoopGroup(poolSize); } return _clientPool; }
protected DeviceRunner(IEventLoopGroup eventLoopGroup, string deviceKey, string iotHubConnectionString, IPEndPoint endpoint, string tlsHostName) { this.deviceKey = deviceKey; this.endpoint = endpoint; this.tlsHostName = tlsHostName; this.connectionStringBuilder = IotHubConnectionStringBuilder.Create(iotHubConnectionString.Contains("DeviceId=") ? iotHubConnectionString : iotHubConnectionString + ";DeviceId=abc"); this.bootstrap = new Bootstrap() .Group(eventLoopGroup) .Channel<TcpSocketChannel>() .Option(ChannelOption.TcpNodelay, false); }
public void SetUp(BenchmarkContext context) { ClientGroup = new MultithreadEventLoopGroup(1); ServerGroup = new MultithreadEventLoopGroup(1); WorkerGroup = new MultithreadEventLoopGroup(); var iso = Encoding.GetEncoding("ISO-8859-1"); message = iso.GetBytes("ABC"); // pre-allocate all messages foreach (var m in Enumerable.Range(0, WriteCount)) { messages[m] = Unpooled.WrappedBuffer(message); } _inboundThroughputCounter = context.GetCounter(InboundThroughputCounterName); _outboundThroughputCounter = context.GetCounter(OutboundThroughputCounterName); var counterHandler = new CounterHandlerInbound(_inboundThroughputCounter); _signal = new ManualResetEventSlimReadFinishedSignal(ResetEvent); var sb = new ServerBootstrap().Group(ServerGroup, WorkerGroup).Channel<TcpServerSocketChannel>() .ChildOption(ChannelOption.TcpNodelay, true) .ChildHandler( new ActionChannelInitializer<TcpSocketChannel>( channel => { channel.Pipeline.AddLast(GetEncoder()) .AddLast(GetDecoder()) .AddLast(counterHandler) .AddLast(new CounterHandlerOutbound(_outboundThroughputCounter)) .AddLast(new ReadFinishedHandler(_signal, WriteCount)); })); var cb = new ClientBootstrap().Group(ClientGroup) .Option(ChannelOption.TcpNodelay, true) .Channel<TcpSocketChannel>().Handler(new ActionChannelInitializer<TcpSocketChannel>( channel => { channel.Pipeline.AddLast(GetEncoder()).AddLast(GetDecoder()).AddLast(counterHandler) .AddLast(new CounterHandlerOutbound(_outboundThroughputCounter)); })); // start server _serverChannel = sb.BindAsync(TEST_ADDRESS).Result; // connect to server _clientChannel = cb.ConnectAsync(_serverChannel.LocalAddress).Result; //_clientChannel.Configuration.AutoRead = false; }
public TcpSocketChannelAndReactorCompatSpecs() { _clientGroup = new MultithreadEventLoopGroup(1); _serverBootstrap = new ServerBootstrap() .SetTransport(TransportType.Tcp) .SetDecoder(new LengthFieldFrameBasedDecoder(int.MaxValue, 0, 4, 0, 4)) .SetEncoder(new LengthFieldPrepender(4, false)).Build(); _clientBootstrap = new ClientBootstrap() .Channel<TcpSocketChannel>() .Group(_clientGroup) .Handler(new ActionChannelInitializer<TcpSocketChannel>(channel => { channel.Pipeline.AddLast(new LengthFieldBasedFrameDecoder(int.MaxValue, 0, 4, 0, 4, true)) .AddLast(new HeliosBackwardsCompatabilityLengthFramePrepender(4, false)) .AddLast(new ReadRecorderHandler(_received, _resetEvent, ReadCount)); })); }
public TcpServerSocketChannelAndConnectionCompatSpecs() { _serverGroup = new MultithreadEventLoopGroup(1); _clientBootstrap = new ClientBootstrap() .SetTransport(TransportType.Tcp) .SetDecoder(new LengthFieldFrameBasedDecoder(int.MaxValue, 0, 4, 0, 4)) .SetEncoder(new LengthFieldPrepender(4, false)) .WorkerThreads(1).Build(); _serverBootstrap = new ServerBootstrap() .Channel<TcpServerSocketChannel>() .Group(_serverGroup) .ChildHandler(new ActionChannelInitializer<TcpSocketChannel>(channel => { channel.Pipeline.AddLast(new LengthFieldBasedFrameDecoder(int.MaxValue, 0, 4, 0, 4, true)) .AddLast(new HeliosBackwardsCompatabilityLengthFramePrepender(4, false)) .AddLast(new EchoHandler()); })); }
public void SetUp(BenchmarkContext context) { ClientGroup = new MultithreadEventLoopGroup(1); ServerGroup = new MultithreadEventLoopGroup(2); var iso = Encoding.GetEncoding("ISO-8859-1"); message = iso.GetBytes("ABC"); _inboundThroughputCounter = context.GetCounter(InboundThroughputCounterName); _outboundThroughputCounter = context.GetCounter(OutboundThroughputCounterName); var counterHandler = new CounterHandlerInbound(_inboundThroughputCounter); _signal = new SimpleReadFinishedSignal(); var sb = new ServerBootstrap().Group(ServerGroup).Channel<LocalServerChannel>() .ChildHandler( new ActionChannelInitializer<LocalChannel>( channel => { channel.Pipeline.AddLast(GetEncoder()) .AddLast(GetDecoder()) .AddLast(counterHandler) .AddLast(new CounterHandlerOutbound(_outboundThroughputCounter)) .AddLast(new ReadFinishedHandler(_signal, WriteCount)); })); var cb = new ClientBootstrap().Group(ClientGroup) .Channel<LocalChannel>() .Handler(new ActionChannelInitializer<LocalChannel>( channel => { channel.Pipeline.AddLast(GetEncoder()).AddLast(GetDecoder()).AddLast(counterHandler) .AddLast(new CounterHandlerOutbound(_outboundThroughputCounter)); })); // start server _serverChannel = sb.BindAsync(TEST_ADDRESS).Result; // connect to server _clientChannel = cb.ConnectAsync(_serverChannel.LocalAddress).Result; }
public void SetUp(BenchmarkContext context) { ServerGroup = new MultithreadEventLoopGroup(1); WorkerGroup = new MultithreadEventLoopGroup(); var iso = Encoding.GetEncoding("ISO-8859-1"); message = Unpooled.Buffer().WriteInt(3).WriteBytes(iso.GetBytes("ABC")).ToArray(); _inboundThroughputCounter = context.GetCounter(InboundThroughputCounterName); _outboundThroughputCounter = context.GetCounter(OutboundThroughputCounterName); var counterHandler = new CounterHandlerInbound(_inboundThroughputCounter); _signal = new ManualResetEventSlimReadFinishedSignal(ResetEvent); var sb = new ServerBootstrap().Group(ServerGroup, WorkerGroup).Channel<TcpServerSocketChannel>() .ChildOption(ChannelOption.TcpNodelay, true) .ChildHandler( new ActionChannelInitializer<TcpSocketChannel>( channel => { channel.Pipeline.AddLast(GetEncoder()) .AddLast(GetDecoder()) .AddLast(counterHandler) .AddLast(new CounterHandlerOutbound(_outboundThroughputCounter)) .AddLast(new ReadFinishedHandler(_signal, WriteCount)); })); // start server _serverChannel = sb.BindAsync(TEST_ADDRESS).Result; // connect to server var address = (IPEndPoint) _serverChannel.LocalAddress; ClientSocket = new System.Net.Sockets.Socket(AddressFamily.InterNetworkV6, SocketType.Stream, ProtocolType.Tcp); ClientSocket.Connect(address.Address, address.Port); Stream = new NetworkStream(ClientSocket, true); }
public void SetUp(BenchmarkContext context) { this.ServerGroup = new MultithreadEventLoopGroup(1); this.WorkerGroup = new MultithreadEventLoopGroup(); Encoding iso = Encoding.GetEncoding("ISO-8859-1"); this.message = Unpooled.Buffer().WriteInt(3).WriteBytes(iso.GetBytes("ABC")).ToArray(); this.inboundThroughputCounter = context.GetCounter(InboundThroughputCounterName); var counterHandler = new CounterHandlerInbound(this.inboundThroughputCounter); this.signal = new ManualResetEventSlimReadFinishedSignal(this.ResetEvent); // using default settings this.serverBufferAllocator = new PooledByteBufferAllocator(); ServerBootstrap sb = new ServerBootstrap() .Group(this.ServerGroup, this.WorkerGroup) .Channel<TcpServerSocketChannel>() .ChildOption(ChannelOption.Allocator, this.serverBufferAllocator) .ChildHandler(new ActionChannelInitializer<TcpSocketChannel>(channel => { channel.Pipeline .AddLast(this.GetEncoder()) .AddLast(this.GetDecoder()) .AddLast(counterHandler) .AddLast(new ReadFinishedHandler(this.signal, WriteCount)); })); // start server this.serverChannel = sb.BindAsync(TEST_ADDRESS).Result; // connect to server var address = (IPEndPoint)this.serverChannel.LocalAddress; this.ClientSocket = new Socket(AddressFamily.InterNetworkV6, SocketType.Stream, ProtocolType.Tcp); this.ClientSocket.Connect(address.Address, address.Port); this.Stream = new NetworkStream(this.ClientSocket, true); }
public DefaultEventLoop(IEventLoopGroup parent, IThreadFactory threadFactory, IRejectedExecutionHandler rejectedHandler, int maxPendingTasks) : base(parent, threadFactory, true, NewBlockingTaskQueue(maxPendingTasks), NewBlockingTaskQueue(maxPendingTasks), rejectedHandler) { Start(); }
protected HeliosTransport(ActorSystem system, Config config) { Config = config; System = system; Settings = new HeliosTransportSettings(config); Log = Logging.GetLogger(System, GetType()); _serverEventLoopGroup = new MultithreadEventLoopGroup(Settings.ServerSocketWorkerPoolSize); _clientEventLoopGroup = new MultithreadEventLoopGroup(Settings.ClientSocketWorkerPoolSize); }
public DefaultEventLoop(IEventLoopGroup parent, IRejectedExecutionHandler rejectedHandler, int maxPendingTasks) : this(parent, DefaultThreadFactory <DefaultEventLoop> .Instance, rejectedHandler, maxPendingTasks) { }
public DefaultEventLoop(IEventLoopGroup parent, IThreadFactory threadFactory, int maxPendingTasks) : this(parent, threadFactory, RejectedExecutionHandlers.Reject(), maxPendingTasks) { }
private static void Main() { JsonConvert.DefaultSettings = () => new JsonSerializerSettings { Converters = new List <JsonConverter> { new IPEndPointConverter() } }; var jsonlog = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "auth.json"); var logfile = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "auth.log"); Log.Logger = new LoggerConfiguration() .WriteTo.File(new JsonFormatter(), jsonlog) .WriteTo.File(logfile) .WriteTo.Console(outputTemplate: "[{Level} {SourceContext}] {Message}{NewLine}{Exception}") .MinimumLevel.Verbose() .CreateLogger(); AppDomain.CurrentDomain.UnhandledException += OnUnhandledException; TaskScheduler.UnobservedTaskException += OnUnobservedTaskException; AuthDatabase.Initialize(); Log.Information("Starting server..."); AuthServer.Initialize(new Configuration()); AuthServer.Instance.Listen(Config.Instance.Listener); s_apiEventLoopGroup = new MultithreadEventLoopGroup(2); s_loginapiHost = new ServerBootstrap() .Group(s_apiEventLoopGroup) .Channel <TcpServerSocketChannel>() .Handler(new ActionChannelInitializer <IChannel>(ch => { })) .ChildHandler(new ActionChannelInitializer <IChannel>(ch => { ch.Pipeline.AddLast(new LoginServerHandler()); })) .BindAsync(Config.Instance.AuthAPI.Listener).WaitEx(); s_apiHost = new ServerBootstrap() .Group(s_apiEventLoopGroup) .Channel <TcpServerSocketChannel>() .Handler(new ActionChannelInitializer <IChannel>(ch => { })) .ChildHandler(new ActionChannelInitializer <IChannel>(ch => { ch.Pipeline.AddLast(new APIServerHandler()); })) .BindAsync(Config.Instance.API.Listener).WaitEx(); Log.Information("Ready for connections!"); if (Config.Instance.NoobMode) { Log.Warning("!!! NOOB MODE IS ENABLED! EVERY LOGIN SUCCEEDS AND OVERRIDES ACCOUNT LOGIN DETAILS !!!"); } Console.CancelKeyPress += OnCancelKeyPress; while (true) { var input = Console.ReadLine(); if (input == null) { break; } if (input.Equals("exit", StringComparison.InvariantCultureIgnoreCase) || input.Equals("quit", StringComparison.InvariantCultureIgnoreCase) || input.Equals("stop", StringComparison.InvariantCultureIgnoreCase)) { break; } } Exit(); }
public DefaultEventLoop(IEventLoopGroup parent, int maxPendingTasks) : this(parent, RejectedExecutionHandlers.Reject(), maxPendingTasks) { }
internal DispatcherEventLoop(IEventLoopGroup parent) : this(parent, DefaultThreadFactory <DispatcherEventLoop> .Instance) { }
Func <IPAddress, int, Task <IChannel> > CreateWebSocketChannelFactory(IotHubConnectionString iotHubConnectionString, MqttTransportSettings settings) { return(async(address, port) => { string additionalQueryParams = ""; #if WINDOWS_UWP || NETSTANDARD1_3 // UWP and NETSTANDARD1_3 implementation doesn't set client certs, so we want to tell the IoT Hub to not ask for them additionalQueryParams = "?iothub-no-client-cert=true"; #endif IEventLoopGroup eventLoopGroup = EventLoopGroupPool.TakeOrAdd(this.eventLoopGroupKey); var websocketUri = new Uri(WebSocketConstants.Scheme + iotHubConnectionString.HostName + ":" + WebSocketConstants.SecurePort + WebSocketConstants.UriSuffix + additionalQueryParams); var websocket = new ClientWebSocket(); websocket.Options.AddSubProtocol(WebSocketConstants.SubProtocols.Mqtt); #if !WINDOWS_UWP // UWP does not support proxies // Check if we're configured to use a proxy server IWebProxy webProxy = WebRequest.DefaultWebProxy; Uri proxyAddress = null; #if !NETSTANDARD1_3 proxyAddress = webProxy?.GetProxy(websocketUri); #endif if (!websocketUri.Equals(proxyAddress)) { // Configure proxy server websocket.Options.Proxy = webProxy; } #endif if (settings.ClientCertificate != null) { websocket.Options.ClientCertificates.Add(settings.ClientCertificate); } #if !WINDOWS_UWP && !NETSTANDARD1_3 // UseDefaultCredentials is not in UWP and NetStandard else { websocket.Options.UseDefaultCredentials = true; } #endif using (var cancellationTokenSource = new CancellationTokenSource(TimeSpan.FromMinutes(1))) { await websocket.ConnectAsync(websocketUri, cancellationTokenSource.Token); } #if WINDOWS_UWP PlatformProvider.Platform = new UWPPlatform(); #endif var clientChannel = new ClientWebSocketChannel(null, websocket); clientChannel .Option(ChannelOption.Allocator, UnpooledByteBufferAllocator.Default) .Option(ChannelOption.AutoRead, false) .Option(ChannelOption.RcvbufAllocator, new AdaptiveRecvByteBufAllocator()) .Option(ChannelOption.MessageSizeEstimator, DefaultMessageSizeEstimator.Default) .Pipeline.AddLast( MqttEncoder.Instance, new MqttDecoder(false, MaxMessageSize), this.mqttIotHubAdapterFactory.Create(this, iotHubConnectionString, settings)); await eventLoopGroup.GetNext().RegisterAsync(clientChannel); this.ScheduleCleanup(() => { EventLoopGroupPool.Release(this.eventLoopGroupKey); return TaskConstants.Completed; }); return clientChannel; }); }
public LocalChannelTest() { _group1 = new MultithreadEventLoopGroup(2); _group2 = new MultithreadEventLoopGroup(2); _sharedGroup = new MultithreadEventLoopGroup(1); }
public FlowControlHandlerTest() { this.group = new MultithreadEventLoopGroup(); }
/// <summary> /// 创建 TCP 协议封装器。 /// </summary> /// <param name="factory">给定的 <see cref="IBootstrapWrapperFactory"/>。</param> /// <param name="useLibuv">使用 LIBUV。</param> /// <param name="group">输出 <see cref="IEventLoopGroup"/>。</param> /// <returns>返回 <see cref="IBootstrapWrapper"/>。</returns> public static IBootstrapWrapper CreateTcp(this IBootstrapWrapperFactory factory, bool useLibuv, out IEventLoopGroup group) => factory.NotNull(nameof(factory)) .Create(useLibuv, out group) .Configure(bootstrap => { bootstrap.Option(ChannelOption.TcpNodelay, true); if (useLibuv) { bootstrap.Channel <TcpChannel>(); } else { bootstrap.Channel <TcpSocketChannel>(); } });
public void SetUp(BenchmarkContext context) { TaskScheduler.UnobservedTaskException += (sender, args) => Console.WriteLine(args.Exception); this.ClientGroup = new MultithreadEventLoopGroup(1); this.ServerGroup = new MultithreadEventLoopGroup(1); this.WorkerGroup = new MultithreadEventLoopGroup(); Encoding iso = Encoding.GetEncoding("ISO-8859-1"); this.message = iso.GetBytes("ABC"); this.inboundThroughputCounter = context.GetCounter(InboundThroughputCounterName); this.outboundThroughputCounter = context.GetCounter(OutboundThroughputCounterName); var counterHandler = new CounterHandlerInbound(this.inboundThroughputCounter); this.signal = new ManualResetEventSlimReadFinishedSignal(this.ResetEvent); // reserve up to 10mb of 16kb buffers on both client and server; we're only sending about 700k worth of messages this.serverBufferAllocator = new PooledByteBufferAllocator(); this.clientBufferAllocator = new PooledByteBufferAllocator(); Assembly assembly = typeof(TcpChannelPerfSpecs).Assembly; byte[] certificateData; using (Stream sourceStream = assembly.GetManifestResourceStream(assembly.GetManifestResourceNames()[0])) using (var tempStream = new MemoryStream()) { sourceStream.CopyTo(tempStream); certificateData = tempStream.ToArray(); } var tlsCertificate = new X509Certificate2(certificateData, "password"); string targetHost = tlsCertificate.GetNameInfo(X509NameType.DnsName, false); ServerBootstrap sb = new ServerBootstrap() .Group(this.ServerGroup, this.WorkerGroup) .Channel<TcpServerSocketChannel>() .ChildOption(ChannelOption.Allocator, this.serverBufferAllocator) .ChildHandler(new ActionChannelInitializer<TcpSocketChannel>(channel => { channel.Pipeline //.AddLast(TlsHandler.Server(tlsCertificate)) .AddLast(this.GetEncoder()) .AddLast(this.GetDecoder()) .AddLast(counterHandler) .AddLast(new CounterHandlerOutbound(this.outboundThroughputCounter)) .AddLast(new ReadFinishedHandler(this.signal, WriteCount)); })); Bootstrap cb = new Bootstrap() .Group(this.ClientGroup) .Channel<TcpSocketChannel>() .Option(ChannelOption.Allocator, this.clientBufferAllocator) .Handler(new ActionChannelInitializer<TcpSocketChannel>( channel => { channel.Pipeline //.AddLast(TlsHandler.Client(targetHost, null, (sender, certificate, chain, errors) => true)) .AddLast(this.GetEncoder()) .AddLast(this.GetDecoder()) .AddLast(counterHandler) .AddLast(new CounterHandlerOutbound(this.outboundThroughputCounter)); })); // start server this.serverChannel = sb.BindAsync(TEST_ADDRESS).Result; // connect to server this.clientChannel = cb.ConnectAsync(this.serverChannel.LocalAddress).Result; }
/// <summary> /// 创建 TCP 协议服务端封装器。 /// </summary> /// <param name="factory">给定的 <see cref="IBootstrapWrapperFactory"/>。</param> /// <param name="useLibuv">使用 LIBUV。</param> /// <param name="bossGroup">输出引领 <see cref="IEventLoopGroup"/>。</param> /// <param name="workerGroup">输出工作 <see cref="IEventLoopGroup"/>。</param> /// <returns>返回 <see cref="IServerBootstrapWrapper"/>。</returns> public static IServerBootstrapWrapper CreateTcpServer(this IBootstrapWrapperFactory factory, bool useLibuv, out IEventLoopGroup bossGroup, out IEventLoopGroup workerGroup) => factory.NotNull(nameof(factory)) .CreateServer(useLibuv, out bossGroup, out workerGroup) .Configure(bootstrap => { if (useLibuv) { bootstrap.Channel <TcpServerChannel>(); if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux) || RuntimeInformation.IsOSPlatform(OSPlatform.OSX)) { bootstrap .Option(ChannelOption.SoReuseport, true) .ChildOption(ChannelOption.SoReuseaddr, true); factory.Logger.LogInformation($"Run in {Environment.OSVersion.Platform}"); } } else { bootstrap.Channel <TcpServerSocketChannel>(); } });
private static void Main() { JsonConvert.DefaultSettings = () => new JsonSerializerSettings { Converters = new List <JsonConverter> { new IPEndPointConverter() } }; var jsonlog = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "AuthServer.json"); var logfile = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "AuthServer.log"); Log.Logger = new LoggerConfiguration() .WriteTo.File(new JsonFormatter(), jsonlog) .WriteTo.File(logfile) .WriteTo.Console(outputTemplate: "[{Level} {SourceContext}] {Message}{NewLine}{Exception}") .MinimumLevel.Verbose() .CreateLogger(); var Logger = Log.ForContext(Constants.SourceContextPropertyName, "Initialiazor"); AppDomain.CurrentDomain.UnhandledException += OnUnhandledException; TaskScheduler.UnobservedTaskException += OnUnobservedTaskException; AuthDatabase.Initialize(); Logger.Information("Starting server..."); if (!Directory.Exists("XBN")) { throw new Exception("XBN folder is missing!"); } foreach (var xbn in Enum.GetValues(typeof(XBNType)).Cast <XBNType>().ToList()) { var name = $"XBN//{xbn.ToString()}.xbn"; if (File.Exists(name)) { var data = File.ReadAllBytes(name); XBNdata.TryAdd(xbn, data); Logger.Information($"Cached xbnfile: {name}"); } } Network.AuthServer.Initialize(new Configuration()); Network.AuthServer.Instance.Listen(Config.Instance.Listener); s_apiEventLoopGroup = new MultithreadEventLoopGroup(2); s_loginapiHost = new ServerBootstrap() .Group(s_apiEventLoopGroup) .Channel <TcpServerSocketChannel>() .Handler(new ActionChannelInitializer <IChannel>(ch => { })) .ChildHandler(new ActionChannelInitializer <IChannel>(ch => { ch.Pipeline.AddLast(new LoginServerHandler()); })) .BindAsync(Config.Instance.AuthAPI.Listener).WaitEx(); s_apiHost = new ServerBootstrap() .Group(s_apiEventLoopGroup) .Channel <TcpServerSocketChannel>() .Handler(new ActionChannelInitializer <IChannel>(ch => { })) .ChildHandler(new ActionChannelInitializer <IChannel>(ch => { ch.Pipeline.AddLast(new APIServerHandler()); })) .BindAsync(Config.Instance.API.Listener).WaitEx(); Logger.Information("Ready for connections!"); if (Config.Instance.NoobMode) { Logger.Warning( "!!! NOOB MODE IS ENABLED! EVERY LOGIN SUCCEEDS AND OVERRIDES ACCOUNT LOGIN DETAILS !!!"); } Console.CancelKeyPress += OnCancelKeyPress; while (true) { var input = Console.ReadLine(); if (input == null) { break; } if (input.Equals("exit", StringComparison.InvariantCultureIgnoreCase) || input.Equals("quit", StringComparison.InvariantCultureIgnoreCase) || input.Equals("stop", StringComparison.InvariantCultureIgnoreCase)) { break; } } Exit(); }
/// <summary> /// Initializes a new instance of the <see cref="XmppClient"/> class. /// </summary> /// <param name="pipelineInitializerAction">The pipeline initializer action.</param> /// <param name="eventLoopGroup">The event loop group.</param> public XmppClient(Action <IChannelPipeline, ISession> pipelineInitializerAction, IEventLoopGroup eventLoopGroup) : base(pipelineInitializerAction, eventLoopGroup) { }
public void SetUp(BenchmarkContext context) { TaskScheduler.UnobservedTaskException += (sender, args) => Console.WriteLine(args.Exception); this.ClientGroup = new MultithreadEventLoopGroup(1); this.ServerGroup = new MultithreadEventLoopGroup(1); this.WorkerGroup = new MultithreadEventLoopGroup(); Encoding iso = Encoding.GetEncoding("ISO-8859-1"); this.message = iso.GetBytes("ABC"); this.inboundThroughputCounter = context.GetCounter(InboundThroughputCounterName); this.outboundThroughputCounter = context.GetCounter(OutboundThroughputCounterName); var counterHandler = new CounterHandlerInbound(this.inboundThroughputCounter); this.signal = new ManualResetEventSlimReadFinishedSignal(this.ResetEvent); // reserve up to 10mb of 16kb buffers on both client and server; we're only sending about 700k worth of messages this.serverBufferAllocator = new PooledByteBufferAllocator(); this.clientBufferAllocator = new PooledByteBufferAllocator(); Assembly assembly = typeof(TcpChannelPerfSpecs).Assembly; var tlsCertificate = TestResourceHelper.GetTestCertificate(); string targetHost = tlsCertificate.GetNameInfo(X509NameType.DnsName, false); ServerBootstrap sb = new ServerBootstrap() .Group(this.ServerGroup, this.WorkerGroup) .Channel <TcpServerSocketChannel>() .ChildOption(ChannelOption.Allocator, this.serverBufferAllocator) .ChildHandler(new ActionChannelInitializer <TcpSocketChannel>(channel => { channel.Pipeline //.AddLast(TlsHandler.Server(tlsCertificate)) .AddLast(this.GetEncoder()) .AddLast(this.GetDecoder()) .AddLast(counterHandler) .AddLast(new CounterHandlerOutbound(this.outboundThroughputCounter)) .AddLast(new ReadFinishedHandler(this.signal, WriteCount)); })); Bootstrap cb = new Bootstrap() .Group(this.ClientGroup) .Channel <TcpSocketChannel>() .Option(ChannelOption.Allocator, this.clientBufferAllocator) .Handler(new ActionChannelInitializer <TcpSocketChannel>( channel => { channel.Pipeline //.AddLast(TlsHandler.Client(targetHost, null, (sender, certificate, chain, errors) => true)) .AddLast(this.GetEncoder()) .AddLast(this.GetDecoder()) .AddLast(counterHandler) .AddLast(new CounterHandlerOutbound(this.outboundThroughputCounter)); })); // start server this.serverChannel = sb.BindAsync(TEST_ADDRESS).Result; // connect to server this.clientChannel = cb.ConnectAsync(this.serverChannel.LocalAddress).Result; }
public ServerChannelHandler(IServerChannelFactory factory, IEventLoopGroup childLoopGroup, IChannelHandler childhandler) { mChildHandler = childhandler; mChildLoopGroup = childLoopGroup; mFactory = factory; }
/// <summary> /// Creates a new instance of <see cref="AffinitizedEventLoopGroup"/>. /// </summary> /// <param name="innerGroup"><see cref="IEventLoopGroup"/> serving as an actual provider of <see cref="IEventLoop"/>s.</param> public AffinitizedEventLoopGroup(IEventLoopGroup innerGroup) { this.innerGroup = innerGroup; }
static async Task Main(string[] args) { ExampleHelper.SetConsoleLogger(); Console.WriteLine( $"\n{RuntimeInformation.OSArchitecture} {RuntimeInformation.OSDescription}" + $"\n{RuntimeInformation.ProcessArchitecture} {RuntimeInformation.FrameworkDescription}" + $"\nProcessor Count : {Environment.ProcessorCount}\n"); bool useLibuv = ServerSettings.UseLibuv; Console.WriteLine("Transport type : " + (useLibuv ? "Libuv" : "Socket")); if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) { GCSettings.LatencyMode = GCLatencyMode.SustainedLowLatency; } Console.WriteLine($"Server garbage collection : {(GCSettings.IsServerGC ? "Enabled" : "Disabled")}"); Console.WriteLine($"Current latency mode for garbage collection: {GCSettings.LatencyMode}"); Console.WriteLine("\n"); IEventLoopGroup bossGroup; IEventLoopGroup workGroup; IEventLoopGroup bossGroup2 = null; IEventLoopGroup workGroup2 = null; if (useLibuv) { var dispatcher = new DispatcherEventLoopGroup(); bossGroup = dispatcher; workGroup = new WorkerEventLoopGroup(dispatcher); dispatcher = new DispatcherEventLoopGroup(); bossGroup2 = dispatcher; workGroup2 = new WorkerEventLoopGroup(dispatcher); } else { bossGroup = new MultithreadEventLoopGroup(1); workGroup = new MultithreadEventLoopGroup(); } IChannel http2Channel = null; IChannel httpChannel = null; try { Http2Server http2 = useLibuv ? new Http2Server(bossGroup2, workGroup2) : new Http2Server(bossGroup, workGroup); http2Channel = await http2.StartAsync(); Console.WriteLine("Open your web browser and navigate to " + "http://127.0.0.1:" + HttpServer.PORT); HttpServer http = new HttpServer(bossGroup, workGroup); httpChannel = await http.StartAsync(); Console.WriteLine("按任意键退出"); Console.ReadKey(); } catch (Exception exc) { Console.WriteLine(exc.ToString()); Console.ReadKey(); } finally { if (http2Channel != null) { await http2Channel.CloseAsync(); } if (httpChannel != null) { await httpChannel.CloseAsync(); } if (workGroup2 != null) { await workGroup2.ShutdownGracefullyAsync(); } if (bossGroup2 != null) { await bossGroup2.ShutdownGracefullyAsync(); } await workGroup.ShutdownGracefullyAsync(); await bossGroup.ShutdownGracefullyAsync(); } }
/// <summary>Run socket server /// </summary> public async ValueTask RunAsync() { if (_boundChannel != null) { _logger.LogInformation($"Server is running! Don't run again! ChannelId:{_boundChannel.Id.AsShortText()}"); return; } _bossGroup = new MultithreadEventLoopGroup(_extraSetting.BossGroupEventLoopCount); _workerGroup = new MultithreadEventLoopGroup(_extraSetting.WorkGroupEventLoopCount); try { var bootstrap = new ServerBootstrap(); bootstrap .Group(_bossGroup, _workerGroup) .Channel <TcpServerSocketChannel>() .Option(ChannelOption.SoBacklog, _extraSetting.SoBacklog) .ChildOption(ChannelOption.TcpNodelay, _extraSetting.TcpNodelay) .ChildOption(ChannelOption.WriteBufferHighWaterMark, _extraSetting.WriteBufferHighWaterMark) .ChildOption(ChannelOption.WriteBufferLowWaterMark, _extraSetting.WriteBufferLowWaterMark) .ChildOption(ChannelOption.SoRcvbuf, _extraSetting.SoRcvbuf) .ChildOption(ChannelOption.SoSndbuf, _extraSetting.SoSndbuf) .ChildOption(ChannelOption.SoReuseaddr, _extraSetting.SoReuseaddr) .ChildOption(ChannelOption.AutoRead, _extraSetting.AutoRead) .Handler(new LoggingHandler(nameof(DotNettySocketServer))) .ChildHandler(new ActionChannelInitializer <IChannel>(channel => { IChannelPipeline pipeline = channel.Pipeline; //if (_setting.IsSsl && _setting.TlsCertificate != null) //{ // pipeline.AddLast("tls", TlsHandler.Server(_setting.TlsCertificate)); //} pipeline.AddLast("framing-enc", new LengthFieldPrepender(4)); pipeline.AddLast("framing-dec", new LengthFieldBasedFrameDecoder(int.MaxValue, 0, 4, 0, 4)); //coder and encoder pipeline.AddLast(new PacketDecoder(), new PacketEncoder()); //Handle PingPacket pipeline.AddLast("PingPacketHandler", _app.ServiceProvider.CreateInstance <PingPacketHandler>()); //SocketServer handler Func <string, MessageReqPacket, ValueTask> writeMessageReqPacketHandler = WriteMessageReqPacketAsync; Action <PushRespPacket> setPushRespPacketHandler = SetPushRespPacket; Action <IChannel, bool> channelActiveInActiveHandler = ActiveInActiveHandler; pipeline.AddLast("SocketServerHandler", _app.ServiceProvider.CreateInstance <SocketServerHandler>(writeMessageReqPacketHandler, setPushRespPacketHandler, channelActiveInActiveHandler)); })); _boundChannel = await bootstrap.BindAsync(_setting.ListeningEndPoint); _isRunning = true; _logger.LogInformation($"Socket server run! ListeningEndPoint:{_setting.ListeningEndPoint}, ChannelId:{_boundChannel.Id.AsLongText()}"); StartScanTimeoutRequestTask(); StartHandleMessageReqPacketTask(); } catch (Exception ex) { _logger.LogError(ex, "Socket server run fail,ex:{0}.", ex.Message); await Task.WhenAll( _bossGroup.ShutdownGracefullyAsync(TimeSpan.FromMilliseconds(_setting.QuietPeriodMilliSeconds), TimeSpan.FromSeconds(_setting.CloseTimeoutSeconds)), _workerGroup.ShutdownGracefullyAsync(TimeSpan.FromMilliseconds(_setting.QuietPeriodMilliSeconds), TimeSpan.FromSeconds(_setting.CloseTimeoutSeconds))); } }
Func <IPAddress, int, Task <IChannel> > CreateChannelFactory(IotHubConnectionString iotHubConnectionString, MqttTransportSettings settings) { #if WINDOWS_UWP return(async(address, port) => { PlatformProvider.Platform = new UWPPlatform(); var eventLoopGroup = new MultithreadEventLoopGroup(); var streamSocket = new StreamSocket(); await streamSocket.ConnectAsync(new HostName(iotHubConnectionString.HostName), port.ToString(), SocketProtectionLevel.PlainSocket); streamSocket.Control.IgnorableServerCertificateErrors.Add(ChainValidationResult.Untrusted); await streamSocket.UpgradeToSslAsync(SocketProtectionLevel.Tls12, new HostName(iotHubConnectionString.HostName)); var streamSocketChannel = new StreamSocketChannel(streamSocket); streamSocketChannel.Pipeline.AddLast( MqttEncoder.Instance, new MqttDecoder(false, MaxMessageSize), this.mqttIotHubAdapterFactory.Create(this, iotHubConnectionString, settings)); streamSocketChannel.Configuration.SetOption(ChannelOption.Allocator, UnpooledByteBufferAllocator.Default); await eventLoopGroup.GetNext().RegisterAsync(streamSocketChannel); this.ScheduleCleanup(() => { EventLoopGroupPool.Release(this.eventLoopGroupKey); return TaskConstants.Completed; }); return streamSocketChannel; }); #else return((address, port) => { IEventLoopGroup eventLoopGroup = EventLoopGroupPool.TakeOrAdd(this.eventLoopGroupKey); Func <Stream, SslStream> streamFactory = stream => new SslStream(stream, true, settings.RemoteCertificateValidationCallback); var clientTlsSettings = settings.ClientCertificate != null ? new ClientTlsSettings(iotHubConnectionString.HostName, new List <X509Certificate> { settings.ClientCertificate }) : new ClientTlsSettings(iotHubConnectionString.HostName); Bootstrap bootstrap = new Bootstrap() .Group(eventLoopGroup) .Channel <TcpSocketChannel>() .Option(ChannelOption.TcpNodelay, true) .Option(ChannelOption.Allocator, UnpooledByteBufferAllocator.Default) .Handler(new ActionChannelInitializer <ISocketChannel>(ch => { var tlsHandler = new TlsHandler(streamFactory, clientTlsSettings); ch.Pipeline .AddLast( tlsHandler, MqttEncoder.Instance, new MqttDecoder(false, MaxMessageSize), this.mqttIotHubAdapterFactory.Create(this, iotHubConnectionString, settings)); })); this.ScheduleCleanup(() => { EventLoopGroupPool.Release(this.eventLoopGroupKey); return TaskConstants.Completed; }); return bootstrap.ConnectAsync(address, port); }); #endif }
public void SetUp(BenchmarkContext context) { ClientGroup = new MultithreadEventLoopGroup(Environment.ProcessorCount/2); ServerGroup = new MultithreadEventLoopGroup(1); WorkerGroup = new MultithreadEventLoopGroup(Environment.ProcessorCount/2); _shutdownBenchmark = new CancellationTokenSource(); _clientChannels = new ConcurrentBag<IChannel>(); _inboundThroughputCounter = context.GetCounter(InboundThroughputCounterName); _outboundThroughputCounter = context.GetCounter(OutboundThroughputCounterName); _clientConnectedCounter = context.GetCounter(ClientConnectCounterName); _errorCounter = context.GetCounter(ErrorCounterName); _signal = new ManualResetEventSlimReadFinishedSignal(ResetEvent); var sb = new ServerBootstrap().Group(ServerGroup, WorkerGroup).Channel<TcpServerSocketChannel>() .ChildOption(ChannelOption.TcpNodelay, true) .ChildHandler(new ActionChannelInitializer<TcpSocketChannel>(channel => { channel.Pipeline.AddLast(GetEncoder()) .AddLast(GetDecoder()) .AddLast(new IntCodec(true)) .AddLast(new CounterHandlerInbound(_inboundThroughputCounter)) .AddLast(new CounterHandlerOutbound(_outboundThroughputCounter)) .AddLast(new ErrorCounterHandler(_errorCounter)); })); ClientBootstrap = new ClientBootstrap().Group(ClientGroup) .Option(ChannelOption.TcpNodelay, true) .Channel<TcpSocketChannel>().Handler(new ActionChannelInitializer<TcpSocketChannel>( channel => { channel.Pipeline.AddLast(GetEncoder()) .AddLast(GetDecoder()) .AddLast(new IntCodec(true)) .AddLast(new CounterHandlerInbound(_inboundThroughputCounter)) .AddLast(new CounterHandlerOutbound(_outboundThroughputCounter)) .AddLast(new ErrorCounterHandler(_errorCounter)); })); var token = _shutdownBenchmark.Token; _eventLoop = () => { while (!token.IsCancellationRequested) { foreach (var channel in _clientChannels) { // unrolling a loop channel.WriteAsync(ThreadLocalRandom.Current.Next()); channel.WriteAsync(ThreadLocalRandom.Current.Next()); channel.WriteAsync(ThreadLocalRandom.Current.Next()); channel.WriteAsync(ThreadLocalRandom.Current.Next()); channel.WriteAsync(ThreadLocalRandom.Current.Next()); channel.WriteAsync(ThreadLocalRandom.Current.Next()); channel.WriteAsync(ThreadLocalRandom.Current.Next()); channel.WriteAsync(ThreadLocalRandom.Current.Next()); channel.WriteAsync(ThreadLocalRandom.Current.Next()); channel.Flush(); } // sleep for a tiny bit, then get going again Thread.Sleep(40); } }; // start server _serverChannel = sb.BindAsync(TEST_ADDRESS).Result; // connect to server with 1 client initially _clientChannels.Add(ClientBootstrap.ConnectAsync(_serverChannel.LocalAddress).Result); }
protected override IEventLoopGroup NewWorkerGroup(IEventLoopGroup serverGroup) => new MultithreadEventLoopGroup(1);
TaskCompletionSource <ConnectResult> connectFuture; //create a Task start with Connect, end by ConnAct. public async Task <ConnectResult> ConnectAsync(string host, int port) { if (isConnected()) { return(new ConnectResult(true, ConnectReturnCode.Accepted, channel.CloseCompletion)); } if (eventLoopGroup == null) { eventLoopGroup = new MultithreadEventLoopGroup(); } connectFuture = new TaskCompletionSource <ConnectResult>(); X509Certificate2 cert = null; string targetHost = null; if (ClientSettings.IsSsl) { cert = new X509Certificate2(Path.Combine(ClientSettings.ProcessDirectory, ClientSettings.KeyFile), ClientSettings.Password); targetHost = cert.GetNameInfo(X509NameType.DnsName, false); } var bootstrap = new Bootstrap(); bootstrap .Group(eventLoopGroup) .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))); } if (ClientSettings.EnableLoggingHandler) { pipeline.AddLast(new LoggingHandler()); } pipeline.AddLast(MqttEncoder.Instance); pipeline.AddLast(new MqttDecoder(false, ClientSettings.MaxMessageSize)); AddHandlers(pipeline); pipeline.AddLast(new MqttHandler(this)); })); try { IChannel clientChannel = await bootstrap.ConnectAsync(new IPEndPoint(IPAddress.Parse(host), port)); if (clientChannel.Open) { channel = clientChannel; _ = clientChannel.CloseCompletion.ContinueWith((t, s) => { var self = (MqttClient)s; if (self.isConnected()) { return; } if (self.OnConnectionChange != null) { if (connectFuture.Task.IsCompleted) { var result = connectFuture.Task.Result; if (result.ReturnCode != ConnectReturnCode.Accepted) { ChannelClosedException e = new ChannelClosedException(result.ReturnCode.ToString()); self.OnConnectionChange.OnConnectionLost(e); connectFuture.TrySetException(e); }//ConnAct with refused code. } else { ChannelClosedException e = new ChannelClosedException("Channel is closed!", connectFuture.Task.Exception); self.OnConnectionChange.OnConnectionLost(e); connectFuture.TrySetException(e); }//Channel closed before ConnAct. } pendingPublishes.Clear(); pendingIncomingQoS2Publishes.Clear(); pendingSubscribes.Clear(); pendingSubscribeTopics.Clear(); pendingUnsubscribes.Clear(); topicSubscriptions.Clear(); subscribedTopics.Clear(); callbackSubscriptions.Clear(); reconnecting = true; scheduleReconnect(host, port);//auto reconnect when channel closed. }, this, TaskContinuationOptions.ExecuteSynchronously); } else { var e = new ClosedChannelException(); if (OnConnectionChange != null) { OnConnectionChange.OnConnectionLost(e); } connectFuture.SetException(e); scheduleReconnect(host, port);//auto reconnect when connect failed. } } catch (Exception e) { connectFuture.SetException(e); scheduleReconnect(host, port); //auto reconnect when connect error. } return(await connectFuture.Task); }
public DefaultEventLoop(IEventLoopGroup parent) : this(parent, DefaultMaxPendingTasks) { }
public LoopExecutor(IEventLoopGroup parent, string threadName) : this(parent, threadName, DefaultBreakoutInterval) { }
public DefaultEventLoop(IEventLoopGroup parent, IRejectedExecutionHandler rejectedHandler) : this(parent, rejectedHandler, queueFactory : null) { }
/// <summary> /// Initializes a new instance of the <see cref="XmppConnection"/> class. /// </summary> /// <param name="pipelineInitializerAction">The pipeline initializer action.</param> /// <param name="eventLoopGroup">The event loop group.</param> protected XmppConnection(Action <IChannelPipeline> pipelineInitializerAction, IEventLoopGroup eventLoopGroup) { Contract.Requires <ArgumentNullException>(eventLoopGroup != null, $"{nameof(eventLoopGroup)} cannot be null"); this.eventLoopGroup = eventLoopGroup; Bootstrap .Group(eventLoopGroup) .Channel <TcpSocketChannel>() .Option(ChannelOption.TcpNodelay, true) .Option(ChannelOption.SoKeepalive, true) .Resolver(HostnameResolver) .Option(ChannelOption.Allocator, UnpooledByteBufferAllocator.Default) .Handler(new ActionChannelInitializer <ISocketChannel>(channel => { Pipeline = channel.Pipeline; Pipeline.AddLast2(new ZlibDecoder()); Pipeline.AddLast2(new KeepAliveHandler()); Pipeline.AddLast2(new XmlStreamDecoder()); Pipeline.AddLast2(new ZlibEncoder()); Pipeline.AddLast2(new XmppXElementEncoder()); Pipeline.AddLast2(new UTF8StringEncoder()); Pipeline.AddLast2(xmppStreamEventHandler); Pipeline.AddLast2(new StreamFooterHandler()); Pipeline.AddLast2(XmppStanzaHandler); Pipeline.AddLast2(new CatchAllXmppStanzaHandler()); Pipeline.AddLast2(new DisconnectHandler(this)); pipelineInitializerAction?.Invoke(Pipeline); })); }
public DefaultEventLoop(IEventLoopGroup parent, IRejectedExecutionHandler rejectedHandler, IEventLoopTaskQueueFactory queueFactory) : this(parent, DefaultThreadFactory <DefaultEventLoop> .Instance, rejectedHandler, queueFactory) { }
ServerBootstrap SetupServerBootstrap() { int maxInboundMessageSize = this.settingsProvider.GetIntegerSetting("MaxInboundMessageSize", DefaultMaxInboundMessageSize); int threadCount = this.settingsProvider.GetIntegerSetting("ThreadCount", this.defaultThreadCount); int listenBacklogSize = this.settingsProvider.GetIntegerSetting("ListenBacklogSize", DefaultListenBacklogSize); int parentEventLoopCount = this.settingsProvider.GetIntegerSetting("EventLoopCount", DefaultParentEventLoopCount); var settings = new Settings(this.settingsProvider); MessagingBridgeFactoryFunc bridgeFactory = this.mqttConnectionProvider.Connect; var bootstrap = new ServerBootstrap(); // multithreaded event loop that handles the incoming connection IEventLoopGroup parentEventLoopGroup = new MultithreadEventLoopGroup(parentEventLoopCount); // multithreaded event loop (worker) that handles the traffic of the accepted connections this.eventLoopGroup = new MultithreadEventLoopGroup(threadCount); bootstrap.Group(parentEventLoopGroup, this.eventLoopGroup) .Option(ChannelOption.SoBacklog, listenBacklogSize) // Allow listening socket to force bind to port if previous socket is still in TIME_WAIT // Fixes "address is already in use" errors .Option(ChannelOption.SoReuseaddr, true) .ChildOption(ChannelOption.Allocator, this.byteBufferAllocator) .ChildOption(ChannelOption.AutoRead, AutoRead) // channel that accepts incoming connections .Channel <TcpServerSocketChannel>() // Channel initializer, it is handler that is purposed to help configure a new channel .ChildHandler( new ActionChannelInitializer <ISocketChannel>( channel => { var identityProvider = new DeviceIdentityProvider(this.authenticator, this.usernameParser, this.clientCredentialsFactory, this.metadataStore, this.clientCertAuthAllowed); // configure the channel pipeline of the new Channel by adding handlers TlsSettings serverSettings = new ServerTlsSettings( certificate: this.tlsCertificate, negotiateClientCertificate: this.clientCertAuthAllowed, checkCertificateRevocation: false, enabledProtocols: this.sslProtocols); channel.Pipeline.AddLast( new TlsHandler( stream => new SslStream( stream, true, (sender, remoteCertificate, remoteChain, sslPolicyErrors) => this.RemoteCertificateValidationCallback(identityProvider, remoteCertificate, remoteChain)), serverSettings)); channel.Pipeline.AddLast( MqttEncoder.Instance, new MqttDecoder(true, maxInboundMessageSize), new MqttAdapter( settings, this.sessionProvider, identityProvider, null, bridgeFactory)); })); var mqttWebSocketListener = new MqttWebSocketListener( settings, bridgeFactory, this.authenticator, this.usernameParser, this.clientCredentialsFactory, () => this.sessionProvider, new MultithreadEventLoopGroup(Environment.ProcessorCount), this.byteBufferAllocator, AutoRead, maxInboundMessageSize, this.clientCertAuthAllowed, this.metadataStore); this.webSocketListenerRegistry.TryRegister(mqttWebSocketListener); return(bootstrap); }
public DefaultEventLoop(IEventLoopGroup parent, IThreadFactory threadFactory, IEventLoopTaskQueueFactory queueFactory) : this(parent, threadFactory, RejectedExecutionHandlers.Reject(), queueFactory) { }
public SimpleChannelInboundHandler0(IEventLoopGroup group, CountdownEvent latch, bool sameEventLoop) { _group = group; _latch = latch; _sameEventLoop = sameEventLoop; }
public StableTelemetryRunner(IEventLoopGroup eventLoopGroup, string deviceKey, string iotHubConnectionString, IPEndPoint endpoint, string tlsHostName) : base(eventLoopGroup, deviceKey, iotHubConnectionString, endpoint, tlsHostName) { }
/// <summary> /// 创建 UDP 协议封装器。 /// </summary> /// <param name="factory">给定的 <see cref="IBootstrapWrapperFactory"/>。</param> /// <param name="group">输出 <see cref="IEventLoopGroup"/>。</param> /// <returns>返回 <see cref="IBootstrapWrapper"/>。</returns> public static IBootstrapWrapper CreateUdp(this IBootstrapWrapperFactory factory, out IEventLoopGroup group) => factory.NotNull(nameof(factory)) .Create(false, out group) .Configure(bootstrap => bootstrap.Channel <SocketDatagramChannel>());