Synnefo » Pithos MS Client

#region

/* -----------------------------------------------------------------------

 * <copyright file="FileAgent.cs" company="GRNet">

 * 

 * Copyright 2011-2012 GRNET S.A. All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or

 * without modification, are permitted provided that the following

 * conditions are met:

 *

 *   1. Redistributions of source code must retain the above

 *      copyright notice, this list of conditions and the following

 *      disclaimer.

 *

 *   2. Redistributions in binary form must reproduce the above

 *      copyright notice, this list of conditions and the following

 *      disclaimer in the documentation and/or other materials

 *      provided with the distribution.

 *

 *

 * THIS SOFTWARE IS PROVIDED BY GRNET S.A. ``AS IS'' AND ANY EXPRESS

 * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GRNET S.A OR

 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF

 * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED

 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN

 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

 * POSSIBILITY OF SUCH DAMAGE.

 *

 * The views and conclusions contained in the software and

 * documentation are those of the authors and should not be

 * interpreted as representing official policies, either expressed

 * or implied, of GRNET S.A.

 * </copyright>

 * -----------------------------------------------------------------------

 */

#endregion

using System;

using System.Collections.Generic;

using System.Diagnostics.Contracts;

using System.IO;

using System.Linq;

using System.Reflection;

using System.Threading.Tasks;

using Pithos.Interfaces;

using Pithos.Network;

using log4net;

namespace Pithos.Core.Agents

{

//    [Export]

    public class FileAgent

    {

        private static readonly ILog Log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);

        /*

                Agent<WorkflowState> _agent;

        */

        private FileSystemWatcher _watcher;

        private FileSystemWatcherAdapter _adapter;

        private FileEventIdleBatch _eventIdleBatch;

        //[Import]

        public IStatusKeeper StatusKeeper { get; set; }

        public IStatusNotification StatusNotification { get; set; }

        //[Import]

        public IPithosWorkflow Workflow { get; set; }

        //[Import]

        //public WorkflowAgent WorkflowAgent { get; set; }

        private AccountInfo AccountInfo { get; set; }

        internal string RootPath { get;  set; }

        public TimeSpan IdleTimeout { get; set; }

        public PollAgent PollAgent { get; set; }

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

        {

            PollAgent.SynchNow();

        }

/*

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

        }

*/

        public void Start(AccountInfo accountInfo,string rootPath)

        {

            if (accountInfo==null)

                throw new ArgumentNullException("accountInfo");

            if (String.IsNullOrWhiteSpace(rootPath))

                throw new ArgumentNullException("rootPath");

            if (!Path.IsPathRooted(rootPath))

                throw new ArgumentException("rootPath must be an absolute path","rootPath");

            if (IdleTimeout == null)

                throw new InvalidOperationException("IdleTimeout must have a valid value");

                Contract.EndContractBlock();

            AccountInfo = accountInfo;

            RootPath = rootPath;

            _eventIdleBatch = new FileEventIdleBatch((int)IdleTimeout.TotalMilliseconds, ProcessBatchedEvents);

            _watcher = new FileSystemWatcher(rootPath) { IncludeSubdirectories = true, InternalBufferSize = 8 * 4096 };

            _adapter = new FileSystemWatcherAdapter(_watcher);

            _adapter.Changed += OnFileEvent;

            _adapter.Created += OnFileEvent;

            _adapter.Deleted += OnFileEvent;

            //_adapter.Renamed += OnRenameEvent;

            _adapter.Moved += OnMoveEvent;

            _watcher.EnableRaisingEvents = true;

/*            

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

                UpdateFileChecksum(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;                

            }

        }

*/

        public string CachePath { get; set; }

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

        public List<string> SelectivePaths

        {

            get { return _selectivePaths; }

            set { _selectivePaths = value; }

        }

*/

        public Selectives Selectives { get; set; }

/*

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

        }

*/

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

                                 orderby filePath ascending 

                                 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)

                                 orderby file.FullName ascending 

                                 select file;

