Synnefo » Pithos MS Client

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

                var empty = (IList<string>)new List<string>();

                if (client.StatusCode == HttpStatusCode.Created)                    

                {

                    return empty;

                }

                            //We need to cleanup the content before returning it because it contains

                            //error content after the list of hashes

                            var hashes = new List<string>();

                            string line=null;

                            //All lines up to the first empty line are hashes

                            while(!String.IsNullOrWhiteSpace(line=reader.ReadLine()))

                            {

                                hashes.Add(line);

                            }

                            return hashes;

                return empty;

        public Task<byte[]> GetBlock(string container, Uri relativeUrl, long start, long? end=null)

        {

            if (String.IsNullOrWhiteSpace(Token))

                throw new InvalidOperationException("Invalid Token");

            if (StorageUrl == null)

                throw new InvalidOperationException("Invalid Storage Url");

            if (String.IsNullOrWhiteSpace(container))

                throw new ArgumentNullException("container");

            if (relativeUrl== null)

                throw new ArgumentNullException("relativeUrl");

            if (end.HasValue && end<0)

                throw new ArgumentOutOfRangeException("end");

            if (start<0)

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

            return client.DownloadDataTask(uri)

                .ContinueWith(t=>

                                  {

                                      client.Dispose();

                                      return t.Result;

                                  });

        }

        public Task PostBlock(string container,byte[] block)

        {

            if (String.IsNullOrWhiteSpace(container))

                throw new ArgumentNullException("container");

            if (block == null)

                throw new ArgumentNullException("block");

            if (String.IsNullOrWhiteSpace(Token))

                throw new InvalidOperationException("Invalid Token");

            if (StorageUrl == null)

                throw new InvalidOperationException("Invalid Storage Url");            

            Contract.EndContractBlock();

            var builder = 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");

            //Not much point to this as the server will timeout if we try to get the 

            //hashmap too quickly.

            var tcs = new TaskCompletionSource<bool>();

            client.UploadProgressChanged += (sender, args) =>

            {

                Trace.TraceInformation("[BLOCK POST PROGRESS] {0}% {1} of {2}",

                                        args.ProgressPercentage, args.BytesSent,

                                        args.TotalBytesToSend);

                if (args.BytesSent == args.TotalBytesToSend)

                    tcs.SetResult(false);                

            };

            client.UploadFileCompleted += (sender, args) =>

            {

                if (args.Error != null)

                    tcs.SetException(args.Error);

                else

                {

                    Trace.TraceInformation("[BLOCK POST PROGRESS] Completed ");

                    tcs.TrySetResult(true);

                }

            };

            client.UploadDataTask(uri, "POST", block);

            //Send the block

            var uploadTask = tcs.Task

                .ContinueWith(upload =>

                {

                    client.Dispose();

                    if (upload.IsFaulted)

                    {

                        var exception = upload.Exception.InnerException;

                        Trace.TraceError("[BLOCK POST] FAIL with \r{0}", exception);                        

                        throw exception;

                    }

                    else

                    {

                        Trace.TraceInformation("[BLOCK POST] END");                        

                    }

                });

            return uploadTask;            

        }

                                          {

                                              var exc = upload.Exception.InnerException;

                                              Trace.TraceError("[PUT] FAIL for {0} with \r{1}",objectName,exc);

                                              throw exc;