Synnefo » Pithos MS Client

/*

        private void ProcessBatchedEvents(Dictionary<string, FileSystemEventArgs[]> fileEvents)

        {

            StatusNotification.SetPithosStatus(PithosStatus.LocalSyncing,String.Format("Uploading {0} files",fileEvents.Count));

            //Start with events that do not originate in one of the ignored folders

            var initialEvents = from evt in fileEvents

                              where !IgnorePaths(evt.Key)

                              select evt;

            IEnumerable<KeyValuePair<string, FileSystemEventArgs[]>> cleanEvents;

            var selectiveEnabled = Selectives.IsSelectiveEnabled(AccountInfo.AccountKey);

            //When selective sync is enabled,

            if (selectiveEnabled)

            {

                //Include all selected items

                var selectedEvents = from evt in initialEvents

                                     where Selectives.IsSelected(AccountInfo, evt.Key)

                                     select evt;                

                //And all folder creations in the unselected folders

                var folderCreations = from evt in initialEvents

                                      let folderPath=evt.Key

                                      //The original folder may not exist due to renames. Just make sure that the path is not a file

                                      where !File.Exists(folderPath)

                                            //We only want unselected items

                                            && !Selectives.IsSelected(AccountInfo, folderPath)

                                            //Is there any creation event related to the folder?

                                            && evt.Value.Any(arg => arg.ChangeType == WatcherChangeTypes.Created)

                                      select evt;

                cleanEvents = selectedEvents.Union(folderCreations).ToList();

            }

            //If selective is disabled, only exclude the shared folders 

            else

            {

                cleanEvents = (from evt in initialEvents

                              where !evt.Key.IsSharedTo(AccountInfo)

                              select evt).ToList();

            }

            foreach (var fileEvent in cleanEvents)

            {

                //var filePath = fileEvent.Key;

                var changes = fileEvent.Value;

                var isNotFile = !File.Exists(fileEvent.Key);

                foreach (var change in changes)

                {

                    if (change.ChangeType == WatcherChangeTypes.Renamed)

                    {

                        var rename = (MovedEventArgs) change;

                        _agent.Post(new WorkflowState(change)

                                        {

                                            AccountInfo = AccountInfo,

                                            OldPath = rename.OldFullPath,

                                            OldFileName = Path.GetFileName(rename.OldName),

                                            Path = rename.FullPath,

                                            FileName = Path.GetFileName(rename.Name),

                                            TriggeringChange = rename.ChangeType

                                        });

                    }

                    else

                    {

                        var isCreation = selectiveEnabled && isNotFile && change.ChangeType == WatcherChangeTypes.Created;

                        _agent.Post(new WorkflowState(change)

                                        {

                                            AccountInfo = AccountInfo,

                                            Path = change.FullPath,

                                            FileName = Path.GetFileName(change.Name),

                                            TriggeringChange = change.ChangeType,

                                            IsCreation=isCreation

                                        });

                    }

                }

            }

            StatusNotification.SetPithosStatus(PithosStatus.LocalComplete);

        }

*/

/*            

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

            {

                Action loop = null;

                loop = () =>

                {

                    var message = inbox.Receive();

                    var process=message.Then(Process,inbox.CancellationToken);                    

                    inbox.LoopAsync(process,loop,ex=>

                        Log.ErrorFormat("[ERROR] File Event Processing:\r{0}", ex));

                };

                loop();

            });*/

/*

        private Task<object> Process(WorkflowState state)

        {

            if (state==null)

                throw new ArgumentNullException("state");

            Contract.EndContractBlock();

            if (Ignore(state.Path))

                return CompletedTask<object>.Default;

            var networkState = NetworkGate.GetNetworkState(state.Path);

            //Skip if the file is already being downloaded or uploaded and 

            //the change is create or modify

            if (networkState != NetworkOperation.None &&

                (

                    state.TriggeringChange == WatcherChangeTypes.Created ||

                    state.TriggeringChange == WatcherChangeTypes.Changed

                ))

                return CompletedTask<object>.Default;

            try

            {

                //StatusKeeper.EnsureFileState(state.Path);

                UpdateFileStatus(state);

                UpdateOverlayStatus(state);

                UpdateLastMD5(state);

                WorkflowAgent.Post(state);

            }

            catch (IOException exc)

            {

                if (File.Exists(state.Path))

                {

                    Log.WarnFormat("File access error occured, retrying {0}\n{1}", state.Path, exc);

                    _agent.Post(state);

                }

                else

                {

                    Log.WarnFormat("File {0} does not exist. Will be ignored\n{1}", state.Path, exc);

                }

            }

            catch (Exception exc)

            {

                Log.WarnFormat("Error occured while indexing{0}. The file will be skipped\n{1}",

                               state.Path, exc);

            }

            return CompletedTask<object>.Default;

        }

        public bool Pause

        {

            get { return _watcher == null || !_watcher.EnableRaisingEvents; }

            set

            {

                if (_watcher != null)

                    _watcher.EnableRaisingEvents = !value;                

            }

        }

*/

        /*private List<string> _selectivePaths = new List<string>();

        public List<string> SelectivePaths

        {

            get { return _selectivePaths; }

            set { _selectivePaths = value; }

        }

*/

