Synnefo » Pithos MS Client

    <Compile Include="NativeMethods.cs" />

<!--    <Window.TaskbarItemInfo>

    </Window.TaskbarItemInfo>-->

using System.Runtime.InteropServices;

        private TaskbarViewModel _taskbar;

        public TaskbarViewModel Taskbar

        {

            get { return _taskbar; }

            set

            {

                _taskbar = value;

            }

        }

            string path=Settings.PithosPath;

            if (String.IsNullOrWhiteSpace(path))

                throw new ArgumentNullException("path", "The path parameter must not be emtpy");

            if (!Directory.Exists(path) && !File.Exists(path))

                throw new FileNotFoundException("The specified file or path does not exist", path);

            IntPtr pathPointer = Marshal.StringToCoTaskMemAuto(path);

            try

            {

                NativeMethods.SHChangeNotify(HChangeNotifyEventID.SHCNE_UPDATEITEM,

                                             HChangeNotifyFlags.SHCNF_PATHW | HChangeNotifyFlags.SHCNF_FLUSHNOWAIT,

                                             pathPointer, IntPtr.Zero);

            }

            finally

            {

                Marshal.FreeHGlobal(pathPointer);

            }

                    return ((global::Pithos.Interfaces.AccountsCollection)(this["Accounts"]));

        private string _statusIcon="Images/Tray.ico";

using Pithos.Network;

        ConcurrentDictionary<string, NetworkOperation> _networkState = new ConcurrentDictionary<string, NetworkOperation>();

        public void SetNetworkState(string path, NetworkOperation operation)

            _networkState[path.ToLower()] = operation;

            if (operation == NetworkOperation.None)

                NetworkOperation oldOperation;

                _networkState.TryRemove(path, out oldOperation);

        public NetworkOperation GetNetworkState(string path)

            NetworkOperation operation;

            if (_networkState.TryGetValue(path, out operation))

                return operation;

            return NetworkOperation.None;

        public int BlockSize { get; set; }

    <ProjectReference Include="..\Pithos.Network\Pithos.Network.csproj">

      <Project>{C8E2BC8B-C7F1-4222-855C-4B04A57FFDFD}</Project>

      <Name>Pithos.Network</Name>

    </ProjectReference>

                                        NativeMethods.RaiseChangeNotification(path);

            Assert.DoesNotThrow(() => NativeMethods.RaiseChangeNotification(path));

