Example #1
0
 /// <summary>
 /// Marks the specified {@code promise} as success.  If the {@code promise} is done already, log a message.
 /// </summary>
 public static void SafeSetSuccess(TaskCompletionSource promise)
 {
     if (promise != TaskCompletionSource.Void && !promise.TryComplete())
     {
         ChannelEventSource.Log.Warning(string.Format("Failed to mark a promise as success because it is done already: {0}", promise));
     }
 }
Example #2
0
 /// <summary>
 /// Marks the specified {@code promise} as success.  If the {@code promise} is done already, log a message.
 /// </summary>
 public static void SafeSetSuccess(TaskCompletionSource promise, IInternalLogger logger)
 {
     if (promise != TaskCompletionSource.Void && !promise.TryComplete())
     {
         logger.Warn(string.Format("Failed to mark a promise as success because it is done already: {0}", promise));
     }
 }
Example #3
0
 public static void SafeSetSuccess(TaskCompletionSource promise, ILogger logger)
 {
     if (promise != TaskCompletionSource.Void && !promise.TryComplete())
     {
         logger.Warning("Failed to complete task successfully because it is done already: {0}", promise);
     }
 }
Example #4
0
        protected override void ChannelRead0(IChannelHandlerContext ctx, object msg)
        {
            IChannel ch = ctx.Channel;

            if (Handshaker.IsHandshakeComplete)
            {
                return;
            }
            try
            {
                Handshaker.FinishHandshake(ch, (IFullHttpResponse)msg);
                CompletionSource.TryComplete();
            }
            catch (WebSocketHandshakeException e)
            {
                CompletionSource.TrySetException(e);
            }
        }
Example #5
0
        public async Task StartAsync(EndPoint endPoint)
        {
            if (_logger.IsEnabled(LogLevel.Debug))
            {
                _logger.LogDebug($"准备启动服务主机，监听地址：{endPoint}。");
            }
            var serverCompletion = new TaskCompletionSource();
            var bossGroup        = new MultithreadEventLoopGroup(1);
            var workerGroup      = new MultithreadEventLoopGroup();//Default eventLoopCount is Environment.ProcessorCount * 2
            var bootstrap        = new ServerBootstrap();

            bootstrap
            .Group(bossGroup, workerGroup)
            .Channel <TcpServerSocketChannel>()
            .Option(ChannelOption.SoReuseport, true)
            .ChildOption(ChannelOption.SoReuseaddr, true)
            .Option(ChannelOption.SoBacklog, AppConfig.ServerOptions.SoBacklog)
            .ChildHandler(new ActionChannelInitializer <IChannel>(channel =>
            {
                IChannelPipeline pipeline = channel.Pipeline;
                pipeline.AddLast("encoder", new HttpResponseEncoder());
                pipeline.AddLast(new HttpRequestDecoder(int.MaxValue, 8192, 8192, true));
                pipeline.AddLast(new HttpObjectAggregator(int.MaxValue));
                pipeline.AddLast(new ServerHandler(async(contenxt, message) =>
                {
                    var sender = new DotNettyHttpServerMessageSender(_transportMessageEncoder, contenxt, _serializer);
                    await OnReceived(sender, message);
                }, _logger, _serializer));
                serverCompletion.TryComplete();
            }));
            try
            {
                _channel = await bootstrap.BindAsync(endPoint);

                if (_logger.IsEnabled(LogLevel.Debug))
                {
                    _logger.LogDebug($"Http服务主机启动成功，监听地址：{endPoint}。");
                }
            }
            catch
            {
                _logger.LogError($"Http服务主机启动失败，监听地址：{endPoint}。 ");
            }
        }
Example #6
0
        private void ConnectFinish(SocketAsyncEventArgs e)
        {
            TaskCompletionSource promise = this.ConnectPromise;

            if (e.SocketError == SocketError.Success)
            {
                Open = true;
                this.Pipeline.FireChannelActive();
                promise.TryComplete();
            }
            else
            {
                this.UnsafeCloseAsync();
                // this.Pipeline.FireExceptionCaught(new SocketException((int)e.SocketError));
                promise.TrySetException(new SocketException((int)e.SocketError));
            }

            e.Dispose();
        }
Example #7
0
        protected override void ChannelRead0(IChannelHandlerContext context, object message)
        {
            var channel = context.Channel;

            if (!_handshaker.IsHandshakeComplete)
            {
                try
                {
                    _handshaker.FinishHandshake(channel, (IFullHttpResponse)message);
                    _logger.LogInformation("WebSocket Client connected!");
                    _completionSource.TryComplete();
                }
                catch (WebSocketHandshakeException e)
                {
                    _logger.LogInformation("WebSocket Client failed to connect");
                    _completionSource.TrySetException(e);
                }

                return;
            }


            if (message is IFullHttpResponse response)
            {
                throw new InvalidOperationException(
                          $"Unexpected FullHttpResponse (getStatus={response.Status}, content={response.Content.ToString(_client.Encoding)})");
            }

            if (message is TextWebSocketFrame textFrame)
            {
                _logger.LogInformation($"WebSocket Client received message: {textFrame.Text()}");
            }
            else if (message is PongWebSocketFrame)
            {
                _logger.LogInformation("WebSocket Client received pong");
            }
            else if (message is CloseWebSocketFrame)
            {
                _logger.LogInformation("WebSocket Client received closing");
                channel.CloseAsync();
            }
        }
