Synnefo » Pithos MS Client

        public IStatusNotification StatusNotification { get; set; }

        [Import]

        public FileAgent FileAgent {get;set;}

        private static readonly ILog Log = LogManager.GetLogger("NetworkAgent");

        {

            Contract.EndContractBlock();

            BlockSize = blockSize;

            BlockHash = blockHash;

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

        {

            if (action == null)

                throw new ArgumentNullException("action");

            Contract.EndContractBlock();

            using (log4net.ThreadContext.Stacks["NETWORK"].Push("PROCESS"))

            {                

                Log.InfoFormat("[ACTION] Start Processing {0}:{1}->{2}", action.Action, action.LocalFile,

                               action.CloudFile.Name);

                var localFile = action.LocalFile;

                var downloadPath = (cloudFile == null)

                                       ? String.Empty

                try

                {

                    switch (action.Action)

                    {

                        case CloudActionType.UploadUnconditional:

                            break;

                        case CloudActionType.DownloadUnconditional:

                                              downloadPath);

                            break;

                        case CloudActionType.DeleteCloud:

                            break;

                        case CloudActionType.RenameCloud:

                            var moveAction = (CloudMoveAction)action;

                                            moveAction.NewFileName);

                            break;

                        case CloudActionType.MustSynch:

                            if (!File.Exists(downloadPath))

                            {

                                var cloudUri = new Uri(action.CloudFile.Name, UriKind.Relative);

                            }

                            else

                            {

                            }

                            break;

                    }

                {

                    Log.ErrorFormat("{0} : {1} -> {2}  failed because the file was not found.\n Rescheduling a delete",

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

                }

                catch (Exception exc)

                {

            }

        }

        {

            if (action==null)

                throw new ArgumentNullException("action");

            if (action.LocalFile==null)

            var account = cloudFile.Account;

            //Use "pithos" by default if no container is specified

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

            var cloudHash = cloudFile.Hash.ToLower();

            if (lastUpTime <= lastLocalTime)

            {

                //It probably means it was changed while the app was down                        

                                action.TopHash.Value);

            }

            else

                {

                    case FileStatus.Unchanged:                        

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

                        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

        {

            if (cloudAction == null)

                throw new ArgumentNullException("cloudAction");

            Contract.EndContractBlock();

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

            if (cloudAction.LocalFile != null)

            {

                                     .TopHash.ToHashString());

                else

                {

            }

        }

        //Remote files are polled periodically. Any changes are processed

        {   

            Contract.EndContractBlock();

            {

                //Get the list of server objects changed since the last check

                //Get the list of deleted objects since the last check

                var listAll = Task.Factory.TrackedSequence(

                    () => listObjects,

                    () => listTrash,

                    () => listShared);

                var enqueueFiles = listAll.ContinueWith(task =>

                    if (task.IsFaulted)

                    {

                        //ListObjects failed at this point, need to reschedule

                        return;

                    }

                    using (log4net.ThreadContext.Stacks["SCHEDULE"].Push("Process Results"))

                        var realTrash = from trash in trashObjects

                                        where !remoteObjects.Any(info => info.Hash == trash.Hash)

                                        select trash;

                        var remote = from info in remoteObjects.Union(sharedObjects)

                                     select info;

                        //Create a list of actions from the remote files

                        //And remove those that are already being processed by the agent

                        var distinctActions = allActions

                    }

                });

                {                    

                    if (t.IsFaulted)

                    {

                    {

                        Log.Info("[LISTENER] Finished");

                    }

                });

            }

        }

        //Creates an appropriate action for each server file

        {

            if (remote==null)

                throw new ArgumentNullException();

            //over the remote files

            foreach (var objectInfo in remote)

            {

                //and remove any matching objects from the list, adding them to the commonObjects list

                if (FileAgent.Exists(relativePath))

                {

                    var state = FileState.FindByFilePath(localFile.FullName);

                    //Common files should be checked on a per-case basis to detect differences, which is newer

                }

                else

                {

                    //If there is no match we add them to the localFiles list

                    //but only if the file is not marked for deletion

                    var fileStatus = StatusKeeper.GetFileStatus(targetFile);

                    if (fileStatus != FileStatus.Deleted)

                    {

                        //Remote files should be downloaded

                    }

                }

            }            

        }

        {

            foreach (var trashObject in trashObjects)

            {

                //and remove any matching objects from the list, adding them to the commonObjects list

                FileAgent.Delete(relativePath);                                

            }

        }

        {

            if (String.IsNullOrWhiteSpace(account))

                throw new ArgumentNullException("account");

            if (String.IsNullOrWhiteSpace(container))

            //The local file is already renamed

            this.StatusKeeper.SetFileOverlayStatus(newPath, FileOverlayStatus.Modified);

            this.StatusKeeper.SetFileStatus(newPath, FileStatus.Unchanged);

            this.StatusKeeper.SetFileOverlayStatus(newPath, FileOverlayStatus.Normal);

            NativeMethods.RaiseChangeNotification(newPath);

        }

        {

            if (String.IsNullOrWhiteSpace(account))

                throw new ArgumentNullException("account");

            if (String.IsNullOrWhiteSpace(container))

            using ( log4net.ThreadContext.Stacks["DeleteCloudFile"].Push("Delete"))

            {

                var info = FileAgent.GetFileInfo(fileName);

            }

        }

        //Download a file.

        {

            if (String.IsNullOrWhiteSpace(account))

                throw new ArgumentNullException("account");

            if (String.IsNullOrWhiteSpace(container))

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

            Contract.EndContractBlock();

            download.Wait();

        }

        {

            if (String.IsNullOrWhiteSpace(account))

                throw new ArgumentNullException("account");

            if (String.IsNullOrWhiteSpace(container))

                //The file's hashmap will be stored in the same location with the extension .hashmap

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

                //Retrieve the hashmap from the server

                yield return getHashMap;

                var serverHash=getHashMap.Result;

                //If it's a small file

                var downloadTask=(serverHash.Hashes.Count == 1 )

                    //Download it in one go

                    //Otherwise download it block by block

                yield return downloadTask;

                //Retrieve the object's metadata

                //And store it

                StatusKeeper.StoreInfo(localPath, info);

        }

        //Download a small file with a single GET operation

        {

            if (String.IsNullOrWhiteSpace(account))

                throw new ArgumentNullException("account");

            if (String.IsNullOrWhiteSpace(container))

                Directory.CreateDirectory(directoryPath);

            //Download the object to the temporary location

            {

                t.PropagateExceptions();

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

        }

        //Download a file asynchronously using blocks

        {

            if (String.IsNullOrWhiteSpace(account))

                throw new ArgumentNullException("account");

            if (String.IsNullOrWhiteSpace(container))

                throw new ArgumentNullException("serverHash");

            Contract.EndContractBlock();

        }

        {

            if (String.IsNullOrWhiteSpace(account))

                throw new ArgumentNullException("account");

            if (String.IsNullOrWhiteSpace(container))

            //Calculate the file's treehash

            yield return calcHash;                        

            var treeHash = calcHash.Result;

                        continue;

                    }

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

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

                    long? end = null;

                    if (i < upHashes.Length - 1 )

                    //Download the missing block

                    yield return getBlock;

                    var block = getBlock.Result;

        }

        {

            if (String.IsNullOrWhiteSpace(account))

                throw new ArgumentNullException("account");

            if (String.IsNullOrWhiteSpace(container))

                throw new ArgumentNullException("topHash");

            Contract.EndContractBlock();

            upload.Wait();

        }

        {

            if (String.IsNullOrWhiteSpace(account))

                throw new ArgumentNullException("account");

            if (String.IsNullOrWhiteSpace(container))

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

                yield break;

            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)

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

                var cloudHash = info.Hash.ToLower();

                //If the file hashes match, abort the upload

                //And then upload it

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

                {

                    //To upload using a hashmap

                    //First, calculate the tree hash

                    yield return treeHash;

                }

                else

                {

                    //Otherwise do a regular PUT

                }

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

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

            StatusNotification.NotifyChangedFile(fullFileName);

        }

        {

            if (String.IsNullOrWhiteSpace(account))

                throw new ArgumentNullException("account");

            if (String.IsNullOrWhiteSpace(container))

            var fullFileName = fileInfo.FullName;

            //Send the hashmap to the server            

            yield return hashPut;

            var missingHashes = hashPut.Result;

            while (missingHashes.Count > 0)

            {

                foreach (var missingHash in missingHashes)

                {

                    //Find the proper block

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

                    //And upload the block                

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

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

                }

                //Repeat until there are no more missing hashes

                yield return hashPut;

                missingHashes = hashPut.Result;

            }

        }

    }