Example #1
0
            public void FinishConnect(SocketChannelAsyncOperation operation)
            {
                Contract.Assert(this.channel.EventLoop.InEventLoop);

                AbstractSocketChannel ch = this.Channel;

                try
                {
                    bool wasActive = ch.Active;
                    ch.DoFinishConnect(operation);
                    this.FulfillConnectPromise(wasActive);
                }
                catch (Exception ex)
                {
                    TaskCompletionSource promise = ch.connectPromise;
                    var remoteAddress            = (EndPoint)promise?.Task.AsyncState;
                    this.FulfillConnectPromise(this.AnnotateConnectException(ex, remoteAddress));
                }
                finally
                {
                    // Check for null as the connectTimeoutFuture is only created if a connectTimeoutMillis > 0 is used
                    // See https://github.com/netty/netty/issues/1770
                    ch.connectCancellationTask?.Cancel();
                    ch.connectPromise = null;
                }
            }
            public void FinishConnect(SocketChannelAsyncOperation operation)
            {
                // Note this method is invoked by the event loop only if the connection attempt was
                // neither cancelled nor timed out.

                Contract.Assert(this.channel.EventLoop.InEventLoop);

                AbstractSocketChannel ch = this.Channel;

                try
                {
                    bool wasActive = !ch.ResetState(StateFlags.ActivationPending);
                    ch.DoFinishConnect(operation);
                    this.FulfillConnectPromise(wasActive);
                }
                catch (Exception ex)
                {
                    TaskCompletionSource promise       = ch.connectPromise;
                    EndPoint             remoteAddress = promise == null ? null : (EndPoint)promise.Task.AsyncState;
                    this.FulfillConnectPromise(this.AnnotateConnectException(ex, remoteAddress));
                }
                finally
                {
                    // Check for null as the connectTimeoutFuture is only created if a connectTimeoutMillis > 0 is used
                    // See https://github.com/netty/netty/issues/1770
                    if (ch.connectCancellation != null)
                    {
                        ch.connectCancellation.Cancel();
                    }
                    ch.connectPromise = null;
                }
            }
Example #3
0
        /// <remarks>PORT NOTE: matches behavior of NioEventLoop.processSelectedKey</remarks>
        static void OnIoCompleted(object sender, SocketAsyncEventArgs args)
        {
            var operation = (SocketChannelAsyncOperation)args;
            AbstractSocketChannel channel = operation.Channel;
            var        @unsafe            = (ISocketChannelUnsafe)channel.Unsafe;
            IEventLoop eventLoop          = channel.EventLoop;

            switch (args.LastOperation)
            {
            case SocketAsyncOperation.Accept:
                if (eventLoop.InEventLoop)
                {
                    @unsafe.FinishRead(operation);
                }
                else
                {
                    eventLoop.Execute(ReadCallbackAction, @unsafe, operation);
                }
                break;

            case SocketAsyncOperation.Connect:
                if (eventLoop.InEventLoop)
                {
                    @unsafe.FinishConnect(operation);
                }
                else
                {
                    eventLoop.Execute(ConnectCallbackAction, @unsafe, operation);
                }
                break;

            case SocketAsyncOperation.Receive:
            case SocketAsyncOperation.ReceiveFrom:
                if (eventLoop.InEventLoop)
                {
                    @unsafe.FinishRead(operation);
                }
                else
                {
                    eventLoop.Execute(ReadCallbackAction, @unsafe, operation);
                }
                break;

            case SocketAsyncOperation.Send:
            case SocketAsyncOperation.SendTo:
                if (eventLoop.InEventLoop)
                {
                    @unsafe.FinishWrite(operation);
                }
                else
                {
                    eventLoop.Execute(WriteCallbackAction, @unsafe, operation);
                }
                break;

            default:
                // todo: think of a better way to comm exception
                throw new ArgumentException("The last operation completed on the socket was not expected");
            }
        }
        public SocketChannelAsyncOperation(AbstractSocketChannel channel, bool setEmptyBuffer)
        {
            Contract.Requires(channel != null);

            this.Channel = channel;
            this.Completed += AbstractSocketChannel.IoCompletedCallback;
            if (setEmptyBuffer)
            {
                this.SetBuffer(ArrayExtensions.ZeroBytes, 0, 0);
            }
        }
        public SocketChannelAsyncOperation(AbstractSocketChannel channel, bool setEmptyBuffer)
        {
            Contract.Requires(channel != null);

            this.Channel    = channel;
            this.Completed += AbstractSocketChannel.IoCompletedCallback;
            if (setEmptyBuffer)
            {
                this.SetBuffer(ArrayExtensions.ZeroBytes, 0, 0);
            }
        }
Example #6
0
            public sealed override Task ConnectAsync(EndPoint remoteAddress, EndPoint localAddress)
            {
                // todo: handle cancellation
                AbstractSocketChannel ch = this.Channel;

                if (!ch.Open)
                {
                    return(this.CreateClosedChannelExceptionTask());
                }

                try
                {
                    if (ch.connectPromise != null)
                    {
                        throw new InvalidOperationException("connection attempt already made");
                    }

                    bool wasActive = this.channel.Active;
                    if (ch.DoConnect(remoteAddress, localAddress))
                    {
                        this.FulfillConnectPromise(wasActive);
                        return(TaskEx.Completed);
                    }
                    else
                    {
                        ch.connectPromise = new TaskCompletionSource(remoteAddress);

                        // Schedule connect timeout.
                        TimeSpan connectTimeout = ch.Configuration.ConnectTimeout;
                        if (connectTimeout > TimeSpan.Zero)
                        {
                            ch.connectCancellationTask = ch.EventLoop.Schedule(
                                (c, a) =>
                            {
                                // todo: make static / cache delegate?..
                                var self = (AbstractSocketChannel)c;
                                // todo: call Socket.CancelConnectAsync(...)
                                TaskCompletionSource promise = self.connectPromise;
                                var cause = new ConnectTimeoutException("connection timed out: " + a.ToString());
                                if (promise != null && promise.TrySetException(cause))
                                {
                                    self.CloseAsync();
                                }
                            },
                                this.channel,
                                remoteAddress,
                                connectTimeout);
                        }

                        ch.connectPromise.Task.ContinueWith(
                            (t, s) =>
                        {
                            var c = (AbstractSocketChannel)s;
                            c.connectCancellationTask?.Cancel();
                            c.connectPromise = null;
                            c.CloseAsync();
                        },
                            ch,
                            TaskContinuationOptions.OnlyOnCanceled | TaskContinuationOptions.ExecuteSynchronously);

                        return(ch.connectPromise.Task);
                    }
                }
                catch (Exception ex)
                {
                    this.CloseIfClosed();
                    return(TaskEx.FromException(this.AnnotateConnectException(ex, remoteAddress)));
                }
            }
Example #7
0
 protected AbstractSocketUnsafe(AbstractSocketChannel channel)
     : base(channel)
 {
 }
 protected AbstractSocketUnsafe(AbstractSocketChannel channel)
     : base(channel)
 {
 }
 public SocketChannelAsyncOperation(AbstractSocketChannel channel)
     : this(channel, true)
 {
 }
 public SocketChannelAsyncOperation(AbstractSocketChannel channel)
     : this(channel, true)
 {
 }