// Authors:
// Geoff Norton (gnorton@customerdna.com)
// Cody Russell (cody@xamarin.com)
+// Alexis Christoforides (lexas@xamarin.com)
//
// (c) 2004 Geoff Norton
// Copyright 2014 Xamarin Inc
using System.Runtime.InteropServices;
using System.Text;
using System.Threading;
+using System.Reflection;
namespace System.IO {
VM = -11
}
+ [Flags]
enum FilterFlags : uint {
ReadPoll = EventFlags.Flag0,
ReadOutOfBand = EventFlags.Flag1,
[StructLayout(LayoutKind.Sequential)]
struct kevent : IDisposable {
- public int ident;
+ public UIntPtr ident;
public EventFilter filter;
public EventFlags flags;
public FilterFlags fflags;
if (udata != IntPtr.Zero)
Marshal.FreeHGlobal (udata);
}
+
+
}
+ [StructLayout(LayoutKind.Sequential)]
struct timespec {
- public int tv_sec;
- public int tv_usec;
+ public IntPtr tv_sec;
+ public IntPtr tv_usec;
}
class PathData
{
public string Path;
public bool IsDirectory;
+ public int Fd;
}
class KqueueMonitor : IDisposable
public void Dispose ()
{
- Stop ();
+ CleanUp ();
}
public void Start ()
{
- conn = kqueue ();
+ lock (stateLock) {
+ if (started)
+ return;
- if (thread == null) {
- thread = new Thread (new ThreadStart (Monitor));
+ conn = kqueue ();
+
+ if (conn == -1)
+ throw new IOException (String.Format (
+ "kqueue() error at init, error code = '{0}'", Marshal.GetLastWin32Error ()));
+
+ thread = new Thread (() => DoMonitor ());
thread.IsBackground = true;
thread.Start ();
- }
- var pathData = Add (fsw.FullPath);
+ startedEvent.WaitOne ();
- Scan (pathData);
+ if (failedInit) {
+ thread.Join ();
+ CleanUp ();
+ throw new IOException ("Monitor thread failed while initializing.");
+ }
+ else
+ started = true;
+ }
}
public void Stop ()
{
- stop = true;
-
- if (thread != null)
- thread.Interrupt ();
+ lock (stateLock) {
+ if (!started)
+ return;
+
+ requestStop = true;
+ thread.Join ();
+ requestStop = false;
+
+ CleanUp ();
+ started = false;
+ }
+ }
+ void CleanUp ()
+ {
if (conn != -1)
close (conn);
conn = -1;
+
+ foreach (int fd in fdsDict.Keys)
+ close (fd);
+
+ fdsDict.Clear ();
+ pathsDict.Clear ();
}
- private PathData FindPath (string path)
+ void DoMonitor ()
{
- foreach (KeyValuePair<PathData, int> kv in paths) {
- if (kv.Key.Path == path)
- return kv.Key;
+ Exception exc = null;
+ failedInit = false;
+
+ try {
+ Setup ();
+ } catch (Exception e) {
+ failedInit = true;
+ exc = e;
+ } finally {
+ startedEvent.Set ();
+ }
+
+ if (failedInit) {
+ fsw.OnError (new ErrorEventArgs (exc));
+ return;
}
- return null;
+ try {
+ Monitor ();
+ } catch (Exception e) {
+ exc = e;
+ } finally {
+ if (!requestStop) { // failure
+ CleanUp ();
+ started = false;
+ }
+ if (exc != null)
+ fsw.OnError (new ErrorEventArgs (exc));
+ }
}
- private PathData FindPath (int fd)
+ void Setup ()
+ {
+ var initialFds = new List<int> ();
+
+ // GetFilenameFromFd() returns the *realpath* which can be different than fsw.FullPath because symlinks.
+ // If so, introduce a fixup step.
+ int fd = open (fsw.FullPath, O_EVTONLY, 0);
+ var resolvedFullPath = GetFilenameFromFd (fd);
+ close (fd);
+
+ if (resolvedFullPath != fsw.FullPath)
+ fixupPath = resolvedFullPath;
+ else
+ fixupPath = null;
+
+ Scan (fsw.FullPath, false, ref initialFds);
+
+ var immediate_timeout = new timespec { tv_sec = (IntPtr)0, tv_usec = (IntPtr)0 };
+ var eventBuffer = new kevent[0]; // we don't want to take any events from the queue at this point
+ var changes = CreateChangeList (ref initialFds);
+
+ int numEvents = kevent (conn, changes, changes.Length, eventBuffer, eventBuffer.Length, ref immediate_timeout);
+
+ if (numEvents == -1) {
+ var errMsg = String.Format ("kevent() error at initial event registration, error code = '{0}'", Marshal.GetLastWin32Error ());
+ throw new IOException (errMsg);
+ }
+ }
+
+ kevent[] CreateChangeList (ref List<int> FdList)
{
- foreach (KeyValuePair<PathData, int> kv in paths) {
- if (kv.Value == fd)
- return kv.Key;
+ if (FdList.Count == 0)
+ return emptyEventList;
+
+ var changes = new List<kevent> ();
+ foreach (int fd in FdList) {
+ var change = new kevent {
+
+ ident = (UIntPtr)fd,
+ filter = EventFilter.Vnode,
+ flags = EventFlags.Add | EventFlags.Enable | EventFlags.Clear,
+ fflags = FilterFlags.VNodeDelete | FilterFlags.VNodeExtend |
+ FilterFlags.VNodeRename | FilterFlags.VNodeAttrib |
+ FilterFlags.VNodeLink | FilterFlags.VNodeRevoke |
+ FilterFlags.VNodeWrite,
+ data = IntPtr.Zero,
+ udata = IntPtr.Zero
+ };
+
+ changes.Add (change);
}
+ FdList.Clear ();
- return null;
+ return changes.ToArray ();
}
- private void Monitor ()
+ void Monitor ()
{
- bool firstRun = true;
+ var timeout = new timespec { tv_sec = (IntPtr)0, tv_usec = (IntPtr)500000000 };
+ var eventBuffer = new kevent[32];
+ var newFds = new List<int> ();
+ List<PathData> removeQueue = new List<PathData> ();
+ List<string> rescanQueue = new List<string> ();
- while (!stop) {
- removeQueue.ForEach (Remove);
+ while (!requestStop) {
+ var changes = CreateChangeList (ref newFds);
- var changes = new List<kevent> ();
- var outEvents = new List<kevent> ();
+ int numEvents = kevent (conn, changes, changes.Length, eventBuffer, eventBuffer.Length, ref timeout);
- rescanQueue.ForEach (fd => {
- var path = FindPath (fd);
- Scan (path, !firstRun);
- });
- rescanQueue.Clear ();
-
- foreach (KeyValuePair<PathData, int> kv in paths) {
- var change = new kevent {
- ident = kv.Value,
- filter = EventFilter.Vnode,
- flags = EventFlags.Add | EventFlags.Enable | EventFlags.Clear,
- fflags = FilterFlags.VNodeDelete | FilterFlags.VNodeExtend |
- FilterFlags.VNodeRename | FilterFlags.VNodeAttrib |
- FilterFlags.VNodeLink | FilterFlags.VNodeRevoke |
- FilterFlags.VNodeWrite,
- data = IntPtr.Zero,
- udata = IntPtr.Zero
- };
-
- changes.Add (change);
- outEvents.Add (new kevent ());
+ if (numEvents == -1) {
+ var errMsg = String.Format ("kevent() error, error code = '{0}'", Marshal.GetLastWin32Error ());
+ fsw.OnError (new ErrorEventArgs (new IOException (errMsg)));
}
- if (changes.Count > 0) {
- var outArray = outEvents.ToArray ();
- var changesArray = changes.ToArray ();
- int numEvents = kevent (conn, changesArray, changesArray.Length, outArray, outArray.Length, IntPtr.Zero);
-
- for (var i = 0; i < numEvents; i++) {
- var kevt = outArray [i];
- var pathData = FindPath (kevt.ident);
-
- if ((kevt.fflags & FilterFlags.VNodeDelete) != 0) {
- removeQueue.Add (kevt.ident);
- PostEvent (FileAction.Removed, pathData.Path);
- } else if (((kevt.fflags & FilterFlags.VNodeRename) != 0) || ((kevt.fflags & FilterFlags.VNodeRevoke) != 0) || ((kevt.fflags & FilterFlags.VNodeWrite) != 0)) {
- if (pathData.IsDirectory && Directory.Exists (pathData.Path))
- rescanQueue.Add (kevt.ident);
-
- if ((kevt.fflags & FilterFlags.VNodeRename) != 0) {
- var fd = paths [pathData];
- var newFilename = GetFilenameFromFd (fd);
- var oldFilename = pathData.Path;
-
- Remove (pathData);
- PostEvent (FileAction.RenamedNewName, oldFilename, newFilename);
-
- Add (newFilename, false);
- }
- } else if ((kevt.fflags & FilterFlags.VNodeAttrib) != 0) {
- PostEvent (FileAction.Modified, pathData.Path);
- }
+ if (numEvents == 0)
+ continue;
+
+ for (var i = 0; i < numEvents; i++) {
+ var kevt = eventBuffer [i];
+ var pathData = fdsDict [(int)kevt.ident];
+
+ if ((kevt.flags & EventFlags.Error) == EventFlags.Error) {
+ var errMsg = String.Format ("kevent() error watching path '{0}', error code = '{1}'", pathData.Path, kevt.data);
+ fsw.OnError (new ErrorEventArgs (new IOException (errMsg)));
+ continue;
}
- } else {
- Thread.Sleep (500);
+
+ if ((kevt.fflags & FilterFlags.VNodeDelete) == FilterFlags.VNodeDelete || (kevt.fflags & FilterFlags.VNodeRevoke) == FilterFlags.VNodeRevoke)
+ removeQueue.Add (pathData);
+
+ else if ((kevt.fflags & FilterFlags.VNodeWrite) == FilterFlags.VNodeWrite) {
+ if (pathData.IsDirectory)
+ rescanQueue.Add (pathData.Path);
+ else
+ PostEvent (FileAction.Modified, pathData.Path);
+ }
+
+ else if ((kevt.fflags & FilterFlags.VNodeRename) == FilterFlags.VNodeRename) {
+ var newFilename = GetFilenameFromFd (pathData.Fd);
+
+ if (newFilename.StartsWith (fsw.FullPath))
+ Rename (pathData, newFilename);
+ else //moved outside of our watched dir so stop watching
+ RemoveTree (pathData);
+ }
+
+ else if ((kevt.fflags & FilterFlags.VNodeAttrib) == FilterFlags.VNodeAttrib || (kevt.fflags & FilterFlags.VNodeExtend) == FilterFlags.VNodeExtend)
+ PostEvent (FileAction.Modified, pathData.Path);
}
- firstRun = false;
+ removeQueue.ForEach (Remove);
+ removeQueue.Clear ();
+
+ rescanQueue.ForEach (path => {
+ Scan (path, true, ref newFds);
+ });
+ rescanQueue.Clear ();
}
}
- private PathData Add (string path, bool postEvents = false)
+ PathData Add (string path, bool postEvents, ref List<int> fds)
{
+ PathData pathData;
+ pathsDict.TryGetValue (path, out pathData);
+
+ if (pathData != null)
+ return pathData;
+
var fd = open (path, O_EVTONLY, 0);
- if (fd == -1)
+ if (fd == -1) {
+ fsw.OnError (new ErrorEventArgs (new IOException (String.Format (
+ "open() error while attempting to process path '{0}', error code = '{1}'", path, Marshal.GetLastWin32Error ()))));
return null;
+ }
- var attrs = File.GetAttributes (path);
- bool isDir = false;
- if ((attrs & FileAttributes.Directory) == FileAttributes.Directory)
- isDir = true;
+ try {
+ fds.Add (fd);
- var pathData = new PathData {
- Path = path,
- IsDirectory = isDir
- };
+ var attrs = File.GetAttributes (path);
- if (FindPath (path) == null) {
- paths.Add (pathData, fd);
+ pathData = new PathData {
+ Path = path,
+ Fd = fd,
+ IsDirectory = (attrs & FileAttributes.Directory) == FileAttributes.Directory
+ };
+
+ pathsDict.Add (path, pathData);
+ fdsDict.Add (fd, pathData);
if (postEvents)
PostEvent (FileAction.Added, path);
+
+ return pathData;
+ } catch (Exception e) {
+ close (fd);
+ fsw.OnError (new ErrorEventArgs (e));
+ return null;
}
- return pathData;
}
- private void Remove (int fd)
+ void Remove (PathData pathData)
{
- var path = FindPath (fd);
- paths.Remove (path);
- removeQueue.Remove (fd);
-
- close (fd);
+ fdsDict.Remove (pathData.Fd);
+ pathsDict.Remove (pathData.Path);
+ close (pathData.Fd);
+ PostEvent (FileAction.Removed, pathData.Path);
}
- private void Remove (PathData pathData)
+ void RemoveTree (PathData pathData)
{
- var fd = paths [pathData];
- paths.Remove (pathData);
- removeQueue.Remove (fd);
+ var toRemove = new List<PathData> ();
- close (fd);
+ toRemove.Add (pathData);
+
+ if (pathData.IsDirectory) {
+ var prefix = pathData.Path + Path.DirectorySeparatorChar;
+ foreach (var path in pathsDict.Keys)
+ if (path.StartsWith (prefix)) {
+ toRemove.Add (pathsDict [path]);
+ }
+ }
+ toRemove.ForEach (Remove);
}
- private void Scan (PathData pathData, bool postEvents = false)
+ void Rename (PathData pathData, string newRoot)
{
- var path = pathData.Path;
+ var toRename = new List<PathData> ();
+ var oldRoot = pathData.Path;
+
+ toRename.Add (pathData);
+
+ if (pathData.IsDirectory) {
+ var prefix = oldRoot + Path.DirectorySeparatorChar;
+ foreach (var path in pathsDict.Keys)
+ if (path.StartsWith (prefix))
+ toRename.Add (pathsDict [path]);
+ }
- Add (path, postEvents);
+ toRename.ForEach ((pd) => {
+ var oldPath = pd.Path;
+ var newPath = newRoot + oldPath.Substring (oldRoot.Length);
+ pd.Path = newPath;
+ pathsDict.Remove (oldPath);
+ pathsDict.Add (newPath, pd);
+ });
- if (!fsw.IncludeSubdirectories)
+ PostEvent (FileAction.RenamedNewName, oldRoot, newRoot);
+ }
+
+ void Scan (string path, bool postEvents, ref List<int> fds)
+ {
+ if (requestStop)
+ return;
+
+ var pathData = Add (path, postEvents, ref fds);
+
+ if (pathData == null)
+ return;
+
+ if (!pathData.IsDirectory)
return;
- var attrs = File.GetAttributes (path);
- if ((attrs & FileAttributes.Directory) == FileAttributes.Directory) {
- var dirsToProcess = new List<string> ();
- dirsToProcess.Add (path);
+ var dirsToProcess = new List<string> ();
+ dirsToProcess.Add (path);
+
+ while (dirsToProcess.Count > 0) {
+ var tmp = dirsToProcess [0];
+ dirsToProcess.RemoveAt (0);
+
+ var info = new DirectoryInfo (tmp);
+ FileSystemInfo[] fsInfos = null;
+ try {
+ fsInfos = info.GetFileSystemInfos ();
+
+ } catch (IOException) {
+ // this can happen if the directory has been deleted already.
+ // that's okay, just keep processing the other dirs.
+ fsInfos = new FileSystemInfo[0];
+ }
- while (dirsToProcess.Count > 0) {
- var tmp = dirsToProcess [0];
- dirsToProcess.RemoveAt (0);
+ foreach (var fsi in fsInfos) {
+ if ((fsi.Attributes & FileAttributes.Directory) == FileAttributes.Directory && !fsw.IncludeSubdirectories)
+ continue;
- var info = new DirectoryInfo (tmp);
- foreach (var fsi in info.GetFileSystemInfos ()) {
- if (Add (fsi.FullName, postEvents) == null)
- continue;
+ if ((fsi.Attributes & FileAttributes.Directory) != FileAttributes.Directory && !fsw.Pattern.IsMatch (fsi.FullName))
+ continue;
- var childAttrs = File.GetAttributes (fsi.FullName);
- if ((childAttrs & FileAttributes.Directory) == FileAttributes.Directory)
- dirsToProcess.Add (fsi.FullName);
- }
+ var currentPathData = Add (fsi.FullName, postEvents, ref fds);
+
+ if (currentPathData != null && currentPathData.IsDirectory)
+ dirsToProcess.Add (fsi.FullName);
}
}
}
-
- private void PostEvent (FileAction action, string path, string newPath = null)
+
+ void PostEvent (FileAction action, string path, string newPath = null)
{
RenamedEventArgs renamed = null;
if (action == 0)
return;
+ // only post events that match filter pattern. check both old and new paths for renames
+ if (!fsw.Pattern.IsMatch (path) && (newPath == null || !fsw.Pattern.IsMatch (newPath)))
+ return;
+
if (action == FileAction.RenamedNewName)
renamed = new RenamedEventArgs (WatcherChangeTypes.Renamed, "", newPath, path);
private string GetFilenameFromFd (int fd)
{
- var sb = new StringBuilder (1024);
+ var sb = new StringBuilder (__DARWIN_MAXPATHLEN);
- if (fcntl (fd, F_GETPATH, sb) != -1)
+ if (fcntl (fd, F_GETPATH, sb) != -1) {
+ if (fixupPath != null)
+ sb.Replace (fixupPath, fsw.FullPath, 0, fixupPath.Length); // see Setup()
return sb.ToString ();
- else
+ } else {
+ fsw.OnError (new ErrorEventArgs (new IOException (String.Format (
+ "fcntl() error while attempting to get path for fd '{0}', error code = '{1}'", fd, Marshal.GetLastWin32Error ()))));
return String.Empty;
+ }
}
- private const int O_EVTONLY = 0x8000;
- private const int F_GETPATH = 50;
- private FileSystemWatcher fsw;
- private int conn;
- private Thread thread;
- private bool stop;
- private readonly List<int> removeQueue = new List<int> ();
- private readonly List<int> rescanQueue = new List<int> ();
- private readonly Dictionary<PathData, int> paths = new Dictionary<PathData, int> ();
+ const int O_EVTONLY = 0x8000;
+ const int F_GETPATH = 50;
+ const int __DARWIN_MAXPATHLEN = 1024;
+ static readonly kevent[] emptyEventList = new System.IO.kevent[0];
+
+ FileSystemWatcher fsw;
+ int conn;
+ Thread thread;
+ volatile bool requestStop = false;
+ AutoResetEvent startedEvent = new AutoResetEvent (false);
+ bool started = false;
+ bool failedInit = false;
+ object stateLock = new object ();
+
+ readonly Dictionary<string, PathData> pathsDict = new Dictionary<string, PathData> ();
+ readonly Dictionary<int, PathData> fdsDict = new Dictionary<int, PathData> ();
+ string fixupPath = null;
[DllImport ("libc", EntryPoint="fcntl", CharSet=CharSet.Auto, SetLastError=true)]
static extern int fcntl (int file_names_by_descriptor, int cmd, StringBuilder sb);
extern static int kqueue ();
[DllImport ("libc")]
- extern static int kevent(int kq, [In]kevent[] ev, int nchanges, [Out]kevent[] evtlist, int nevents, IntPtr time);
+ extern static int kevent (int kq, [In]kevent[] ev, int nchanges, [Out]kevent[] evtlist, int nevents, [In] ref timespec time);
}
class KeventWatcher : IFileWatcher
monitor = (KqueueMonitor)watches [fsw];
} else {
monitor = new KqueueMonitor (fsw);
+ watches.Add (fsw, monitor);
}
-
- watches.Add (fsw, monitor);
-
+
monitor.Start ();
}
monitor.Stop ();
}
-
-
+
[DllImport ("libc")]
extern static int close (int fd);
projects / mono.git / commitdiff