Example #8
0
        protected override void ChannelRead0(IChannelHandlerContext context, object msg)
        {
            IChannel ch = context.Channel;

            if (!handshaker.IsHandshakeComplete)
            {
                try
                {
                    handshaker.FinishHandshake(ch, (IFullHttpResponse)msg);
                    completionSource.TryComplete();
                    _client._event.OnConnectAction?.Invoke();
                }
                catch (WebSocketHandshakeException e)
                {
                    completionSource.TrySetException(e);
                }

                return;
            }

            if (msg is IFullHttpResponse response)
            {
                throw new InvalidOperationException($"Unexpected FullHttpResponse (getStatus={response.Status}, content={response.Content.ToString(Encoding.UTF8)})");
            }

            if (msg is TextWebSocketFrame textFrame)
            {
                _client._event.OnReceiveTextAction?.Invoke(textFrame.Text());
            }
            else if (msg is BinaryWebSocketFrame binaryFrame)
            {
                _client._event.OnReceiveBinaryAction?.Invoke(binaryFrame.Content.ToBytes());
            }
            else if (msg is PongWebSocketFrame)
            {
            }
            else if (msg is CloseWebSocketFrame)
            {
                ch.CloseAsync();
            }
        }
Example #9
0
 async void StopAsync()
 {
     try
     {
         if (channel != null)
         {
             await channel.CloseAsync();
         }
         if (parentEventLoopGroup != null)
         {
             await eventLoopGroup.ShutdownGracefullyAsync();
         }
         if (eventLoopGroup != null)
         {
             await eventLoopGroup.ShutdownGracefullyAsync();
         }
     }
     finally
     {
         closeCompletionSource.TryComplete();
     }
 }
Example #10
0
        public static void LinkOutcome(this Task task, TaskCompletionSource taskCompletionSource)
        {
            switch (task.Status)
            {
            case TaskStatus.RanToCompletion:
                taskCompletionSource.TryComplete();
                break;

            case TaskStatus.Canceled:
                taskCompletionSource.TrySetCanceled();
                break;

            case TaskStatus.Faulted:
                taskCompletionSource.TrySetException(task.Exception);
                break;

            default:
                task.ContinueWith(
                    LinkOutcomeContinuationAction,
                    taskCompletionSource,
                    TaskContinuationOptions.ExecuteSynchronously);
                break;
            }
        }
Example #11
0
            void FulfillConnectPromise(bool wasActive)
            {
                // Regardless if the connection attempt was cancelled, channelActive() event should be triggered,
                // because what happened is what happened.
                if (!wasActive && this.channel.Active)
                {
                    this.channel.Pipeline.FireChannelActive();
                }

                TaskCompletionSource promise = this.Channel.connectPromise;

                // If promise is null, then it the channel was Closed via cancellation and the promise has been notified already.
                if (promise != null)
                {
                    // trySuccess() will return false if a user cancelled the connection attempt.
                    bool promiseSet = promise.TryComplete();

                    // If a user cancelled the connection attempt, close the channel, which is followed by channelInactive().
                    if (!promiseSet)
                    {
                        this.CloseSafe();
                    }
                }
            }
Example #12
0
 public override Task ConnectAsync(IChannelHandlerContext context, EndPoint remoteAddress,
                                   EndPoint localAddress)
 {
     _promise.TryComplete();
     return(base.ConnectAsync(context, remoteAddress, localAddress));
 }
Example #13
0
 public void Signal()
 {
     _tcs.TryComplete();
 }