using Pithos.Network;

        [Import]

        public FileAgent FileAgent {get;set;}

        /*

*/

        private int _blockSize;

        private string _blockHash;

        public void Start(string pithosContainer, string trashContainer, int blockSize, string blockHash)

            _blockSize = blockSize;

            _blockHash = blockHash;

        class ObjectInfoByNameComparer:IEqualityComparer<ObjectInfo>

        {

            public bool Equals(ObjectInfo x, ObjectInfo y)

            {

                return x.Name.Equals(y.Name,StringComparison.InvariantCultureIgnoreCase);

            }

            public int GetHashCode(ObjectInfo obj)

            {

                return obj.Name.ToLower().GetHashCode();

            }

        }

                //ListObjects failed at this point, need to reschedule

                if (task.IsFaulted)

                {

                    Trace.TraceError("[FAIL] ListObjects in ProcessRemoteFiles with {0}",task.Exception);

                    ProcessRemoteFiles(accountPath, since);

                    return;

                }

                var remote=(from info in remoteObjects

                                  let name=info.Name

                                  where !name.EndsWith(".ignore",StringComparison.InvariantCultureIgnoreCase) &&

                                  !name.StartsWith("fragments/",StringComparison.InvariantCultureIgnoreCase)

                                select info)

                                .Distinct(new ObjectInfoByNameComparer()).ToDictionary(info=> info.Name.ToLower(), info=>info);

                var commonObjects = new List<Tuple<ObjectInfo, FileInfo>>();

                var localFiles = new List<FileInfo>();

                //In order to avoid multiple iterations over the files, we iterate only once

                foreach (var fileInfo in FileAgent.EnumerateFileInfos())

                {

                    var relativeUrl=fileInfo.AsRelativeUrlTo(FileAgent.RootPath);

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

                    if (remote.ContainsKey(relativeUrl))

                    {

                        commonObjects.Add(Tuple.Create(remote[relativeUrl], fileInfo));

                        remote.Remove(relativeUrl);

                    }

                    else

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

                        localFiles.Add(fileInfo);

                }

                //At the end of the iteration, the *remote* list will contain the files that exist 

                //only on the server

                //Local files should be uploaded

                var actionsForLocal = from localFile in localFiles

                                select new CloudAction(CloudActionType.UploadUnconditional, 

                                    localFile, 

                                    ObjectInfo.Empty);                

                //Remote files should be downloaded

                var actionsForRemote = from dictPair in remote

                                       let upFile = dictPair.Value

                                       select new CloudAction(CloudActionType.DownloadUnconditional, null, upFile);

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

                var actionsForCommon = from pair in commonObjects

                                       let objectInfo = pair.Item1

                                       let localFile = pair.Item2

                                       select new CloudAction(CloudActionType.MustSynch, localFile, objectInfo);

                //Collect all the actions

                var allActions = actionsForLocal.Union(actionsForRemote).Union(actionsForCommon);

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

                var distinctActions =allActions

                //Queue all the actions

                _agent.AddFromEnumerable(distinctActions);

                StatusNotification.NotifyChange(String.Format("Processing {0} files", distinctActions.Count));

                ProcessRemoteFiles(accountPath, nextSince);

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

                        UploadCloudFile(localFile, action.LocalHash.Value);

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

                                    UploadCloudFile(localFile, action.LocalHash.Value);

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

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

            NativeMethods.RaiseChangeNotification(newPath);

        //Download a file.

        private void DownloadCloudFile(string container, Uri relativeUrl, string localPath)

            if (relativeUrl==null)

                throw new ArgumentNullException("relativeUrl");

            var url = relativeUrl.ToString();

            if (url.EndsWith(".ignore",StringComparison.InvariantCultureIgnoreCase))

            //Are we already downloading or uploading the file? 

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

            {

                if (gate.Failed)

                    return;

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

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

                var getHashMap = CloudClient.GetHashMap(container,url);

                //And save it

                var saveHashMap = getHashMap.ContinueWith(t =>

                {

                    var treeHash = t.Result;

                    treeHash.Save(hashPath);

                });

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

                var directoryPath=Path.GetDirectoryName(tempPath);

                if (!Directory.Exists(directoryPath))

                    Directory.CreateDirectory(directoryPath);

                //Download the object to the temporary location

                var getObject = CloudClient.GetObject(container, url, tempPath).ContinueWith(t =>

                {

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

                });

                //Retrieve the object's metadata

                var getInfo = saveHashMap.ContinueWith(t => getObject).ContinueWith(t =>

                            CloudClient.GetObjectInfo(container, url));

                //And store it

                var storeInfo = getInfo.ContinueWith(t =>

                            StatusKeeper.StoreInfo(localPath, t.Result));

                storeInfo.Wait();

            }

        private void UploadCloudFile(FileInfo fileInfo, string hash)

            if (fileInfo==null)

                throw new ArgumentNullException("fileInfo");

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

            var url = fileInfo.AsRelativeUrlTo(FileAgent.RootPath);

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

            {

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

                if (gate.Failed)

                    return;

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

                var info = CloudClient.GetObjectInfo(_pithosContainer, url);

                //If the file hashes match, abort the upload

                if (hash.Equals(info.Hash, StringComparison.InvariantCultureIgnoreCase))

                    //but store any metadata changes 

                    this.StatusKeeper.StoreInfo(fileInfo.FullName, info);

                    Trace.TraceInformation("Skip upload of {0}, hashes match", fileInfo.FullName);

                    return;

                //If the file was last modified by a hashmap operation, its hash will be a treehash

                //We must load the local file's treehash and check it against the object's hash 

                //The hash will be stored under the fragments path, in the same relative path as to

                //the pithos root path

                var relativePath = fileInfo.AsRelativeTo(FileAgent.RootPath);

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

                //Load the hash or calculate a new one

                var hashFileExists = File.Exists(hashPath);

                var treeHash = hashFileExists ?

                    TreeHash.LoadTreeHash(hashPath, Guid.NewGuid()).Result

                    : Signature.CalculateTreeHash(fileInfo.FullName, _blockSize, _blockHash);

                //If this is a new treehash, store it

                if (!hashFileExists)

                    treeHash.Save(hashPath);

                var topHash = treeHash.TopHash.ToHashString();

                if (topHash.Equals(info.Hash, StringComparison.InvariantCultureIgnoreCase))

                    this.StatusKeeper.StoreInfo(fileInfo.FullName, info);

                    Trace.TraceInformation("Skip upload of {0}, treehashes match", fileInfo.FullName);

                    return;                    

                //Does the object exist or not?

                //Calculate or load the file's hashmap                

                /*

                 if (fileInfo.Bytes > _blockSize)

                 {

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

                //Load the existing hashPath, if we have one, or calculate a new one

                var treeHash = File.Exists(hashPath) ?

                    TreeHash.LoadTreeHash(hashPath, Guid.NewGuid()).Result 

                    : Signature.CalculateTreeHash(fileInfo.FullName, _blockSize , _blockHash);

                //Do the Hashmap Put

                Task<string> putHashMap=CloudClient.PutHashMap(_pithosContainer,url, treeHash);

                putHashMap.Wait();

                 }*/                    

            //

                var putOrUpdate = Task.Factory.StartNew(() =>

                {

                    //Mark the file as modified while we upload it

                    var setStatus = Task.Factory.StartNew(() =>

                        StatusKeeper.SetFileOverlayStatus(fileInfo.FullName,FileOverlayStatus.Modified));

                    //And then upload it

                    var put = setStatus.ContinueWith(t =>

                        CloudClient.PutObject(_pithosContainer,url,fileInfo.FullName, hash));

                });

                putOrUpdate.Wait();

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

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

            }

            //Notify the Shell to update the overlays

            NativeMethods.RaiseChangeNotification(fileInfo.FullName);

        //We should avoid processing files stored in the Fragments folder

        //The Full path to the fragments folder is stored in FragmentsPath

        public string FragmentsPath { get; set; }

            var pendingEntries = (from state in FileState.Queryable

                                 where interruptedStates.Contains(state.OverlayStatus) &&

                                       !state.FilePath.StartsWith(FragmentsPath) &&

                                       !state.FilePath.EndsWith(".ignore")

                                 select state).ToList();

            var staleEntries = from state in pendingEntries

                                  where !File.Exists(state.FilePath)

                                  select state;

            var staleKeys = staleEntries.Select(state=>state.Id);

            FileState.DeleteAll(staleKeys);

            var validEntries = from state in pendingEntries.Except(staleEntries)

                             where File.Exists(state.FilePath)

            _agent.AddFromEnumerable(validEntries);

        }       

