Synnefo » Pithos MS Client

        private DeleteAgent _deleteAgent { get; set; }

                _deleteAgent.StatusNotification = value;

                    _deleteAgent.ProceedEvent.Wait();

            using (log4net.ThreadContext.Stacks["Operation"].Push(action.ToString()))

                    //UpdateStatus(PithosStatus.Syncing);

                        _deleteAgent.Post((CloudDeleteAction)action);

                    if (_deleteAgent.IsDeletedFile(action))

                                await UploadCloudFile(action);

                                await DownloadCloudFile(accountInfo, cloudFile, downloadPath);

                                    await DownloadCloudFile(accountInfo, cloudFile, downloadPath);

                {

            using (var gateOld = NetworkGate.Acquire(previousFullPath, NetworkOperation.Renaming))

            using (var gateNew = NetworkGate.Acquire(newPath,NetworkOperation.Renaming))

                var localFile = action.LocalFile;

                if (cloudHash == localHash)

                    await DownloadCloudFile(accountInfo, cloudFile, downloadPath);

            _deleteAgent.ProceedEvent.Wait();

                _deleteAgent.Post((CloudDeleteAction)cloudAction);

            return _deleteAgent.ProceedEvent.WaitAsync();

        private static FileAgent GetFileAgent(AccountInfo accountInfo)

        {

            return AgentLocator<FileAgent>.Get(accountInfo.AccountPath);

        }

        //Download a file.

        private async Task DownloadCloudFile(AccountInfo accountInfo, ObjectInfo cloudFile , string filePath)

        {

            if (accountInfo == null)

                throw new ArgumentNullException("accountInfo");

            if (cloudFile == null)

                throw new ArgumentNullException("cloudFile");

            if (String.IsNullOrWhiteSpace(cloudFile.Account))

                throw new ArgumentNullException("cloudFile");

            if (String.IsNullOrWhiteSpace(cloudFile.Container))

                throw new ArgumentNullException("cloudFile");

            if (String.IsNullOrWhiteSpace(filePath))

                throw new ArgumentNullException("filePath");

            if (!Path.IsPathRooted(filePath))

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

            Contract.EndContractBlock();

            using (ThreadContext.Stacks["Operation"].Push("DownloadCloudFile"))

            {

                var localPath = Interfaces.FileInfoExtensions.GetProperFilePathCapitalization(filePath);

                var relativeUrl = new Uri(cloudFile.Name, UriKind.Relative);

                var url = relativeUrl.ToString();

                if (cloudFile.Name.EndsWith(".ignore", StringComparison.InvariantCultureIgnoreCase))

                    return;

                //Are we already downloading or uploading the file? 

                using (var gate = NetworkGate.Acquire(localPath, NetworkOperation.Downloading))

                {

                    if (gate.Failed)

                        return;

                    var client = new CloudFilesClient(accountInfo);

                    var account = cloudFile.Account;

                    var container = cloudFile.Container;

                    if (cloudFile.IsDirectory)

                    {

                        if (!Directory.Exists(localPath))

                            try

                            {

                                Directory.CreateDirectory(localPath);

                                if (Log.IsDebugEnabled)

                                    Log.DebugFormat("Created Directory [{0}]",localPath);

                            }

                            catch (IOException)

                            {

                                var localInfo = new FileInfo(localPath);

                                if (localInfo.Exists && localInfo.Length == 0)

                                {

                                    Log.WarnFormat("Malformed directory object detected for [{0}]",localPath);

                                    localInfo.Delete();

                                    Directory.CreateDirectory(localPath);

                                    if (Log.IsDebugEnabled)

                                        Log.DebugFormat("Created Directory [{0}]", localPath);

                                }

                            }

                    }

                    else

                    {

                        var isChanged = IsObjectChanged(cloudFile, localPath);

                        if (isChanged)

                        {

                            //Retrieve the hashmap from the server

                            var serverHash = await client.GetHashMap(account, container, url);

                            //If it's a small file

                            if (serverHash.Hashes.Count == 1)

                                //Download it in one go

                                await

                                    DownloadEntireFileAsync(accountInfo, client, cloudFile, relativeUrl, localPath,

                                                            serverHash);

                            //Otherwise download it block by block

                            else

                                await

                                    DownloadWithBlocks(accountInfo, client, cloudFile, relativeUrl, localPath,

                                                       serverHash);

                            if (cloudFile.AllowedTo == "read")

                            {

                                var attributes = File.GetAttributes(localPath);

                                File.SetAttributes(localPath, attributes | FileAttributes.ReadOnly);

                            }

                        }

                    }

                    //Now we can store the object's metadata without worrying about ghost status entries

                    StatusKeeper.StoreInfo(localPath, cloudFile);

                }

            }

        }

        private bool IsObjectChanged(ObjectInfo cloudFile, string localPath)

        {

            //If the target is a directory, there are no changes to download

            if (Directory.Exists(localPath))

                return false;

            //If the file doesn't exist, we have a chagne

            if (!File.Exists(localPath)) 

                return true;

            //If there is no stored state, we have a change

            var localState = StatusKeeper.GetStateByFilePath(localPath);

            if (localState == null)

                return true;

            var info = new FileInfo(localPath);

            var shortHash = info.ComputeShortHash();

            //If the file is different from the stored state, we have a change

            if (localState.ShortHash != shortHash)

                return true;

            //If the top hashes differ, we have a change

            return (localState.Checksum != cloudFile.Hash);

        }

        //Download a small file with a single GET operation

        private async Task DownloadEntireFileAsync(AccountInfo accountInfo, CloudFilesClient client, ObjectInfo cloudFile, Uri relativeUrl, string filePath,TreeHash serverHash)

        {

            if (client == null)

                throw new ArgumentNullException("client");

            if (cloudFile==null)

                throw new ArgumentNullException("cloudFile");

            if (relativeUrl == null)

                throw new ArgumentNullException("relativeUrl");

            if (String.IsNullOrWhiteSpace(filePath))

                throw new ArgumentNullException("filePath");

            if (!Path.IsPathRooted(filePath))

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

            if (cloudFile.IsDirectory)

                throw new ArgumentException("cloudFile is a directory, not a file","cloudFile");

            Contract.EndContractBlock();

            var localPath = Pithos.Interfaces.FileInfoExtensions.GetProperFilePathCapitalization(filePath);

            StatusNotification.SetPithosStatus(PithosStatus.LocalSyncing,String.Format("Downloading {0}",Path.GetFileName(localPath)));

            StatusNotification.Notify(new CloudNotification { Data = cloudFile });

            var fileAgent = GetFileAgent(accountInfo);

            //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.CachePath, relativePath + ".download");

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

            var tempFolder = Path.GetDirectoryName(tempPath);

            if (!Directory.Exists(tempFolder))

                Directory.CreateDirectory(tempFolder);

            //Download the object to the temporary location

            await client.GetObject(cloudFile.Account, cloudFile.Container, relativeUrl.ToString(), tempPath);

            //Create the local folder if it doesn't exist (necessary for shared objects)

            var localFolder = Path.GetDirectoryName(localPath);

            if (!Directory.Exists(localFolder))

                try

                {

                    Directory.CreateDirectory(localFolder);

                }

                catch (IOException)

                {

                    //A file may already exist that has the same name as the new folder.

                    //This may be an artifact of the way Pithos handles directories

                    var fileInfo = new FileInfo(localFolder);

                    if (fileInfo.Exists && fileInfo.Length == 0)

                    {

                        Log.WarnFormat("Malformed directory object detected for [{0}]", localFolder);

                        fileInfo.Delete();

                        Directory.CreateDirectory(localFolder);

                    }

                    else 

                        throw;

                }

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

            //Notify listeners that a local file has changed

            StatusNotification.NotifyChangedFile(localPath);

        }

        //Download a file asynchronously using blocks

        public async Task DownloadWithBlocks(AccountInfo accountInfo, CloudFilesClient client, ObjectInfo cloudFile, Uri relativeUrl, string filePath, TreeHash serverHash)

        {

            if (client == null)

                throw new ArgumentNullException("client");

            if (cloudFile == null)

                throw new ArgumentNullException("cloudFile");

            if (relativeUrl == null)

                throw new ArgumentNullException("relativeUrl");

            if (String.IsNullOrWhiteSpace(filePath))

                throw new ArgumentNullException("filePath");

            if (!Path.IsPathRooted(filePath))

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

            if (serverHash == null)

                throw new ArgumentNullException("serverHash");

            if (cloudFile.IsDirectory)

                throw new ArgumentException("cloudFile is a directory, not a file", "cloudFile");

            Contract.EndContractBlock();

           var fileAgent = GetFileAgent(accountInfo);

            var localPath = Interfaces.FileInfoExtensions.GetProperFilePathCapitalization(filePath);

            //Calculate the relative file path for the new file

            var relativePath = relativeUrl.RelativeUriToFilePath();

            var blockUpdater = new BlockUpdater(fileAgent.CachePath, localPath, relativePath, serverHash);

            StatusNotification.SetPithosStatus(PithosStatus.LocalSyncing,String.Format("Calculating hashmap for {0} before download",Path.GetFileName(localPath)));

            //Calculate the file's treehash

            var treeHash = await Signature.CalculateTreeHashAsync(localPath, serverHash.BlockSize, serverHash.BlockHash, 2);

            //And compare it with the server's hash

            var upHashes = serverHash.GetHashesAsStrings();

            var localHashes = treeHash.HashDictionary;

            ReportDownloadProgress(Path.GetFileName(localPath),0,upHashes.Length,cloudFile.Bytes);

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

            {

                //For every non-matching hash

                var upHash = upHashes[i];

                if (!localHashes.ContainsKey(upHash))

                {

                    StatusNotification.Notify(new CloudNotification { Data = cloudFile });

                    if (blockUpdater.UseOrphan(i, upHash))

                    {

                        Log.InfoFormat("[BLOCK GET] ORPHAN FOUND for {0} of {1} for {2}", i, upHashes.Length, localPath);

                        continue;

                    }

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

                    var start = i*serverHash.BlockSize;

                    //To download the last block just pass a null for the end of the range

                    long? end = null;

                    if (i < upHashes.Length - 1 )

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

                    //Download the missing block

                    var block = await client.GetBlock(cloudFile.Account, cloudFile.Container, relativeUrl, start, end);

                    //and store it

                    blockUpdater.StoreBlock(i, block);

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

                }

                ReportDownloadProgress(Path.GetFileName(localPath), i, upHashes.Length, cloudFile.Bytes);

            }

            //Want to avoid notifications if no changes were made

            var hasChanges = blockUpdater.HasBlocks;

            blockUpdater.Commit();

            if (hasChanges)

                //Notify listeners that a local file has changed

                StatusNotification.NotifyChangedFile(localPath);

            Log.InfoFormat("[BLOCK GET] COMPLETE {0}", localPath);            

        }

        private async Task UploadCloudFile(CloudAction action)

        {

            if (action == null)

                throw new ArgumentNullException("action");           

            Contract.EndContractBlock();

            using(ThreadContext.Stacks["Operation"].Push("UploadCloudFile"))

            {

                try

                {

                    var accountInfo = action.AccountInfo;

                    var fileInfo = action.LocalFile;

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

                        return;

                    //

                    if (action.FileState == null)

                        action.FileState = StatusKeeper.GetStateByFilePath(fileInfo.FullName);

                    if (action.FileState == null)

                    {

                        Log.WarnFormat("File [{0}] has no local state. It was probably created by a download action",fileInfo.FullName);

                        return;

                    }

                    //Do not upload files in conflict

                    if (action.FileState.FileStatus == FileStatus.Conflict )

                    {

                        Log.InfoFormat("Skipping file in conflict [{0}]",fileInfo.FullName);

                        return;

                    }

                    if (action.FileState.FileStatus == FileStatus.Forbidden)

                    {

                        Log.InfoFormat("Skipping forbidden file [{0}]",fileInfo.FullName);

                        return;

                    }

                    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, StringComparison.Ordinal);

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

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

                    {

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

                        if (gate.Failed)

                            return;

                        var cloudFile = action.CloudFile;

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

                        try

                        {

                        var client = new CloudFilesClient(accountInfo);

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

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

                        //If this is a read-only file, do not upload changes

                        if (cloudInfo.AllowedTo == "read")

                            return;

                        //TODO: Check how a directory hash is calculated -> All dirs seem to have the same hash

                            if (fileInfo is DirectoryInfo)

                            {

                                //If the directory doesn't exist the Hash property will be empty

                                if (String.IsNullOrWhiteSpace(cloudInfo.Hash))

                                    //Go on and create the directory

                                    await

                                        client.PutObject(account, cloudFile.Container, cloudFile.Name, fullFileName,

                                                         String.Empty, "application/directory");

                            }

                            else

                            {

                                var cloudHash = cloudInfo.Hash.ToLower();

                                StatusNotification.Notify(new StatusNotification(String.Format("Hashing {0} for Upload",fileInfo.Name)));

                                //TODO: This is the same as the calculation for the Local Hash!

                                //First, calculate the tree hash

/*

                                var treeHash = await Signature.CalculateTreeHashAsync(fullFileName, accountInfo.BlockSize,

                                                                                      accountInfo.BlockHash, 2);

*/

                                var treeHash = action.TreeHash.Value;

                                var topHash = treeHash.TopHash.ToHashString();

                                //var topHash = action.TopHash.Value;

                                //If the file hashes match, abort the upload

                                if (topHash == cloudHash /*|| topHash == cloudHash*/)

                                {

                                    //but store any metadata changes 

                                    StatusKeeper.StoreInfo(fullFileName, cloudInfo);

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

                                    return;

                                }

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

                                //the relevant block

                                //TODO: If the upload fails with a 403, abort it and mark conflict

                                await

                                    UploadWithHashMap(accountInfo, cloudFile, fileInfo as FileInfo, cloudFile.Name, treeHash);

                            }

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

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

                        }

                        catch (WebException exc)

                        {

                            var response=(exc.Response as HttpWebResponse);

                            if (response == null)

                                throw;

                            if (response.StatusCode == HttpStatusCode.Forbidden)

                            {

                                StatusKeeper.SetFileState(fileInfo.FullName,FileStatus.Forbidden, FileOverlayStatus.Conflict);                                

                            }

                        }

                    }

                    //Notify the Shell to update the overlays

                    NativeMethods.RaiseChangeNotification(fullFileName);

                    StatusNotification.NotifyChangedFile(fullFileName);

                }

                catch (AggregateException ex)

                {

                    var exc = ex.InnerException as WebException;

                    if (exc == null)

                        throw ex.InnerException;

                    if (HandleUploadWebException(action, exc))

                        return;

                    throw;

                }

                catch (WebException ex)

                {

                    if (HandleUploadWebException(action, ex))

                        return;

                    throw;

                }

                catch (Exception ex)

                {

                    Log.Error("Unexpected error while uploading file", ex);

                    throw;

                }

            }

        }

        private bool HandleUploadWebException(CloudAction action, WebException exc)

        {

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

            }

            return false;

        }

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

        {

            if (accountInfo == null)

                throw new ArgumentNullException("accountInfo");

            if (cloudFile==null)

                throw new ArgumentNullException("cloudFile");

            if (fileInfo == null)

                throw new ArgumentNullException("fileInfo");

            if (String.IsNullOrWhiteSpace(url))

                throw new ArgumentNullException(url);

            if (treeHash==null)

                throw new ArgumentNullException("treeHash");

            if (String.IsNullOrWhiteSpace(cloudFile.Container) )

                throw new ArgumentException("Invalid container","cloudFile");

            Contract.EndContractBlock();

            StatusNotification.Notify(new StatusNotification(String.Format("Uploading {0}", fileInfo.Name)));

            var fullFileName = fileInfo.GetProperCapitalization();

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

            var container = cloudFile.Container ;

            var client = new CloudFilesClient(accountInfo);            

            //Send the hashmap to the server            

            var missingHashes =  await client.PutHashMap(account, container, url, treeHash);

            int block = 0;

            ReportUploadProgress(fileInfo.Name,block++, missingHashes.Count, fileInfo.Length);

            //If the server returns no missing hashes, we are done

            while (missingHashes.Count > 0)

            {

                var buffer = new byte[accountInfo.BlockSize];

                foreach (var missingHash in missingHashes)

                {

                    //Find the proper block

                    var blockIndex = treeHash.HashDictionary[missingHash];

                    long offset = blockIndex*accountInfo.BlockSize;

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

                    try

                    {

                        //And upload the block                

                        await client.PostBlock(account, container, buffer, 0, read);

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

                    }

                    catch (Exception exc)

                    {

                        Log.Error(String.Format("Uploading block {0} of {1}", blockIndex, fullFileName), exc);

                    }

                    ReportUploadProgress(fileInfo.Name,block++, missingHashes.Count, fileInfo.Length);

                }

                //Repeat until there are no more missing hashes                

                missingHashes = await client.PutHashMap(account, container, url, treeHash);

            }

            ReportUploadProgress(fileInfo.Name, missingHashes.Count, missingHashes.Count, fileInfo.Length);

        }

        private void ReportUploadProgress(string fileName,int block, int totalBlocks, long fileSize)

        {

            StatusNotification.Notify(totalBlocks == 0

                                          ? new ProgressNotification(fileName, "Uploading", 1, 1, fileSize)

                                          : new ProgressNotification(fileName, "Uploading", block, totalBlocks, fileSize));

        }

        private void ReportDownloadProgress(string fileName,int block, int totalBlocks, long fileSize)

        {

            StatusNotification.Notify(totalBlocks == 0

                                          ? new ProgressNotification(fileName, "Downloading", 1, 1, fileSize)

                                          : new ProgressNotification(fileName, "Downloading", block, totalBlocks, fileSize));

        }