Example #14
0
        public async Task EchoServerAndClient()
        {
            var         testPromise     = new TaskCompletionSource();
            var         tlsCertificate  = TestResourceHelper.GetTestCertificate();
            Func <Task> closeServerFunc = await this.StartServerAsync(true, ch =>
            {
                ch.Pipeline.AddLast("server logger", new LoggingHandler("SERVER"));
                ch.Pipeline.AddLast("server tls", TlsHandler.Server(tlsCertificate));
                ch.Pipeline.AddLast("server logger2", new LoggingHandler("SER***"));
                ch.Pipeline.AddLast("server prepender", new LengthFieldPrepender(2));
                ch.Pipeline.AddLast("server decoder", new LengthFieldBasedFrameDecoder(ushort.MaxValue, 0, 2, 0, 2));
                ch.Pipeline.AddLast(new EchoChannelHandler());
            }, testPromise);

            var       group        = new MultithreadEventLoopGroup();
            var       readListener = new ReadListeningHandler(DefaultTimeout);
            Bootstrap b            = new Bootstrap()
                                     .Group(group)
                                     .Channel <TcpSocketChannel>()
                                     .Option(ChannelOption.TcpNodelay, true)
                                     .Handler(new ActionChannelInitializer <ISocketChannel>(ch =>
            {
                string targetHost     = tlsCertificate.GetNameInfo(X509NameType.DnsName, false);
                var clientTlsSettings = new ClientTlsSettings(targetHost);
                ch.Pipeline.AddLast("client logger", new LoggingHandler("CLIENT"));
                ch.Pipeline.AddLast("client tls", new TlsHandler(stream => new SslStream(stream, true, (sender, certificate, chain, errors) => true), clientTlsSettings));
                ch.Pipeline.AddLast("client logger2", new LoggingHandler("CLI***"));
                ch.Pipeline.AddLast("client prepender", new LengthFieldPrepender(2));
                ch.Pipeline.AddLast("client decoder", new LengthFieldBasedFrameDecoder(ushort.MaxValue, 0, 2, 0, 2));
                ch.Pipeline.AddLast(readListener);
            }));

            this.Output.WriteLine("Configured Bootstrap: {0}", b);

            IChannel clientChannel = null;

            try
            {
                clientChannel = await b.ConnectAsync(IPAddress.Loopback, Port);

                this.Output.WriteLine("Connected channel: {0}", clientChannel);

                string[] messages = { "message 1", string.Join(",", Enumerable.Range(1, 300)) };
                foreach (string message in messages)
                {
                    await clientChannel.WriteAndFlushAsync(Unpooled.WrappedBuffer(Encoding.UTF8.GetBytes(message))).WithTimeout(DefaultTimeout);

                    var responseMessage = Assert.IsAssignableFrom <IByteBuffer>(await readListener.ReceiveAsync());
                    Assert.Equal(message, responseMessage.ToString(Encoding.UTF8));
                }

                testPromise.TryComplete();
                await testPromise.Task.WithTimeout(TimeSpan.FromSeconds(30));
            }
            finally
            {
                Task serverCloseTask = closeServerFunc();
                clientChannel?.CloseAsync().Wait(TimeSpan.FromSeconds(5));
                group.ShutdownGracefullyAsync().Wait(TimeSpan.FromSeconds(5));
                if (!serverCloseTask.Wait(ShutdownTimeout))
                {
                    this.Output.WriteLine("Didn't stop in time.");
                }
            }
        }
Example #15
0
        public async Task MqttServerAndClient()
        {
            var testPromise = new TaskCompletionSource();

            var         tlsCertificate     = TestResourceHelper.GetTestCertificate();
            var         serverReadListener = new ReadListeningHandler();
            IChannel    serverChannel      = null;
            Func <Task> closeServerFunc    = await this.StartServerAsync(true, ch =>
            {
                serverChannel = ch;
                ch.Pipeline.AddLast("server logger", new LoggingHandler("SERVER"));
                ch.Pipeline.AddLast("server tls", TlsHandler.Server(tlsCertificate));
                ch.Pipeline.AddLast("server logger2", new LoggingHandler("SER***"));
                ch.Pipeline.AddLast(
                    MqttEncoder.Instance,
                    new MqttDecoder(true, 256 * 1024),
                    serverReadListener);
            }, testPromise);

            var       group = new MultithreadEventLoopGroup();
            var       clientReadListener = new ReadListeningHandler();
            Bootstrap b = new Bootstrap()
                          .Group(group)
                          .Channel <TcpSocketChannel>()
                          .Option(ChannelOption.TcpNodelay, true)
                          .Handler(new ActionChannelInitializer <ISocketChannel>(ch =>
            {
                string targetHost     = tlsCertificate.GetNameInfo(X509NameType.DnsName, false);
                var clientTlsSettings = new ClientTlsSettings(targetHost);

                ch.Pipeline.AddLast("client logger", new LoggingHandler("CLIENT"));
                ch.Pipeline.AddLast("client tls", new TlsHandler(stream => new SslStream(stream, true, (sender, certificate, chain, errors) => true), clientTlsSettings));
                ch.Pipeline.AddLast("client logger2", new LoggingHandler("CLI***"));
                ch.Pipeline.AddLast(
                    MqttEncoder.Instance,
                    new MqttDecoder(false, 256 * 1024),
                    clientReadListener);
            }));

            this.Output.WriteLine("Configured Bootstrap: {0}", b);

            IChannel clientChannel = null;

            try
            {
                clientChannel = await b.ConnectAsync(IPAddress.Loopback, Port);

                this.Output.WriteLine("Connected channel: {0}", clientChannel);

                await Task.WhenAll(this.RunMqttClientScenarioAsync(clientChannel, clientReadListener), this.RunMqttServerScenarioAsync(serverChannel, serverReadListener))
                .WithTimeout(TimeSpan.FromSeconds(30));

                testPromise.TryComplete();
                await testPromise.Task;
            }
            finally
            {
                Task serverCloseTask = closeServerFunc();
                clientChannel?.CloseAsync().Wait(TimeSpan.FromSeconds(5));
                group.ShutdownGracefullyAsync().Wait(TimeSpan.FromSeconds(5));
                if (!serverCloseTask.Wait(ShutdownTimeout))
                {
                    this.Output.WriteLine("Didn't stop in time.");
                }
            }
        }
Example #16
0
 public void Complete()
 {
     TaskCompletionSource.TryComplete();
 }