/trunk/Pithos.Network/CloudFilesClient.cs - Diff - Pithos MS Client - Greek Research and Technology Network's projects

Revision 4d301e8e trunk/Pithos.Network/CloudFilesClient.cs

     using System.Security.Cryptography;
     using System.Text;
     using System.Threading.Tasks;
     using Hammock;
     using Hammock.Caching;
     using Hammock.Retries;
     using Hammock.Serialization;
     using Hammock.Tasks;
     using Hammock.Web;
     using Newtonsoft.Json;
     using Pithos.Interfaces;
     using WebHeaderCollection = System.Net.WebHeaderCollection;
     namespace Pithos.Network
+    {
-...
         public class CloudFilesClient:ICloudClient
+        {
             private RestClient _client;
             private PithosClient _client;
             private readonly TimeSpan _shortTimeout = TimeSpan.FromSeconds(10);
             private readonly int _retries = 5;
             private RetryPolicy _retryPolicy;
             private readonly int _retries = 5;
             public string ApiKey { get; set; }
             public string UserName { get; set; }
             public Uri StorageUrl { get; set; }
-...
                 UserName = userName;
                 ApiKey = apiKey;
                 var proxy = Proxy != null ? Proxy.ToString() : null;
                 if (UsePithos)
+                {
                     Token = ApiKey;
-...
+                {
                     string authUrl = String.Format("{0}/{1}", AuthenticationUrl, VersionPath);
                     var authClient = new RestClient {Path = authUrl, Proxy = proxy};
                     var authClient = new PithosClient{BaseAddress= authUrl};
                     if (Proxy != null)
                         authClient.Proxy = new WebProxy(Proxy);
                     authClient.AddHeader("X-Auth-User", UserName);
                     authClient.AddHeader("X-Auth-Key", ApiKey);
                     authClient.Headers.Add("X-Auth-User", UserName);
                     authClient.Headers.Add("X-Auth-Key", ApiKey);
                     var response = authClient.Request();
                     var response = authClient.DownloadStringWithRetry("",3);
                     ThrowIfNotStatusOK(response, "Authentication failed");
                     authClient.AssertStatusOK("Authentication failed");
                     var keys = response.Headers.AllKeys.AsQueryable();
                     //var keys = authClient.ResponseHeaders.AllKeys.AsQueryable();
                     string storageUrl = GetHeaderValue("X-Storage-Url", response, keys);
                     string storageUrl = authClient.GetHeaderValue("X-Storage-Url");
                     if (String.IsNullOrWhiteSpace(storageUrl))
                         throw new InvalidOperationException("Failed to obtain storage url");
                     StorageUrl = new Uri(storageUrl);
                     var token = GetHeaderValue("X-Auth-Token", response, keys);
                     var token = authClient.GetHeaderValue("X-Auth-Token");
                     if (String.IsNullOrWhiteSpace(token))
                         throw new InvalidOperationException("Failed to obtain token url");
                     Token = token;
+                }
                 _retryPolicy = new RetryPolicy { RetryCount = _retries };
                 _retryPolicy.RetryConditions.Add(new TimeoutRetryCondition());
                 /*_retryPolicy = new RetryPolicy { RetryCount = _retries };
                 _retryPolicy.RetryConditions.Add(new TimeoutRetryCondition());*/
                 _client = new RestClient { Authority = StorageUrl.AbsoluteUri, Path = UserName, Proxy = proxy };
                 _client.FileProgress += OnFileProgress;
                 _client = new PithosClient{
                     BaseAddress  = StorageUrl.AbsoluteUri,
                     Timeout=10000,
                     Retries=3};
                 if (Proxy!=null)
                     _client.Proxy = new WebProxy(Proxy);
                 //_client.FileProgress += OnFileProgress;
                 _client.AddHeader("X-Auth-Token", Token);
                 _client.Headers.Add("X-Auth-Token", Token);
                 /*if (UsePithos)
+                {
                     _client.AddHeader("X-Auth-User", UserName);
-...
                 Trace.TraceInformation("[AUTHENTICATE] End for {0}", userName);
+            }
             private void OnFileProgress(object sender, FileProgressEventArgs e)
            /* private void OnFileProgress(object sender, FileProgressEventArgs e)
+            {
                 Trace.TraceInformation("[PROGRESS] {0} {1:p} {2} of {3}",e.FileName,(double)e.BytesWritten/e.TotalBytes, e.BytesWritten,e.TotalBytes);
+            }
             }*/
             public IList<ContainerInfo> ListContainers()
+            {
-...
                 //appends a / unless a Path is specified.
                 //Create a request with a complete path
                 var request = new RestRequest { Path = StorageUrl.ToString(), RetryPolicy = _retryPolicy,Timeout = _shortTimeout };
                 request.AddParameter("format","json");
                 //var request = new RestRequest { Path = StorageUrl.ToString(), RetryPolicy = _retryPolicy,Timeout = _shortTimeout };
                 //request.AddParameter("format","json");
                 //Create a client clone
                 /*var url = String.Join("/", new[] { _client.Authority, StorageUrl.ToString() });
                 var builder=new UriBuilder(url);
                 builder.Query = "format=json";
                 var client= new PithosClient(_client){Timeout=10};   */
                 var content=_client.DownloadStringWithRetry("",3);
                 _client.Parameters.Clear();
                 _client.Parameters.Add("format", "json");
                 _client.AssertStatusOK("List Containers failed");
                 if (_client.StatusCode==HttpStatusCode.NoContent)
                     return new List<ContainerInfo>();
                 var infos = JsonConvert.DeserializeObject<IList<ContainerInfo>>(content);
                 return infos;
     /*
                 var client = new RestClient{Proxy=Proxy.ToString()};
                 foreach (var header in _client.GetAllHeaders())
+                {
                     client.AddHeader(header.Name,header.Value);
+                }
+                }
                 var response = client.Request(request);
-...
                 var infos=JsonConvert.DeserializeObject<IList<ContainerInfo>>(response.Content);
                 return infos;
                 return infos;*/
+            }
             public IList<ObjectInfo> ListObjects(string container)
-...
                 Trace.TraceInformation("[START] ListObjects");
                 var request = new RestRequest { Path = container, RetryPolicy = _retryPolicy, Timeout = TimeSpan.FromMinutes(1) };
                 request.AddParameter("format", "json");
                 var response = _client.Request(request);
                 var infos = InfosFromContent(response);
                 //var request = new RestRequest { Path = container, RetryPolicy = _retryPolicy, Timeout = TimeSpan.FromMinutes(1) };
                 //request.AddParameter("format", "json");
                 //var response = _client.Request(request);
     /*
                 var url = String.Join("/", new[] { _client.Authority, container });
                 var builder = new UriBuilder(url) {Query = "format=json"};
                 var client = new PithosClient(_client) { Timeout = 60000 };
     */
                 _client.Parameters.Clear();
                 _client.Parameters.Add("format", "json");
                 var content = _client.DownloadStringWithRetry(container, 3);
                 _client.AssertStatusOK("ListObjects failed");
                 var infos = JsonConvert.DeserializeObject<IList<ObjectInfo>>(content);
                 Trace.TraceInformation("[END] ListObjects");
                 return infos;
-...
                 Trace.TraceInformation("[START] ListObjects");
                 var request = new RestRequest { Path = container,RetryPolicy = _retryPolicy, Timeout = TimeSpan.FromMinutes(1) };
                /* var request = new RestRequest { Path = container,RetryPolicy = _retryPolicy, Timeout = TimeSpan.FromMinutes(1) };
                 request.AddParameter("format", "json");
                 request.AddParameter("path", folder);
                 var response = _client.Request(request);
                 request.AddParameter("path", folder);*/
                 _client.Parameters.Clear();
                 _client.Parameters.Add("format", "json");
                 _client.Parameters.Add("path", folder);
                 var content = _client.DownloadStringWithRetry(container, 3);
                 _client.AssertStatusOK("ListObjects failed");
                 var infos = JsonConvert.DeserializeObject<IList<ObjectInfo>>(content);
                /* var response = _client.Request(request);
                 var infos = InfosFromContent(response);
                 var infos = InfosFromContent(response);*/
                 Trace.TraceInformation("[END] ListObjects");
                 return infos;
+            }
             private static IList<ObjectInfo> InfosFromContent(RestResponse response)
      /*       private static IList<ObjectInfo> InfosFromContent(RestResponse response)
+            {
                 if (response.TimedOut)
                     return new List<ObjectInfo>();
-...
                 var infos = JsonConvert.DeserializeObject<IList<ObjectInfo>>(response.Content);
                 return infos;
+            }
     */
             public bool ContainerExists(string container)
+            {
                 if (String.IsNullOrWhiteSpace(container))
                     throw new ArgumentNullException("container", "The container property can't be empty");
                 var request = new RestRequest { Path = container, Method = WebMethod.Head, RetryPolicy = _retryPolicy,Timeout = _shortTimeout };
                 var response = _client.Request(request);
                 _client.Parameters.Clear();
                 _client.Head(container,3);
                 //var request = new RestRequest { Path = container, Method = WebMethod.Head, RetryPolicy = _retryPolicy,Timeout = _shortTimeout };
                 //var response = _client.Request(request);
                 switch(response.StatusCode)
                 switch (_client.StatusCode)
+                {
                     case HttpStatusCode.OK:
                     case HttpStatusCode.NoContent:
-...
                     case HttpStatusCode.NotFound:
                         return false;
                     default:
                         throw CreateWebException("ContainerExists",response.StatusCode);
                         throw CreateWebException("ContainerExists", _client.StatusCode);
+                }
+            }
-...
                     throw new ArgumentNullException("objectName", "The objectName property can't be empty");
     /*
                 var request = new RestRequest { Path = container + "/" + objectName, Method = WebMethod.Head,RetryPolicy = _retryPolicy, Timeout = _shortTimeout };
                 var response = _client.Request(request);
     */
                 _client.Parameters.Clear();
                 _client.Head(container + "/" + objectName, 3);
                 switch (response.StatusCode)
                 switch (_client.StatusCode)
+                {
                     case HttpStatusCode.OK:
                     case HttpStatusCode.NoContent:
-...
                     case HttpStatusCode.NotFound:
                         return false;
                     default:
                         throw CreateWebException("ObjectExists",response.StatusCode);
                         throw CreateWebException("ObjectExists", _client.StatusCode);
+                }
+            }
-...
                     throw new ArgumentNullException("objectName", "The objectName property can't be empty");
     /*
                 var request = new RestRequest { Path = container + "/" + objectName, Method = WebMethod.Head, RetryPolicy = _retryPolicy,Timeout = _shortTimeout };
                 var response = _client.Request(request);
     */
                 try
+                {
                     _client.Parameters.Clear();
                 if (response.TimedOut)
                     return ObjectInfo.Empty;
                     _client.Head(container + "/" + objectName, 3);
                 switch (response.StatusCode)
+                {
                     case HttpStatusCode.OK:
                     case HttpStatusCode.NoContent:
                         var keys = response.Headers.AllKeys.AsQueryable();
                         var tags=(from key in keys
                                  where key.StartsWith("X-Object-Meta-")
                                  let name=key.Substring(14)
                                  select new {Name=name,Value=response.Headers[name]})
                                  .ToDictionary(t=>t.Name,t=>t.Value);
                         var extensions = (from key in keys
                                           where key.StartsWith("X-Object-") && !key.StartsWith("X-Object-Meta-")
                                           let name = key.Substring(9)
                                           select new { Name = name, Value = response.Headers[name] })
                                  .ToDictionary(t => t.Name, t => t.Value);
                         return new ObjectInfo
+                                   {
                                        Name = objectName,
                                        Bytes = long.Parse(GetHeaderValue("Content-Length", response, keys)),
                                        Hash = GetHeaderValue("ETag", response, keys),
                                        Content_Type = GetHeaderValue("Content-Type", response, keys),
                                        Tags=tags,
                                        Extensions=extensions
                                    };
                     case HttpStatusCode.NotFound:
                     if (_client.TimedOut)
                         return ObjectInfo.Empty;
                     default:
                         if (request.RetryState.RepeatCount > 0)
+                        {
                             Trace.TraceWarning("[RETRY FAIL] GetObjectInfo for {0} failed after {1} retries",
                                                           objectName, request.RetryState.RepeatCount);
                     switch (_client.StatusCode)
+                    {
                         case HttpStatusCode.OK:
                         case HttpStatusCode.NoContent:
                             var keys = _client.ResponseHeaders.AllKeys.AsQueryable();
                             var tags = (from key in keys
                                         where key.StartsWith("X-Object-Meta-")
                                         let name = key.Substring(14)
                                         select new { Name = name, Value = _client.ResponseHeaders[name] })
                                 .ToDictionary(t => t.Name, t => t.Value);
                             var extensions = (from key in keys
                                               where key.StartsWith("X-Object-") && !key.StartsWith("X-Object-Meta-")
                                               let name = key.Substring(9)
                                               select new { Name = name, Value = _client.ResponseHeaders[name] })
                                 .ToDictionary(t => t.Name, t => t.Value);
                             return new ObjectInfo
+                                       {
                                            Name = objectName,
                                            Bytes =
                                                long.Parse(_client.GetHeaderValue("Content-Length")),
                                            Hash = _client.GetHeaderValue("ETag"),
                                            Content_Type = _client.GetHeaderValue("Content-Type"),
                                            Tags = tags,
                                            Extensions = extensions
                                        };
                         case HttpStatusCode.NotFound:
                             return ObjectInfo.Empty;
+                        }
                         if (response.InnerException != null)
                             throw new WebException(String.Format("[FAIL] GetObjectInfo for {0} failed with unexpected status code {1}", objectName, response.StatusCode), response.InnerException);
                         throw new WebException(String.Format("[FAIL] GetObjectInfo for {0} failed with unexpected status code {1}", objectName, response.StatusCode));
                         default:
                             throw new WebException(
                                 String.Format("[FAIL] GetObjectInfo for {0} failed with unexpected status code {1}",
                                               objectName, _client.StatusCode));
+                    }
+                }
                 catch (RetryException e)
+                {
                     Trace.TraceWarning("[RETRY FAIL] GetObjectInfo for {0} failed.");
                     return ObjectInfo.Empty;
+                }
                 catch (WebException e)
+                {
                     Trace.TraceError(String.Format("[FAIL] GetObjectInfo for {0} failed with unexpected status code {1}",
                                                   objectName, _client.StatusCode), e);
                     throw;
+                }
+            }
             public void CreateFolder(string container, string folder)
-...
                     throw new ArgumentNullException("folder", "The folder property can't be empty");
                 var folderUrl=String.Format("{0}/{1}",container,folder);
     /*
                 var request = new RestRequest { Path = folderUrl, Method = WebMethod.Put, RetryPolicy = _retryPolicy,Timeout = _shortTimeout };
                 request.AddHeader("Content-Type", @"application/directory");
                 request.AddHeader("Content-Length", "0");
     */
                 _client.Parameters.Clear();
                 _client.Headers.Add("Content-Type", @"application/directory");
                 _client.Headers.Add("Content-Length", "0");
                 _client.PutWithRetry(folderUrl,3);
                 var response = _client.Request(request);
                 if (response.StatusCode != HttpStatusCode.Created && response.StatusCode != HttpStatusCode.Accepted)
                     throw CreateWebException("CreateFolder", response.StatusCode);
                 if (_client.StatusCode != HttpStatusCode.Created && _client.StatusCode != HttpStatusCode.Accepted)
                     throw CreateWebException("CreateFolder", _client.StatusCode);
+            }
-...
                 if (String.IsNullOrWhiteSpace(container))
                     throw new ArgumentNullException("container", "The container property can't be empty");
     /*
                 var request = new RestRequest { Path = container, Method = WebMethod.Head, RetryPolicy = _retryPolicy,Timeout = _shortTimeout };
                 var response = _client.Request(request);
                 switch(response.StatusCode)
     */
                 _client.Head(container);
                 switch (_client.StatusCode)
