Synnefo » Pithos MS Client

// -----------------------------------------------------------------------

// <copyright file="PithosClient.cs" company="Microsoft">

// TODO: Update copyright text.

// </copyright>

// -----------------------------------------------------------------------

using System.Collections.Specialized;

using System.Diagnostics;

using System.Diagnostics.Contracts;

using System.IO;

using System.Net;

using System.Runtime.Serialization;

using System.Threading.Tasks;

namespace Pithos.Network

{

    using System;

    using System.Collections.Generic;

    using System.Linq;

    using System.Text;

    /// <summary>

    /// TODO: Update summary.

    /// </summary>

    public class PithosClient:WebClient

    {

        public int Timeout { get; set; }

        public bool TimedOut { get; set; }

        public HttpStatusCode StatusCode { get; private set; }

        public string StatusDescription { get; set; }

        public int Retries { get; set; }

        private readonly Dictionary<string, string> _parameters=new Dictionary<string, string>();

        public Dictionary<string, string> Parameters

        {

            get { return _parameters; }            

        }

        public PithosClient():base()

        {

        }

        public PithosClient(PithosClient other)

            : base()

        {

            CopyHeaders(other);

            Timeout = other.Timeout;

            Retries = other.Retries;

            BaseAddress = other.BaseAddress;             

            foreach (var parameter in other.Parameters)

            {

                Parameters.Add(parameter.Key,parameter.Value);

            }

            this.Proxy = other.Proxy;

        }

        protected override WebRequest GetWebRequest(Uri address)

        {

            TimedOut = false;

            HttpWebRequest request = base.GetWebRequest(address) as HttpWebRequest;

            request.AutomaticDecompression = DecompressionMethods.Deflate | DecompressionMethods.GZip;

            if(Timeout>0)

                request.Timeout = Timeout;

            return request; 

        }

        protected override WebResponse GetWebResponse(WebRequest request, IAsyncResult result)

        {

            var response = (HttpWebResponse) base.GetWebResponse(request, result);

            StatusCode=response.StatusCode;

            StatusDescription=response.StatusDescription;

            return response;

        }

        protected override WebResponse GetWebResponse(WebRequest request)

        {

            try

            {

            var response = (HttpWebResponse)base.GetWebResponse(request);

            StatusCode = response.StatusCode;

            StatusDescription = response.StatusDescription;

            return response;

            }

            catch (WebException exc)

            {

                if (exc.Response!=null && exc.Response.ContentLength > 0)

                {

                    string content = GetContent(exc.Response);

                    Trace.TraceError(content);

                }

                throw;

            }

        }

        private static string GetContent(WebResponse webResponse)

        {

            string content;

            using (var stream = webResponse.GetResponseStream())

            using (var reader = new StreamReader(stream))

            {

                content = reader.ReadToEnd();

            }

            return content;

        }

        public string DownloadStringWithRetry(string address,int retries=0)

        {

            if (address == null)

                throw new ArgumentNullException("address");

            var actualAddress = GetActualAddress(address);

            TraceStart("GET",actualAddress);            

            var actualRetries = (retries == 0) ? Retries : retries;

            var task = Retry(() =>

            {

                var uriString = String.Join("/", BaseAddress, actualAddress);

                var content = base.DownloadString(uriString);

                if (StatusCode == HttpStatusCode.NoContent)

                    return String.Empty;

                return content;

            }, actualRetries);

            var result = task.Result;

            return result;

        }

        public void Head(string address,int retries=0)

        {

            RetryWithoutContent(address, retries, "HEAD");

        }

        public void PutWithRetry(string address, int retries = 0)

        {

            RetryWithoutContent(address, retries, "PUT");

        }

        public void DeleteWithRetry(string address,int retries=0)

        {

            RetryWithoutContent(address, retries, "DELETE");

        }

        public string GetHeaderValue(string headerName)

        {

            var values=this.ResponseHeaders.GetValues(headerName);

            if (values == null)

                throw new WebException(String.Format("The {0}  header is missing", headerName));

            else

                return values[0];

        }

        private void RetryWithoutContent(string address, int retries, string method)

        {

            if (address == null)

                throw new ArgumentNullException("address");

            var actualAddress = GetActualAddress(address);            

            var actualRetries = (retries == 0) ? Retries : retries;

            var task = Retry(() =>

            {

                var uriString = String.Join("/",BaseAddress ,actualAddress);

                var uri = new Uri(uriString);

                var request =  GetWebRequest(uri);

                request.Method = method;

                if (ResponseHeaders!=null)

                    ResponseHeaders.Clear();

                TraceStart(method, uriString);

                var response = (HttpWebResponse)GetWebResponse(request);

                StatusCode = response.StatusCode;

                StatusDescription = response.StatusDescription;                

                return 0;

            }, actualRetries);

            task.Wait();

        }

        private static void TraceStart(string method, string actualAddress)

        {

            Trace.WriteLine(String.Format("[{0}] {1} {2}", method, DateTime.Now, actualAddress));

        }

        private string GetActualAddress(string address)

        {

            if (Parameters.Count == 0)

                return address;

            var addressBuilder=new StringBuilder(address);            

            bool isFirst = true;

            foreach (var parameter in Parameters)

            {

                if(isFirst)

                    addressBuilder.AppendFormat("?{0}={1}", parameter.Key, parameter.Value);

                else

                    addressBuilder.AppendFormat("&{0}={1}", parameter.Key, parameter.Value);

                isFirst = false;

            }

            return addressBuilder.ToString();

        }

