Synnefo » Pithos MS Client

/*

                    var process=Process(message);

*/

/*

                    process1.ContinueWith(t =>

                    {

                        inbox.DoAsync(loop);

                        if (t.IsFaulted)

                        {

                            var ex = t.Exception.InnerException;

                            if (ex is OperationCanceledException)

                                inbox.Stop();

                        }

                    });

*/

                    //inbox.DoAsync(loop);

                    var process = message.ContinueWith(t =>

                    {

                        var action = t.Result;

                        Process(action);

                        inbox.DoAsync(loop);

                    });

                    process.ContinueWith(t =>

                    {

                        inbox.DoAsync(loop);

                        if (t.IsFaulted)

                            var ex = t.Exception.InnerException;

                            if (ex is OperationCanceledException)

                                inbox.Stop();

                        }

                    });

                };

                loop();

            });

        {            

            var listObjects = Task.Factory.StartNewDelayed(10000).ContinueWith(t =>

                CloudClient.ListObjects(PithosContainer,since));

        private Task Process(Task<CloudAction> action)

        {

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

        }

        private void Process(CloudAction action)

        {

            if (action==null)

                throw new ArgumentNullException("action");

            Contract.EndContractBlock();

            Trace.TraceInformation("[ACTION] Start Processing {0}:{1}->{2}", action.Action, action.LocalFile, action.CloudFile.Name);

            var localFile = action.LocalFile;

            var cloudFile = action.CloudFile;

            var downloadPath = (cloudFile == null) ? String.Empty

                                    : Path.Combine(FileAgent.RootPath, cloudFile.Name.RelativeUrlToFilePath());

            try

            {

                switch (action.Action)

                {

                    case CloudActionType.UploadUnconditional:

                        UploadCloudFile(localFile, action.LocalHash.Value,action.TopHash.Value);

                        break;

                    case CloudActionType.DownloadUnconditional:

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

                        break;

                    case CloudActionType.DeleteCloud:

                        DeleteCloudFile(cloudFile.Name);

                        break;

                    case CloudActionType.RenameCloud:

                        RenameCloudFile(action.OldFileName, action.NewPath, action.NewFileName);

                        break;

                    case CloudActionType.MustSynch:

                        if (File.Exists(downloadPath))

                        {                            

                            var cloudHash = cloudFile.Hash;

                            var localHash = action.LocalHash.Value;

                            var topHash = action.TopHash.Value;

                            //Not enough to compare only the local hashes, also have to compare the tophashes

                            if (!cloudHash.Equals(localHash, StringComparison.InvariantCultureIgnoreCase) &&

                                !cloudHash.Equals(topHash, StringComparison.InvariantCultureIgnoreCase))

                            {

                                var lastLocalTime = localFile.LastWriteTime;

                                var lastUpTime = cloudFile.Last_Modified;

                                if (lastUpTime <= lastLocalTime)

                                {

                                    //Local change while the app was down or Files in conflict

                                    //Maybe need to store version as well, to check who has the latest version

                                    //StatusKeeper.SetFileOverlayStatus(downloadPath, FileOverlayStatus.Conflict);

                                    UploadCloudFile(localFile, action.LocalHash.Value,action.TopHash.Value);

                                }

                                else

                                {

                                    var status = StatusKeeper.GetFileStatus(downloadPath);

                                    switch (status)

                                    {

                                        case FileStatus.Unchanged:

                                            //It he cloud file has a later date, it was modified by another user or computer.

                                            //If the local file's status is Unchanged, we should go on and download the cloud file

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

                                            break;

                                        case FileStatus.Modified:

                                            //If the local file is Modified, we may have a conflict. In this case we should mark the file as Conflict

                                            //We can't ensure that a file modified online since the last time will appear as Modified, unless we 

                                            //index all files before we start listening.

                                            StatusKeeper.SetFileOverlayStatus(downloadPath, FileOverlayStatus.Conflict);

                                            break;

                                        case FileStatus.Created:

                                            //If the local file is Created, it means that the local and cloud files aren't related yet have the same name

                                            //In this case we must mark the file as in conflict

                                            //Other cases should never occur. Mark them as Conflict as well but log a warning

                                            StatusKeeper.SetFileOverlayStatus(downloadPath,FileOverlayStatus.Conflict);

                                            break;

                                        default:

                                            //If the local file is Created, it means that the local and cloud files aren't related yet have the same name

                                            //In this case we must mark the file as in conflict

                                            //Other cases should never occur. Mark them as Conflict as well but log a warning

                                            StatusKeeper.SetFileOverlayStatus(downloadPath,FileOverlayStatus.Conflict);

                                            Trace.TraceWarning("Unexcepted status {0} for file {1}->{2}",status,downloadPath,action.CloudFile.Name);

                                            break;

                                    }

                                }

                            }

                        }

                        else

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

                        break;

                }

                Trace.TraceInformation("[ACTION] End Processing {0}:{1}->{2}", action.Action, action.LocalFile, action.CloudFile.Name);

            }

            catch (OperationCanceledException)

            {

                throw;

            }

            catch (Exception exc)

            {

                Trace.TraceError("[REQUEUE] {0} : {1} -> {2} due to exception\r\n{3}",

                                action.Action, action.LocalFile, action.CloudFile, exc);

                _agent.Post(action);

            }

        }

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

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

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

                //Replace the existing file with the temp

                if (File.Exists(localPath))

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

                else

                    File.Move(tempPath, 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);

        }