+                {
                     case HttpStatusCode.NoContent:
                         var keys = response.Headers.AllKeys.AsQueryable();
                         var containerInfo = new ContainerInfo
+                                                {
                                                     Name = container,
                                                     Count =long.Parse(GetHeaderValue("X-Container-Object-Count", response, keys)),
                                                     Bytes =long.Parse(GetHeaderValue("X-Container-Bytes-Used", response, keys))
                                                     Count =long.Parse(_client.GetHeaderValue("X-Container-Object-Count")),
                                                     Bytes = long.Parse(_client.GetHeaderValue("X-Container-Bytes-Used"))
                                                 };
                         return containerInfo;
                     case HttpStatusCode.NotFound:
                         return ContainerInfo.Empty;
                     default:
                         throw CreateWebException("GetContainerInfo", response.StatusCode);
                         throw CreateWebException("GetContainerInfo", _client.StatusCode);
+                }
+            }
-...
                 if (String.IsNullOrWhiteSpace(container))
                     throw new ArgumentNullException("container", "The container property can't be empty");
                 var request = new RestRequest { Path = container, Method = WebMethod.Put, RetryPolicy = _retryPolicy,Timeout = _shortTimeout };
     /*
                 var request = new RestRequest { Path = container, Method = WebMethod.Put, RetryPolicy = _retryPolicy,Timeout = _shortTimeout };
                 var response = _client.Request(request);
     */
                 _client.PutWithRetry(container,3);
                 var expectedCodes = new[]{HttpStatusCode.Created ,HttpStatusCode.Accepted , HttpStatusCode.OK};
                 if (!expectedCodes.Contains(response.StatusCode))
                     throw CreateWebException("CreateContainer", response.StatusCode);
                 if (!expectedCodes.Contains(_client.StatusCode))
                     throw CreateWebException("CreateContainer", _client.StatusCode);
