Synnefo » Pithos MS Client

	    private readonly PollAgent _pollAgent;

	    private readonly NetworkAgent _networkAgent;

	    private MiniStatusViewModel _miniStatus;

			    MigrateFolders(account);

				if (Monitors.TryGetValue(account.AccountKey, out monitor))

				{

					//If the account is active

		        PithosMonitor monitor;

		        if (Monitors.TryGetValue(message.Account.AccountKey, out monitor))

		        {

		            monitor.SetSelectivePaths(message.Uris, message.Added, message.Removed);

		        }

        {

            var comparer = new LocalFileComparer();

            var account = new AccountInfo();

            Assert.That(comparer.Equals(x, y), Is.True);

        }

        {

            var comparer = new LocalFileComparer();

            var account = new AccountInfo();

            Assert.That(comparer.Equals(x, y), Is.True);

        }

        [Test]

        {

            var comparer = new LocalFileComparer();

            var account = new AccountInfo();

            Assert.That(comparer.Equals(x, y), Is.False);

        }

    public class CloudAction

    {

        public AccountInfo AccountInfo { get; set; }

        public CloudActionType Action { get; set; }

        public FileSystemInfo LocalFile { get; set; }

            get { return  CloudFile!=null && AccountInfo.UserName != CloudFile.Account; }

        }

        {

            if (accountInfo==null)

                throw new ArgumentNullException("accountInfo");

            Action = action;

            AccountInfo = accountInfo;

        }

        {

            if(blockSize<=0)

                throw new ArgumentOutOfRangeException("blockSize");

    public class CloudDownloadAction:CloudAction

    {

        {            

            if (String.IsNullOrWhiteSpace(cloudFile.Container))

                throw new ArgumentException("CloudFile.Container","cloudFile");

    }

    public class CloudDeleteAction:CloudAction

    {

        {            

        }

        {

            CloudFile = cloudFile;

            LocalFile = fileInfo;

        }

        public CloudDeleteAction(CloudAction action)

        {}

        [ContractInvariantMethod]

    public class CloudUploadAction:CloudAction

    {

        {

        }

        public FileSystemInfo OldLocalFile { get; set; }

        {

            LocalFile = newFile;

            CloudFile = CreateObjectInfoFor(accountInfo, newFile);

                if (!localHashes.ContainsKey(upHash))

                {

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

                    if (blockUpdater.UseOrphan(i, upHash))

                    {

            var localPath = 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

                    if (change.ChangeType == WatcherChangeTypes.Renamed)

                    {

                        var rename = (MovedEventArgs) change;

                                        {

                                            AccountInfo = AccountInfo,

                                            OldPath = rename.OldFullPath,

                                        });

                    }

                    else

                        {

                            AccountInfo = AccountInfo,

                            Path = change.FullPath,

                        yield return new CloudAction(accountInfo, CloudActionType.MustSynch,

                                                     localFile, objectInfo, state, accountInfo.BlockSize,

                    }

                }

                else

                {

                    //Remote files should be downloaded

                }

            }

        }

                        //For each moved object we need to move both the local file and update                                                

                        yield return new CloudAction(accountInfo, CloudActionType.RenameLocal,

                                                     previousFile, objectInfo, state, accountInfo.BlockSize,

                        //For modified files, we need to download the changes as well

                        if (objectInfo.Hash!=objectInfo.PreviousHash)

                    }

                }

                //If the previous file does not exist, we need to download it in the new location

                else

                {

                    //Remote files should be downloaded

                }

            }

        }

                    var state = StatusKeeper.GetStateByFilePath(localFile.WithProperCapitalization().FullName);

                    yield return new CloudAction(accountInfo, CloudActionType.MustSynch,

                                                     localFile, objectInfo, state, accountInfo.BlockSize,

                }

                else

                {

                    //Remote files should be downloaded

                }

            }

using System.Linq;

using System.Net;

using System.Reflection;

using System.Threading;

using System.Threading.Tasks;

using Pithos.Interfaces;

                                    topHash = treeHash.TopHash.ToHashString();

                                }

                                //If the file hashes match, abort the upload

                                {

                                    //but store any metadata changes 

                                    StatusKeeper.StoreInfo(fullFileName, cloudInfo);

                            case FileStatus.Modified:

                                NetworkAgent.Post(new CloudUploadAction(accountInfo, info, fileState,

                                                                        accountInfo.BlockSize,

                                break;

                            case FileStatus.Deleted:

                                DeleteChildObjects(state, fileState);

                                break;

                            case FileStatus.Renamed:

                                if (state.OldPath == null)

                                                             : new FileInfo(state.Path);

                                NetworkAgent.Post(new CloudMoveAction(accountInfo, CloudActionType.RenameCloud,

                                                                      oldInfo,

                                //TODO: Do I have to move children as well or will Pithos handle this?

                               //Need to find all children of the OLD filepath

                                //MoveChildObjects(state);

                    var childInfo = child.IsFolder

                                        ? (FileSystemInfo) new DirectoryInfo(child.FilePath)

                                        : new FileInfo(child.FilePath);

                }

            }

        }

{

    public class WorkflowState

    {

        public AccountInfo AccountInfo { get; set; }

        public string Path { get; set; }

        }

*/

        {

        }

        public WorkflowState(AccountInfo accountInfo, FileState state)

                throw new ArgumentNullException("state");

            Contract.EndContractBlock();

            AccountInfo = accountInfo;

            Path = state.FilePath.ToLower();

            FileName = System.IO.Path.GetFileName(state.FilePath).ToLower();

    {

        private readonly List<string> _knownContainers= new List<string>{"trash"};

        public string Name { get; set; }

        public string Hash { get; set; }

        public string X_Object_Hash { get { return Hash; } set { Hash = value; } }

                                                   Account = account,

                                                   Container = container,

                                                   Name = objectName,

                                                   Content_Type = client.GetHeaderValue("Content-Type"),

                                                   Bytes = Convert.ToInt64(client.GetHeaderValue("Content-Length",true)),

                                                   Tags = tags,

                {

                    Bytes = length,

                    BlockSize = blockSize,

                };

                return treeHash;

            }

        }

            }

        }

        //Saves the Json representation to a file

        public async Task Save(string filePath)

        {