mcs/class/System/System.IO/KeventWatcher.cs

   1 //
   2 // System.IO.KeventWatcher.cs: interface with osx kevent
   3 //
   4 // Authors:
   5 //      Geoff Norton (gnorton@customerdna.com)
   6 //
   7 // (c) 2004 Geoff Norton
   8
   9 //
  10 // Permission is hereby granted, free of charge, to any person obtaining
  11 // a copy of this software and associated documentation files (the
  12 // "Software"), to deal in the Software without restriction, including
  13 // without limitation the rights to use, copy, modify, merge, publish,
  14 // distribute, sublicense, and/or sell copies of the Software, and to
  15 // permit persons to whom the Software is furnished to do so, subject to
  16 // the following conditions:
  17 //
  18 // The above copyright notice and this permission notice shall be
  19 // included in all copies or substantial portions of the Software.
  20 //
  21 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  22 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  23 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  24 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  25 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  26 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  27 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  28 //
  29
  30 using System;
  31 using System.Collections;
  32 using System.ComponentModel;
  33 using System.Runtime.CompilerServices;
  34 using System.Runtime.InteropServices;
  35 using System.Text;
  36 using System.Threading;
  37
  38 namespace System.IO {
  39
  40         struct kevent {
  41                 public int ident;
  42                 public short filter;
  43                 public ushort flags;
  44                 public uint fflags;
  45                 public int data;
  46                 public IntPtr udata;
  47
  48                 public void Dispose ()
  49                 {
  50                         if (udata != IntPtr.Zero)
  51                                 Marshal.FreeHGlobal (udata);
  52                 }
  53         }
  54
  55         struct timespec {
  56                 public int tv_sec;
  57                 public int tv_usec;
  58         }
  59
  60         class KeventFileData {
  61                 public FileSystemInfo fsi;
  62                 public DateTime LastAccessTime;
  63                 public DateTime LastWriteTime;
  64
  65                 public KeventFileData(FileSystemInfo fsi, DateTime LastAccessTime, DateTime LastWriteTime) {
  66                         this.fsi = fsi;
  67                         this.LastAccessTime = LastAccessTime;
  68                         this.LastWriteTime = LastWriteTime;
  69                 }
  70         }
  71
  72         class KeventData {
  73                 public FileSystemWatcher FSW;
  74                 public string Directory;
  75                 public string FileMask;
  76                 public bool IncludeSubdirs;
  77                 public bool Enabled;
  78                 public Hashtable DirEntries;
  79                 public kevent ev;
  80         }
  81
  82         class KeventWatcher : IFileWatcher
  83         {
  84                 static bool failed;
  85                 static KeventWatcher instance;
  86                 static Hashtable watches;
  87                 static Hashtable requests;
  88                 static Thread thread;
  89                 static int conn;
  90                 static bool stop;
  91
  92                 private KeventWatcher ()
  93                 {
  94                 }
  95
  96                 public static bool GetInstance (out IFileWatcher watcher)
  97                 {
  98                         lock (typeof (KeventWatcher)) {
  99                                 if (failed == true) {
 100                                         watcher = null;
 101                                         return false;
 102                                 }
 103
 104                                 if (instance != null) {
 105                                         watcher = instance;
 106                                         return true;
 107                                 }
 108
 109                                 watches = Hashtable.Synchronized (new Hashtable ());
 110                                 requests = Hashtable.Synchronized (new Hashtable ());
 111                                 conn = kqueue();
 112                                 if (conn == -1) {
 113                                         failed = true;
 114                                         watcher = null;
 115                                         return false;
 116                                 }
 117
 118                                 instance = new KeventWatcher ();
 119                                 watcher = instance;
 120                                 return true;
 121                         }
 122                 }
 123
 124                 public void StartDispatching (FileSystemWatcher fsw)
 125                 {
 126                         KeventData data;
 127                         lock (this) {
 128                                 if (thread == null) {
 129                                         thread = new Thread (new ThreadStart (Monitor));
 130                                         thread.IsBackground = true;
 131                                         thread.Start ();
 132                                 }
 133
 134                                 data = (KeventData) watches [fsw];
 135                         }
 136
 137                         if (data == null) {
 138                                 data = new KeventData ();
 139                                 data.FSW = fsw;
 140                                 data.Directory = fsw.FullPath;
 141                                 data.FileMask = fsw.MangledFilter;
 142                                 data.IncludeSubdirs = fsw.IncludeSubdirectories;
 143
 144                                 data.Enabled = true;
 145                                 lock (this) {
 146                                         StartMonitoringDirectory (data);
 147                                         watches [fsw] = data;
 148                                         stop = false;
 149                                 }
 150                         }
 151                 }
 152
 153                 static void StartMonitoringDirectory (KeventData data)
 154                 {
 155                         DirectoryInfo dir = new DirectoryInfo (data.Directory);
 156                         if(data.DirEntries == null) {
 157                                 data.DirEntries = new Hashtable();
 158                                 foreach (FileSystemInfo fsi in dir.GetFileSystemInfos() )
 159                                         data.DirEntries.Add(fsi.FullName, new KeventFileData(fsi, fsi.LastAccessTime, fsi.LastWriteTime));
 160                         }
 161
 162                         int fd = open(data.Directory, 0, 0);
 163                         kevent ev = new kevent();
 164                         ev.udata = IntPtr.Zero;
 165                         timespec nullts = new timespec();
 166                         nullts.tv_sec = 0;
 167                         nullts.tv_usec = 0;
 168                         if (fd > 0) {
 169                                 ev.ident = fd;
 170                                 ev.filter = -4;
 171                                 ev.flags = 1 | 4 | 20;
 172                                 ev.fflags = 20 | 2 | 1 | 8;
 173                                 ev.data = 0;
 174                                 ev.udata = Marshal.StringToHGlobalAuto (data.Directory);
 175                                 kevent outev = new kevent();
 176                                 outev.udata = IntPtr.Zero;
 177                                 kevent (conn, ref ev, 1, ref outev, 0, ref nullts);
 178                                 data.ev = ev;
 179                                 requests [fd] = data;
 180                         }
 181
 182                         if (!data.IncludeSubdirs)
 183                                 return;
 184
 185                 }
 186
 187                 public void StopDispatching (FileSystemWatcher fsw)
 188                 {
 189                         KeventData data;
 190                         lock (this) {
 191                                 data = (KeventData) watches [fsw];
 192                                 if (data == null)
 193                                         return;
 194
 195                                 StopMonitoringDirectory (data);
 196                                 watches.Remove (fsw);
 197                                 if (watches.Count == 0)
 198                                         stop = true;
 199
 200                                 if (!data.IncludeSubdirs)
 201                                         return;
 202
 203                         }
 204                 }
 205
 206                 static void StopMonitoringDirectory (KeventData data)
 207                 {
 208                         close(data.ev.ident);
 209                 }
 210
 211                 void Monitor ()
 212                 {
 213
 214                         while (!stop) {
 215                                 kevent ev = new kevent();
 216                                 ev.udata = IntPtr.Zero;
 217                                 kevent nullev = new kevent();
 218                                 nullev.udata = IntPtr.Zero;
 219                                 timespec ts = new timespec();
 220                                 ts.tv_sec = 0;
 221                                 ts.tv_usec = 0;
 222                                 int haveEvents;
 223                                 lock (this) {
 224                                         haveEvents = kevent (conn, ref nullev, 0, ref ev, 1, ref ts);
 225                                 }
 226
 227                                 if (haveEvents > 0) {
 228                                         // Restart monitoring
 229                                         KeventData data = (KeventData) requests [ev.ident];
 230                                         StartMonitoringDirectory(data);
 231                                         ProcessEvent (ev);
 232                                 } else {
 233                                         System.Threading.Thread.Sleep (500);
 234                                 }
 235                         }
 236
 237                         lock (this) {
 238                                 thread = null;
 239                                 stop = false;
 240                         }
 241                 }
 242
 243                 void ProcessEvent (kevent ev)
 244                 {
 245                         lock (this) {
 246                                 KeventData data = (KeventData) requests [ev.ident];
 247                                 if (!data.Enabled)
 248                                         return;
 249
 250                                 FileSystemWatcher fsw;
 251                                 string filename = "";
 252
 253                                 fsw = data.FSW;
 254                                 FileAction fa = 0;
 255                                 DirectoryInfo dir = new DirectoryInfo (data.Directory);
 256                                 FileSystemInfo changedFsi = null;
 257
 258                                 try {
 259                                         foreach (FileSystemInfo fsi in dir.GetFileSystemInfos() )
 260                                                 if (data.DirEntries.ContainsKey (fsi.FullName) && (fsi is FileInfo)) {
 261                                                         KeventFileData entry = (KeventFileData) data.DirEntries [fsi.FullName];
 262                                                         if ( (entry.LastWriteTime != fsi.LastWriteTime) || (entry.LastAccessTime != fsi.LastAccessTime) ) {
 263                                                                 filename = fsi.Name;
 264                                                                 fa = FileAction.Modified;
 265                                                                 data.DirEntries [fsi.FullName] = new KeventFileData(fsi, fsi.LastAccessTime, fsi.LastWriteTime);
 266                                                                 if (fsw.IncludeSubdirectories && fsi is DirectoryInfo) {
 267                                                                         data.Directory = filename;
 268                                                                         requests [ev.ident] = data;
 269                                                                         ProcessEvent(ev);
 270                                                                 }
 271                                                                 PostEvent(filename, fsw, fa, changedFsi);
 272                                                         }
 273                                                 }
 274                                 } catch (Exception) {
 275                                         // The file system infos were changed while we processed them
 276                                 }
 277                                 // Deleted
 278                                 try {
 279                                         bool deleteMatched = true;
 280                                         while(deleteMatched) {
 281                                                 foreach (KeventFileData entry in data.DirEntries.Values) {
 282                                                         if (!File.Exists (entry.fsi.FullName) && !Directory.Exists (entry.fsi.FullName)) {
 283                                                                 filename = entry.fsi.Name;
 284                                                                 fa = FileAction.Removed;
 285                                                                 data.DirEntries.Remove (entry.fsi.FullName);
 286                                                                 PostEvent(filename, fsw, fa, changedFsi);
 287                                                                 break;
 288                                                         }
 289                                                 }
 290                                                 deleteMatched = false;
 291                                         }
 292                                 } catch (Exception) {
 293                                         // The file system infos were changed while we processed them
 294                                 }
 295                                 // Added
 296                                 try {
 297                                         foreach (FileSystemInfo fsi in dir.GetFileSystemInfos())
 298                                                 if (!data.DirEntries.ContainsKey (fsi.FullName)) {
 299                                                         changedFsi = fsi;
 300                                                         filename = fsi.Name;
 301                                                         fa = FileAction.Added;
 302                                                         data.DirEntries [fsi.FullName] = new KeventFileData(fsi, fsi.LastAccessTime, fsi.LastWriteTime);
 303                                                         PostEvent(filename, fsw, fa, changedFsi);
 304                                                 }
 305                                 } catch (Exception) {
 306                                         // The file system infos were changed while we processed them
 307                                 }
 308
 309
 310                         }
 311                 }
 312
 313                 private void PostEvent (string filename, FileSystemWatcher fsw, FileAction fa, FileSystemInfo changedFsi) {
 314                         RenamedEventArgs renamed = null;
 315                         if (fa == 0)
 316                                 return;
 317
 318                         if (fsw.IncludeSubdirectories && fa == FileAction.Added) {
 319                                 if (changedFsi is DirectoryInfo) {
 320                                         KeventData newdirdata = new KeventData ();
 321                                         newdirdata.FSW = fsw;
 322                                         newdirdata.Directory = changedFsi.FullName;
 323                                         newdirdata.FileMask = fsw.MangledFilter;
 324                                         newdirdata.IncludeSubdirs = fsw.IncludeSubdirectories;
 325
 326                                         newdirdata.Enabled = true;
 327                                         lock (this) {
 328                                                 StartMonitoringDirectory (newdirdata);
 329                                         }
 330                                 }
 331                         }
 332
 333                         if (!fsw.Pattern.IsMatch(filename))
 334                                 return;
 335
 336                         lock (fsw) {
 337                                 fsw.DispatchEvents (fa, filename, ref renamed);
 338                                 if (fsw.Waiting) {
 339                                         fsw.Waiting = false;
 340                                         System.Threading.Monitor.PulseAll (fsw);
 341                                 }
 342                         }
 343                 }
 344
 345                 [DllImport ("libc")]
 346                 extern static int open(string path, int flags, int mode_t);
 347
 348                 [DllImport ("libc")]
 349                 extern static int close(int fd);
 350
 351                 [DllImport ("libc")]
 352                 extern static int kqueue();
 353
 354                 [DllImport ("libc")]
 355                 extern static int kevent(int kqueue, ref kevent ev, int nchanges, ref kevent evtlist,  int nevents, ref timespec ts);
 356         }
 357 }
 358