/*

        public void Post(WorkflowState workflowState)

        {

            if (workflowState == null)

                throw new ArgumentNullException("workflowState");

            Contract.EndContractBlock();

            _agent.Post(workflowState);

        }

        public void Stop()

        {

            if (_watcher != null)

            {

                _watcher.Dispose();

            }

            _watcher = null;

            if (_agent!=null)

                _agent.Stop();

        }

*/

/*        private static bool FoundInRoot(string filePath, string rootPath)

        {

            //var rootDirectory = new DirectoryInfo(rootPath);

            //If the paths are equal, return true

            if (filePath.Equals(rootPath, StringComparison.InvariantCultureIgnoreCase))

                return true;

            //If the filepath is below the root path

            if (filePath.StartsWith(rootPath,StringComparison.InvariantCulture))

            {

                //Get the relative path

                var relativePath = filePath.Substring(rootPath.Length + 1);

                //If the relativePath does NOT contains a path separator, we found a match

                return (!relativePath.Contains(@"\"));

            }

            //If the filepath is not under the root path, return false

            return false;            

        }*/

        /*

        //Post a Change message for renames containing the old and new names

        void OnRenameEvent(object sender, RenamedEventArgs e)

        {

            var oldFullPath = e.OldFullPath;

            var fullPath = e.FullPath;

            if (Ignore(oldFullPath) || Ignore(fullPath))

                return;

            _agent.Post(new WorkflowState

            {

                AccountInfo=AccountInfo,

                OldPath = oldFullPath,

                OldFileName = e.OldName,

                Path = fullPath,

                FileName = e.Name,

                TriggeringChange = e.ChangeType

            });

        }

        */

    /*    private WorkflowState UpdateOverlayStatus(WorkflowState state)

        {

            if (state==null)

                throw new ArgumentNullException("state");

            Contract.EndContractBlock();

            if (state.Skip)

                return state;

            switch (state.Status)

            {

                case FileStatus.Created:

                    this.StatusKeeper.SetFileOverlayStatus(state.Path, FileOverlayStatus.Modified,state.ETag).Wait();

                    break;

                case FileStatus.Modified:

                    this.StatusKeeper.SetFileOverlayStatus(state.Path, FileOverlayStatus.Modified, state.ETag).Wait();

                    break;

                case FileStatus.Deleted:

                    //this.StatusAgent.RemoveFileOverlayStatus(state.Path);

                    break;

                case FileStatus.Renamed:

                    this.StatusKeeper.ClearFileStatus(state.OldPath);

                    this.StatusKeeper.SetFileOverlayStatus(state.Path, FileOverlayStatus.Modified, state.ETag).Wait();

                    break;

                case FileStatus.Unchanged:

                    this.StatusKeeper.SetFileOverlayStatus(state.Path, FileOverlayStatus.Normal, state.ETag).Wait();

                    break;

            }

            if (state.Status == FileStatus.Deleted)

                NativeMethods.RaiseChangeNotification(Path.GetDirectoryName(state.Path));

            else

                NativeMethods.RaiseChangeNotification(state.Path);

            return state;

        }

        private WorkflowState UpdateFileChecksum(WorkflowState state)

        {

            if (state.Skip)

                return state;

            if (state.Status == FileStatus.Deleted)

                return state;

            var path = state.Path;

            //Skip calculation for folders

            if (Directory.Exists(path))

                return state;

            var info = new FileInfo(path);

            using (StatusNotification.GetNotifier("Hashing {0}", "Finished Hashing {0}", info.Name))

            {

                var etag = info.ComputeShortHash(StatusNotification);

                var progress = new Progress<double>(d =>

                    StatusNotification.Notify(new StatusNotification(String.Format("Hashing {0} of {1}", d, info.Name))));

                string merkleHash = info.CalculateHash(StatusKeeper.BlockSize, StatusKeeper.BlockHash,PollAgent.CancellationToken,progress);

                StatusKeeper.UpdateFileChecksum(path, etag, merkleHash);

                state.Hash = merkleHash;

                return state;

            }

        }*/