code.grnet.gr Git - pithos-ms-client/blob - trunk/Pithos.Network/CloudFilesClient.cs

   1 #region\r
   2 /* -----------------------------------------------------------------------\r
   3  * <copyright file="CloudFilesClient.cs" company="GRNet">\r
   4  * \r
   5  * Copyright 2011-2012 GRNET S.A. All rights reserved.\r
   6  *\r
   7  * Redistribution and use in source and binary forms, with or\r
   8  * without modification, are permitted provided that the following\r
   9  * conditions are met:\r
  10  *\r
  11  *   1. Redistributions of source code must retain the above\r
  12  *      copyright notice, this list of conditions and the following\r
  13  *      disclaimer.\r
  14  *\r
  15  *   2. Redistributions in binary form must reproduce the above\r
  16  *      copyright notice, this list of conditions and the following\r
  17  *      disclaimer in the documentation and/or other materials\r
  18  *      provided with the distribution.\r
  19  *\r
  20  *\r
  21  * THIS SOFTWARE IS PROVIDED BY GRNET S.A. ``AS IS'' AND ANY EXPRESS\r
  22  * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\r
  23  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR\r
  24  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GRNET S.A OR\r
  25  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\r
  26  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\r
  27  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF\r
  28  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED\r
  29  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT\r
  30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN\r
  31  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\r
  32  * POSSIBILITY OF SUCH DAMAGE.\r
  33  *\r
  34  * The views and conclusions contained in the software and\r
  35  * documentation are those of the authors and should not be\r
  36  * interpreted as representing official policies, either expressed\r
  37  * or implied, of GRNET S.A.\r
  38  * </copyright>\r
  39  * -----------------------------------------------------------------------\r
  40  */\r
  41 #endregion\r
  42 \r
  43 // **CloudFilesClient** provides a simple client interface to CloudFiles and Pithos\r
  44 //\r
  45 // The class provides methods to upload/download files, delete files, manage containers\r
  46 \r
  47 \r
  48 using System;\r
  49 using System.Collections.Generic;\r
  50 using System.Collections.Specialized;\r
  51 using System.ComponentModel.Composition;\r
  52 using System.Diagnostics;\r
  53 using System.Diagnostics.Contracts;\r
  54 using System.IO;\r
  55 using System.Linq;\r
  56 using System.Net;\r
  57 using System.Net.Http;\r
  58 using System.Net.Http.Headers;\r
  59 using System.Reflection;\r
  60 using System.Threading;\r
  61 using System.Threading.Tasks;\r
  62 using Newtonsoft.Json;\r
  63 using Pithos.Interfaces;\r
  64 using Pithos.Network;\r
  65 using log4net;\r
  66 \r
  67 namespace Pithos.Network\r
  68 {\r
  69 \r
  70     [Export(typeof(ICloudClient))]\r
  71     public class CloudFilesClient:ICloudClient,IDisposable\r
  72     {\r
  73         private const string TOKEN_HEADER = "X-Auth-Token";\r
  74         private static readonly ILog Log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);\r
  75 \r
  76         //CloudFilesClient uses *_baseClient* internally to communicate with the server\r
  77         //RestClient provides a REST-friendly interface over the standard WebClient.\r
  78         private RestClient _baseClient;\r
  79 \r
  80         private HttpClient _baseHttpClient;\r
  81         private HttpClient _baseHttpClientNoTimeout;\r
  82         \r
  83 \r
  84         //During authentication the client provides a UserName \r
  85         public string UserName { get; set; }\r
  86         \r
  87         //and and ApiKey to the server\r
  88         public string ApiKey { get; set; }\r
  89         \r
  90         //And receives an authentication Token. This token must be provided in ALL other operations,\r
  91         //in the X-Auth-Token header\r
  92         private string _token;\r
  93         private readonly string _emptyGuid = Guid.Empty.ToString();\r
  94         private readonly Uri _emptyUri = new Uri("",UriKind.Relative);\r
  95 \r
  96         private HttpClientHandler _httpClientHandler = new HttpClientHandler\r
  97                                                            {\r
  98                                                                AllowAutoRedirect = true,\r
  99                                                                AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate,\r
 100                                                                UseCookies = true,                                \r
 101                                                            };\r
 102 \r
 103 \r
 104         public string Token\r
 105         {\r
 106             get { return _token; }\r
 107             set\r
 108             {\r
 109                 _token = value;\r
 110                 _baseClient.Headers[TOKEN_HEADER] = value;\r
 111             }\r
 112         }\r
 113 \r
 114         //The client also receives a StorageUrl after authentication. All subsequent operations must\r
 115         //use this url\r
 116         public Uri StorageUrl { get; set; }\r
 117 \r
 118 \r
 119         public Uri RootAddressUri { get; set; }\r
 120 \r
 121 \r
 122         public double DownloadPercentLimit { get; set; }\r
 123         public double UploadPercentLimit { get; set; }\r
 124 \r
 125         public string AuthenticationUrl { get; set; }\r
 126 \r
 127  \r
 128         public string VersionPath\r
 129         {\r
 130             get { return UsePithos ? "v1" : "v1.0"; }\r
 131         }\r
 132 \r
 133         public bool UsePithos { get; set; }\r
 134 \r
 135 \r
 136 \r
 137         public CloudFilesClient(string userName, string apiKey)\r
 138         {\r
 139             UserName = userName;\r
 140             ApiKey = apiKey;\r
 141         }\r
 142 \r
 143         public CloudFilesClient(AccountInfo accountInfo)\r
 144         {\r
 145             if (accountInfo==null)\r
 146                 throw new ArgumentNullException("accountInfo");\r
 147             Contract.Ensures(!String.IsNullOrWhiteSpace(Token));\r
 148             Contract.Ensures(StorageUrl != null);\r
 149             Contract.Ensures(_baseClient != null);\r
 150             Contract.Ensures(RootAddressUri != null);\r
 151             Contract.EndContractBlock();          \r
 152 \r
 153             _baseClient = new RestClient\r
 154             {\r
 155                 BaseAddress = accountInfo.StorageUri.ToString(),\r
 156                 Timeout = 30000,\r
 157                 Retries = 3,\r
 158             };\r
 159             StorageUrl = accountInfo.StorageUri;\r
 160             Token = accountInfo.Token;\r
 161             UserName = accountInfo.UserName;\r
 162 \r
 163             //Get the root address (StorageUrl without the account)\r
 164             var storageUrl = StorageUrl.AbsoluteUri;\r
 165             var usernameIndex = storageUrl.LastIndexOf(UserName);\r
 166             var rootUrl = storageUrl.Substring(0, usernameIndex);\r
 167             RootAddressUri = new Uri(rootUrl);\r
 168 \r
 169             var httpClientHandler = new HttpClientHandler\r
 170             {\r
 171                 AllowAutoRedirect = true,\r
 172                 AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate,\r
 173                 UseCookies = true,\r
 174             };\r
 175 \r
 176 \r
 177             _baseHttpClient = new HttpClient(httpClientHandler)\r
 178             {\r
 179                 BaseAddress = StorageUrl,\r
 180                 Timeout = TimeSpan.FromSeconds(30)\r
 181             };\r
 182             _baseHttpClient.DefaultRequestHeaders.Add(TOKEN_HEADER, Token);\r
 183 \r
 184             _baseHttpClientNoTimeout = new HttpClient(httpClientHandler)\r
 185             {\r
 186                 BaseAddress = StorageUrl,\r
 187                 Timeout = TimeSpan.FromMilliseconds(-1)\r
 188             };\r
 189             _baseHttpClientNoTimeout.DefaultRequestHeaders.Add(TOKEN_HEADER, Token);\r
 190 \r
 191 \r
 192         }\r
 193 \r
 194 \r
 195         private static void AssertStatusOK(HttpResponseMessage response, string message)\r
 196         {\r
 197             var statusCode = response.StatusCode;\r
 198             if (statusCode >= HttpStatusCode.BadRequest)\r
 199                 throw new WebException(String.Format("{0} with code {1} - {2}", message, statusCode, response.ReasonPhrase));\r
 200         }\r
 201 \r
 202         public async Task<AccountInfo> Authenticate()\r
 203         {\r
 204             if (String.IsNullOrWhiteSpace(UserName))\r
 205                 throw new InvalidOperationException("UserName is empty");\r
 206             if (String.IsNullOrWhiteSpace(ApiKey))\r
 207                 throw new InvalidOperationException("ApiKey is empty");\r
 208             if (String.IsNullOrWhiteSpace(AuthenticationUrl))\r
 209                 throw new InvalidOperationException("AuthenticationUrl is empty");\r
 210             Contract.Ensures(!String.IsNullOrWhiteSpace(Token));\r
 211             Contract.Ensures(StorageUrl != null);\r
 212             Contract.Ensures(_baseClient != null);\r
 213             Contract.Ensures(RootAddressUri != null);\r
 214             Contract.EndContractBlock();\r
 215 \r
 216 \r
 217             Log.InfoFormat("[AUTHENTICATE] Start for {0}", UserName);\r
 218 \r
 219             var groups = new List<Group>();\r
 220 \r
 221             using (var authClient = new HttpClient(_httpClientHandler,false){ BaseAddress = new Uri(AuthenticationUrl),Timeout=TimeSpan.FromSeconds(30) })\r
 222             {                \r
 223 \r
 224                 authClient.DefaultRequestHeaders.Add("X-Auth-User", UserName);\r
 225                 authClient.DefaultRequestHeaders.Add("X-Auth-Key", ApiKey);\r
 226 \r
 227                 string storageUrl;\r
 228                 string token;\r
 229                 \r
 230                 using (var response = await authClient.GetAsyncWithRetries(new Uri(VersionPath, UriKind.Relative),3).ConfigureAwait(false)) // .DownloadStringWithRetryRelative(new Uri(VersionPath, UriKind.Relative), 3);                    \r
 231                 {\r
 232                     AssertStatusOK(response,"Authentication failed");\r
 233                 \r
 234                     storageUrl = response.Headers.GetFirstValue("X-Storage-Url");\r
 235                     if (String.IsNullOrWhiteSpace(storageUrl))\r
 236                         throw new InvalidOperationException("Failed to obtain storage url");\r
 237 \r
 238                     token = response.Headers.GetFirstValue(TOKEN_HEADER);\r
 239                     if (String.IsNullOrWhiteSpace(token))\r
 240                         throw new InvalidOperationException("Failed to obtain token url");\r
 241 \r
 242                 }\r
 243 \r
 244 \r
 245                 _baseClient = new RestClient\r
 246                 {\r
 247                     BaseAddress = storageUrl,\r
 248                     Timeout = 30000,\r
 249                     Retries = 3,                    \r
 250                 };\r
 251 \r
 252                 StorageUrl = new Uri(storageUrl);\r
 253                 Token = token;\r
 254 \r
 255                 \r
 256 \r
 257                                                                \r
 258                 //Get the root address (StorageUrl without the account)\r
 259                 var usernameIndex=storageUrl.LastIndexOf(UserName);\r
 260                 var rootUrl = storageUrl.Substring(0, usernameIndex);\r
 261                 RootAddressUri = new Uri(rootUrl);\r
 262                 \r
 263 \r
 264                 _baseHttpClient = new HttpClient(_httpClientHandler,false)\r
 265                 {\r
 266                     BaseAddress = StorageUrl,\r
 267                     Timeout = TimeSpan.FromSeconds(30)\r
 268                 };\r
 269                 _baseHttpClient.DefaultRequestHeaders.Add(TOKEN_HEADER, token);\r
 270 \r
 271                 _baseHttpClientNoTimeout = new HttpClient(_httpClientHandler,false)\r
 272                 {\r
 273                     BaseAddress = StorageUrl,\r
 274                     Timeout = TimeSpan.FromMilliseconds(-1)\r
 275                 };\r
 276                 _baseHttpClientNoTimeout.DefaultRequestHeaders.Add(TOKEN_HEADER, token);\r
 277 \r
 278                 /* var keys = authClient.ResponseHeaders.AllKeys.AsQueryable();\r
 279                 groups = (from key in keys\r
 280                             where key.StartsWith("X-Account-Group-")\r
 281                             let name = key.Substring(16)\r
 282                             select new Group(name, authClient.ResponseHeaders[key]))\r
 283                         .ToList();\r
 284                     \r
 285 */\r
 286             }\r
 287 \r
 288             Log.InfoFormat("[AUTHENTICATE] End for {0}", UserName);\r
 289             Debug.Assert(_baseClient!=null);\r
 290 \r
 291             return new AccountInfo {StorageUri = StorageUrl, Token = Token, UserName = UserName,Groups=groups};            \r
 292 \r
 293         }\r
 294 \r
 295         private static void TraceStart(string method, Uri actualAddress)\r
 296         {\r
 297             Log.InfoFormat("[{0}] {1} {2}", method, DateTime.Now, actualAddress);\r
 298         }\r
 299 \r
 300         private async Task<string> GetStringAsync(Uri targetUri, string errorMessage,DateTimeOffset? since=null)\r
 301         {\r
 302             TraceStart("GET",targetUri);\r
 303             var request = new HttpRequestMessage(HttpMethod.Get, targetUri);            \r
 304             if (since.HasValue)\r
 305             {\r
 306                 request.Headers.IfModifiedSince = since.Value;\r
 307             }\r
 308             using (var response = await _baseHttpClient.SendAsyncWithRetries(request,3).ConfigureAwait(false))\r
 309             {\r
 310                 AssertStatusOK(response, errorMessage);\r
 311 \r
 312                 if (response.StatusCode == HttpStatusCode.NoContent)\r
 313                     return String.Empty;\r
 314 \r
 315                 var content = await response.Content.ReadAsStringAsync().ConfigureAwait(false);\r
 316                 return content;\r
 317             }\r
 318         }\r
 319 \r
 320         public async Task<IList<ContainerInfo>> ListContainers(string account)\r
 321         {\r
 322 \r
 323             var targetUrl = GetTargetUrl(account);\r
 324             var targetUri = new Uri(String.Format("{0}?format=json", targetUrl));\r
 325             var result = await GetStringAsync(targetUri, "List Containers failed").ConfigureAwait(false);\r
 326             if (String.IsNullOrWhiteSpace(result))\r
 327                 return new List<ContainerInfo>();\r
 328             var infos = JsonConvert.DeserializeObject<IList<ContainerInfo>>(result);\r
 329             foreach (var info in infos)\r
 330             {\r
 331                 info.Account = account;\r
 332             }\r
 333             return infos;\r
 334         }\r
 335 \r
 336         \r
 337         private string GetAccountUrl(string account)\r
 338         {\r
 339             return RootAddressUri.Combine(account).AbsoluteUri;\r
 340         }\r
 341 \r
 342         public IList<ShareAccountInfo> ListSharingAccounts(DateTime? since=null)\r
 343         {\r
 344             using (ThreadContext.Stacks["Share"].Push("List Accounts"))\r
 345             {\r
 346                 if (Log.IsDebugEnabled) Log.DebugFormat("START");\r
 347 \r
 348                 var targetUri = new Uri(String.Format("{0}?format=json", RootAddressUri), UriKind.Absolute);\r
 349                 var content=TaskEx.Run(async ()=>await GetStringAsync(targetUri, "ListSharingAccounts failed", since).ConfigureAwait(false)).Result;\r
 350 \r
 351                 //If the result is empty, return an empty list,\r
 352                 var infos = String.IsNullOrWhiteSpace(content)\r
 353                                 ? new List<ShareAccountInfo>()\r
 354                             //Otherwise deserialize the account list into a list of ShareAccountInfos\r
 355                                 : JsonConvert.DeserializeObject<IList<ShareAccountInfo>>(content);\r
 356 \r
 357                 Log.DebugFormat("END");\r
 358                 return infos;\r
 359             }\r
 360         }\r
 361 \r
 362 \r
 363         /// <summary>\r
 364         /// Request listing of all objects in a container modified since a specific time.\r
 365         /// If the *since* value is missing, return all objects\r
 366         /// </summary>\r
 367         /// <param name="knownContainers">Use the since variable only for the containers listed in knownContainers. Unknown containers are considered new\r
 368         /// and should be polled anyway\r
 369         /// </param>\r
 370         /// <param name="since"></param>\r
 371         /// <returns></returns>\r
 372         public IList<ObjectInfo> ListSharedObjects(HashSet<string> knownContainers, DateTimeOffset? since)\r
 373         {\r
 374 \r
 375             using (ThreadContext.Stacks["Share"].Push("List Objects"))\r
 376             {\r
 377                 if (Log.IsDebugEnabled) Log.DebugFormat("START");\r
 378                 //'since' is not used here because we need to have ListObjects return a NoChange result\r
 379                 //for all shared accounts,containers\r
 380 \r
 381                 Func<ContainerInfo, string> getKey = c => String.Format("{0}\\{1}", c.Account, c.Name);\r
 382                 \r
 383                 var containers = (from account in ListSharingAccounts()\r
 384                                  let conts = TaskEx.Run(async ()=>await ListContainers(account.name).ConfigureAwait(false)).Result\r
 385                                  from container in conts\r
 386                                  select container).ToList();                \r
 387                 var items = from container in containers \r
 388                             let actualSince=knownContainers.Contains(getKey(container))?since:null\r
 389                             select ListObjects(container.Account , container.Name,  actualSince);\r
 390                 var objects=items.SelectMany(r=> r).ToList();\r
 391 \r
 392                 //For each object\r
 393                 //Check parents recursively up to (but not including) the container.\r
 394                 //If parents are missing, add them to the list\r
 395                 //Need function to calculate all parent URLs\r
 396                 objects = AddMissingParents(objects);\r
 397                 \r
 398                 //Store any new containers\r
 399                 foreach (var container in containers)\r
 400                 {\r
 401                     knownContainers.Add(getKey(container));\r
 402                 }\r
 403 \r
 404 \r
 405 \r
 406                 if (Log.IsDebugEnabled) Log.DebugFormat("END");\r
 407                 return objects;\r
 408             }\r
 409         }\r
 410 \r
 411         private List<ObjectInfo> AddMissingParents(List<ObjectInfo> objects)\r
 412         {\r
 413             //TODO: Remove short-circuit when we decide to use Missing Parents functionality\r
 414             //return objects;\r
 415 \r
 416             var existingUris = objects.ToDictionary(o => o.Uri, o => o);\r
 417             foreach (var objectInfo in objects)\r
 418             {\r
 419                 //Can be null when retrieving objects to show in selective sync\r
 420                 if (objectInfo.Name == null)\r
 421                     continue;\r
 422 \r
 423                 //No need to unescape here, the parts will be used to create new ObjectInfos\r
 424                 var parts = objectInfo.Name.ToString().Split(new[]{'/'},StringSplitOptions.RemoveEmptyEntries);\r
 425                 //If there is no parent, skip\r
 426                 if (parts.Length == 1)\r
 427                     continue;\r
 428                 var baseParts = new[]\r
 429                                   {\r
 430                                       objectInfo.Uri.Host, objectInfo.Uri.Segments[1].TrimEnd('/'),objectInfo.Account,objectInfo.Container.ToString()\r
 431                                   };\r
 432                 for (var partIdx = 0; partIdx < parts.Length - 1; partIdx++)\r
 433                 {\r
 434                     var nameparts = parts.Range(0, partIdx).ToArray();\r
 435                     var parentName= String.Join("/", nameparts);\r
 436 \r
 437                     var parentParts = baseParts.Concat(nameparts);\r
 438                     var parentUrl = objectInfo.Uri.Scheme+ "://" + String.Join("/", parentParts);\r
 439                     \r
 440                     var parentUri = new Uri(parentUrl, UriKind.Absolute);\r
 441 \r
 442                     ObjectInfo existingInfo;\r
 443                     if (!existingUris.TryGetValue(parentUri,out existingInfo))\r
 444                     {\r
 445                         var h = parentUrl.GetHashCode();\r
 446                         var reverse = new string(parentUrl.Reverse().ToArray());\r
 447                         var rh = reverse.GetHashCode();\r
 448                         var b1 = BitConverter.GetBytes(h);\r
 449                         var b2 = BitConverter.GetBytes(rh);\r
 450                         var g = new Guid(0,0,0,b1.Concat(b2).ToArray());\r
 451                         \r
 452 \r
 453                         existingUris[parentUri] = new ObjectInfo\r
 454                                                       {\r
 455                                                           Account = objectInfo.Account,\r
 456                                                           Container = objectInfo.Container,\r
 457                                                           Content_Type = ObjectInfo.CONTENT_TYPE_DIRECTORY,\r
 458                                                           ETag = Signature.MERKLE_EMPTY,\r
 459                                                           X_Object_Hash = Signature.MERKLE_EMPTY,\r
 460                                                           Name=new Uri(parentName,UriKind.Relative),\r
 461                                                           StorageUri=objectInfo.StorageUri,\r
 462                                                           Bytes = 0,\r
 463                                                           UUID=g.ToString(),                                                          \r
 464                                                       };\r
 465                     }\r
 466                 }\r
 467             }\r
 468             return existingUris.Values.ToList();\r
 469         }\r
 470 \r
 471         public void SetTags(ObjectInfo target,IDictionary<string,string> tags)\r
 472         {\r
 473             if (String.IsNullOrWhiteSpace(Token))\r
 474                 throw new InvalidOperationException("The Token is not set");\r
 475             if (StorageUrl == null)\r
 476                 throw new InvalidOperationException("The StorageUrl is not set");\r
 477             if (target == null)\r
 478                 throw new ArgumentNullException("target");\r
 479             Contract.EndContractBlock();\r
 480 \r
 481             using (ThreadContext.Stacks["Share"].Push("Share Object"))\r
 482             {\r
 483                 if (Log.IsDebugEnabled) Log.DebugFormat("START");\r
 484 \r
 485                 using (var client = new RestClient(_baseClient))\r
 486                 {\r
 487 \r
 488                     client.BaseAddress = GetAccountUrl(target.Account);\r
 489 \r
 490                     client.Parameters.Clear();\r
 491                     client.Parameters.Add("update", "");\r
 492 \r
 493                     foreach (var tag in tags)\r
 494                     {\r
 495                         var headerTag = String.Format("X-Object-Meta-{0}", tag.Key);\r
 496                         client.Headers.Add(headerTag, tag.Value);\r
 497                     }\r
 498                     \r
 499                     client.DownloadStringWithRetryRelative(target.Container, 3);\r
 500 \r
 501                     \r
 502                     client.AssertStatusOK("SetTags failed");\r
 503                     //If the status is NOT ACCEPTED we have a problem\r
 504                     if (client.StatusCode != HttpStatusCode.Accepted)\r
 505                     {\r
 506                         Log.Error("Failed to set tags");\r
 507                         throw new Exception("Failed to set tags");\r
 508                     }\r
 509 \r
 510                     if (Log.IsDebugEnabled) Log.DebugFormat("END");\r
 511                 }\r
 512             }\r
 513 \r
 514 \r
 515         }\r
 516 \r
 517         public void ShareObject(string account, Uri container, Uri objectName, string shareTo, bool read, bool write)\r
 518         {\r
 519             if (String.IsNullOrWhiteSpace(Token))\r
 520                 throw new InvalidOperationException("The Token is not set");\r
 521             if (StorageUrl==null)\r
 522                 throw new InvalidOperationException("The StorageUrl is not set");\r
 523             if (container==null)\r
 524                 throw new ArgumentNullException("container");\r
 525             if (container.IsAbsoluteUri)\r
 526                 throw new ArgumentException("container");\r
 527             if (objectName==null)\r
 528                 throw new ArgumentNullException("objectName");\r
 529             if (objectName.IsAbsoluteUri)\r
 530                 throw new ArgumentException("objectName");\r
 531             if (String.IsNullOrWhiteSpace(account))\r
 532                 throw new ArgumentNullException("account");\r
 533             if (String.IsNullOrWhiteSpace(shareTo))\r
 534                 throw new ArgumentNullException("shareTo");\r
 535             Contract.EndContractBlock();\r
 536 \r
 537             using (ThreadContext.Stacks["Share"].Push("Share Object"))\r
 538             {\r
 539                 if (Log.IsDebugEnabled) Log.DebugFormat("START");\r
 540                 \r
 541                 using (var client = new RestClient(_baseClient))\r
 542                 {\r
 543 \r
 544                     client.BaseAddress = GetAccountUrl(account);\r
 545 \r
 546                     client.Parameters.Clear();\r
 547                     client.Parameters.Add("format", "json");\r
 548 \r
 549                     string permission = "";\r
 550                     if (write)\r
 551                         permission = String.Format("write={0}", shareTo);\r
 552                     else if (read)\r
 553                         permission = String.Format("read={0}", shareTo);\r
 554                     client.Headers.Add("X-Object-Sharing", permission);\r
 555 \r
 556                     var content = client.DownloadStringWithRetryRelative(container, 3);\r
 557 \r
 558                     client.AssertStatusOK("ShareObject failed");\r
 559 \r
 560                     //If the result is empty, return an empty list,\r
 561                     var infos = String.IsNullOrWhiteSpace(content)\r
 562                                     ? new List<ObjectInfo>()\r
 563                                 //Otherwise deserialize the object list into a list of ObjectInfos\r
 564                                     : JsonConvert.DeserializeObject<IList<ObjectInfo>>(content);\r
 565 \r
 566                     if (Log.IsDebugEnabled) Log.DebugFormat("END");\r
 567                 }\r
 568             }\r
 569 \r
 570 \r
 571         }\r
 572 \r
 573         public async Task<AccountInfo> GetAccountPolicies(AccountInfo accountInfo)\r
 574         {\r
 575             if (accountInfo==null)\r
 576                 throw new ArgumentNullException("accountInfo");\r
 577             Contract.EndContractBlock();\r
 578 \r
 579             using (ThreadContext.Stacks["Account"].Push("GetPolicies"))\r
 580             {\r
 581                 if (Log.IsDebugEnabled) Log.DebugFormat("START");\r
 582 \r
 583 /*\r
 584                 if (_baseClient == null)\r
 585                 {\r
 586                     _baseClient = new RestClient\r
 587                     {\r
 588                         BaseAddress = accountInfo.StorageUri.ToString(),\r
 589                         Timeout = 30000,\r
 590                         Retries = 3,\r
 591                     };\r
 592                 }\r
 593 \r
 594 */                \r
 595                 var containerUri = GetTargetUri(accountInfo.UserName);\r
 596                 var targetUri = new Uri(String.Format("{0}?format=json", containerUri), UriKind.Absolute);\r
 597                 using(var response=await _baseHttpClient.HeadAsyncWithRetries(targetUri,3).ConfigureAwait(false))\r
 598                 {\r
 599                     \r
 600                     var quotaValue=response.Headers.GetFirstValue("X-Account-Policy-Quota");\r
 601                     var bytesValue = response.Headers.GetFirstValue("X-Account-Bytes-Used");\r
 602                     long quota, bytes;\r
 603                     if (long.TryParse(quotaValue, out quota))\r
 604                         accountInfo.Quota = quota;\r
 605                     if (long.TryParse(bytesValue, out bytes))\r
 606                         accountInfo.BytesUsed = bytes;\r
 607 \r
 608                     return accountInfo;   \r
 609                 }\r
 610 \r
 611 \r
 612                 //using (var client = new RestClient(_baseClient))\r
 613                 //{\r
 614                 //    if (!String.IsNullOrWhiteSpace(accountInfo.UserName))\r
 615                 //        client.BaseAddress = GetAccountUrl(accountInfo.UserName);\r
 616 \r
 617                 //    client.Parameters.Clear();\r
 618                 //    client.Parameters.Add("format", "json");                    \r
 619                 //    client.Head(_emptyUri, 3);\r
 620 \r
 621                 //    var quotaValue=client.ResponseHeaders["X-Account-Policy-Quota"];\r
 622                 //    var bytesValue= client.ResponseHeaders["X-Account-Bytes-Used"];\r
 623 \r
 624                 //    long quota, bytes;\r
 625                 //    if (long.TryParse(quotaValue, out quota))\r
 626                 //        accountInfo.Quota = quota;\r
 627                 //    if (long.TryParse(bytesValue, out bytes))\r
 628                 //        accountInfo.BytesUsed = bytes;\r
 629                     \r
 630                 //    return accountInfo;\r
 631 \r
 632                 //}\r
 633 \r
 634             }\r
 635         }\r
 636 \r
 637         public void UpdateMetadata(ObjectInfo objectInfo)\r
 638         {\r
 639             if (objectInfo == null)\r
 640                 throw new ArgumentNullException("objectInfo");\r
 641             Contract.EndContractBlock();\r
 642 \r
 643             using (ThreadContext.Stacks["Objects"].Push("UpdateMetadata"))\r
 644             {\r
 645                 if (Log.IsDebugEnabled) Log.DebugFormat("START");\r
 646 \r
 647 \r
 648                 using(var client=new RestClient(_baseClient))\r
 649                 {\r
 650 \r
 651                     client.BaseAddress = GetAccountUrl(objectInfo.Account);\r
 652                     \r
 653                     client.Parameters.Clear();\r
 654                     \r
 655 \r
 656                     //Set Tags\r
 657                     foreach (var tag in objectInfo.Tags)\r
 658                     {\r
 659                         var headerTag = String.Format("X-Object-Meta-{0}", tag.Key);\r
 660                         client.Headers.Add(headerTag, tag.Value);\r
 661                     }\r
 662 \r
 663                     //Set Permissions\r
 664 \r
 665                     var permissions=objectInfo.GetPermissionString();\r
 666                     client.SetNonEmptyHeaderValue("X-Object-Sharing",permissions);\r
 667 \r
 668                     client.SetNonEmptyHeaderValue("Content-Disposition",objectInfo.ContendDisposition);\r
 669                     client.SetNonEmptyHeaderValue("Content-Encoding",objectInfo.ContentEncoding);\r
 670                     client.SetNonEmptyHeaderValue("X-Object-Manifest",objectInfo.Manifest);\r
 671                     var isPublic = objectInfo.IsPublic.ToString().ToLower();\r
 672                     client.Headers.Add("X-Object-Public", isPublic);\r
 673 \r
 674 \r
 675                     var address = String.Format("{0}/{1}?update=",objectInfo.Container, objectInfo.Name);\r
 676                     client.PostWithRetry(new Uri(address,UriKind.Relative),"application/xml");\r
 677                     \r
 678                     client.AssertStatusOK("UpdateMetadata failed");\r
 679                     //If the status is NOT ACCEPTED or OK we have a problem\r
 680                     if (!(client.StatusCode == HttpStatusCode.Accepted || client.StatusCode == HttpStatusCode.OK))\r
 681                     {\r
 682                         Log.Error("Failed to update metadata");\r
 683                         throw new Exception("Failed to update metadata");\r
 684                     }\r
 685 \r
 686                     if (Log.IsDebugEnabled) Log.DebugFormat("END");\r
 687                 }\r
 688             }\r
 689 \r
 690         }\r
 691 \r
 692         public void UpdateMetadata(ContainerInfo containerInfo)\r
 693         {\r
 694             if (containerInfo == null)\r
 695                 throw new ArgumentNullException("containerInfo");\r
 696             Contract.EndContractBlock();\r
 697 \r
 698             using (ThreadContext.Stacks["Containers"].Push("UpdateMetadata"))\r
 699             {\r
 700                 if (Log.IsDebugEnabled) Log.DebugFormat("START");\r
 701 \r
 702 \r
 703                 using(var client=new RestClient(_baseClient))\r
 704                 {\r
 705 \r
 706                     client.BaseAddress = GetAccountUrl(containerInfo.Account);\r
 707                     \r
 708                     client.Parameters.Clear();\r
 709                     \r
 710 \r
 711                     //Set Tags\r
 712                     foreach (var tag in containerInfo.Tags)\r
 713                     {\r
 714                         var headerTag = String.Format("X-Container-Meta-{0}", tag.Key);\r
 715                         client.Headers.Add(headerTag, tag.Value);\r
 716                     }\r
 717 \r
 718                     \r
 719                     //Set Policies\r
 720                     foreach (var policy in containerInfo.Policies)\r
 721                     {\r
 722                         var headerPolicy = String.Format("X-Container-Policy-{0}", policy.Key);\r
 723                         client.Headers.Add(headerPolicy, policy.Value);\r
 724                     }\r
 725 \r
 726 \r
 727                     var uriBuilder = client.GetAddressBuilder(containerInfo.Name,_emptyUri);\r
 728                     var uri = uriBuilder.Uri;\r
 729 \r
 730                     client.UploadValues(uri,new NameValueCollection());\r
 731 \r
 732 \r
 733                     client.AssertStatusOK("UpdateMetadata failed");\r
 734                     //If the status is NOT ACCEPTED or OK we have a problem\r
 735                     if (!(client.StatusCode == HttpStatusCode.Accepted || client.StatusCode == HttpStatusCode.OK))\r
 736                     {\r
 737                         Log.Error("Failed to update metadata");\r
 738                         throw new Exception("Failed to update metadata");\r
 739                     }\r
 740 \r
 741                     if (Log.IsDebugEnabled) Log.DebugFormat("END");\r
 742                 }\r
 743             }\r
 744 \r
 745         }\r
 746 \r
 747        \r
 748 \r
 749 \r
 750         public IList<ObjectInfo> ListObjects(string account, Uri container, DateTimeOffset? since = null)\r
 751         {\r
 752             if (container==null)\r
 753                 throw new ArgumentNullException("container");\r
 754             if (container.IsAbsoluteUri)\r
 755                 throw new ArgumentException("container");\r
 756             Contract.EndContractBlock();\r
 757 \r
 758             using (ThreadContext.Stacks["Objects"].Push("List"))\r
 759             {\r
 760 \r
 761                 var containerUri = GetTargetUri(account).Combine(container);\r
 762                 var targetUri = new Uri(String.Format("{0}?format=json", containerUri), UriKind.Absolute);\r
 763 \r
 764                 var content =TaskEx.Run(async ()=>await GetStringAsync(targetUri, "ListObjects failed", since).ConfigureAwait(false)).Result;\r
 765 \r
 766                 //304 will result in an empty string. Empty containers return an empty json array\r
 767                 if (String.IsNullOrWhiteSpace(content))\r
 768                      return new[] {new NoModificationInfo(account, container)};\r
 769 \r
 770                  //If the result is empty, return an empty list,\r
 771                  var infos = String.IsNullOrWhiteSpace(content)\r
 772                                  ? new List<ObjectInfo>()\r
 773                              //Otherwise deserialize the object list into a list of ObjectInfos\r
 774                                  : JsonConvert.DeserializeObject<IList<ObjectInfo>>(content);\r
 775 \r
 776                  foreach (var info in infos)\r
 777                  {\r
 778                      info.Container = container;\r
 779                      info.Account = account;\r
 780                      info.StorageUri = StorageUrl;\r
 781                  }\r
 782                  if (Log.IsDebugEnabled) Log.DebugFormat("END");\r
 783                  return infos;\r
 784             }\r
 785         }\r
 786 \r
 787         public IList<ObjectInfo> ListObjects(string account, Uri container, Uri folder, DateTimeOffset? since = null)\r
 788         {\r
 789             if (container==null)\r
 790                 throw new ArgumentNullException("container");\r
 791             if (container.IsAbsoluteUri)\r
 792                 throw new ArgumentException("container");\r
 793             Contract.EndContractBlock();\r
 794 \r
 795             using (ThreadContext.Stacks["Objects"].Push("List"))\r
 796             {\r
 797                 if (Log.IsDebugEnabled) Log.DebugFormat("START");\r
 798 \r
 799                 var containerUri = GetTargetUri(account).Combine(container);\r
 800                 var targetUri = new Uri(String.Format("{0}?format=json&path={1}", containerUri,folder), UriKind.Absolute);\r
 801                 var content = TaskEx.Run(async ()=>await GetStringAsync(targetUri, "ListObjects failed", since).ConfigureAwait(false)).Result;                \r
 802 \r
 803                 //304 will result in an empty string. Empty containers return an empty json array\r
 804                 if (String.IsNullOrWhiteSpace(content))\r
 805                     return new[] { new NoModificationInfo(account, container) };\r
 806 \r
 807 \r
 808                 var infos = JsonConvert.DeserializeObject<IList<ObjectInfo>>(content);\r
 809                 foreach (var info in infos)\r
 810                 {\r
 811                     info.Account = account;\r
 812                     if (info.Container == null)\r
 813                         info.Container = container;\r
 814                     info.StorageUri = StorageUrl;\r
 815                 }\r
 816                 if (Log.IsDebugEnabled) Log.DebugFormat("END");\r
 817                 return infos;\r
 818 /*\r
 819                 using (var client = new RestClient(_baseClient))\r
 820                 {\r
 821                     if (!String.IsNullOrWhiteSpace(account))\r
 822                         client.BaseAddress = GetAccountUrl(account);\r
 823 \r
 824                     client.Parameters.Clear();\r
 825                     client.Parameters.Add("format", "json");\r
 826                     client.Parameters.Add("path", folder.ToString());\r
 827                     client.IfModifiedSince = since;\r
 828                     var content = client.DownloadStringWithRetryRelative(container, 3);\r
 829                     client.AssertStatusOK("ListObjects failed");\r
 830 \r
 831                     if (client.StatusCode==HttpStatusCode.NotModified)\r
 832                         return new[]{new NoModificationInfo(account,container,folder)};\r
 833 \r
 834                     var infos = JsonConvert.DeserializeObject<IList<ObjectInfo>>(content);\r
 835                     foreach (var info in infos)\r
 836                     {\r
 837                         info.Account = account;\r
 838                         if (info.Container == null)\r
 839                             info.Container = container;\r
 840                         info.StorageUri = StorageUrl;\r
 841                     }\r
 842                     if (Log.IsDebugEnabled) Log.DebugFormat("END");\r
 843                     return infos;\r
 844                 }\r
 845 */\r
 846             }\r
 847         }\r
 848 \r
 849  \r
 850         public async Task<bool> ContainerExists(string account, Uri container)\r
 851         {\r
 852             if (container==null)\r
 853                 throw new ArgumentNullException("container", "The container property can't be empty");\r
 854             if (container.IsAbsoluteUri)\r
 855                 throw new ArgumentException( "The container must be relative","container");\r
 856             Contract.EndContractBlock();\r
 857 \r
 858             using (ThreadContext.Stacks["Containters"].Push("Exists"))\r
 859             {\r
 860                 if (Log.IsDebugEnabled) Log.DebugFormat("START");\r
 861 \r
 862                 var targetUri = GetTargetUri(account).Combine(container);\r
 863 \r
 864                 using (var response =await _baseHttpClient.HeadAsyncWithRetries(targetUri, 3))\r
 865                 {\r
 866 \r
 867                     bool result;\r
 868                     switch (response.StatusCode)\r
 869                     {\r
 870                         case HttpStatusCode.OK:\r
 871                         case HttpStatusCode.NoContent:\r
 872                             result = true;\r
 873                             break;\r
 874                         case HttpStatusCode.NotFound:\r
 875                             result = false;\r
 876                             break;\r
 877                         default:\r
 878                             throw CreateWebException("ContainerExists", response.StatusCode);\r
 879                     }\r
 880                     if (Log.IsDebugEnabled) Log.DebugFormat("END");\r
 881 \r
 882                     return result;\r
 883                 }\r
 884 \r
 885             }\r
 886         }\r
 887 \r
 888         private Uri GetTargetUri(string account)\r
 889         {\r
 890             return new Uri(GetTargetUrl(account),UriKind.Absolute);\r
 891         }\r
 892 \r
 893         private string GetTargetUrl(string account)\r
 894         {\r
 895             return String.IsNullOrWhiteSpace(account)\r
 896                        ? _baseHttpClient.BaseAddress.ToString()\r
 897                        : GetAccountUrl(account);\r
 898         }\r
 899 \r
 900         public async Task<bool> ObjectExists(string account, Uri container, Uri objectName)\r
 901         {\r
 902             if (container == null)\r
 903                 throw new ArgumentNullException("container", "The container property can't be empty");\r
 904             if (container.IsAbsoluteUri)\r
 905                 throw new ArgumentException("The container must be relative","container");\r
 906             if (objectName == null)\r
 907                 throw new ArgumentNullException("objectName", "The objectName property can't be empty");\r
 908             if (objectName.IsAbsoluteUri)\r
 909                 throw new ArgumentException("The objectName must be relative","objectName");\r
 910             Contract.EndContractBlock();\r
 911 \r
 912                 var targetUri=GetTargetUri(account).Combine(container).Combine(objectName);\r
 913 \r
 914             using (var response = await _baseHttpClient.HeadAsyncWithRetries(targetUri, 3).ConfigureAwait(false))\r
 915             {\r
 916                 switch (response.StatusCode)\r
 917                 {\r
 918                     case HttpStatusCode.OK:\r
 919                     case HttpStatusCode.NoContent:\r
 920                         return true;\r
 921                     case HttpStatusCode.NotFound:\r
 922                         return false;\r
 923                     default:\r
 924                         throw CreateWebException("ObjectExists", response.StatusCode);\r
 925                 }\r
 926             }\r
 927         }\r
 928 \r
 929         public async Task<ObjectInfo> GetObjectInfo(string account, Uri container, Uri objectName)\r
 930         {\r
 931             if (container == null)\r
 932                 throw new ArgumentNullException("container", "The container property can't be empty");\r
 933             if (container.IsAbsoluteUri)\r
 934                 throw new ArgumentException("The container must be relative", "container");\r
 935             if (objectName == null)\r
 936                 throw new ArgumentNullException("objectName", "The objectName property can't be empty");\r
 937             if (objectName.IsAbsoluteUri)\r
 938                 throw new ArgumentException("The objectName must be relative", "objectName");\r
 939             Contract.EndContractBlock();\r
 940 \r
 941             using (ThreadContext.Stacks["Objects"].Push("GetObjectInfo"))\r
 942             {\r
 943 \r
 944                 var targetUri = GetTargetUri(account).Combine(container).Combine(objectName);\r
 945                 try\r
 946                 {\r
 947                     using (var response = await _baseHttpClient.HeadAsyncWithRetries(targetUri, 3,true))\r
 948                     {\r
 949                         switch (response.StatusCode)\r
 950                         {\r
 951                             case HttpStatusCode.OK:\r
 952                             case HttpStatusCode.NoContent:\r
 953                                 var tags = response.Headers.GetMeta("X-Object-Meta-");\r
 954                                 var extensions = (from header in response.Headers\r
 955                                                   where\r
 956                                                       header.Key.StartsWith("X-Object-") &&\r
 957                                                       !header.Key.StartsWith("X-Object-Meta-")\r
 958                                                   select new {Name = header.Key, Value = header.Value.FirstOrDefault()})\r
 959                                     .ToDictionary(t => t.Name, t => t.Value);\r
 960 \r
 961                                 var permissions = response.Headers.GetFirstValue("X-Object-Sharing");\r
 962 \r
 963 \r
 964                                 var info = new ObjectInfo\r
 965                                                {\r
 966                                                    Account = account,\r
 967                                                    Container = container,\r
 968                                                    Name = objectName,\r
 969                                                    ETag = response.Headers.ETag.NullSafe(e=>e.Tag),\r
 970                                                    UUID = response.Headers.GetFirstValue("X-Object-UUID"),\r
 971                                                    X_Object_Hash = response.Headers.GetFirstValue("X-Object-Hash"),\r
 972                                                    Content_Type = response.Headers.GetFirstValue("Content-Type"),\r
 973                                                    Bytes = Convert.ToInt64(response.Content.Headers.ContentLength),\r
 974                                                    Tags = tags,\r
 975                                                    Last_Modified = response.Content.Headers.LastModified,\r
 976                                                    Extensions = extensions,\r
 977                                                    ContentEncoding =\r
 978                                                        response.Content.Headers.ContentEncoding.FirstOrDefault(),\r
 979                                                    ContendDisposition =\r
 980                                                        response.Content.Headers.ContentDisposition.NullSafe(c=>c.ToString()),\r
 981                                                    Manifest = response.Headers.GetFirstValue("X-Object-Manifest"),\r
 982                                                    PublicUrl = response.Headers.GetFirstValue("X-Object-Public"),\r
 983                                                    StorageUri = StorageUrl,\r
 984                                                };\r
 985                                 info.SetPermissions(permissions);\r
 986                                 return info;\r
 987                             case HttpStatusCode.NotFound:\r
 988                                 return ObjectInfo.Empty;\r
 989                             default:\r
 990                                 throw new WebException(\r
 991                                     String.Format("[FAIL] GetObjectInfo for {0} failed with unexpected status code {1}",\r
 992                                                   objectName, response.StatusCode));\r
 993                         }\r
 994                     }\r
 995                 }\r
 996                 catch (RetryException)\r
 997                 {\r
 998                     Log.WarnFormat("[RETRY FAIL] GetObjectInfo for {0} failed.", objectName);\r
 999                     return ObjectInfo.Empty;\r
1000                 }\r
1001                 catch (WebException e)\r
1002                 {\r
1003                     Log.Error(\r
1004                         String.Format("[FAIL] GetObjectInfo for {0} failed with unexpected status {1}",\r
1005                                       objectName, e.Status), e);\r
1006                     throw;\r
1007                 }\r
1008             }\r
1009         }\r
1010 \r
1011 \r
1012 \r
1013         public async Task CreateFolder(string account, Uri container, Uri folder)\r
1014         {\r
1015             if (container == null)\r
1016                 throw new ArgumentNullException("container", "The container property can't be empty");\r
1017             if (container.IsAbsoluteUri)\r
1018                 throw new ArgumentException("The container must be relative","container");\r
1019             if (folder == null)\r
1020                 throw new ArgumentNullException("folder", "The objectName property can't be empty");\r
1021             if (folder.IsAbsoluteUri)\r
1022                 throw new ArgumentException("The objectName must be relative","folder");\r
1023             Contract.EndContractBlock();\r
1024 \r
1025             var folderUri=container.Combine(folder);            \r
1026             var targetUri = GetTargetUri(account).Combine(folderUri);\r
1027             var message = new HttpRequestMessage(HttpMethod.Put, targetUri);\r
1028             \r
1029             message.Headers.Add("Content-Type", ObjectInfo.CONTENT_TYPE_DIRECTORY);\r
1030             message.Headers.Add("Content-Length", "0");\r
1031             using (var response = await _baseHttpClient.SendAsyncWithRetries(message, 3).ConfigureAwait(false))\r
1032             {\r
1033                 if (response.StatusCode != HttpStatusCode.Created && response.StatusCode != HttpStatusCode.Accepted)\r
1034                     throw CreateWebException("CreateFolder", response.StatusCode);\r
1035             }\r
1036         }\r
1037 \r
1038         private Dictionary<string, string> GetMeta(HttpResponseMessage response,string metaPrefix)\r
1039         {\r
1040             if (String.IsNullOrWhiteSpace(metaPrefix))\r
1041                 throw new ArgumentNullException("metaPrefix");\r
1042             Contract.EndContractBlock();\r
1043 \r
1044             var dict = (from header in response.Headers\r
1045                         where header.Key.StartsWith(metaPrefix)\r
1046                          select new { Name = header.Key, Value = String.Join(",", header.Value) })\r
1047                         .ToDictionary(t => t.Name, t => t.Value);\r
1048 \r
1049           \r
1050             return dict;\r
1051         }\r
1052 \r
1053 \r
1054         public async Task<ContainerInfo> GetContainerInfo(string account, Uri container)\r
1055         {\r
1056             if (container == null)\r
1057                 throw new ArgumentNullException("container", "The container property can't be empty");\r
1058             if (container.IsAbsoluteUri)\r
1059                 throw new ArgumentException("The container must be relative","container");\r
1060             Contract.EndContractBlock();\r
1061 \r
1062             var targetUri = GetTargetUri(account).Combine(container);            \r
1063             using (var response = await _baseHttpClient.HeadAsyncWithRetries(targetUri, 3).ConfigureAwait(false))\r
1064             {\r
1065                 if (Log.IsDebugEnabled)\r
1066                     Log.DebugFormat("ContainerInfo data: {0}\n{1}",response,await response.Content.ReadAsStringAsync().ConfigureAwait(false));\r
1067                 switch (response.StatusCode)\r
1068                 {\r
1069                     case HttpStatusCode.OK:\r
1070                     case HttpStatusCode.NoContent:\r
1071                         var tags = GetMeta(response,"X-Container-Meta-");\r
1072                         var policies = GetMeta(response,"X-Container-Policy-");\r
1073 \r
1074                         var containerInfo = new ContainerInfo\r
1075                                                 {\r
1076                                                     Account = account,\r
1077                                                     Name = container,\r
1078                                                     StorageUrl = StorageUrl.ToString(),\r
1079                                                     Count =long.Parse(response.Headers.GetFirstValue("X-Container-Object-Count")),\r
1080                                                     Bytes = long.Parse(response.Headers.GetFirstValue("X-Container-Bytes-Used")),\r
1081                                                     BlockHash = response.Headers.GetFirstValue("X-Container-Block-Hash"),\r
1082                                                     BlockSize =\r
1083                                                         int.Parse(response.Headers.GetFirstValue("X-Container-Block-Size")),\r
1084                                                     Last_Modified = response.Content.Headers.LastModified,\r
1085                                                     Tags = tags,\r
1086                                                     Policies = policies\r
1087                                                 };\r
1088 \r
1089 \r
1090                         return containerInfo;\r
1091                     case HttpStatusCode.NotFound:\r
1092                         return ContainerInfo.Empty;\r
1093                     default:\r
1094                         throw CreateWebException("GetContainerInfo", response.StatusCode);\r
1095                 }\r
1096             }            \r
1097         }\r
1098 \r
1099         public async Task CreateContainer(string account, Uri container)\r
1100         {\r
1101             if (container == null)\r
1102                 throw new ArgumentNullException("container", "The container property can't be empty");\r
1103             if (container.IsAbsoluteUri)\r
1104                 throw new ArgumentException("The container must be relative","container");\r
1105             Contract.EndContractBlock();\r
1106 \r
1107             var targetUri=GetTargetUri(account).Combine(container);\r
1108             var message = new HttpRequestMessage(HttpMethod.Put, targetUri);\r
1109             message.Headers.Add("Content-Length", "0");\r
1110             using (var response =await _baseHttpClient.SendAsyncWithRetries(message, 3).ConfigureAwait(false))\r
1111             {            \r
1112                 var expectedCodes = new[] {HttpStatusCode.Created, HttpStatusCode.Accepted, HttpStatusCode.OK};\r
1113                 if (!expectedCodes.Contains(response.StatusCode))\r
1114                     throw CreateWebException("CreateContainer", response.StatusCode);\r
1115             }\r
1116         }\r
1117 \r
1118         public async Task WipeContainer(string account, Uri container)\r
1119         {\r
1120             if (container == null)\r
1121                 throw new ArgumentNullException("container", "The container property can't be empty");\r
1122             if (container.IsAbsoluteUri)\r
1123                 throw new ArgumentException("The container must be relative", "container");\r
1124             Contract.EndContractBlock();\r
1125 \r
1126             await DeleteContainer(account, new Uri(String.Format("{0}?delimiter=/", container), UriKind.Relative)).ConfigureAwait(false);\r
1127         }\r
1128 \r
1129 \r
1130         public async Task DeleteContainer(string account, Uri container)\r
1131         {\r
1132             if (container == null)\r
1133                 throw new ArgumentNullException("container", "The container property can't be empty");\r
1134             if (container.IsAbsoluteUri)\r
1135                 throw new ArgumentException("The container must be relative","container");\r
1136             Contract.EndContractBlock();\r
1137 \r
1138             var targetUri = GetTargetUri(account).Combine(container);\r
1139             var message = new HttpRequestMessage(HttpMethod.Delete, targetUri);\r
1140             using (var response = await _baseHttpClient.SendAsyncWithRetries(message, 3).ConfigureAwait(false))\r
1141             {\r
1142                 var expectedCodes = new[] { HttpStatusCode.NotFound, HttpStatusCode.NoContent };\r
1143                 if (!expectedCodes.Contains(response.StatusCode))\r
1144                     throw CreateWebException("DeleteContainer", response.StatusCode);\r
1145             }\r
1146 \r
1147         }\r
1148 \r
1149         /// <summary>\r
1150         /// \r
1151         /// </summary>\r
1152         /// <param name="account"></param>\r
1153         /// <param name="container"></param>\r
1154         /// <param name="objectName"></param>\r
1155         /// <param name="fileName"></param>\r
1156         /// <param name="cancellationToken"> </param>\r
1157         /// <returns></returns>\r
1158         /// <remarks>This method should have no timeout or a very long one</remarks>\r
1159         //Asynchronously download the object specified by *objectName* in a specific *container* to \r
1160         // a local file\r
1161         public async Task GetObject(string account, Uri container, Uri objectName, string fileName,CancellationToken cancellationToken)\r
1162         {\r
1163             if (container == null)\r
1164                 throw new ArgumentNullException("container", "The container property can't be empty");\r
1165             if (container.IsAbsoluteUri)\r
1166                 throw new ArgumentException("The container must be relative","container");\r
1167             if (objectName == null)\r
1168                 throw new ArgumentNullException("objectName", "The objectName property can't be empty");\r
1169             if (objectName.IsAbsoluteUri)\r
1170                 throw new ArgumentException("The objectName must be relative","objectName");\r
1171             Contract.EndContractBlock();\r
1172                         \r
1173 \r
1174             try\r
1175             {\r
1176                 //WebClient, and by extension RestClient, are not thread-safe. Create a new RestClient\r
1177                 //object to avoid concurrency errors.\r
1178                 //\r
1179                 //Download operations take a long time therefore they have no timeout.\r
1180                 using(var client = new RestClient(_baseClient) { Timeout = 0 })\r
1181                 {\r
1182                     if (!String.IsNullOrWhiteSpace(account))\r
1183                         client.BaseAddress = GetAccountUrl(account);\r
1184 \r
1185                     //The container and objectName are relative names. They are joined with the client's\r
1186                     //BaseAddress to create the object's absolute address\r
1187                     var builder = client.GetAddressBuilder(container, objectName);\r
1188                     var uri = builder.Uri;\r
1189 \r
1190                     //Download progress is reported to the Trace log\r
1191                     Log.InfoFormat("[GET] START {0}", objectName);\r
1192                     /*client.DownloadProgressChanged += (sender, args) =>\r
1193                                                       Log.InfoFormat("[GET PROGRESS] {0} {1}% {2} of {3}",\r
1194                                                                      fileName, args.ProgressPercentage,\r
1195                                                                      args.BytesReceived,\r
1196                                                                      args.TotalBytesToReceive);*/\r
1197                     var progress = new Progress<DownloadProgressChangedEventArgs>(args =>\r
1198                                 {\r
1199                                     Log.InfoFormat("[GET PROGRESS] {0} {1}% {2} of {3}",\r
1200                                                    fileName, args.ProgressPercentage,\r
1201                                                    args.BytesReceived,\r
1202                                                    args.TotalBytesToReceive);\r
1203                                     if (DownloadProgressChanged!=null)\r
1204                                         DownloadProgressChanged(this, new DownloadArgs(args));\r
1205                                 });\r
1206                     \r
1207                     //Start downloading the object asynchronously                    \r
1208                     await client.DownloadFileTaskAsync(uri, fileName, cancellationToken,progress).ConfigureAwait(false);\r
1209 \r
1210                     //Once the download completes\r
1211                     //Delete the local client object\r
1212                 }\r
1213                 //And report failure or completion\r
1214             }\r
1215             catch (Exception exc)\r
1216             {\r
1217                 Log.ErrorFormat("[GET] FAIL {0} with {1}", objectName, exc);\r
1218                 throw;\r
1219             }\r
1220 \r
1221             Log.InfoFormat("[GET] END {0}", objectName);                                             \r
1222 \r
1223 \r
1224         }\r
1225 \r
1226         public async Task<IList<string>> PutHashMap(string account, Uri container, Uri objectName, TreeHash hash)\r
1227         {\r
1228             if (container == null)\r
1229                 throw new ArgumentNullException("container", "The container property can't be empty");\r
1230             if (container.IsAbsoluteUri)\r
1231                 throw new ArgumentException("The container must be relative","container");\r
1232             if (objectName == null)\r
1233                 throw new ArgumentNullException("objectName", "The objectName property can't be empty");\r
1234             if (objectName.IsAbsoluteUri)\r
1235                 throw new ArgumentException("The objectName must be relative","objectName");\r
1236             if (hash == null)\r
1237                 throw new ArgumentNullException("hash");\r
1238             if (String.IsNullOrWhiteSpace(Token))\r
1239                 throw new InvalidOperationException("Invalid Token");\r
1240             if (StorageUrl == null)\r
1241                 throw new InvalidOperationException("Invalid Storage Url");\r
1242             Contract.EndContractBlock();\r
1243 \r
1244             \r
1245 \r
1246             //The container and objectName are relative names. They are joined with the client's\r
1247             //BaseAddress to create the object's absolute address\r
1248 \r
1249             var targetUri = GetTargetUri(account).Combine(container).Combine(objectName);\r
1250   \r
1251 \r
1252             var uri = new Uri(String.Format("{0}?format=json&hashmap",targetUri),UriKind.Absolute);\r
1253 \r
1254             \r
1255             //Send the tree hash as Json to the server            \r
1256             var jsonHash = hash.ToJson();\r
1257             if (Log.IsDebugEnabled)\r
1258                 Log.DebugFormat("Hashes:\r\n{0}", jsonHash);\r
1259 \r
1260             var message = new HttpRequestMessage(HttpMethod.Put, uri)\r
1261             {\r
1262                 Content = new StringContent(jsonHash)\r
1263             };\r
1264             message.Headers.Add("ETag",hash.TopHash.ToHashString());\r
1265             \r
1266             //Don't use a timeout because putting the hashmap may be a long process\r
1267 \r
1268             using (var response = await _baseHttpClientNoTimeout.SendAsyncWithRetries(message, 3).ConfigureAwait(false))\r
1269             {\r
1270                 var empty = (IList<string>)new List<string>();\r
1271                 \r
1272                 switch (response.StatusCode)\r
1273                 {\r
1274                     case HttpStatusCode.Created:\r
1275                         //The server will respond either with 201-created if all blocks were already on the server\r
1276                         return empty;\r
1277                     case HttpStatusCode.Conflict:\r
1278                         //or with a 409-conflict and return the list of missing parts\r
1279                         using (var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false))\r
1280                         using(var reader=stream.GetLoggedReader(Log))\r
1281                         {                            \r
1282                             var serializer = new JsonSerializer();                            \r
1283                             serializer.Error += (sender, args) => Log.ErrorFormat("Deserialization error at [{0}] [{1}]", args.ErrorContext.Error, args.ErrorContext.Member);\r
1284                             var hashes = (List<string>)serializer.Deserialize(reader, typeof(List<string>));\r
1285                             return hashes;\r
1286                         }                        \r
1287                     default:\r
1288                         //All other cases are unexpected\r
1289                         //Ensure that failure codes raise exceptions\r
1290                         response.EnsureSuccessStatusCode();\r
1291                         //And log any other codes as warngings, but continute processing\r
1292                         Log.WarnFormat("Unexcpected status code when putting map: {0} - {1}",response.StatusCode,response.ReasonPhrase);\r
1293                         return empty;\r
1294                 }\r
1295             }\r
1296 \r
1297         }\r
1298 \r
1299 \r
1300         public async Task<byte[]> GetBlock(string account, Uri container, Uri relativeUrl, long start, long? end, CancellationToken cancellationToken)\r
1301         {\r
1302             if (String.IsNullOrWhiteSpace(Token))\r
1303                 throw new InvalidOperationException("Invalid Token");\r
1304             if (StorageUrl == null)\r
1305                 throw new InvalidOperationException("Invalid Storage Url");\r
1306             if (container == null)\r
1307                 throw new ArgumentNullException("container", "The container property can't be empty");\r
1308             if (container.IsAbsoluteUri)\r
1309                 throw new ArgumentException("The container must be relative","container");\r
1310             if (relativeUrl == null)\r
1311                 throw new ArgumentNullException("relativeUrl");\r
1312             if (end.HasValue && end < 0)\r
1313                 throw new ArgumentOutOfRangeException("end");\r
1314             if (start < 0)\r
1315                 throw new ArgumentOutOfRangeException("start");\r
1316             Contract.EndContractBlock();\r
1317 \r
1318 \r
1319             var targetUri = GetTargetUri(account).Combine(container).Combine(relativeUrl);\r
1320             var message = new HttpRequestMessage(HttpMethod.Get, targetUri);\r
1321             //Don't add a range if start=0, end=null (empty files)\r
1322             if (start!=0 || end!=null)\r
1323                 message.Headers.Range=new RangeHeaderValue(start,end);\r
1324 \r
1325             //Don't use a timeout because putting the hashmap may be a long process\r
1326 \r
1327             IProgress<DownloadArgs> progress = new Progress<DownloadArgs>(args =>\r
1328                 {\r
1329                     Log.DebugFormat("[GET PROGRESS] {0} {1}% {2} of {3}",\r
1330                                     targetUri.Segments.Last(), args.ProgressPercentage,\r
1331                                     args.BytesReceived,\r
1332                                     args.TotalBytesToReceive);\r
1333 \r
1334                     if (DownloadProgressChanged!=null)\r
1335                         DownloadProgressChanged(this,  args);\r
1336                 });\r
1337 \r
1338 \r
1339             using (var response = await _baseHttpClientNoTimeout.SendAsyncWithRetries(message, 3, false,HttpCompletionOption.ResponseHeadersRead,\r
1340                                                           cancellationToken).ConfigureAwait(false))\r
1341             using (var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false))\r
1342             using(var targetStream=new MemoryStream())\r
1343             {\r
1344                 \r
1345                 long totalSize = response.Content.Headers.ContentLength ?? 0;\r
1346                 long total = 0;\r
1347                 var buffer = new byte[65536];\r
1348                 int read;\r
1349                 while ((read = await stream.ReadAsync(buffer, 0, buffer.Length).ConfigureAwait(false)) != 0)\r
1350                 {\r
1351                     total += read;\r
1352                     progress.Report(new DownloadArgs(total, totalSize));\r
1353                     await targetStream.WriteAsync(buffer, 0, read).ConfigureAwait(false);\r
1354                 }\r
1355 \r
1356                 var result = targetStream.ToArray();\r
1357                 return result;\r
1358             }\r
1359        \r
1360         }\r
1361 \r
1362         public event EventHandler<UploadArgs> UploadProgressChanged;\r
1363         public event EventHandler<DownloadArgs> DownloadProgressChanged;\r
1364         \r
1365 \r
1366         public async Task PostBlock(string account, Uri container, byte[] block, int offset, int count,string blockHash,CancellationToken token)\r
1367         {\r
1368             if (container == null)\r
1369                 throw new ArgumentNullException("container", "The container property can't be empty");\r
1370             if (container.IsAbsoluteUri)\r
1371                 throw new ArgumentException("The container must be relative","container");\r
1372             if (block == null)\r
1373                 throw new ArgumentNullException("block");\r
1374             if (offset < 0 || offset >= block.Length)\r
1375                 throw new ArgumentOutOfRangeException("offset");\r
1376             if (count < 0 || count > block.Length)\r
1377                 throw new ArgumentOutOfRangeException("count");\r
1378             if (String.IsNullOrWhiteSpace(Token))\r
1379                 throw new InvalidOperationException("Invalid Token");\r
1380             if (StorageUrl == null)\r
1381                 throw new InvalidOperationException("Invalid Storage Url");                        \r
1382             Contract.EndContractBlock();\r
1383 \r
1384 \r
1385             try\r
1386             {\r
1387                 var containerUri = GetTargetUri(account).Combine(container);\r
1388                 var targetUri = new Uri(String.Format("{0}?update", containerUri));\r
1389 \r
1390 \r
1391                 //Don't use a timeout because putting the hashmap may be a long process\r
1392 \r
1393 \r
1394                 Log.InfoFormat("[BLOCK POST] START");\r
1395 \r
1396 \r
1397                 var progress = new Progress<UploadArgs>(args =>\r
1398                 {\r
1399                     Log.InfoFormat("[BLOCK POST PROGRESS] {0}% {1} of {2}",\r
1400                         args.ProgressPercentage,\r
1401                         args.BytesSent,\r
1402                         args.TotalBytesToSend);\r
1403                     if (UploadProgressChanged != null)\r
1404                         UploadProgressChanged(this,args);\r
1405                 });\r
1406 \r
1407                 var message = new HttpRequestMessage(HttpMethod.Post, targetUri)\r
1408                                   {\r
1409                                       Content = new ByteArrayContentWithProgress(block, offset, count,progress)\r
1410                                   };\r
1411                 message.Content.Headers.ContentType = MediaTypeHeaderValue.Parse(@"application/octet-stream");\r
1412 \r
1413                 //Send the block\r
1414                 using (var response = await _baseHttpClientNoTimeout.SendAsyncWithRetries(message, 3,false,HttpCompletionOption.ResponseContentRead,token).ConfigureAwait(false))\r
1415                 {                    \r
1416                     Log.InfoFormat("[BLOCK POST PROGRESS] Completed ");\r
1417                     response.EnsureSuccessStatusCode();\r
1418                     var responseHash = await response.Content.ReadAsStringAsync().ConfigureAwait(false);\r
1419                     var cleanHash = responseHash.TrimEnd();\r
1420                     Debug.Assert(blockHash==cleanHash);\r
1421                     if (!blockHash.Equals(cleanHash, StringComparison.OrdinalIgnoreCase))\r
1422                         Log.ErrorFormat("Block hash mismatch posting to [{0}]:[{1}], expected [{2}] but was [{3}]", account, container, blockHash, cleanHash);\r
1423                 }\r
1424                 Log.InfoFormat("[BLOCK POST] END");               \r
1425             }\r
1426             catch (TaskCanceledException )\r
1427             {\r
1428                 Log.Info("Aborting block");\r
1429                 throw;\r
1430             }\r
1431             catch (Exception exc)\r
1432             {\r
1433                 Log.ErrorFormat("[BLOCK POST] FAIL with \r{0}", exc);\r
1434                 throw;\r
1435             }\r
1436         }\r
1437 \r
1438         public async Task PostBlock(string account, Uri container, string filePath, long offset, int count, string blockHash, CancellationToken token)\r
1439         {\r
1440             if (container == null)\r
1441                 throw new ArgumentNullException("container", "The container property can't be empty");\r
1442             if (container.IsAbsoluteUri)\r
1443                 throw new ArgumentException("The container must be relative", "container");\r
1444             if (String.IsNullOrWhiteSpace(filePath))\r
1445                 throw new ArgumentNullException("filePath");\r
1446             if (!File.Exists(filePath))\r
1447                 throw new FileNotFoundException("Missing file","filePath");\r
1448             if (String.IsNullOrWhiteSpace(Token))\r
1449                 throw new InvalidOperationException("Invalid Token");\r
1450             if (StorageUrl == null)\r
1451                 throw new InvalidOperationException("Invalid Storage Url");\r
1452             Contract.EndContractBlock();\r
1453 \r
1454 \r
1455             try\r
1456             {\r
1457                 var containerUri = GetTargetUri(account).Combine(container);\r
1458                 var targetUri = new Uri(String.Format("{0}?update", containerUri));\r
1459 \r
1460 \r
1461                 //Don't use a timeout because putting the hashmap may be a long process\r
1462 \r
1463 \r
1464                 Log.InfoFormat("[BLOCK POST] START");\r
1465 \r
1466 \r
1467                 var progress = new Progress<UploadArgs>(args =>\r
1468                 {\r
1469                     Log.InfoFormat("[BLOCK POST PROGRESS] {0}% {1} of {2} at {3:###,} Kbps ",\r
1470                         args.ProgressPercentage,\r
1471                         args.BytesSent,\r
1472                         args.TotalBytesToSend,args.Speed);\r
1473                     if (UploadProgressChanged != null)\r
1474                         UploadProgressChanged(this, args);\r
1475                 });\r
1476 \r
1477                 var message = new HttpRequestMessage(HttpMethod.Post, targetUri)\r
1478                 {\r
1479                     Content = new FileBlockContent(filePath, offset, count, progress)\r
1480                 };\r
1481                 message.Content.Headers.ContentType = MediaTypeHeaderValue.Parse(@"application/octet-stream");\r
1482 \r
1483                 //Send the block\r
1484                 using (var response = await _baseHttpClientNoTimeout.SendAsyncWithRetries(message, 3, false, HttpCompletionOption.ResponseContentRead, token).ConfigureAwait(false))\r
1485                 {\r
1486                     Log.InfoFormat("[BLOCK POST PROGRESS] Completed ");\r
1487                     response.EnsureSuccessStatusCode();\r
1488                     var responseHash = await response.Content.ReadAsStringAsync().ConfigureAwait(false);\r
1489                     var cleanHash = responseHash.TrimEnd();\r
1490                     Debug.Assert(blockHash == cleanHash);\r
1491                     if (!blockHash.Equals(cleanHash, StringComparison.OrdinalIgnoreCase))\r
1492                         Log.ErrorFormat("Block hash mismatch posting to [{0}]:[{1}], expected [{2}] but was [{3}]", account, container, blockHash, cleanHash);\r
1493                 }\r
1494                 Log.InfoFormat("[BLOCK POST] END");\r
1495             }\r
1496             catch (TaskCanceledException)\r
1497             {\r
1498                 Log.Info("Aborting block");\r
1499                 throw;\r
1500             }                \r
1501             catch (Exception exc)\r
1502             {\r
1503                 Log.ErrorFormat("[BLOCK POST] FAIL with \r{0}", exc);\r
1504                 throw;\r
1505             }\r
1506         }\r
1507 \r
1508 \r
1509         public async Task<TreeHash> GetHashMap(string account, Uri container, Uri objectName)\r
1510         {\r
1511             if (container == null)\r
1512                 throw new ArgumentNullException("container", "The container property can't be empty");\r
1513             if (container.IsAbsoluteUri)\r
1514                 throw new ArgumentException("The container must be relative","container");\r
1515             if (objectName == null)\r
1516                 throw new ArgumentNullException("objectName", "The objectName property can't be empty");\r
1517             if (objectName.IsAbsoluteUri)\r
1518                 throw new ArgumentException("The objectName must be relative","objectName");\r
1519             if (String.IsNullOrWhiteSpace(Token))\r
1520                 throw new InvalidOperationException("Invalid Token");\r
1521             if (StorageUrl == null)\r
1522                 throw new InvalidOperationException("Invalid Storage Url");\r
1523             Contract.EndContractBlock();\r
1524 \r
1525             try\r
1526             {\r
1527 \r
1528                 var objectUri = GetTargetUri(account).Combine(container).Combine(objectName);\r
1529                 var targetUri = new Uri(String.Format("{0}?format=json&hashmap", objectUri));\r
1530 \r
1531                 //Start downloading the object asynchronously\r
1532                 var json = await GetStringAsync(targetUri, "").ConfigureAwait(false);\r
1533                 var treeHash = TreeHash.Parse(json);\r
1534                 Log.InfoFormat("[GET HASH] END {0}", objectName);\r
1535                 return treeHash;\r
1536 \r
1537             }\r
1538             catch (Exception exc)\r
1539             {\r
1540                 Log.ErrorFormat("[GET HASH] END {0} with {1}", objectName, exc);\r
1541                 throw;\r
1542             }\r
1543 \r
1544         }\r
1545 \r
1546 \r
1547         /// <summary>\r
1548         /// \r
1549         /// </summary>\r
1550         /// <param name="account"></param>\r
1551         /// <param name="container"></param>\r
1552         /// <param name="objectName"></param>\r
1553         /// <param name="fileName"></param>\r
1554         /// <param name="hash">Optional hash value for the file. If no hash is provided, the method calculates a new hash</param>\r
1555         /// <param name="contentType"> </param>\r
1556         /// <remarks>>This method should have no timeout or a very long one</remarks>\r
1557         public async Task PutObject(string account, Uri container, Uri objectName, string fileName, string hash = Signature.MERKLE_EMPTY, string contentType = "application/octet-stream")\r
1558         {\r
1559             if (container == null)\r
1560                 throw new ArgumentNullException("container", "The container property can't be empty");\r
1561             if (container.IsAbsoluteUri)\r
1562                 throw new ArgumentException("The container must be relative","container");\r
1563             if (objectName == null)\r
1564                 throw new ArgumentNullException("objectName", "The objectName property can't be empty");\r
1565             if (objectName.IsAbsoluteUri)\r
1566                 throw new ArgumentException("The objectName must be relative","objectName");\r
1567             if (String.IsNullOrWhiteSpace(fileName))\r
1568                 throw new ArgumentNullException("fileName", "The fileName property can't be empty");\r
1569             try\r
1570             {\r
1571 \r
1572                 using (var client = new RestClient(_baseClient) { Timeout = 0 })\r
1573                 {\r
1574                     if (!String.IsNullOrWhiteSpace(account))\r
1575                         client.BaseAddress = GetAccountUrl(account);\r
1576 \r
1577                     var builder = client.GetAddressBuilder(container, objectName);\r
1578                     var uri = builder.Uri;\r
1579 \r
1580                     string etag = hash ;\r
1581 \r
1582                     client.Headers.Add("Content-Type", contentType);\r
1583                     if (contentType!=ObjectInfo.CONTENT_TYPE_DIRECTORY)\r
1584                         client.Headers.Add("ETag", etag);\r
1585 \r
1586 \r
1587                     Log.InfoFormat("[PUT] START {0}", objectName);\r
1588                     client.UploadProgressChanged += (sender, args) =>\r
1589                                                         {\r
1590                                                             using (ThreadContext.Stacks["PUT"].Push("Progress"))\r
1591                                                             {\r
1592                                                                 Log.InfoFormat("{0} {1}% {2} of {3}", fileName,\r
1593                                                                                args.ProgressPercentage,\r
1594                                                                                args.BytesSent, args.TotalBytesToSend);\r
1595                                                             }\r
1596                                                         };\r
1597 \r
1598                     client.UploadFileCompleted += (sender, args) =>\r
1599                                                       {\r
1600                                                           using (ThreadContext.Stacks["PUT"].Push("Progress"))\r
1601                                                           {\r
1602                                                               Log.InfoFormat("Completed {0}", fileName);\r
1603                                                           }\r
1604                                                       }; \r
1605                     \r
1606                     if (contentType==ObjectInfo.CONTENT_TYPE_DIRECTORY)\r
1607                         await client.UploadDataTaskAsync(uri, "PUT", new byte[0]).ConfigureAwait(false);\r
1608                     else\r
1609                         await client.UploadFileTaskAsync(uri, "PUT", fileName).ConfigureAwait(false);\r
1610                 }\r
1611 \r
1612                 Log.InfoFormat("[PUT] END {0}", objectName);\r
1613             }\r
1614             catch (Exception exc)\r
1615             {\r
1616                 Log.ErrorFormat("[PUT] END {0} with {1}", objectName, exc);\r
1617                 throw;\r
1618             }                \r
1619 \r
1620         }\r
1621         \r
1622         public async Task MoveObject(string account, Uri sourceContainer, Uri oldObjectName, Uri targetContainer, Uri newObjectName)\r
1623         {\r
1624             if (sourceContainer == null)\r
1625                 throw new ArgumentNullException("sourceContainer", "The sourceContainer property can't be empty");\r
1626             if (sourceContainer.IsAbsoluteUri)\r
1627                 throw new ArgumentException("The sourceContainer must be relative","sourceContainer");\r
1628             if (oldObjectName == null)\r
1629                 throw new ArgumentNullException("oldObjectName", "The oldObjectName property can't be empty");\r
1630             if (oldObjectName.IsAbsoluteUri)\r
1631                 throw new ArgumentException("The oldObjectName must be relative","oldObjectName");\r
1632             if (targetContainer == null)\r
1633                 throw new ArgumentNullException("targetContainer", "The targetContainer property can't be empty");\r
1634             if (targetContainer.IsAbsoluteUri)\r
1635                 throw new ArgumentException("The targetContainer must be relative","targetContainer");\r
1636             if (newObjectName == null)\r
1637                 throw new ArgumentNullException("newObjectName", "The newObjectName property can't be empty");\r
1638             if (newObjectName.IsAbsoluteUri)\r
1639                 throw new ArgumentException("The newObjectName must be relative","newObjectName");\r
1640             Contract.EndContractBlock();\r
1641 \r
1642             var baseUri = GetTargetUri(account);\r
1643             var targetUri = baseUri.Combine(targetContainer).Combine(newObjectName);\r
1644             var sourceUri = new Uri(String.Format("/{0}/{1}", sourceContainer, oldObjectName),UriKind.Relative);\r
1645 \r
1646             var message = new HttpRequestMessage(HttpMethod.Put, targetUri);\r
1647             message.Headers.Add("X-Move-From", sourceUri.ToString());\r
1648             using (var response = await _baseHttpClient.SendAsyncWithRetries(message, 3).ConfigureAwait(false))\r
1649             {\r
1650                 var expectedCodes = new[] {HttpStatusCode.OK, HttpStatusCode.NoContent, HttpStatusCode.Created};\r
1651                 if (!expectedCodes.Contains(response.StatusCode))\r
1652                     throw CreateWebException("MoveObject", response.StatusCode);\r
1653             }\r
1654         }\r
1655 \r
1656         public async Task DeleteObject(string account, Uri sourceContainer, Uri objectName, bool isDirectory)\r
1657         {\r
1658             if (sourceContainer == null)\r
1659                 throw new ArgumentNullException("sourceContainer", "The sourceContainer property can't be empty");\r
1660             if (sourceContainer.IsAbsoluteUri)\r
1661                 throw new ArgumentException("The sourceContainer must be relative","sourceContainer");\r
1662             if (objectName == null)\r
1663                 throw new ArgumentNullException("objectName", "The objectName property can't be empty");\r
1664             if (objectName.IsAbsoluteUri)\r
1665                 throw new ArgumentException("The objectName must be relative","objectName");\r
1666             Contract.EndContractBlock();\r
1667 \r
1668 \r
1669 \r
1670             var sourceUri = new Uri(String.Format("/{0}/{1}", sourceContainer, objectName),UriKind.Relative);\r
1671 \r
1672             \r
1673             if (objectName.OriginalString.EndsWith(".ignore"))\r
1674                 using(var response = await _baseHttpClient.DeleteAsync(sourceUri)){}\r
1675             else\r
1676             {\r
1677                 var relativeUri = new Uri(String.Format("{0}/{1}", FolderConstants.TrashContainer, objectName),\r
1678                                                 UriKind.Relative);\r
1679 \r
1680 /*\r
1681                 var relativeUri = isDirectory\r
1682                                       ? new Uri(\r
1683                                             String.Format("{0}/{1}?delimiter=/", FolderConstants.TrashContainer,\r
1684                                                           objectName), UriKind.Relative)\r
1685                                       : new Uri(String.Format("{0}/{1}", FolderConstants.TrashContainer, objectName),\r
1686                                                 UriKind.Relative);\r
1687 \r
1688 */\r
1689                 var targetUri = GetTargetUri(account).Combine(relativeUri);\r
1690 \r
1691 \r
1692                 var message = new HttpRequestMessage(HttpMethod.Put, targetUri);\r
1693                 message.Headers.Add("X-Move-From", sourceUri.ToString());\r
1694 \r
1695                 Log.InfoFormat("[TRASH] [{0}] to [{1}]", sourceUri, targetUri);\r
1696                 using (var response = await _baseHttpClient.SendAsyncWithRetries(message, 3))\r
1697                 {\r
1698                     var expectedCodes = new[]\r
1699                                             {\r
1700                                                 HttpStatusCode.OK, HttpStatusCode.NoContent, HttpStatusCode.Created,\r
1701                                                 HttpStatusCode.NotFound\r
1702                                             };\r
1703                     if (!expectedCodes.Contains(response.StatusCode))\r
1704                         throw CreateWebException("DeleteObject", response.StatusCode);\r
1705                 }\r
1706             }\r
1707 /*\r
1708             \r
1709 \r
1710             var targetUrl = FolderConstants.TrashContainer + "/" + objectName;\r
1711 /*\r
1712             if (isDirectory)\r
1713                 targetUrl = targetUrl + "?delimiter=/";\r
1714 #1#\r
1715 \r
1716             var sourceUrl = String.Format("/{0}/{1}", sourceContainer, objectName);\r
1717 \r
1718             using (var client = new RestClient(_baseClient))\r
1719             {\r
1720                 if (!String.IsNullOrWhiteSpace(account))\r
1721                     client.BaseAddress = GetAccountUrl(account);\r
1722 \r
1723                 client.Headers.Add("X-Move-From", sourceUrl);\r
1724                 client.AllowedStatusCodes.Add(HttpStatusCode.NotFound);\r
1725                 Log.InfoFormat("[TRASH] [{0}] to [{1}]",sourceUrl,targetUrl);\r
1726                 client.PutWithRetry(new Uri(targetUrl,UriKind.Relative), 3);\r
1727 \r
1728                 var expectedCodes = new[] {HttpStatusCode.OK, HttpStatusCode.NoContent, HttpStatusCode.Created,HttpStatusCode.NotFound};\r
1729                 if (!expectedCodes.Contains(client.StatusCode))\r
1730                     throw CreateWebException("DeleteObject", client.StatusCode);\r
1731             }\r
1732 */\r
1733         }\r
1734 \r
1735       \r
1736         private static WebException CreateWebException(string operation, HttpStatusCode statusCode)\r
1737         {\r
1738             return new WebException(String.Format("{0} failed with unexpected status code {1}", operation, statusCode));\r
1739         }\r
1740 \r
1741 \r
1742         public async Task<bool> CanUpload(string account, ObjectInfo cloudFile)\r
1743         {\r
1744             Contract.Requires(!String.IsNullOrWhiteSpace(account));\r
1745             Contract.Requires(cloudFile!=null);\r
1746 \r
1747                 var parts = cloudFile.Name.ToString().Split('/');\r
1748                 var folder = String.Join("/", parts,0,parts.Length-1);\r
1749 \r
1750                 var fileName = String.Format("{0}/{1}.pithos.ignore", folder, Guid.NewGuid());\r
1751                 var fileUri=fileName.ToEscapedUri();                                            \r
1752 \r
1753                 try\r
1754                 {\r
1755                     var relativeUri = cloudFile.Container.Combine(fileUri);\r
1756                     var targetUri = GetTargetUri(account).Combine(relativeUri);\r
1757                     var message = new HttpRequestMessage(HttpMethod.Put, targetUri);\r
1758                     message.Content.Headers.ContentType =new MediaTypeHeaderValue("application/octet-stream");\r
1759                     var response=await _baseHttpClient.SendAsyncWithRetries(message, 3);                    \r
1760                     var expectedCodes = new[] { HttpStatusCode.OK, HttpStatusCode.NoContent, HttpStatusCode.Created};\r
1761                     var result=(expectedCodes.Contains(response.StatusCode));\r
1762                     await DeleteObject(account, cloudFile.Container, fileUri, cloudFile.IsDirectory);\r
1763                     return result;\r
1764                 }\r
1765                 catch\r
1766                 {\r
1767                     return false;\r
1768                 }\r
1769             \r
1770         }\r
1771 \r
1772         ~CloudFilesClient()\r
1773         {\r
1774             Dispose(false);\r
1775         }\r
1776 \r
1777         public void Dispose()\r
1778         {\r
1779             Dispose(true);\r
1780             GC.SuppressFinalize(this);\r
1781         }\r
1782 \r
1783         protected virtual void Dispose(bool disposing)\r
1784         {\r
1785             if (disposing)\r
1786             {\r
1787                 if (_httpClientHandler!=null)\r
1788                     _httpClientHandler.Dispose();\r
1789                 if (_baseClient!=null)\r
1790                     _baseClient.Dispose();\r
1791                 if(_baseHttpClient!=null)\r
1792                     _baseHttpClient.Dispose();\r
1793                 if (_baseHttpClientNoTimeout!=null)\r
1794                     _baseHttpClientNoTimeout.Dispose();\r
1795             }\r
1796             _httpClientHandler = null;\r
1797             _baseClient = null;\r
1798             _baseHttpClient = null;\r
1799             _baseHttpClientNoTimeout = null;\r
1800         }\r
1801     }\r
1802 \r
1803     public class ShareAccountInfo\r
1804     {\r
1805         public DateTime? last_modified { get; set; }\r
1806         public string name { get; set; }\r
1807     }\r
1808 }\r