            return monitoredFiles;

        }                

        public IEnumerable<FileSystemInfo> EnumerateFileSystemInfos(string searchPattern="*")

        {

            var rootDir = new DirectoryInfo(RootPath);

            //Ensure folders appear first, to allow folder processing as soon as possilbe

            var folders = (from file in rootDir.EnumerateDirectories(searchPattern, SearchOption.AllDirectories)

                                     where !Ignore(file.FullName)

                                     orderby file.FullName ascending

                                     select file).ToList();

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

                                  where !Ignore(file.FullName)

                                  orderby file.Length ascending

                                  select file as FileSystemInfo).ToList();

            var monitoredFiles = folders

                                 //Process small files first, leaving expensive large files for last

                                 .Concat(files);

            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)

                                 orderby file.FullName ascending 

                                 select file.AsRelativeUrlTo(RootPath);

            return monitoredFiles;

        }                

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

        {

            var rootDir = new DirectoryInfo(RootPath);

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

                                 where !Ignore(file.FullName)

                                 orderby file.FullName ascending 

                                 select file.AsRelativeUrlTo(RootPath);

            return monitoredFiles;

        }                

        public bool Ignore(string filePath)

        {

            if (IgnorePaths(filePath)) return true;

            //If selective sync is enabled, 

            if (IsUnselectedRootFolder(filePath))

                    return false;

            //Ignore if selective synchronization is defined, 

            //And the target file is not below any of the selective paths

            var ignore = !Selectives.IsSelected(AccountInfo, filePath);

            return ignore;

        }

        public bool IsUnselectedRootFolder(string filePath)

        {

            return Selectives.IsSelectiveEnabled(AccountInfo.AccountKey) //propagate folder events 

                   && Directory.Exists(filePath) //from the container root folder only. Note, in the first level below the account root path are the containers

                   && FoundBelowRoot(filePath, RootPath, 2);

        }

        public bool IgnorePaths(string filePath)

        {

//Ignore all first-level directories and files (ie at the container folders level)

            if (FoundBelowRoot(filePath, RootPath, 1))

                return true;

            //Ignore first-level items under the "others" folder (ie at the accounts folders level).

            var othersPath = Path.Combine(RootPath, FolderConstants.OthersFolder);

            if (FoundBelowRoot(filePath, othersPath, 1))

                return true;

            //Ignore second-level (container) folders under the "others" folder (ie at the container folders level). 

            if (FoundBelowRoot(filePath, othersPath, 2))

                return true;

            //Ignore anything happening in the cache path

            if (filePath.StartsWith(CachePath))

                return true;

            //Finally, ignore events about one of the ignored files

            return _ignoreFiles.ContainsKey(filePath.ToLower());

        }

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

        }*/

        private static bool FoundBelowRoot(string filePath, string rootPath,int level)

        {

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

                var levels=relativePath.ToCharArray().Count(c=>c=='\\')+1;                

                return levels==level;

            }

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

            });

        }

        */

        //Post a Change message for all events except rename

        void OnFileEvent(object sender, FileSystemEventArgs e)

        {

            //Ignore events that affect the cache folder

            var filePath = e.FullPath;

            if (Ignore(filePath))

                return;

            _eventIdleBatch.Post(e);

        }

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

        void OnMoveEvent(object sender, MovedEventArgs e)

        {

            var oldFullPath = e.OldFullPath;

            var fullPath = e.FullPath;

            //If the source path is one of the ignored folders, ignore

            if (IgnorePaths(oldFullPath)) 

                return;

            //TODO: Must prevent move propagation if the source folder is blocked by selective sync

            //Ignore takes into account Selective Sync

            if (Ignore(fullPath))

                return;

            _eventIdleBatch.Post(e);

        }

        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 Dictionary<string, string> _ignoreFiles=new Dictionary<string, string>();

        private WorkflowState UpdateFileStatus(WorkflowState state)

        {

            if (state==null)

                throw new ArgumentNullException("state");

            if (String.IsNullOrWhiteSpace(state.Path))

                throw new ArgumentException("The state's Path can't be empty","state");

            Contract.EndContractBlock();

            var path = state.Path;

            var 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==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.ShortHash).Wait();

                    break;

                case FileStatus.Modified:

                    this.StatusKeeper.SetFileOverlayStatus(state.Path, FileOverlayStatus.Modified, state.ShortHash).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.ShortHash).Wait();

                    break;

                case FileStatus.Unchanged:

                    this.StatusKeeper.SetFileOverlayStatus(state.Path, FileOverlayStatus.Normal, state.ShortHash).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 shortHash = info.ComputeShortHash();

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

                StatusKeeper.UpdateFileChecksum(path, shortHash, merkleHash);

                state.Hash = merkleHash;

                return state;

            }

        }

        //Does the file exist in the container's local folder?

        public bool Exists(string relativePath)

        {

            if (String.IsNullOrWhiteSpace(relativePath))

                throw new ArgumentNullException("relativePath");

            //A RootPath must be set before calling this method

            if (String.IsNullOrWhiteSpace(RootPath))

                throw new InvalidOperationException("RootPath was not set");

            Contract.EndContractBlock();

            //Create the absolute path by combining the RootPath with the relativePath

            var absolutePath=Path.Combine(RootPath, relativePath);

            //Is this a valid file?

            if (File.Exists(absolutePath))

                return true;

            //Or a directory?

            if (Directory.Exists(absolutePath))

                return true;

            //Fail if it is neither

            return false;

        }

        public static FileAgent GetFileAgent(AccountInfo accountInfo)

        {

            return GetFileAgent(accountInfo.AccountPath);

        }

        public static FileAgent GetFileAgent(string rootPath)

        {

            return AgentLocator<FileAgent>.Get(rootPath.ToLower());

        }

        public FileSystemInfo GetFileSystemInfo(string relativePath)

        {

            if (String.IsNullOrWhiteSpace(relativePath))

                throw new ArgumentNullException("relativePath");

            //A RootPath must be set before calling this method

            if (String.IsNullOrWhiteSpace(RootPath))

                throw new InvalidOperationException("RootPath was not set");            

            Contract.EndContractBlock();            

            var absolutePath = Path.Combine(RootPath, relativePath);

            if (Directory.Exists(absolutePath))

                return new DirectoryInfo(absolutePath).WithProperCapitalization();

            else

                return new FileInfo(absolutePath).WithProperCapitalization();

        }

        public void Delete(string relativePath)

        {

            var absolutePath = Path.Combine(RootPath, relativePath).ToLower();

            if (Log.IsDebugEnabled)

                Log.DebugFormat("Deleting {0}", absolutePath);

            if (File.Exists(absolutePath))

            {    

                try

                {

                    File.Delete(absolutePath);

                }

                //The file may have been deleted by another thread. Just ignore the relevant exception

                catch (FileNotFoundException) { }

            }

            else if (Directory.Exists(absolutePath))

            {

                try

                {

                    Directory.Delete(absolutePath, true);

                }

                //The directory may have been deleted by another thread. Just ignore the relevant exception

                catch (DirectoryNotFoundException){}                

            }

            //_ignoreFiles[absolutePath] = absolutePath;                

            StatusKeeper.ClearFileStatus(absolutePath);

        }

    }

}