using System.IO;

using Pithos.Network;

       [HasMany(Cascade = ManyRelationCascadeEnum.AllDeleteOrphan, Lazy = true,Inverse=true)]

            //Skip updating the hash for folders

            if (Directory.Exists(FilePath))

                return Task.Factory.StartNew(() => this);

       // void RaiseChangeNotification(string path);

        int BlockSize { get; set; }

        public void SetNetworkState(string path, NetworkOperation operation)

        public NetworkOperation GetNetworkState(string path)

            return default(NetworkOperation);

        public abstract string BlockHash { get; set; }

        public abstract int BlockSize { get; set; }

using Pithos.Network;

        ConcurrentDictionary<string, NetworkOperation> _networkState = new ConcurrentDictionary<string, NetworkOperation>();

        public void SetNetworkState(string path, NetworkOperation operation)

            _networkState[path.ToLower()] = operation;

            if (operation == NetworkOperation.None)

                NetworkOperation oldOperation;

                _networkState.TryRemove(path, out oldOperation);

        public NetworkOperation GetNetworkState(string path)

            NetworkOperation operation;

            if (_networkState.TryGetValue(path, out operation))

                return operation;

            return NetworkOperation.None;

        public int BlockSize { get; set; }

using System.IO;

    public enum HChangeNotifyEventID

    public static class NativeMethods

        public static void RaiseChangeNotification(string path)

        {

            if (String.IsNullOrWhiteSpace(path))

                throw new ArgumentNullException("path", "The path parameter must not be emtpy");

            if (!Directory.Exists(path) && !File.Exists(path))

                throw new FileNotFoundException("The specified file or path does not exist", path);

            IntPtr pathPointer = Marshal.StringToCoTaskMemAuto(path);

            try

            {

                NativeMethods.SHChangeNotify(HChangeNotifyEventID.SHCNE_UPDATEITEM,

                                             HChangeNotifyFlags.SHCNF_PATHW | HChangeNotifyFlags.SHCNF_FLUSHNOWAIT,

                                             pathPointer, IntPtr.Zero);

            }

            finally

            {

                Marshal.FreeHGlobal(pathPointer);

            }

        }

    <Compile Include="Agents\CloudAction.cs" />

    <Compile Include="Agents\FileAgent.cs" />

    <Compile Include="Agents\FileInfoExtensions.cs" />

    <Compile Include="NetworkGate.cs" />

