Synnefo » Pithos MS Client

using System;

using System.Collections.Concurrent;

using System.Collections.Generic;

using System.Diagnostics.Contracts;

using System.Linq;

using System.Text;

using System.Threading;

using System.Threading.Tasks;

namespace Pithos.Core

{

    public class Agent<TMessage> : IDisposable

    {        

        private readonly BlockingCollection<TMessage> _messages = new BlockingCollection<TMessage>();

        private readonly CancellationTokenSource _cancelSource = new CancellationTokenSource();

        public CancellationToken CancellationToken;

        private readonly Action<Agent<TMessage>> _process;

        public Agent(Action<Agent<TMessage>> action)

        {

            _process = action;

            CancellationToken = _cancelSource.Token;

        }

        public void Post(TMessage message)

        {

            _messages.Add(message);

        }

        /// <summary>

        /// Receives a message asynchronously, optionally with a timeout. Receive throws a TimeoutException if the timeout expires

        /// </summary>

        /// <param name="timeout">Optional timeout in milliseconds. If provided, Receive fails with a TimeoutException if no message is available in the specified time</param>

        /// <returns>A Task that will return the message asynchronously</returns>

        public Task<TMessage> Receive(int timeout = -1)

        {

            return Task<TMessage>.Factory.StartNew(() =>

            {

                TMessage item;

                if (!_messages.TryTake(out item, timeout, CancellationToken))

                    throw new TimeoutException();

                return item;

            });

        }

        /// <summary>

        /// Receives a message asynchronously, optionally with a timeout. TryReceive returns an empty task if the timeout expires

        /// </summary>

        /// <param name="timeout">Optional timeout in milliseconds. If provided, Receive returns an empty task</param>

        /// <returns>A Task that will return the message asynchronously</returns>

        public Task<TMessage> TryReceive(int timeout = -1)

        {

            return Task<TMessage>.Factory.StartNew(() =>

            {

                TMessage item;

                _messages.TryTake(out item, timeout, CancellationToken);

                return item;

            });

        }

        /// <summary>

        /// Start the agent

        /// </summary>

        public void Start()

        {

            Task.Factory.StartNew(() => _process(this), CancellationToken);            

        }

        /// <summary>

        /// Create and start a new agent for the specified type of message

        /// </summary>

        /// <param name="action">The message processing action</param>

        /// <returns>A started Agent</returns>

        public static Agent<TMessage> Start(Action<Agent<TMessage>> action)

        {

            var agent = new Agent<TMessage>(action);

            agent.Start();

            return agent;

        }

        /// <summary>

        /// Stops the agent 

        /// </summary>

        public void Stop()

        {

            //Stop the message queue

            _messages.CompleteAdding();

            //And signal the cancellation

            _cancelSource.Cancel();

        }

        /// <summary>

        /// Execute an action asynchronously, using the agent's cancellation source

        /// </summary>

        /// <param name="action">The action to execute</param>

        public void DoAsync(Action action)

        {

            Contract.Requires(action!=null);

            Task.Factory.StartNew(action, CancellationToken);

        }

        ~Agent()

        {

            Dispose(false);

        }

        public void Dispose()

        {

            Dispose(true);

            GC.SuppressFinalize(this);

        }

        protected void Dispose(bool disposing)

        {

            if (disposing)

            {

                Stop();

                _messages.Dispose();

                _cancelSource.Dispose();

            }

        }

        public IEnumerable<TMessage> GetEnumerable()

        {

            return _messages;

        }

        public Task LoopAsync(Task process, Action loop,Action<Exception> onError=null)

        {

            Contract.Requires(process!=null);

            Contract.Requires(loop!=null);

            return process.ContinueWith(t =>

            {   

                Task.Factory.StartNew(loop, CancellationToken);

                if (t.IsFaulted)

                {

                    var ex = t.Exception.InnerException;

                    if (ex is OperationCanceledException)

                        Stop();

                    if (onError != null)

                        onError(ex);

                }

            },CancellationToken);

        }

        public Task<T> LoopAsync<T>(Task<T> process, Action loop,Action<Exception> onError=null)

        {

            return process.ContinueWith(t =>

            {   

                //Spawn the Loop immediatelly

                Task.Factory.StartNew(loop,CancellationToken);

                //Then process possible exceptions

                if (t.IsFaulted)

                {

                    var ex = t.Exception.InnerException;

                    if (ex is OperationCanceledException)

                        Stop();

                    if (onError != null)

                        onError(ex);

                }

                return default(T);

            },CancellationToken);

        }

    }

}