Synnefo » Pithos MS Client

        private void UploadCloudFile(CloudAction action)

                var upload = Task.Factory.Iterate(UploadIterator(action));

                upload.Wait();

            }                

            catch (AggregateException ex)

            {                

                var exc = ex.InnerException as WebException;

                if (exc==null)

                    throw ex.InnerException;

                var response = exc.Response as HttpWebResponse;

                if (response==null)

                    throw exc;

                if (response.StatusCode == HttpStatusCode.Unauthorized)

                {

                    Log.Error("Not allowed to upload file", exc);

                    var message = String.Format("Not allowed to uplad file {0}",action.LocalFile.FullName);

                    StatusKeeper.SetFileState(action.LocalFile.FullName,FileStatus.Unchanged,FileOverlayStatus.Normal);

                    StatusNotification.NotifyChange(message,TraceLevel.Warning);

                    return;

                }

                throw;

            }

        }

        private IEnumerable<Task> UploadIterator(CloudAction action)

        {

            if (action == null)

                throw new ArgumentNullException("action");            

            Contract.EndContractBlock();

            var accountInfo=action.AccountInfo;

            var fileInfo=action.LocalFile;                        

            if (fileInfo.Extension.Equals("ignore", StringComparison.InvariantCultureIgnoreCase))

                yield break;

            var relativePath = fileInfo.AsRelativeTo(accountInfo.AccountPath);

            if (relativePath.StartsWith(FolderConstants.OthersFolder))

            {

                var parts=relativePath.Split('\\');

                var accountName = parts[1];

                var oldName = accountInfo.UserName;

                var absoluteUri = accountInfo.StorageUri.AbsoluteUri;

                var nameIndex=absoluteUri.IndexOf(oldName);

                var root=absoluteUri.Substring(0, nameIndex);

                accountInfo = new AccountInfo

                    UserName = accountName,

                    AccountPath = Path.Combine(accountInfo.AccountPath, parts[0], parts[1]),

                    StorageUri = new Uri(root + accountName),

                    BlockHash=accountInfo.BlockHash,

                    BlockSize=accountInfo.BlockSize,

                    Token=accountInfo.Token

                };

            }

            var fullFileName = fileInfo.FullName;

            using(var gate=NetworkGate.Acquire(fullFileName,NetworkOperation.Uploading))

            {

                //Abort if the file is already being uploaded or downloaded

                if (gate.Failed)

                    yield break;

                var cloudFile = action.CloudFile;

                var account = cloudFile.Account ?? accountInfo.UserName;

                var client = new CloudFilesClient(accountInfo);

                //Even if GetObjectInfo times out, we can proceed with the upload            

                var info = client.GetObjectInfo(account, cloudFile.Container, cloudFile.Name);                

                var cloudHash = info.Hash.ToLower();

                var hash = action.LocalHash.Value;

                var topHash = action.TopHash.Value;

                //If the file hashes match, abort the upload

                if (hash == cloudHash  || topHash ==cloudHash)

                {

                    //but store any metadata changes 

                    this.StatusKeeper.StoreInfo(fullFileName, info);

                    Log.InfoFormat("Skip upload of {0}, hashes match", fullFileName);

                    yield break;

                }

                if (info.AllowedTo=="read")

                    yield break;

                //Mark the file as modified while we upload it

                StatusKeeper.SetFileOverlayStatus(fullFileName, FileOverlayStatus.Modified);

                //And then upload it

                //Upload even small files using the Hashmap. The server may already containt

                //the relevant folder

                //First, calculate the tree hash

                var treeHash = Signature.CalculateTreeHashAsync(fileInfo.FullName, accountInfo.BlockSize,

                    accountInfo.BlockHash);

                yield return treeHash;

                yield return Task.Factory.Iterate(UploadWithHashMap(accountInfo,cloudFile,fileInfo,cloudFile.Name,treeHash));

                //If everything succeeds, change the file and overlay status to normal

                this.StatusKeeper.SetFileState(fullFileName, FileStatus.Unchanged, FileOverlayStatus.Normal);

            //Notify the Shell to update the overlays

            NativeMethods.RaiseChangeNotification(fullFileName);

            StatusNotification.NotifyChangedFile(fullFileName);

        public IEnumerable<Task> UploadWithHashMap(AccountInfo accountInfo,ObjectInfo cloudFile,FileInfo fileInfo,string url,Task<TreeHash> treeHash)

            var hashPut = client.PutHashMap(account, container, url, treeHash.Result);

            yield return hashPut;

            var missingHashes = hashPut.Result;

                    var blockIndex = treeHash.Result.HashDictionary[missingHash];

                    //And upload the block                

                    var postBlock = client.PostBlock(account, container, buffer, 0, read);

                    //We have to handle possible exceptions in a continuation because

                    //*yield return* can't appear inside a try block

                    yield return postBlock.ContinueWith(t => 

                        t.ReportExceptions(

                            exc => Log.ErrorFormat("[ERROR] uploading block {0} of {1}\n{2}", blockIndex, fullFileName, exc),

                            ()=>Log.InfoFormat("[BLOCK] Block {0} of {1} uploaded", blockIndex,fullFileName)));

                //Repeat until there are no more missing hashes

                hashPut = client.PutHashMap(account, container, url, treeHash.Result);

                yield return hashPut;

                missingHashes = hashPut.Result;