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