using Pithos.Network;

        private const string FragmentsFolder = "fragments";

        private int _blockSize;

        private string _blockHash;

        public FileAgent FileAgent { get; set; }

            get { return FileAgent.Pause; }

                FileAgent.Pause = value;

            StatusKeeper.BlockHash = _blockHash;

            StatusKeeper.BlockSize = _blockSize;

            var pithosContainers = new[] { TrashContainer,PithosContainer};

                var info=CloudClient.GetContainerInfo(container);

                if (info == ContainerInfo.Empty)

                {

                    CloudClient.CreateContainer(container);

                    info = CloudClient.GetContainerInfo(container);

                }

                _blockSize = info.BlockSize;

                _blockHash = info.BlockHash;

            var allContainers= CloudClient.ListContainers();

            var extraContainers = from container in allContainers

                                  where !pithosContainers.Contains(container.Name.ToLower())

                                      select container;

                var fragmentsPath=Path.Combine(RootPath, FragmentsFolder);

                    where !filePath.StartsWith(fragmentsPath,StringComparison.InvariantCultureIgnoreCase) &&

                            !filePath.EndsWith(".ignore",StringComparison.InvariantCultureIgnoreCase)

                WorkflowAgent.FragmentsPath = Path.Combine(RootPath, FragmentsFolder);

            NetworkAgent.Start(PithosContainer, TrashContainer,_blockSize,_blockHash);

        //Make sure a hidden fragments folder exists to store partial downloads

        private static string CreateHiddenFolder(string rootPath, string folderName)

        {

            if (String.IsNullOrWhiteSpace(rootPath))

                throw new ArgumentNullException("rootPath");

            if (!Path.IsPathRooted(rootPath))

                throw new ArgumentException("rootPath");

            if (String.IsNullOrWhiteSpace(folderName))

                throw new ArgumentNullException("folderName");

            Contract.EndContractBlock();

            var folder = Path.Combine(rootPath, folderName);

            if (!Directory.Exists(folder))

            {

                var info = Directory.CreateDirectory(folder);

                info.Attributes |= FileAttributes.Hidden;

                Trace.TraceInformation("Created Fragments Folder: {0}", folder);

            }

            return folder;

        }

            FileAgent.StatusKeeper = StatusKeeper;

            FileAgent.Workflow = Workflow;

            FileAgent.FragmentsPath = Path.Combine(RootPath, FragmentsFolder);

            FileAgent.Start(path);

            FileAgent.Stop();

using System.Diagnostics;

            Debug.Assert(!path.Contains("fragments"));

            Debug.Assert(!path.EndsWith(".ignore",StringComparison.InvariantCultureIgnoreCase));

using Pithos.Network;

            CleanupStaleStates();

        }

        private void CleanupStaleStates()

        {

            /*var stales = from state in FileState.Queryable

                         where state.FilePath.StartsWith(@"e:\pithos\fragments")

                         select state.Id;*/

            FileState.DeleteAll(@"FilePath like 'e:\pithos\fragments%'");

            ;

                        try

                        {

                            action();

                        }

                        catch (Exception ex)

                        {

                            Trace.TraceError("[ERROR] STATE \n{0}",ex);

                        }

                using (new SessionScope())

                    var filePath = path.ToLower();

                    var state = FileState.Queryable.FirstOrDefault(s => s.FilePath == filePath);

                    if (state != null)

                    {

                        setter(state);

                        state.Save();

                    }

                    else

                    {

                        state = new FileState {FilePath = filePath};

                        setter(state);

                        state.Save();

                    }                    

            Debug.Assert(!path.Contains("fragments"));

            Debug.Assert(!path.EndsWith(".ignore"));

                using (new SessionScope())

                    var filePath = path.ToLower();

                    var state = FileState.Queryable.FirstOrDefault(s => s.FilePath == filePath);

                    if (state == null)

                    {

                        Trace.TraceWarning("[NOFILE] Unable to set status for {0}.", filePath);

                        return;

                    }

                    setter(state);

                    state.Save();

            _persistenceAgent.Post(() =>

                var filePath = path.ToLower();

                //Load the existing files state and set its properties in one session            

                using (new SessionScope())

                {

                    //Forgetting to use a sessionscope results in two sessions being created, one by 

                    //FirstOrDefault and one by Save()

                    var state =

                        FileState.Queryable.FirstOrDefault(s => s.FilePath == filePath);

                    //Create a new empty state object if this is a new file

                    state = state ?? new FileState();

                    state.FilePath = filePath;

                    state.Checksum = objectInfo.Hash;

                    state.FileStatus = FileStatus.Unchanged;

                    state.OverlayStatus = FileOverlayStatus.Normal;

                    //Create a list of tags from the ObjectInfo's tag dictionary

                    //Make sure to bind each tag to its parent state so we don't have to save each tag separately

                    //state.Tags = (from pair in objectInfo.Tags

                    //                select

                    //                    new FileTag

                    //                        {

                    //                            FileState = state,

                    //                            Name = pair.Key,

                    //                            Value = pair.Value

                    //                        }

                    //            ).ToList();

                    //Do the save

                    state.Save();

                }

            });