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

Revision cfed7823 trunk/Pithos.Network/CloudFilesClient.cs

             //RestClient provides a REST-friendly interface over the standard WebClient.
             private RestClient _baseClient;
             //Some operations can specify a Timeout. The default value of all timeouts is 10 seconds
             private readonly TimeSpan _shortTimeout = TimeSpan.FromSeconds(10);
             //Some operations can be retried before failing. The default number of retries is 5
             private readonly int _retries = 5;
             //During authentication the client provides a UserName
             public string UserName { get; set; }
-...
             //The client also receives a StorageUrl after authentication. All subsequent operations must
             //use this url
             public Uri StorageUrl { get; set; }
             protected Uri RootAddressUri { get; set; }
             public Uri Proxy { get; set; }
             public double DownloadPercentLimit { get; set; }
-...
             //
             public void Authenticate(string userName,string apiKey)
+            {
                 Trace.TraceInformation("[AUTHENTICATE] Start for {0}", userName);
                 if (String.IsNullOrWhiteSpace(userName))
                     throw new ArgumentNullException("userName", "The userName property can't be empty");
                 if (String.IsNullOrWhiteSpace(apiKey))
                     throw new ArgumentNullException("apiKey", "The apiKey property can't be empty");
                 Contract.Ensures(_baseClient != null);
                 Contract.EndContractBlock();
                 Trace.TraceInformation("[AUTHENTICATE] Start for {0}", userName);
                 if (_authenticated)
                     return;
-...
                     if (Proxy != null)
                         authClient.Proxy = new WebProxy(Proxy);
                     Contract.Assume(authClient.Headers!=null);
                     authClient.Headers.Add("X-Auth-User", UserName);
                     authClient.Headers.Add("X-Auth-Key", ApiKey);
-...
                         throw new InvalidOperationException("Failed to obtain storage url");
                     StorageUrl = new Uri(storageUrl);
                     //Get the root address (StorageUrl without the account)
                     var usernameIndex=storageUrl.LastIndexOf(UserName);
                     var rootUrl = storageUrl.Substring(0, usernameIndex);
                     RootAddressUri = new Uri(rootUrl);
                     var token = authClient.GetHeaderValue("X-Auth-Token");
                     if (String.IsNullOrWhiteSpace(token))
                         throw new InvalidOperationException("Failed to obtain token url");
-...
                 if (Proxy!=null)
                     _baseClient.Proxy = new WebProxy(Proxy);
                 Contract.Assume(_baseClient.Headers!=null);
                 _baseClient.Headers.Add("X-Auth-Token", Token);
                 Trace.TraceInformation("[AUTHENTICATE] End for {0}", userName);
+            }
             public IList<ContainerInfo> ListContainers()
             public IList<ContainerInfo> ListContainers(string account)