        public string DownloadStringWithRetry(Uri address,int retries=0)

        {

            if (address == null)

                throw new ArgumentNullException("address");

            var actualRetries = (retries == 0) ? Retries : retries;            

            var task = Retry(() =>

            {

                var content = base.DownloadString(address);

                if (StatusCode == HttpStatusCode.NoContent)

                    return String.Empty;

                return content;

            }, actualRetries);

            var result = task.Result;

            return result;

        }

        /// <summary>

        /// Copies headers from another PithosClient

        /// </summary>

        /// <param name="source">The PithosClient from which the headers are copied</param>

        public void CopyHeaders(PithosClient source)

        {

            Contract.Requires(source != null, "source can't be null");

            if (source == null)

                throw new ArgumentNullException("source", "source can't be null");

            CopyHeaders(source.Headers,Headers);

        }

        /// <summary>

        /// Copies headers from one header collection to another

        /// </summary>

        /// <param name="source">The source collection from which the headers are copied</param>

        /// <param name="target">The target collection to which the headers are copied</param>

        public static void CopyHeaders(WebHeaderCollection source,WebHeaderCollection target)

        {

            Contract.Requires(source != null, "source can't be null");

            Contract.Requires(target != null, "target can't be null");

            if (source == null)

                throw new ArgumentNullException("source", "source can't be null");

            if (target == null)

                throw new ArgumentNullException("target", "target can't be null");

            for (int i = 0; i < source.Count; i++)

            {

                target.Add(source.GetKey(i), source[i]);

            }            

        }

        public void AssertStatusOK(string message)

        {

            if (StatusCode >= HttpStatusCode.BadRequest)

                throw new WebException(String.Format("{0} with code {1} - {2}", message, StatusCode, StatusDescription));

        }

        /*private Func<T> Retry<T>(Func< T> original, int retryCount)

        {

            return () =>

            {

                while (true)

                {

                    try

                    {

                        return original();

                    }

                    catch (WebException e)

                    {

                        var statusCode = ((HttpWebResponse)e.Response).StatusCode;

                        this.StatusCode = statusCode;

                        switch (e.Status)

                        {

                            case WebExceptionStatus.Timeout:

                                TimedOut = true;

                                if (retryCount == 0)

                                {

                                    Trace.TraceError("[ERROR] Timed out too many times. {0}\n", e);

                                    throw new RetryException("Timed out too many times.", e);

                                }

                                retryCount--;

                                Trace.TraceError(

                                    "[RETRY] Timed out after {0} ms. Will retry {1} more times\n{2}", Timeout,

                                    retryCount, e);

                                break;

                            case WebExceptionStatus.ProtocolError:

                                switch (statusCode)

                                {

                                    case HttpStatusCode.NotFound:

                                        {

                                            return default(T);

                                        }

                                    case HttpStatusCode.ServiceUnavailable:

                                        {

                                            TimedOut = false;

                                            if (retryCount == 0)

                                            {

                                                Trace.TraceError("[ERROR] Failed too many times. {0}\n", e);

                                                throw new RetryException("Failed too many times.", e);

                                            }

                                            retryCount--;

                                            Trace.TraceError(

                                                "[RETRY] Failed due to 503. Will retry {0} more times\n{1}", retryCount, e);

                                            break;

                                        }

                                    default:

                                        throw;

                                }

                                break;

                            default:

                                throw;

                        }

                    }

                }

            };

        }*/

        private Task<T> Retry<T>(Func< T> original, int retryCount)

        {

            return Task.Factory.StartNew(() => original()).ContinueWith(_original =>

                {

                    if(_original.IsFaulted )

                    {

                        var e = _original.Exception.InnerException;

                        if (e is WebException)

                        {

                            var we = (e as WebException);

                            var statusCode = HttpStatusCode.RequestTimeout;

                            if (we.Response != null)

                            {                                

                                statusCode = ((HttpWebResponse) we.Response).StatusCode;

                                this.StatusCode = statusCode;

                            }

                            if (we.Status==WebExceptionStatus.Timeout || 

                                (we.Status==WebExceptionStatus.ProtocolError && statusCode==HttpStatusCode.ServiceUnavailable))

                            {

                                TimedOut = true;

                                if (retryCount == 0)

                                {

                                    Trace.TraceError("[ERROR] Timed out too many times. {0}\n", e);

                                    throw new RetryException("Timed out too many times.", e);

                                }

                                Trace.TraceError(

                                    "[RETRY] Timed out after {0} ms. Will retry {1} more times\n{2}", Timeout,

                                    retryCount, e);

                                return Retry(original, retryCount - 1);

                            }

                            if (statusCode==HttpStatusCode.NotFound)

                                return Task<T>.Factory.StartNew(() => default(T));                            

                        }

                        throw e;

                    }

                    else                    

                        return Task<T>.Factory.StartNew(() => _original.Result);

                }).Unwrap();

        }

    }

    public class RetryException:Exception

    {

        public RetryException()

            :base()

        {

        }

        public RetryException(string message)

            :base(message)

        {

        }

        public RetryException(string message,Exception innerException)

            :base(message,innerException)

        {

        }

        public RetryException(SerializationInfo info,StreamingContext context)

            :base(info,context)

        {

        }

    }

}