+            }
             public void DeleteContainer(string container)
-...
                 if (String.IsNullOrWhiteSpace(container))
                     throw new ArgumentNullException("container", "The container property can't be empty");
     /*
                 var request = new RestRequest { Path = container, Method = WebMethod.Delete, RetryPolicy = _retryPolicy,Timeout = _shortTimeout };
                 var response = _client.Request(request);
     */
                 _client.DeleteWithRetry(container,3);
                 var expectedCodes = new[] { HttpStatusCode.NotFound, HttpStatusCode.NoContent};
                 if (!expectedCodes.Contains(response.StatusCode))
                     throw CreateWebException("DeleteContainer", response.StatusCode);
                 if (!expectedCodes.Contains(_client.StatusCode))
                     throw CreateWebException("DeleteContainer", _client.StatusCode);
+            }
-...
                     throw new ArgumentNullException("container", "The container property can't be empty");
                 if (String.IsNullOrWhiteSpace(objectName))
                     throw new ArgumentNullException("objectName", "The objectName property can't be empty");
                 var request = new RestRequest {Path = container + "/" + objectName, Method = WebMethod.Get};
                 /*
                             if (DownloadPercentLimit > 0)
                                 request.TaskOptions = new TaskOptions<int> { RateLimitPercent = DownloadPercentLimit };
                 */
                var request = new RestRequest {Path = container + "/" + objectName, Method = WebMethod.Get};
                            if (DownloadPercentLimit > 0)
                                request.TaskOptions = new TaskOptions<int> { RateLimitPercent = DownloadPercentLimit };
                */
                 try