+            {
                 using (var client = new RestClient(_baseClient))
+                {
                     if (!String.IsNullOrWhiteSpace(account))
                         client.BaseAddress = GetAccountUrl(account);
                     client.Parameters.Clear();
                     client.Parameters.Add("format", "json");
                     var content = client.DownloadStringWithRetry("", 3);
-...
+            }
             private string GetAccountUrl(string account)
+            {
                 return new Uri(this.RootAddressUri, new Uri(account,UriKind.Relative)).AbsoluteUri;
+            }
             public IList<ShareAccountInfo> ListSharingAccounts(DateTime? since=null)
+            {
                 Trace.TraceInformation("[START] ListSharingAccounts");
                 using (var client = new RestClient(_baseClient))
+                {
                     client.Parameters.Clear();
                     client.Parameters.Add("format", "json");
                     client.IfModifiedSince = since;
                     //Extract the username from the base address
                     client.BaseAddress = RootAddressUri.AbsoluteUri;
                     var content = client.DownloadStringWithRetry(@"", 3);
                     client.AssertStatusOK("ListSharingAccounts failed");
                     //If the result is empty, return an empty list,
                     var infos = String.IsNullOrWhiteSpace(content)
                         ? new List<ShareAccountInfo>()
                         //Otherwise deserialize the account list into a list of ShareAccountInfos
                         : JsonConvert.DeserializeObject<IList<ShareAccountInfo>>(content);
                     Trace.TraceInformation("[END] ListSharingAccounts");
                     return infos;
+                }
+            }
             //Request listing of all objects in a container modified since a specific time.
             //If the *since* value is missing, return all objects
             public IList<ObjectInfo> ListObjects(string container, DateTime? since = null)
             public IList<ObjectInfo> ListSharedObjects(DateTime? since = null)
+            {
                 Trace.TraceInformation("[START] ListSharedObjects");
                 var objects=new List<ObjectInfo>();
                 var accounts=ListSharingAccounts(since);
                 foreach (var account in accounts)
+                {
                     var containers=ListContainers(account.name);
                     foreach (var container in containers)
+                    {
                         var containerObjects=ListObjects(account.name, container.Name, account.last_modified);
                         objects.AddRange(containerObjects);
+                    }
+                }
                 return objects;
+            }
             public void ShareObject(string account, string container, string objectName, string shareTo, bool read, bool write)
+            {
                 if (String.IsNullOrWhiteSpace(Token))
                     throw new InvalidOperationException("The Token is not set");
                 if (StorageUrl==null)
                     throw new InvalidOperationException("The StorageUrl is not set");
                 if (String.IsNullOrWhiteSpace(container))
                     throw new ArgumentNullException("container");
                 if (String.IsNullOrWhiteSpace(objectName))
                     throw new ArgumentNullException("objectName");
                 if (String.IsNullOrWhiteSpace(account))
                     throw new ArgumentNullException("account");
                 if (String.IsNullOrWhiteSpace(shareTo))
                     throw new ArgumentNullException("shareTo");
                 Contract.EndContractBlock();
                 using (var client = new RestClient(_baseClient))
+                {
                     client.BaseAddress = GetAccountUrl(account);
                     client.Parameters.Clear();
                     client.Parameters.Add("format", "json");
                     string permission = "";
                     if (write)
                         permission = String.Format("write={0}", shareTo);
                     else if (read)
                         permission=String.Format("read={0}", shareTo);
                     client.Headers.Add("X-Object-Sharing",permission);
                     var content = client.DownloadStringWithRetry(container, 3);
                     client.AssertStatusOK("ShareObject failed");
                     //If the result is empty, return an empty list,
                     var infos = String.IsNullOrWhiteSpace(content)
                         ? new List<ObjectInfo>()
                         //Otherwise deserialize the object list into a list of ObjectInfos
                         : JsonConvert.DeserializeObject<IList<ObjectInfo>>(content);
                     Trace.TraceInformation("[END] ListObjects");
+                }
+            }
             public IList<ObjectInfo> ListObjects(string account, string container, DateTime? since = null)
+            {
                 if (String.IsNullOrWhiteSpace(container))
                     throw new ArgumentNullException("container");
-...
                 using (var client = new RestClient(_baseClient))
+                {
                     if (!String.IsNullOrWhiteSpace(account))
                         client.BaseAddress = GetAccountUrl(account);
                     client.Parameters.Clear();
                     client.Parameters.Add("format", "json");
                     client.IfModifiedSince = since;
-...
                         //Otherwise deserialize the object list into a list of ObjectInfos
                         : JsonConvert.DeserializeObject<IList<ObjectInfo>>(content);
                     foreach (var info in infos)
+                    {
                         info.Container = container;
                         info.Account = account;
+                    }
                     Trace.TraceInformation("[END] ListObjects");
                     return infos;
+                }
-...
             public IList<ObjectInfo> ListObjects(string container, string folder, DateTime? since = null)
             public IList<ObjectInfo> ListObjects(string account, string container, string folder, DateTime? since = null)
+            {
                 if (String.IsNullOrWhiteSpace(container))
                     throw new ArgumentNullException("container");
-...
                 using (var client = new RestClient(_baseClient))
+                {
                     if (!String.IsNullOrWhiteSpace(account))
                         client.BaseAddress = GetAccountUrl(account);
                     client.Parameters.Clear();
                     client.Parameters.Add("format", "json");
                     client.Parameters.Add("path", folder);
-...
+            }
             public bool ContainerExists(string container)
             public bool ContainerExists(string account, string container)
+            {
                 if (String.IsNullOrWhiteSpace(container))
                     throw new ArgumentNullException("container", "The container property can't be empty");
                 Contract.EndContractBlock();
                 using (var client = new RestClient(_baseClient))
+                {
                     if (!String.IsNullOrWhiteSpace(account))
                         client.BaseAddress = GetAccountUrl(account);
                     client.Parameters.Clear();
                     client.Head(container, 3);
-...
+                }
+            }
             public bool ObjectExists(string container,string objectName)
             public bool ObjectExists(string account, string container, string objectName)
+            {
                 if (String.IsNullOrWhiteSpace(container))
                     throw new ArgumentNullException("container", "The container property can't be empty");
                 if (String.IsNullOrWhiteSpace(objectName))
                     throw new ArgumentNullException("objectName", "The objectName property can't be empty");
                 Contract.EndContractBlock();
                 using (var client = new RestClient(_baseClient))
+                {
                     if (!String.IsNullOrWhiteSpace(account))
                         client.BaseAddress = GetAccountUrl(account);
                     client.Parameters.Clear();
                     client.Head(container + "/" + objectName, 3);
-...
+            }
             public ObjectInfo GetObjectInfo(string container, string objectName)
             public ObjectInfo GetObjectInfo(string account, string container, string objectName)
+            {
                 if (String.IsNullOrWhiteSpace(container))
                     throw new ArgumentNullException("container", "The container property can't be empty");
                 if (String.IsNullOrWhiteSpace(objectName))
                     throw new ArgumentNullException("objectName", "The objectName property can't be empty");
                 Contract.EndContractBlock();
                 using (var client = new RestClient(_baseClient))
+                {
                     if (!String.IsNullOrWhiteSpace(account))
                         client.BaseAddress = GetAccountUrl(account);
                     try
+                    {
                         client.Parameters.Clear();
-...
+            }
             public void CreateFolder(string container, string folder)
             public void CreateFolder(string account, string container, string folder)
+            {
                 if (String.IsNullOrWhiteSpace(container))
                     throw new ArgumentNullException("container", "The container property can't be empty");
                 if (String.IsNullOrWhiteSpace(folder))
                     throw new ArgumentNullException("folder", "The folder property can't be empty");
                 Contract.EndContractBlock();
                 var folderUrl=String.Format("{0}/{1}",container,folder);
                 using (var client = new RestClient(_baseClient))
+                {
                     if (!String.IsNullOrWhiteSpace(account))
                         client.BaseAddress = GetAccountUrl(account);
                     client.Parameters.Clear();
                     client.Headers.Add("Content-Type", @"application/directory");
                     client.Headers.Add("Content-Length", "0");
-...
+                }
+            }
             public ContainerInfo GetContainerInfo(string container)
             public ContainerInfo GetContainerInfo(string account, string container)
+            {
                 if (String.IsNullOrWhiteSpace(container))
                     throw new ArgumentNullException("container", "The container property can't be empty");
                 Contract.EndContractBlock();
                 using (var client = new RestClient(_baseClient))
+                {
                     if (!String.IsNullOrWhiteSpace(account))
                         client.BaseAddress = GetAccountUrl(account);
                     client.Head(container);
                     switch (client.StatusCode)
+                    {
-...
+                }
+            }
             public void CreateContainer(string container)
+            {
             public void CreateContainer(string account, string container)
+            {
                 if (String.IsNullOrWhiteSpace(container))
                     throw new ArgumentNullException("container", "The container property can't be empty");
                 Contract.EndContractBlock();
                 using (var client = new RestClient(_baseClient))
+                {
                     if (!String.IsNullOrWhiteSpace(account))
                         client.BaseAddress = GetAccountUrl(account);
                     client.PutWithRetry(container, 3);
                     var expectedCodes = new[] {HttpStatusCode.Created, HttpStatusCode.Accepted, HttpStatusCode.OK};
                     if (!expectedCodes.Contains(client.StatusCode))
-...
+                }
+            }
             public void DeleteContainer(string container)
             public void DeleteContainer(string account, string container)
+            {
                 if (String.IsNullOrWhiteSpace(container))
                     throw new ArgumentNullException("container", "The container property can't be empty");
                 Contract.EndContractBlock();
                 using (var client = new RestClient(_baseClient))
+                {
                     if (!String.IsNullOrWhiteSpace(account))
                         client.BaseAddress = GetAccountUrl(account);
                     client.DeleteWithRetry(container, 3);
                     var expectedCodes = new[] {HttpStatusCode.NotFound, HttpStatusCode.NoContent};
                     if (!expectedCodes.Contains(client.StatusCode))
-...
             /// <summary>
             ///
             /// </summary>
             /// <param name="account"></param>
             /// <param name="container"></param>
             /// <param name="objectName"></param>
             /// <param name="fileName"></param>
-...
             /// <remarks>This method should have no timeout or a very long one</remarks>
             //Asynchronously download the object specified by *objectName* in a specific *container* to
             // a local file
             public Task GetObject(string container, string objectName, string fileName)
             public Task GetObject(string account, string container, string objectName, string fileName)
+            {
                 if (String.IsNullOrWhiteSpace(container))
                     throw new ArgumentNullException("container", "The container property can't be empty");
-...
                 try
+                {
                     //The container and objectName are relative names. They are joined with the client's
                     //BaseAddress to create the object's absolute address
                     var builder = GetAddressBuilder(container, objectName);
                     var uri = builder.Uri;
                     //WebClient, and by extension RestClient, are not thread-safe. Create a new RestClient
                     //object to avoid concurrency errors.
                     //
                     //Download operations take a long time therefore they have no timeout.
                     var client = new RestClient(_baseClient) { Timeout = 0 };
                     if (!String.IsNullOrWhiteSpace(account))
                         client.BaseAddress = GetAccountUrl(account);
                     //The container and objectName are relative names. They are joined with the client's
                     //BaseAddress to create the object's absolute address
                     var builder = client.GetAddressBuilder(container, objectName);
                     var uri = builder.Uri;
                     //Download progress is reported to the Trace log
                     Trace.TraceInformation("[GET] START {0}", objectName);
                     client.DownloadProgressChanged += (sender, args) =>
-...
+            }
             public Task<IList<string>> PutHashMap(string container, string objectName, TreeHash hash)
             public Task<IList<string>> PutHashMap(string account, string container, string objectName, TreeHash hash)
+            {
                 if (String.IsNullOrWhiteSpace(container))
                     throw new ArgumentNullException("container");
-...
                 if (StorageUrl == null)
                     throw new InvalidOperationException("Invalid Storage Url");
                 Contract.EndContractBlock();
                 //Don't use a timeout because putting the hashmap may be a long process
                 var client = new RestClient(_baseClient) { Timeout = 0 };
                 if (!String.IsNullOrWhiteSpace(account))
                     client.BaseAddress = GetAccountUrl(account);
                 //The container and objectName are relative names. They are joined with the client's
                 //BaseAddress to create the object's absolute address
                 var builder = GetAddressBuilder(container, objectName);
                 var builder = client.GetAddressBuilder(container, objectName);
                 builder.Query = "format=json&hashmap";
                 var uri = builder.Uri;
                 //Don't use a timeout because putting the hashmap may be a long process
                 var client = new RestClient(_baseClient) { Timeout = 0 };
                 //Send the tree hash as Json to the server
                 client.Headers[HttpRequestHeader.ContentType] = "application/octet-stream";
-...
+            }
             public Task<byte[]> GetBlock(string container, Uri relativeUrl, long start, long? end=null)
             public Task<byte[]> GetBlock(string account, string container, Uri relativeUrl, long start, long? end)
+            {
                 if (String.IsNullOrWhiteSpace(Token))
                     throw new InvalidOperationException("Invalid Token");
-...
                     throw new ArgumentOutOfRangeException("start");
                 Contract.EndContractBlock();
                 var builder = GetAddressBuilder(container, relativeUrl.ToString());
                 var uri = builder.Uri;
                 //Don't use a timeout because putting the hashmap may be a long process
                 var client = new RestClient(_baseClient) {Timeout = 0, RangeFrom = start, RangeTo = end};
                 if (!String.IsNullOrWhiteSpace(account))
                     client.BaseAddress = GetAccountUrl(account);
                 var builder = client.GetAddressBuilder(container, relativeUrl.ToString());
                 var uri = builder.Uri;
                 return client.DownloadDataTask(uri)
                     .ContinueWith(t=>
+                                      {
-...
+            }
             public Task PostBlock(string container,byte[] block,int offset,int count)
             public Task PostBlock(string account, string container, byte[] block, int offset, int count)
+            {
                 if (String.IsNullOrWhiteSpace(container))
                     throw new ArgumentNullException("container");
-...
                     throw new InvalidOperationException("Invalid Storage Url");
                 Contract.EndContractBlock();
                 var builder = GetAddressBuilder(container, "");
                 //Don't use a timeout because putting the hashmap may be a long process
                 var client = new RestClient(_baseClient) { Timeout = 0 };
                 if (!String.IsNullOrWhiteSpace(account))
                     client.BaseAddress = GetAccountUrl(account);
                 var builder = client.GetAddressBuilder(container, "");
                 //We are doing an update
                 builder.Query = "update";
                 var uri = builder.Uri;
                 //Don't use a timeout because putting the hashmap may be a long process
                 var client = new RestClient(_baseClient) { Timeout = 0 };
                 client.Headers[HttpRequestHeader.ContentType] = "application/octet-stream";
                 Trace.TraceInformation("[BLOCK POST] START");
-...
+            }
             public Task<TreeHash> GetHashMap(string container, string objectName)
             public Task<TreeHash> GetHashMap(string account, string container, string objectName)
+            {
                 if (String.IsNullOrWhiteSpace(container))
                     throw new ArgumentNullException("container");
-...
                 try
+                {
                     //The container and objectName are relative names. They are joined with the client's
                     //BaseAddress to create the object's absolute address
                     var builder = GetAddressBuilder(container, objectName);
                     builder.Query="format=json&hashmap";
                     var uri = builder.Uri;
                     //WebClient, and by extension RestClient, are not thread-safe. Create a new RestClient
                     //object to avoid concurrency errors.
                     //
                     //Download operations take a long time therefore they have no timeout.
                     //TODO: Do we really? this is a hashmap operation, not a download
                     var client = new RestClient(_baseClient) { Timeout = 0 };
                     if (!String.IsNullOrWhiteSpace(account))
                         client.BaseAddress = GetAccountUrl(account);
                     //The container and objectName are relative names. They are joined with the client's
                     //BaseAddress to create the object's absolute address
                     var builder = client.GetAddressBuilder(container, objectName);
                     builder.Query = "format=json&hashmap";
                     var uri = builder.Uri;
                     //Start downloading the object asynchronously
                     var downloadTask = client.DownloadStringTask(uri);
-...
+            }
             private UriBuilder GetAddressBuilder(string container, string objectName)
+            {
                 var builder = new UriBuilder(String.Join("/", _baseClient.BaseAddress, container, objectName));
                 return builder;
+            }
             /// <summary>
             ///
             /// </summary>
             /// <param name="account"></param>
             /// <param name="container"></param>
             /// <param name="objectName"></param>
             /// <param name="fileName"></param>
             /// <param name="hash">Optional hash value for the file. If no hash is provided, the method calculates a new hash</param>
             /// <remarks>>This method should have no timeout or a very long one</remarks>
             public Task PutObject(string container, string objectName, string fileName, string hash = null)
             public Task PutObject(string account, string container, string objectName, string fileName, string hash = null)
+            {
                 if (String.IsNullOrWhiteSpace(container))
                     throw new ArgumentNullException("container", "The container property can't be empty");
-...
                     throw new ArgumentNullException("fileName", "The fileName property can't be empty");
                 if (!File.Exists(fileName))
                     throw new FileNotFoundException("The file does not exist",fileName);
                 Contract.EndContractBlock();
                 try
+                {
                     var builder= GetAddressBuilder(container,objectName);
                     var client = new RestClient(_baseClient){Timeout=0};
                     if (!String.IsNullOrWhiteSpace(account))
                         client.BaseAddress = GetAccountUrl(account);
                     var builder = client.GetAddressBuilder(container, objectName);
                     var uri = builder.Uri;
                     var client = new RestClient(_baseClient){Timeout=0};
                     string etag = hash ?? CalculateHash(fileName);
                     client.Headers.Add("Content-Type", "application/octet-stream");
-...
                 return hash;
+            }
             public void DeleteObject(string container, string objectName)
            /* public void DeleteObject(string container, string objectName,string account)
+            {
                 if (String.IsNullOrWhiteSpace(container))
                     throw new ArgumentNullException("container", "The container property can't be empty");
                 if (String.IsNullOrWhiteSpace(objectName))
                     throw new ArgumentNullException("objectName", "The objectName property can't be empty");
                 Contract.EndContractBlock();
                 using (var client = new RestClient(_baseClient))
+                {
                     if (!String.IsNullOrWhiteSpace(account))
                         client.BaseAddress = GetAccountUrl(account);
                     );
                     client.DeleteWithRetry(container + "/" + objectName, 3);
                     var expectedCodes = new[] {HttpStatusCode.NotFound, HttpStatusCode.NoContent};
-...
                         throw CreateWebException("DeleteObject", client.StatusCode);
+                }
+            }
             }*/
             public void MoveObject(string sourceContainer, string oldObjectName, string targetContainer,string newObjectName)
             public void MoveObject(string account, string sourceContainer, string oldObjectName, string targetContainer, string newObjectName)
+            {
                 if (String.IsNullOrWhiteSpace(sourceContainer))
                     throw new ArgumentNullException("sourceContainer", "The container property can't be empty");
-...
                     throw new ArgumentNullException("targetContainer", "The container property can't be empty");
                 if (String.IsNullOrWhiteSpace(newObjectName))
                     throw new ArgumentNullException("newObjectName", "The newObjectName property can't be empty");
                 Contract.EndContractBlock();
                 var targetUrl = targetContainer + "/" + newObjectName;
                 var sourceUrl = String.Format("/{0}/{1}", sourceContainer, oldObjectName);
                 using (var client = new RestClient(_baseClient))
+                {
                     if (!String.IsNullOrWhiteSpace(account))
                         client.BaseAddress = GetAccountUrl(account);
                     client.Headers.Add("X-Move-From", sourceUrl);
                     client.PutWithRetry(targetUrl, 3);
-...
+                }
+            }
             public void DeleteObject(string sourceContainer, string objectName, string targetContainer)
             public void DeleteObject(string account, string sourceContainer, string objectName, string targetContainer)
+            {
                 if (String.IsNullOrWhiteSpace(sourceContainer))
                     throw new ArgumentNullException("sourceContainer", "The container property can't be empty");
-...
                     throw new ArgumentNullException("objectName", "The oldObjectName property can't be empty");
                 if (String.IsNullOrWhiteSpace(targetContainer))
                     throw new ArgumentNullException("targetContainer", "The container property can't be empty");
                 Contract.EndContractBlock();
                 var targetUrl = targetContainer + "/" + objectName;
                 var sourceUrl = String.Format("/{0}/{1}", sourceContainer, objectName);
                 using (var client = new RestClient(_baseClient))
+                {
                     if (!String.IsNullOrWhiteSpace(account))
                         client.BaseAddress = GetAccountUrl(account);
                     client.Headers.Add("X-Move-From", sourceUrl);
                     client.PutWithRetry(targetUrl, 3);
-...
+        }
         public class ShareAccountInfo
+        {
             public DateTime? last_modified { get; set; }
             public string name { get; set; }
+        }
+    }

Also available in: Unified diff

Synnefo » Pithos MS Client

Revision cfed7823 trunk/Pithos.Network/CloudFilesClient.cs