Synnefo » Pithos MS Client

        public void Start()

        {

            _agent = Agent<CloudAction>.Start(inbox =>

            {

                Action loop = null;

                try

                {

                    _proceedEvent.Reset();

                    //UpdateStatus(PithosStatus.Syncing);

                    var accountInfo = action.AccountInfo;

                {

                    if (_agent.IsEmpty)

                        _proceedEvent.Set();

                }

            }

        }

        private void UpdateStatus(PithosStatus status)

        {

        }

        private void RenameLocalFile(AccountInfo accountInfo, CloudAction action)

                var cloudHash = cloudFile.Hash.ToLower();

                var previousCloudHash = cloudFile.PreviousHash.ToLower();

                //At this point we know that an object has changed on the server and that a local

                //file already exists. We need to decide whether the file has only changed on 

                //the server or there is a conflicting change on the client.

                //

                {

                    Log.InfoFormat("Skipping {0}, hashes match", downloadPath);

                    return;

            Contract.EndContractBlock();

            _deleteAgent.ProceedEvent.Wait();

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

            if (!(cloudAction is CloudDeleteAction) && cloudAction.LocalFile as FileInfo != null)

            {

                var accountInfo = cloudAction.AccountInfo;

                var localFile = (FileInfo) cloudAction.LocalFile;

                if (localFile.Length > accountInfo.BlockSize)

                    cloudAction.TopHash =

                        new Lazy<string>(() => Signature.CalculateTreeHashAsync(localFile,

                {

                    cloudAction.TopHash = new Lazy<string>(() => cloudAction.LocalHash.Value);

                }

            }

            else

            {

                //The hash for a directory is the empty string

                cloudAction.TopHash = new Lazy<string>(() => String.Empty);

            }

            if (cloudAction is CloudDeleteAction)

                _deleteAgent.Post((CloudDeleteAction)cloudAction);

                    }

                    else

                    {

                        {

                        }

                    }

            }

        }

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

        {

            Contract.EndContractBlock();

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

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

            var fileAgent = GetFileAgent(accountInfo);

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

            //Calculate the file's treehash

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

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

                        return;

                    //Do not upload files in conflict

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

                    {

                        var client = new CloudFilesClient(accountInfo);

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

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

                            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

                                    //Go on and create the directory

                                    await

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

                            else

                            {

                                //If the file hashes match, abort the upload

                                {

                                    //but store any metadata changes 

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

                                    return;

                                }

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

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

            Contract.EndContractBlock();

            var fullFileName = fileInfo.GetProperCapitalization();

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

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

        {

        }

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

        {

        }

    }