Synnefo » Pithos MS Client

using System;

using System.Collections.Generic;

using System.ComponentModel.Composition;

using System.Diagnostics;

using System.IO;

using System.Linq;

using System.Text;

using Pithos.Interfaces;

using Pithos.Network;

namespace Pithos.Core.Agents

{

    [Export]

    public class FileAgent

    {

        Agent<WorkflowState> _agent;

        private FileSystemWatcher _watcher;

        [Import]

        public IStatusKeeper StatusKeeper { get; set; }

        [Import]

        public IPithosWorkflow Workflow { get; set; }

        [Import]

        public WorkflowAgent WorkflowAgent { get; set; }

        public string RootPath { get; private set; }

        public void Start(string rootPath)

        {

            RootPath = rootPath;

            _watcher = new FileSystemWatcher(rootPath);

            _watcher.Changed += OnFileEvent;

            _watcher.Created += OnFileEvent;

            _watcher.Deleted += OnFileEvent;

            _watcher.Renamed += OnRenameEvent;

            _watcher.EnableRaisingEvents = true;

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

            {

                Action loop = null;

                loop = () =>

                {

                    var message = inbox.Receive();

                    var process = message.ContinueWith(t =>

                    {

                        var state = t.Result;

                        Process(state);

                        inbox.DoAsync(loop);

                    });

                    process.ContinueWith(t =>

                    {

                        inbox.DoAsync(loop);

                        if (t.IsFaulted)

                        {

                            var ex = t.Exception.InnerException;

                            if (ex is OperationCanceledException)

                                inbox.Stop();

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

                        }

                    });

                };

                loop();

            });

        }

        public bool Pause

        {

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

            set

            {

                if (_watcher != null)

                    _watcher.EnableRaisingEvents = !value;                

            }

        }

        public string FragmentsPath { get; set; }

        public void Post(WorkflowState workflowState)

        {

            _agent.Post(workflowState);

        }

        public void Stop()

        {

            if (_watcher != null)

            {

                _watcher.Changed -= OnFileEvent;

                _watcher.Created -= OnFileEvent;

                _watcher.Deleted -= OnFileEvent;

                _watcher.Renamed -= OnRenameEvent;

                _watcher.Dispose();

            }

            _watcher = null;

            _agent.Stop();

        }

        // Enumerate all files in the Pithos directory except those in the Fragment folder

        // and files with a .ignore extension

        public IEnumerable<string> EnumerateFiles(string searchPattern="*")

        {

            var monitoredFiles = from filePath in Directory.EnumerateFileSystemEntries(RootPath, searchPattern, SearchOption.AllDirectories)

                                 where !Ignore(filePath)

                                 select filePath;

            return monitoredFiles;

        }

        public IEnumerable<FileInfo> EnumerateFileInfos(string searchPattern="*")

        {

            var rootDir = new DirectoryInfo(RootPath);

            var monitoredFiles = from file in rootDir.EnumerateFiles(searchPattern, SearchOption.AllDirectories)

                                 where !Ignore(file.FullName)

                                 select file;

            return monitoredFiles;

        }                

        public IEnumerable<string> EnumerateFilesAsRelativeUrls(string searchPattern="*")

        {

            var rootDir = new DirectoryInfo(RootPath);

            var monitoredFiles = from file in rootDir.EnumerateFiles(searchPattern, SearchOption.AllDirectories)

                                 where !Ignore(file.FullName)

                                 select file.AsRelativeUrlTo(RootPath);

            return monitoredFiles;

        }                

        private bool Ignore(string filePath)

        {

            if (filePath.StartsWith(FragmentsPath))

                return true;

            return false;

        }

        //Post a Change message for all events except rename

        void OnFileEvent(object sender, FileSystemEventArgs e)

        {

            //Ignore events that affect the Fragments folder

            var filePath = e.FullPath;

            if (Ignore(filePath)) 

                return;

            _agent.Post(new WorkflowState { Path = filePath, FileName = e.Name, TriggeringChange = e.ChangeType });

        }

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

            {

                OldPath = oldFullPath,

                OldFileName = e.OldName,

                Path = fullPath,

                FileName = e.Name,

                TriggeringChange = e.ChangeType

            });

        }

        private void Process(WorkflowState state)

        {

            Debug.Assert(!Ignore(state.Path));            

            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;

            UpdateFileStatus(state);

            UpdateOverlayStatus(state);

            UpdateFileChecksum(state);

            WorkflowAgent.Post(state);

        }

        private Dictionary<WatcherChangeTypes, FileStatus> _statusDict = new Dictionary<WatcherChangeTypes, FileStatus>

        {

            {WatcherChangeTypes.Created,FileStatus.Created},

            {WatcherChangeTypes.Changed,FileStatus.Modified},

            {WatcherChangeTypes.Deleted,FileStatus.Deleted},

            {WatcherChangeTypes.Renamed,FileStatus.Renamed}

        };

        private WorkflowState UpdateFileStatus(WorkflowState state)

        {

            Debug.Assert(!state.Path.Contains("fragments"));

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

            string path = state.Path;

            FileStatus status = _statusDict[state.TriggeringChange];

            var oldStatus = Workflow.StatusKeeper.GetFileStatus(path);

            if (status == oldStatus)

            {

                state.Status = status;

                state.Skip = true;

                return state;

            }

            if (state.Status == FileStatus.Renamed)

                Workflow.ClearFileStatus(path);

            state.Status = Workflow.SetFileStatus(path, status);

            return state;

        }

        private WorkflowState UpdateOverlayStatus(WorkflowState state)

        {

            if (state.Skip)

                return state;

            switch (state.Status)

            {

                case FileStatus.Created:

                case FileStatus.Modified:

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

                    break;

                case FileStatus.Deleted:

                    this.StatusKeeper.RemoveFileOverlayStatus(state.Path);

                    break;

                case FileStatus.Renamed:

                    this.StatusKeeper.RemoveFileOverlayStatus(state.OldPath);

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

                    break;

                case FileStatus.Unchanged:

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

                    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;

            string hash = Signature.CalculateMD5(path);

            StatusKeeper.UpdateFileChecksum(path, hash);

            state.Hash = hash;

            return state;

        }

    }

}