Esempio n. 1
0
        public int InvokeAsyncRequest(OutgoingAsync outAsync, bool synchronous)
        {
            //
            // Increase the direct count to prevent the thread pool from being destroyed before
            // invokeAll is called. This will also throw if the object adapter has been deactivated.
            //
            _adapter.IncDirectCount();

            int requestId = 0;

            try
            {
                lock (this)
                {
                    outAsync.Cancelable(this); // This will throw if the request is canceled

                    if (!outAsync.IsOneway)
                    {
                        requestId = ++_requestId;
                        _asyncRequests.Add(requestId, outAsync);
                    }

                    _sendAsyncRequests.Add(outAsync, requestId);
                }
            }
            catch (System.Exception)
            {
                _adapter.DecDirectCount();
                throw;
            }

            outAsync.AttachCollocatedObserver(_adapter, requestId);
            if (!synchronous || outAsync.IsOneway || _reference.InvocationTimeout > 0)
            {
                // Don't invoke from the user thread if async or invocation timeout is set
                // TODO: why is oneway included in this list?
                _adapter.ThreadPool.Dispatch(
                    () =>
                {
                    if (SentAsync(outAsync))
                    {
                        Debug.Assert(outAsync.RequestFrame != null);
                        ValueTask vt = InvokeAllAsync(outAsync.RequestFrame, requestId);
                        // TODO: do something with the value task
                    }
                });
            }
            else // Optimization: directly call invokeAll
            {
                if (SentAsync(outAsync))
                {
                    Debug.Assert(outAsync.RequestFrame != null);
                    ValueTask vt = InvokeAllAsync(outAsync.RequestFrame, requestId);
                    // TODO: do something with the value task
                }
            }
            return(OutgoingAsyncBase.AsyncStatusQueued);
        }
Esempio n. 2
0
 public void add(OutgoingAsync outAsync, int interval)
 {
     lock (this)
     {
         RetryTask task = new RetryTask(this, outAsync);
         _instance.timer().schedule(task, interval);
         _requests.Add(task, null);
     }
 }
Esempio n. 3
0
 public bool sendAsyncRequest(OutgoingAsync @out, out Ice.AsyncCallback sentCallback)
 {
     _m.Lock();
     try
     {
         if (!initialized())
         {
             _requests.AddLast(new Request(@out));
             sentCallback = null;
             return(false);
         }
     }
     finally
     {
         _m.Unlock();
     }
     return(_connection.sendAsyncRequest(@out, _compress, _response, out sentCallback));
 }
Esempio n. 4
0
 public void asyncRequestCanceled(OutgoingAsyncBase outAsync, Ice.LocalException ex)
 {
     lock (this)
     {
         int requestId;
         if (_sendAsyncRequests.TryGetValue(outAsync, out requestId))
         {
             if (requestId > 0)
             {
                 _asyncRequests.Remove(requestId);
             }
             _sendAsyncRequests.Remove(outAsync);
             Ice.AsyncCallback cb = outAsync.completed(ex);
             if (cb != null)
             {
                 outAsync.invokeCompletedAsync(cb);
             }
             _adapter.decDirectCount(); // invokeAll won't be called, decrease the direct count.
             return;
         }
         if (outAsync is OutgoingAsync)
         {
             OutgoingAsync o = (OutgoingAsync)outAsync;
             Debug.Assert(o != null);
             foreach (KeyValuePair <int, OutgoingAsyncBase> e in _asyncRequests)
             {
                 if (e.Value == o)
                 {
                     _asyncRequests.Remove(e.Key);
                     Ice.AsyncCallback cb = outAsync.completed(ex);
                     if (cb != null)
                     {
                         outAsync.invokeCompletedAsync(cb);
                     }
                     return;
                 }
             }
         }
     }
 }
Esempio n. 5
0
 public RetryTask(RetryQueue retryQueue, OutgoingAsync outAsync)
 {
     _retryQueue = retryQueue;
     _outAsync   = outAsync;
 }
Esempio n. 6
0
 internal Request(OutgoingAsync @out)
 {
     this.@out = @out;
 }
Esempio n. 7
0
 public bool sendAsyncRequest(OutgoingAsync @out, out Ice.AsyncCallback sentCallback)
 {
     return(_connection.sendAsyncRequest(@out, _compress, _response, out sentCallback));
 }