/// <summary>
        /// see RepeatTemplate#WaitForResults
        /// </summary>
        /// <param name="state"></param>
        /// <returns></returns>
        protected override bool WaitForResults(IRepeatInternalState state)
        {
            IResultQueue <IResultHolder> queue = ((ResultQueueInternalState)state).ResultQueue;
            bool result = true;

            while (queue.IsExpecting())
            {
                // Careful that no runnables that are not going to finish ever get
                // onto the queue, else this may block forever.
                IResultHolder future;
                try
                {
                    future = queue.Take();
                }
                catch (ThreadInterruptedException)
                {
                    Thread.CurrentThread.Interrupt();
                    throw new RepeatException("InterruptedException while waiting for result.");
                }

                if (future.Error != null)
                {
                    state.GetExceptions().Add(future.Error);
                    result = false;
                }
                else
                {
                    RepeatStatus status = future.Result;
                    result = result && CanContinue(status);
                    ExecuteAfterInterceptors(future.Context, status);
                }
            }
            Assert.State(queue.IsEmpty(), "Future results queue should be empty at end of batch.");
            return(result);
        }
 /// <summary>
 /// see https://msdn.microsoft.com/fr-fr/library/ms244737.aspx
 /// </summary>
 /// <param name="disposing"></param>
 private void Dispose(bool disposing)
 {
     if (disposing && _results != null)
     {
         // free managed resources
         ((ResultHolderResultQueue)_results).Dispose();
         _results = null;
     }
 }
Пример #3
0
        /// <summary>
        /// Initialize the client with a DDPConnector, subscriber and ResultQueue.
        /// This shouldnt be user facing, but is necessary in the concrete classes.
        /// </summary>
        /// <returns>The init.</returns>
        /// <param name="connector">Connector for sending DDP Messages</param>
        /// <param name="subscriber">Subscriber for subscribing to DDP Messages</param>
        /// <param name="queue">Message queue</param>
        protected void Init(IDDPConnector connector, IDataSubscriber subscriber, IResultQueue queue)
        {
            this._connector    = connector;
            this._subscriber   = subscriber;
            this._queueHandler = queue;

            _subscriber.MessageReceived += (msg) =>
            {
                if (MessageReceived != null)
                {
                    MessageReceived(msg);
                }
            };
        }
        /// <summary>
        /// Use the TaskExecutor to generate a result. The
        /// internal state in this case is a queue of unfinished result holders of
        /// IResultHolder. The holder with the return value should not be
        /// on the queue when this method exits. The queue is scoped in the calling
        /// method so there is no need to synchronize access.
        /// </summary>
        /// <param name="context"></param>
        /// <param name="callback"></param>
        /// <param name="state"></param>
        /// <returns></returns>
        protected override RepeatStatus GetNextResult(IRepeatContext context, RepeatCallback callback,
                                                      IRepeatInternalState state)
        {
            ExecutingRunnable            runnable;
            IResultQueue <IResultHolder> queue = ((ResultQueueInternalState)state).ResultQueue;

            do
            {
                // Wrap the callback in a runnable that will add its result to the
                // queue when it is ready.
                runnable = new ExecutingRunnable(callback, context, queue);

                // Tell the runnable that it can expect a result. This could have
                // been in-lined with the constructor, but it might block, so it's
                // better to do it here, since we have the option (it's a private
                // class).
                runnable.Expect();

                //Start the task possibly concurrently / in the future.
                _taskExecutor.Execute(new Task(delegate { runnable.Run(); }));

                // Allow termination policy to update its state. This must happen
                // immediately before or after the call to the task executor.
                Update(context);

                // Keep going until we get a result that is finished, or early
                // termination...
            }while (queue.IsEmpty() && !IsComplete(context));

            IResultHolder result = queue.Take();

            if (result.Error != null)
            {
                throw result.Error;
            }
            return(result.Result);
        }
            /// <summary>
            /// see https://msdn.microsoft.com/fr-fr/library/ms244737.aspx
            /// </summary>
            /// <param name="disposing"></param>
            private void Dispose(bool disposing)
            {
                if (disposing && _results != null)
                {
                    // free managed resources
                    ((ResultHolderResultQueue)_results).Dispose();
                    _results = null;

                }
            }
 /// <summary>
 /// 
 /// </summary>
 /// <param name="throttleLimit"></param>
 public ResultQueueInternalState(int throttleLimit)
 {
     _results = new ResultHolderResultQueue(throttleLimit);
 }
 public ExecutingRunnable(RepeatCallback callback, IRepeatContext context, IResultQueue<IResultHolder> queue)
 {
     _callback = callback;
     Context = context;
     _queue = queue;
 }
Пример #8
0
 public ClientThread(IResultQueue requestQueue, string name, int seed)
 {
     Thread.CurrentThread.Name = name;
     _requestQueue             = requestQueue;
     _random = new Random(seed);
 }
 /// <summary>
 ///
 /// </summary>
 /// <param name="throttleLimit"></param>
 public ResultQueueInternalState(int throttleLimit)
 {
     _results = new ResultHolderResultQueue(throttleLimit);
 }
 public ExecutingRunnable(RepeatCallback callback, IRepeatContext context, IResultQueue <IResultHolder> queue)
 {
     _callback = callback;
     Context   = context;
     _queue    = queue;
 }