Synnefo » Pithos MS Client

// **CloudFilesClient** provides a simple client interface to CloudFiles and Pithos

//

// The class provides methods to upload/download files, delete files, manage containers

using System;

        //CloudFilesClient uses *_baseClient* internally to communicate with the server

        //RestClient provides a REST-friendly interface over the standard WebClient.

        //Some operations can specify a Timeout. The default value of all timeouts is 10 seconds

        //Some operations can be retried before failing. The default number of retries is 5

        //During authentication the client provides a UserName 

        //and and ApiKey to the server

        public string ApiKey { get; set; }

        //And receives an authentication Token. This token must be provided in ALL other operations,

        //in the X-Auth-Token header

        //The client also receives a StorageUrl after authentication. All subsequent operations must

        //use this url

        public Uri StorageUrl { get; set; }

        //

                var content = client.DownloadStringWithRetry("", 3);

        //Request listing of all objects in a container modified since a specific time.

        //If the *since* value is missing, return all objects

                //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);

                    case HttpStatusCode.OK:

                                                    Bytes = long.Parse(client.GetHeaderValue("X-Container-Bytes-Used")),

                                                    BlockHash = client.GetHeaderValue("X-Container-Block-Hash"),

                                                    BlockSize=int.Parse(client.GetHeaderValue("X-Container-Block-Size"))

        /// <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

                throw new ArgumentNullException("objectName", "The objectName property can't be empty");            

            Contract.EndContractBlock();

                //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.

                //Download progress is reported to the Trace log

                                    args.TotalBytesToReceive);                                

                //Start downloading the object asynchronously

                var downloadTask = client.DownloadFileTask(uri, fileName);

                //Once the download completes

                return downloadTask.ContinueWith(download =>

                                          //Delete the local client object

                                          //And report failure or completion

        public Task<string> PutHashMap(string container, string objectName, TreeHash hash)

        {

            if (String.IsNullOrWhiteSpace(container))

                throw new ArgumentNullException("container");

            if (String.IsNullOrWhiteSpace(objectName))

                throw new ArgumentNullException("objectName");

            if (hash==null)

                throw new ArgumentNullException("hash");

            if (String.IsNullOrWhiteSpace(Token))

                throw new InvalidOperationException("Invalid Token");

            if (StorageUrl == null)

                throw new InvalidOperationException("Invalid Storage Url");

            Contract.EndContractBlock();

            //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;

            //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";

            var uploadTask=client.UploadStringTask(uri, "PUT", hash.ToJson());

            return uploadTask.ContinueWith(t =>

            {

                //The server will respond either with 201-created if all blocks were already on the server

                if (client.StatusCode == HttpStatusCode.Created)

                    //in which case we return an empty hash list

                    return t.Result;

                //or with a 409-conflict and return the list of missing parts

                //A 409 will cause an exception so we need to check t.IsFaulted to avoid propagating the exception                

                if (t.IsFaulted)

                {

                    var ex = t.Exception.InnerException;

                    var we = ex as WebException;

                    var response = we.Response as HttpWebResponse;

                    if (response!=null && response.StatusCode==HttpStatusCode.Conflict)

                    {

                        //In case of 409 the missing parts will be in the response content                        

                        using (var stream = response.GetResponseStream())

                        using(var reader=new StreamReader(stream))

                        {

                            var content=reader.ReadToEnd();

                            return content;

                        }                        

                    }

                    else

                        //Any other status code is unexpected and the exception should be rethrown

                        throw ex;

                }

                //Any other status code is unexpected but there was no exception. We can probably continue processing

                else

                {

                    Trace.TraceWarning("Unexcpected status code when putting map: {0} - {1}",client.StatusCode,client.StatusDescription);                    

                }

                return t.Result;

            });

        }

        public Task<TreeHash> GetHashMap(string container, string objectName)

        {

            if (String.IsNullOrWhiteSpace(container))

                throw new ArgumentNullException("container");

            if (String.IsNullOrWhiteSpace(objectName))

                throw new ArgumentNullException("objectName");

            if (String.IsNullOrWhiteSpace(Token))

                throw new InvalidOperationException("Invalid Token");

            if (StorageUrl == null)

                throw new InvalidOperationException("Invalid Storage Url");

            Contract.EndContractBlock();

            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 };

                //Start downloading the object asynchronously

                var downloadTask = client.DownloadStringTask(uri);

                //Once the download completes

                return downloadTask.ContinueWith(download =>

                {

                    //Delete the local client object

                    client.Dispose();

                    //And report failure or completion

                    if (download.IsFaulted)

                    {

                        Trace.TraceError("[GET HASH] FAIL for {0} with \r{1}", objectName,

                                        download.Exception);

                        throw download.Exception;

                    }

                    //The server will return an empty string if the file is empty

                    var json = download.Result;

                    var treeHash = TreeHash.Parse(json);

                    Trace.TraceInformation("[GET HASH] END {0}", objectName);                                             

                    return treeHash;

                });

            }

            catch (Exception exc)

            {

                Trace.TraceError("[GET HASH] END {0} with {1}", objectName, exc);

                throw;

            }

        }

        private UriBuilder GetAddressBuilder(string container, string objectName)

        {

            var builder = new UriBuilder(String.Join("/", _baseClient.BaseAddress, container, objectName));

            return builder;

        }

                var builder= GetAddressBuilder(container,objectName);

                var uri = builder.Uri;