예제 #1
0
        /// <summary>
        /// Marks this operation as timed-out, callbacks with the exception
        /// and sets a handler when the response is received
        /// </summary>
        public bool SetTimedOut(OperationTimedOutException ex, Action onReceive)
        {
            var callback = _callback;

            //When the data is received, invoke on receive callback
            _callback = (_, __) => onReceive();
            //Set the _callback first, as the Invoke method does not check previous state
            Thread.MemoryBarrier();
            var previousState = Interlocked.Exchange(ref _state, StateTimedout);

            switch (previousState)
            {
            case StateInit:
                //Call the original callback
                Task.Factory.StartNew(() => callback(ex, null), CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default);
                return(true);

            case StateCompleted:
                //it arrived while changing the state
                //Invoke on receive
                _callback = Noop;
                //it hasn't actually timed out
                return(false);
            }
            //For cancelled, do not invoke the previous
            return(true);
        }
예제 #2
0
        private void OnTimeout(OperationState state)
        {
            var ex = new OperationTimedOutException(Address, Configuration.SocketOptions.ReadTimeoutMillis);
            //Invoke if it hasn't been invoked yet
            //Once the response is obtained, we decrement the timed out counter
            var timedout = state.SetTimedOut(ex, () => Interlocked.Decrement(ref _timedOutOperations));

            if (!timedout)
            {
                //The response was obtained since the timer elapsed, move on
                return;
            }
            //Increase timed-out counter
            Interlocked.Increment(ref _timedOutOperations);
        }
예제 #3
0
        /// <summary>
        /// Marks this operation as timed-out, callbacks with the exception
        /// and sets a handler when the response is received
        /// </summary>
        public bool SetTimedOut(OperationTimedOutException ex, Action onReceive)
        {
            var previousState = Interlocked.CompareExchange(ref _state, StateTimedout, StateInit);

            if (previousState != StateInit)
            {
                return(false);
            }
            //When the data is received, invoke on receive callback
            var callback = Interlocked.Exchange(ref _callback, (_, __) => onReceive());

            Thread.MemoryBarrier();
            _timeoutCallbackSet = true;
            Task.Factory.StartNew(() => callback(ex, null), CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default);
            return(true);
        }
예제 #4
0
        /// <summary>
        /// Marks this operation as timed-out, callbacks with the exception
        /// and sets a handler when the response is received
        /// </summary>
        public bool MarkAsTimedOut(OperationTimedOutException ex, Action onReceive, long timestamp)
        {
            var previousState = Interlocked.CompareExchange(ref _state, StateTimedout, StateInit);

            if (previousState != StateInit)
            {
                return(false);
            }
            //When the data is received, invoke on receive callback
            var callback = Interlocked.Exchange(ref _callback, (_, __, ___) => onReceive());

#if !NETCORE
            Thread.MemoryBarrier();
#else
            Interlocked.MemoryBarrier();
#endif
            _timeoutCallbackSet = true;
            Task.Factory.StartNew(() => callback(RequestError.CreateClientError(ex, false), null, timestamp), CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default);
            return(true);
        }
예제 #5
0
 private void OnTimeout(object stateObj)
 {
     var streamId = (short)stateObj;
     OperationState state;
     if (!_pendingOperations.TryGetValue(streamId, out state))
     {
         return;
     }
     var ex = new OperationTimedOutException(Address, Configuration.SocketOptions.ReadTimeoutMillis);
     //Invoke if it hasn't been invoked yet
     //Once the response is obtained, we decrement the timed out counter
     var timedout = state.SetTimedOut(ex, () => Interlocked.Decrement(ref _timedOutOperations) );
     if (!timedout)
     {
         //The response was obtained since the timer elapsed, move on
         return;
     }
     //Increase timed-out counter
     Interlocked.Increment(ref _timedOutOperations);
 }
예제 #6
0
 private void OnTimeout(OperationState state)
 {
     var ex = new OperationTimedOutException(Address, Configuration.SocketOptions.ReadTimeoutMillis);
     //Invoke if it hasn't been invoked yet
     //Once the response is obtained, we decrement the timed out counter
     var timedout = state.SetTimedOut(ex, () => Interlocked.Decrement(ref _timedOutOperations) );
     if (!timedout)
     {
         //The response was obtained since the timer elapsed, move on
         return;
     }
     //Increase timed-out counter
     Interlocked.Increment(ref _timedOutOperations);
 }
예제 #7
0
 private void OnTimeout(object stateObj)
 {
     var streamId = (short)stateObj;
     OperationState state;
     if (!_pendingOperations.TryGetValue(streamId, out state))
     {
         return;
     }
     var ex = new OperationTimedOutException(Address, Configuration.SocketOptions.ReadTimeoutMillis);
     //Invoke if it hasn't been invoked yet
     //Once the response is obtained, we decrement the timed out counter
     var timedout = state.SetTimedOut(ex, () => Interlocked.Decrement(ref _timedOutOperations) );
     if (!timedout)
     {
         //The response was obtained since the timer elapsed, move on
         return;
     }
     //Increase timed-out counter
     Interlocked.Increment(ref _timedOutOperations);
 }
예제 #8
0
 /// <summary>
 /// Marks this operation as timed-out, callbacks with the exception 
 /// and sets a handler when the response is received
 /// </summary>
 public bool SetTimedOut(OperationTimedOutException ex, Action onReceive)
 {
     var callback = _callback;
     //When the data is received, invoke on receive callback
     _callback = (_, __) => onReceive();
     //Set the _callback first, as the Invoke method does not check previous state
     Thread.MemoryBarrier();
     var previousState = Interlocked.Exchange(ref _state, StateTimedout);
     switch (previousState)
     {
         case StateInit:
             //Call the original callback
             Task.Factory.StartNew(() => callback(ex, null), CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default);
             return true;
         case StateCompleted:
             //it arrived while changing the state
             //Invoke on receive
             _callback = Noop;
             //it hasn't actually timed out
             return false;
     }
     //For cancelled, do not invoke the previous
     return true;
 }
예제 #9
0
 /// <summary>
 /// Marks this operation as timed-out, callbacks with the exception 
 /// and sets a handler when the response is received
 /// </summary>
 public bool SetTimedOut(OperationTimedOutException ex, Action onReceive)
 {
     var previousState = Interlocked.CompareExchange(ref _state, StateTimedout, StateInit);
     if (previousState != StateInit)
     {
         return false;
     }
     //When the data is received, invoke on receive callback
     var callback = Interlocked.Exchange(ref _callback, (_, __) => onReceive()); 
     Thread.MemoryBarrier();
     _timeoutCallbackSet = true;
     Task.Factory.StartNew(() => callback(ex, null), CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default);
     return true;
 }