+                {
                     var url = String.Join("/", new[] {_client.Authority, container, objectName});
                     var url = String.Join("/", _client.BaseAddress, container, objectName);
                     var uri = new Uri(url);
                     var client = new WebClient();
                     if (!String.IsNullOrWhiteSpace(_client.Proxy))
                     var client = new PithosClient(_client){Timeout=0};
                    /* if (!String.IsNullOrWhiteSpace(_client.Proxy))
                         client.Proxy = new WebProxy(_client.Proxy);
                     CopyHeaders(_client, client);
                     CopyHeaders(_client, client);*/
                     Trace.TraceInformation("[GET] START {0}", objectName);
                     client.DownloadProgressChanged += (sender, args) =>
-...
                                         args.BytesReceived,
                                         args.TotalBytesToReceive);
                     return client.DownloadFileTask(uri, fileName)
                     return _client.DownloadFileTask(uri, fileName)
                         .ContinueWith(download =>
+                                          {
                                               client.Dispose();
-...
                 try
+                {
                     var url = String.Join("/",new[]{_client.Authority,container,objectName});
                     var url = String.Join("/",_client.BaseAddress,container,objectName);
                     var uri = new Uri(url);
                     var client = new WebClient();
                     var client = new PithosClient(_client){Timeout=0};
                     string etag = hash ?? CalculateHash(fileName);
                     client.Headers.Add("Content-Type", "application/octet-stream");
                     client.Headers.Add("ETag", etag);
     /*
                     if(!String.IsNullOrWhiteSpace(_client.Proxy))
                         client.Proxy = new WebProxy(_client.Proxy);
                     CopyHeaders(_client, client);
     */
                     Trace.TraceInformation("[PUT] START {0}", objectName);
                     client.UploadProgressChanged += (sender, args) =>
-...
+            }
     /*
             /// <summary>
             /// Copies headers from a Hammock RestClient to a WebClient
             /// </summary>
-...
+                {
                     target.Headers.Add(header.Name, header.Value);
+                }
+            }
             }*/
            /* /// <summary>
             /// Copies headers from a Hammock RestClient to a WebClient
             /// </summary>
             /// <param name="source">The RestClient from which the headers are copied</param>
             /// <param name="target">The WebClient to which the headers are copied</param>
             private static void CopyHeaders(RestClient source, WebRequest 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 (source == null)
                     throw new ArgumentNullException("target", "target can't be null");
                 foreach (var header in source.GetAllHeaders())
+                {
                     target.Headers.Add(header.Name, header.Value);
+                }
             }*/
             private static string CalculateHash(string fileName)
+            {
                 string hash;
-...
                 if (String.IsNullOrWhiteSpace(objectName))
                     throw new ArgumentNullException("objectName", "The objectName property can't be empty");
     /*
                 var request = new RestRequest { Path = container + "/" + objectName, Method = WebMethod.Delete, RetryPolicy = _retryPolicy,Timeout = _shortTimeout };
                 var response = _client.Request(request);
     */
                 _client.DeleteWithRetry(container + "/" + objectName,3);
                 var expectedCodes = new[] { HttpStatusCode.NotFound, HttpStatusCode.NoContent };
                 if (!expectedCodes.Contains(response.StatusCode))
                     throw CreateWebException("DeleteObject", response.StatusCode);
                 if (!expectedCodes.Contains(_client.StatusCode))
                     throw CreateWebException("DeleteObject", _client.StatusCode);
+            }
-...
                 var targetUrl = targetContainer + "/" + newObjectName;
                 var sourceUrl = String.Format("/{0}/{1}", sourceContainer, oldObjectName);
     /*
                 var request = new RestRequest { Path = targetUrl, Method = WebMethod.Put };
                 request.AddHeader("X-Copy-From",sourceUrl);
                 request.AddPostContent(new byte[]{});
                 var response = _client.Request(request);
     */
                 var client = new PithosClient(_client);
                 client.Headers.Add("X-Copy-From", sourceUrl);
                 client.PutWithRetry(targetUrl,3);
                 var expectedCodes = new[] { HttpStatusCode.OK ,HttpStatusCode.NoContent ,HttpStatusCode.Created };
                 if (expectedCodes.Contains(response.StatusCode))
                 if (expectedCodes.Contains(client.StatusCode))
+                {
                     this.DeleteObject(sourceContainer,oldObjectName);
+                }
                 else
                     throw CreateWebException("MoveObject", response.StatusCode);
                     throw CreateWebException("MoveObject", client.StatusCode);
+            }
             private string GetHeaderValue(string headerName, RestResponse response, IQueryable<string> keys)
             /*private string GetHeaderValue(string headerName, WebHeaderCollection headers, IQueryable<string> keys)
+            {
                 if (keys.Any(key => key == headerName))
                     return response.Headers[headerName];
                     return headers[headerName];
                 else
                     throw new WebException(String.Format("The {0}  header is missing",headerName));
                     throw new WebException(String.Format("The {0}  header is missing", headerName));
             }*/
            /* private static void ThrowIfNotStatusOK(RestResponse response, string message)
+            {
                 int status = (int)response.StatusCode;
                 ThrowIfNotStatusOK(status, message);
+            }
             private static void ThrowIfNotStatusOK(RestResponse response, string message)
             private static void ThrowIfNotStatusOK(HttpWebResponse response, string message)
+            {
                 int status = (int)response.StatusCode;
                 if (status < 200 || status >= 300)
                     throw new WebException(String.Format("{0} with code {1}",message, status));
                 ThrowIfNotStatusOK(status, message);
+            }
             private static void ThrowIfNotStatusOK(int status, string message)
+            {
                 if (status < 200 || status >= 300)
                     throw new WebException(String.Format("{0} with code {1}", message, status));
+            }
             */
             private static WebException CreateWebException(string operation, HttpStatusCode statusCode)
+            {
                 return new WebException(String.Format("{0} failed with unexpected status code {1}", operation, statusCode));
+            }
            /* public static Func<T> Retry<T>(Func<int,T> original, int retryCount,int timeout)
+            {
                 return () =>
+                {
                     while (true)
+                    {
                         try
+                        {
                             return original(timeout);
+                        }
                         catch (WebException e)
+                        {
                             if (e.Status == WebExceptionStatus.Timeout)
+                            {
                                 if (retryCount == 0)
+                                {
                                     throw;
+                                }
                                 retryCount--;
+                            }
                             else
+                            {
                                 throw;
+                            }
+                        }
                         catch (Exception e)
+                        {
                                 throw;
+                        }
+                    }
                 };
             } */
+        }
+    }

Also available in: Unified diff

Synnefo » Pithos MS Client

Revision 4d301e8e trunk/Pithos.Network/CloudFilesClient.cs