Synnefo » Pithos MS Client

using System.Threading;

        public string PithosContainer { get; set; }

        public string TrashContainer { get; private set; }

        public int BlockSize { get; set; }

        public string BlockHash { get; set; }

            PithosContainer = pithosContainer;

            TrashContainer = trashContainer;

            BlockSize = blockSize;

            BlockHash = blockHash;

/*

                    var process=Process(message);

                    inbox.LoopAsync(process, loop);

*/

/*

                    process1.ContinueWith(t =>

                    {

                        inbox.DoAsync(loop);

                        if (t.IsFaulted)

                        {

                            var ex = t.Exception.InnerException;

                            if (ex is OperationCanceledException)

                                inbox.Stop();

                        }

                    });

*/

                    //inbox.DoAsync(loop);

            //If the action targets a local file, add a treehash calculation

            if (cloudAction.LocalFile != null)

            {

                cloudAction.TopHash = new Lazy<string>(() => Signature.CalculateTreeHashAsync(cloudAction.LocalFile, 

                                    BlockSize, BlockHash).Result

                                     .TopHash.ToHashString());

            }

                CloudClient.ListObjects(PithosContainer,since));

                foreach (var message in distinctActions)

                {

                    Post(message);

                }

        private Task Process(Task<CloudAction> action)

        {

            return action.ContinueWith(t=> Process(t.Result));

        }

                        DownloadCloudFile(PithosContainer, new Uri(cloudFile.Name,UriKind.Relative), downloadPath);

                                            DownloadCloudFile(PithosContainer, new Uri(action.CloudFile.Name,UriKind.Relative), downloadPath);

                            DownloadCloudFile(PithosContainer, new Uri(action.CloudFile.Name,UriKind.Relative), downloadPath);

            CloudClient.MoveObject(PithosContainer, oldFileName, PithosContainer, newFileName);

            CloudClient.MoveObject(PithosContainer, fileName, TrashContainer, fileName);

                //var hashPath = Path.Combine(FileAgent.FragmentsPath, relativePath + ".hashmap");

                var getHashMap = CloudClient.GetHashMap(container,url);                

                var downloadTask= getHashMap.ContinueWith(t =>

                    var serverHash=t.Result;

                    //If it's a small file

                    return serverHash.Hashes.Count == 1 

                        //Download it in one go

                        ? DownloadEntireFile(container, relativeUrl, localPath) 

                        //Otherwise download it block by block

                        : DownloadWithBlocks(container, relativeUrl, localPath, serverHash);

                var getInfo = downloadTask.ContinueWith(t =>

        //Download a small file with a single GET operation

        private Task DownloadEntireFile(string container, Uri relativeUrl, string localPath)

        {

            if (String.IsNullOrWhiteSpace(container))

                throw new ArgumentNullException("container");

            if (relativeUrl == null)

                throw new ArgumentNullException("relativeUrl");

            if (String.IsNullOrWhiteSpace(localPath))

                throw new ArgumentNullException("localPath");

            if (!Path.IsPathRooted(localPath))

                throw new ArgumentException("The localPath must be rooted", "localPath");

            Contract.EndContractBlock();

            //Calculate the relative file path for the new file

            var relativePath = relativeUrl.RelativeUriToFilePath();

            //The file will be stored in a temporary location while downloading with an extension .download

            var tempPath = Path.Combine(FileAgent.FragmentsPath, relativePath + ".download");

            //Make sure the target folder exists. DownloadFileTask will not create the folder

            var directoryPath = Path.GetDirectoryName(tempPath);

            if (!Directory.Exists(directoryPath))

                Directory.CreateDirectory(directoryPath);

            //Download the object to the temporary location

            var getObject = CloudClient.GetObject(container, relativeUrl.ToString(), tempPath).ContinueWith(t =>

            {

                //And move it to its actual location once downloading is finished

                if (File.Exists(localPath))

                    File.Replace(tempPath,localPath,null,true);

                else

                    File.Move(tempPath,localPath);

            });

            return getObject;

        }

        public Task DownloadWithBlocks(string container,Uri relativeUrl, string localPath,TreeHash serverHash)

        {

            if (String.IsNullOrWhiteSpace(container))

                throw new ArgumentNullException("container");

            if (relativeUrl == null)

                throw new ArgumentNullException("relativeUrl");

            if (String.IsNullOrWhiteSpace(localPath))

                throw new ArgumentNullException("localPath");

            if (!Path.IsPathRooted(localPath))

                throw new ArgumentException("The localPath must be rooted", "localPath");

            if(serverHash==null)

                throw new ArgumentNullException("serverHash");

            Contract.EndContractBlock();

            //Calculate the relative file path for the new file

            var relativePath = relativeUrl.RelativeUriToFilePath();

            //The file will be stored in a temporary location while downloading with an extension .download

            var tempPath = Path.Combine(FileAgent.FragmentsPath, relativePath + ".download");

            var directoryPath = Path.GetDirectoryName(tempPath);

            if (!Directory.Exists(directoryPath))

                Directory.CreateDirectory(directoryPath);

            //If the local file exists we should make a copy of it to the

            //fragments folder, unless a newer temp copy already exists, which

            //means there is an interrupted download

            if (ShouldCopy(localPath, tempPath))

                File.Copy(localPath, tempPath, true);    

            //Set the size of the file to the size specified in the treehash

            //This will also create an empty file if the file doesn't exist            

            SetFileSize(tempPath, serverHash.Bytes);

            return Task.Factory.StartNew(() =>

            {

                //Calculate the temp file's treehash

                var treeHash = Signature.CalculateTreeHashAsync(tempPath, this.BlockSize,BlockHash).Result;

                //And compare it with the server's hash

                var upHashes = serverHash.GetHashesAsStrings();

                var localHashes = treeHash.HashDictionary;

                for (int i = 0; i < upHashes.Length; i++)

                {

                    //For every non-matching hash

                    if (!localHashes.ContainsKey(upHashes[i]))

                    {

                        Trace.TraceInformation("[BLOCK GET] START {0} of {1} for {2}",i,upHashes.Length,localPath);

                        var start = i*BlockSize;

                        long? end = null;

                        if (i < upHashes.Length - 1 )

                            end= ((i + 1)*BlockSize) ;

                        //Get its block

                        var blockTask = CloudClient.GetBlock(container, relativeUrl,

                                                            start, end);

                        blockTask.ContinueWith(b =>

                        {

                            //And apply it to the temp file

                            var buffer = b.Result;

                            var stream =FileAsync.OpenWrite(tempPath);

                            stream.Seek(start,SeekOrigin.Begin);

                            return stream.WriteAsync(buffer, 0, buffer.Length)

                                .ContinueWith(s => stream.Close());

                        }).Unwrap()

                        .Wait();

                        Trace.TraceInformation("[BLOCK GET] FINISH {0} of {1} for {2}", i, upHashes.Length, localPath);

                    }

                }

                //Replace the existing file with the temp

                if (File.Exists(localPath))

                    File.Replace(tempPath, localPath, null, true);

                else

                    File.Move(tempPath, localPath);

                Trace.TraceInformation("[BLOCK GET] COMPLETE {0}", localPath);

            });

        }

        //Change the file's size, possibly truncating or adding to it

        private static void SetFileSize(string filePath, long fileSize)

        {

            if (String.IsNullOrWhiteSpace(filePath))

                throw new ArgumentNullException("filePath");

            if (!Path.IsPathRooted(filePath))

                throw new ArgumentException("The filePath must be rooted", "filePath");

            if (fileSize<0)

                throw new ArgumentOutOfRangeException("fileSize");

            Contract.EndContractBlock();

            using (var stream = File.Open(filePath, FileMode.OpenOrCreate, FileAccess.Write))

            {

                stream.SetLength(fileSize);

            }

        }

        //Check whether we should copy the local file to a temp path        

        private static bool ShouldCopy(string localPath, string tempPath)

        {

            //No need to copy if there is no file

            if (!File.Exists(localPath))            

                return false;

            //If there is no temp file, go ahead and copy

            if (!File.Exists(tempPath))                

                return true;

            //If there is a temp file and is newer than the actual file, don't copy

            var localLastWrite = File.GetLastWriteTime(localPath);

            var tempLastWrite = File.GetLastWriteTime(tempPath);

            //This could mean there is an interrupted download in progress

            return (tempLastWrite < localLastWrite);

        }

                var info = CloudClient.GetObjectInfo(PithosContainer, url);

                //Mark the file as modified while we upload it

                var setStatus = Task.Factory.StartNew(() =>

                        StatusKeeper.SetFileOverlayStatus(fullFileName, FileOverlayStatus.Modified));

                //And then upload it

                //If the file is larger than the block size, try a hashmap PUT

                if (fileInfo.Length > BlockSize )

                    //To upload using a hashmap

                    //First, calculate the tree hash

                    var treeHash = Signature.CalculateTreeHashAsync(fileInfo.FullName, BlockSize, BlockHash);                    

                    var putHashMap = setStatus.ContinueWith(t=>

                        UploadWithHashMap(fileInfo,url,treeHash));

                    putHashMap.Wait();

                else

                    //Otherwise do a regular PUT

                        CloudClient.PutObject(PithosContainer,url,fullFileName,hash));

                    put.Wait();

                }

        public void UploadWithHashMap(FileInfo fileInfo,string url,Task<TreeHash> treeHash)

        {

            var fullFileName = fileInfo.FullName;

            //Send the hashmap to the server            

            var hashPut = CloudClient.PutHashMap(PithosContainer, url, treeHash.Result);

            var missingHashes = hashPut.Result;

            if (missingHashes.Count == 0)

                return;

            var buffer = new byte[BlockSize];                      

            foreach (var missingHash in missingHashes)

            {

                int blockIndex = -1;

                try

                {

                    //Find the proper block

                    blockIndex = treeHash.Result.HashDictionary[missingHash];

                    var offset = blockIndex*BlockSize;

                    var read = fileInfo.Read(buffer, offset, BlockSize);

                    if (read > 0)

                    {

                        //Copy the actual block data out of the buffer

                        var data = new byte[read];

                        Buffer.BlockCopy(buffer, 0, data, 0, read);

                        //And POST them

                        CloudClient.PostBlock(PithosContainer, data).Wait();

                        Trace.TraceInformation("[BLOCK] Block {0} of {1} uploaded", blockIndex,

                            fullFileName);

                    }

                }

                catch (Exception exc)

                {

                    Trace.TraceError("[ERROR] uploading block {0} of {1}\n{2}", blockIndex, fullFileName, exc);

                }

            }

            UploadWithHashMap(fileInfo, url, treeHash);

        }