?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
* beagled/QueryDriver.cs,beagled/PropertyKeywordFu.cs,
[beagle.git] / beagled / FileSystemQueryable / FileSystemQueryable.cs
blobb520c036c23be72d35d3f9a1646337c2604fda15
1 //
2 // FileSystemQueryable.cs
3 //
4 // Copyright (C) 2004 Novell, Inc.
5 //
6
7 //
8 // Permission is hereby granted, free of charge, to any person obtaining a
9 // copy of this software and associated documentation files (the "Software"),
10 // to deal in the Software without restriction, including without limitation
11 // the rights to use, copy, modify, merge, publish, distribute, sublicense,
12 // and/or sell copies of the Software, and to permit persons to whom the
13 // Software is furnished to do so, subject to the following conditions:
14 //
15 // The above copyright notice and this permission notice shall be included in
16 // all copies or substantial portions of the Software.
17 //
18 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
19 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
21 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
22 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
23 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
24 // DEALINGS IN THE SOFTWARE.
25 //
26
27 using System;
28 using System.Collections;
29 using System.IO;
30 using System.Reflection;
31 using System.Text;
32 using System.Threading;
33
34 using Beagle.Daemon;
35 using Beagle.Util;
36
37 namespace Beagle.Daemon.FileSystemQueryable {
38
39 [QueryableFlavor (Name="Files", Domain=QueryDomain.Local, RequireInotify=false)]
40 [PropertyKeywordMapping (Keyword="extension", PropertyName="beagle:FilenameExtension", IsKeyword=true, Description="File extension, e.g. extension:jpeg. Use extension: to search in files with no extension.")]
41 [PropertyKeywordMapping (Keyword="ext", PropertyName="beagle:FilenameExtension", IsKeyword=true, Description="File extension, e.g. ext:jpeg. Use ext: to search in files with no extension.")]
42 public class FileSystemQueryable : LuceneQueryable {
43
44 static public bool Debug = false;
45
46 private const string SplitFilenamePropKey = "beagle:SplitFilename";
47 public const string ExactFilenamePropKey = "beagle:ExactFilename";
48 public const string TextFilenamePropKey = "beagle:Filename";
49 public const string NoPunctFilenamePropKey = "beagle:NoPunctFilename";
50 public const string FilenameExtensionPropKey = "beagle:FilenameExtension";
51 public const string ParentDirUriPropKey = LuceneQueryingDriver.PrivateNamespace + "ParentDirUri";
52 public const string IsDirectoryPropKey = LuceneQueryingDriver.PrivateNamespace + "IsDirectory";
53
54 // History:
55 // 1: Initially set to force a reindex due to NameIndex changes.
56 // 2: Overhauled everything to use new lucene infrastructure.
57 // 3: Switched to UTC for all times, changed the properties a bit.
58 // 4: Changed the key of TextFilenamePropKey to beagle:Filename - it might be useful in clients.
59 // Make SplitFilenamePropKey unstored
60 const int MINOR_VERSION = 4;
61
62 private object big_lock = new object ();
63
64 private IFileEventBackend event_backend;
65
66 // This is the task that walks the tree structure
67 private TreeCrawlTask tree_crawl_task;
68
69 // This is the task that finds the next place that
70 // needs to be crawled in the tree and spawns off
71 // the appropriate IndexableGenerator.
72 private FileCrawlTask file_crawl_task;
73
74 private ArrayList roots = new ArrayList ();
75 private ArrayList roots_by_path = new ArrayList ();
76
77 private FileNameFilter filter;
78
79 // This is just a copy of the LuceneQueryable's QueryingDriver
80 // cast into the right type for doing internal->external Uri
81 // lookups.
82 private LuceneNameResolver name_resolver;
83
84 //////////////////////////////////////////////////////////////////////////
85
86 private Hashtable cached_uid_by_path = new Hashtable ();
87
88 //////////////////////////////////////////////////////////////////////////
89
90 public FileSystemQueryable () : base ("FileSystemIndex", MINOR_VERSION)
91 {
92 // Set up our event backend
93 if (Inotify.Enabled) {
94 Logger.Log.Debug ("Starting Inotify Backend");
95 event_backend = new InotifyBackend ();
96 } else {
97 Logger.Log.Debug ("Creating null file event backend");
98 event_backend = new NullFileEventBackend ();
99 }
100
101 tree_crawl_task = new TreeCrawlTask (new TreeCrawlTask.Handler (AddDirectory));
102 tree_crawl_task.Source = this;
103
104 file_crawl_task = new FileCrawlTask (this);
105 file_crawl_task.Source = this;
106
107 name_resolver = (LuceneNameResolver) Driver;
108 PreloadDirectoryNameInfo ();
109
110 // Setup our file-name filter
111 filter = new FileNameFilter (this);
112
113 // Do the right thing when paths expire
114 DirectoryModel.ExpireEvent +=
115 new DirectoryModel.ExpireHandler (ExpireDirectoryPath);
116 }
117
118
119 override protected IFileAttributesStore BuildFileAttributesStore ()
120 {
121 return new FileAttributesStore_Mixed (IndexDirectory, IndexFingerprint);
122 }
123
124 override protected LuceneQueryingDriver BuildLuceneQueryingDriver (string index_name,
125 int minor_version,
126 bool read_only_mode)
127 {
128 return new LuceneNameResolver (index_name, minor_version, read_only_mode);
129 }
130
131 public FileNameFilter Filter {
132 get { return filter; }
133 }
134
135 //////////////////////////////////////////////////////////////////////////
136
137 //
138 // This is where we build our Indexables
139 //
140
141 public static void AddStandardPropertiesToIndexable (Indexable indexable,
142 string name,
143 Guid parent_id,
144 bool mutable)
145 {
146 StringBuilder sb;
147 sb = new StringBuilder ();
148
149 string no_ext, ext, no_punct;
150 no_ext = Path.GetFileNameWithoutExtension (name);
151 ext = Path.GetExtension (name).ToLower ();
152
153 sb.Append (no_ext);
154 for (int i = 0; i < sb.Length; ++i)
155 if (! Char.IsLetterOrDigit (sb [i]))
156 sb [i] = ' ';
157 no_punct = sb.ToString ();
158
159
160 Property prop;
161
162 prop = Property.NewKeyword (ExactFilenamePropKey, name);
163 prop.IsMutable = mutable;
164 indexable.AddProperty (prop);
165
166 prop = Property.New (TextFilenamePropKey, no_ext);
167 prop.IsMutable = mutable;
168 indexable.AddProperty (prop);
169
170 prop = Property.New (NoPunctFilenamePropKey, no_punct);
171 prop.IsMutable = mutable;
172 indexable.AddProperty (prop);
173
174 prop = Property.NewUnsearched (FilenameExtensionPropKey, ext);
175 prop.IsMutable = mutable;
176 indexable.AddProperty (prop);
177
178 string str;
179 str = StringFu.FuzzyDivide (no_ext);
180 prop = Property.NewUnstored (SplitFilenamePropKey, str);
181 prop.IsMutable = mutable;
182 indexable.AddProperty (prop);
183
184 if (parent_id == Guid.Empty)
185 return;
186
187 str = GuidFu.ToUriString (parent_id);
188 // We use the uri here to recycle terms in the index,
189 // since each directory's uri will already be indexed.
190 prop = Property.NewUnsearched (ParentDirUriPropKey, str);
191 prop.IsMutable = mutable;
192 indexable.AddProperty (prop);
193 }
194
195 public static void AddStandardPropertiesToIndexable (Indexable indexable,
196 string name,
197 DirectoryModel parent,
198 bool mutable)
199 {
200 AddStandardPropertiesToIndexable (indexable,
201 name,
202 parent == null ? Guid.Empty : parent.UniqueId,
203 mutable);
204
205 indexable.LocalState ["Parent"] = parent;
206 }
207
208 public static Indexable DirectoryToIndexable (string path,
209 Guid id,
210 DirectoryModel parent)
211 {
212 Indexable indexable;
213 try {
214 indexable = new Indexable (IndexableType.Add, GuidFu.ToUri (id));
215 indexable.MimeType = "inode/directory";
216 indexable.NoContent = true;
217 indexable.Timestamp = Directory.GetLastWriteTimeUtc (path);
218 } catch (IOException) {
219 // Looks like the directory was deleted.
220 return null;
221 }
222
223 string name;
224 if (parent == null)
225 name = path;
226 else
227 name = Path.GetFileName (path);
228 AddStandardPropertiesToIndexable (indexable, name, parent, true);
229
230 Property prop;
231 prop = Property.NewBool (IsDirectoryPropKey, true);
232 prop.IsMutable = true; // we want this in the secondary index, for efficiency
233 indexable.AddProperty (prop);
234
235 indexable.LocalState ["Path"] = path;
236
237 return indexable;
238 }
239
240 public static Indexable FileToIndexable (string path,
241 Guid id,
242 DirectoryModel parent,
243 bool crawl_mode)
244 {
245 Indexable indexable;
246
247 try {
248 indexable = new Indexable (IndexableType.Add, GuidFu.ToUri (id));
249 indexable.Timestamp = File.GetLastWriteTimeUtc (path);
250 indexable.ContentUri = UriFu.PathToFileUri (path);
251 indexable.Crawled = crawl_mode;
252 indexable.Filtering = Beagle.IndexableFiltering.Always;
253 } catch (IOException) {
254 // Looks like the file was deleted.
255 return null;
256 }
257
258 AddStandardPropertiesToIndexable (indexable, Path.GetFileName (path), parent, true);
259
260 indexable.LocalState ["Path"] = path;
261
262 return indexable;
263 }
264
265 private static Indexable NewRenamingIndexable (string name,
266 Guid id,
267 DirectoryModel parent,
268 string last_known_path)
269 {
270 Indexable indexable;
271 indexable = new Indexable (IndexableType.PropertyChange, GuidFu.ToUri (id));
272
273 AddStandardPropertiesToIndexable (indexable, name, parent, true);
274
275 indexable.LocalState ["Id"] = id;
276 indexable.LocalState ["LastKnownPath"] = last_known_path;
277
278 return indexable;
279 }
280
281 //////////////////////////////////////////////////////////////////////////
282
283 //
284 // Mapping from directory ids to paths
285 //
286
287 private Hashtable dir_models_by_id = new Hashtable ();
288 private Hashtable name_info_by_id = new Hashtable ();
289
290 // We fall back to using the name information in the index
291 // until we've fully constructed our set of DirectoryModels.
292 private void PreloadDirectoryNameInfo ()
293 {
294 ICollection all;
295 all = name_resolver.GetAllDirectoryNameInfo ();
296 foreach (LuceneNameResolver.NameInfo info in all)
297 name_info_by_id [info.Id] = info;
298 }
299
300 // This only works for directories.
301 private string UniqueIdToDirectoryName (Guid id)
302 {
303 DirectoryModel dir;
304 dir = dir_models_by_id [id] as DirectoryModel;
305 if (dir != null)
306 return dir.FullName;
307
308 LuceneNameResolver.NameInfo info;
309 info = name_info_by_id [id] as LuceneNameResolver.NameInfo;
310 if (info != null) {
311 if (info.ParentId == Guid.Empty) // i.e. this is a root
312 return info.Name;
313 else {
314 string parent_name;
315 parent_name = UniqueIdToDirectoryName (info.ParentId);
316 if (parent_name == null)
317 return null;
318 return Path.Combine (parent_name, info.Name);
319 }
320 }
321
322 return null;
323 }
324
325 private void CacheDirectoryNameChange (Guid id, Guid new_parent_id, string new_name)
326 {
327 LuceneNameResolver.NameInfo info;
328 info = name_info_by_id [id] as LuceneNameResolver.NameInfo;
329 if (info != null) {
330 info.ParentId = new_parent_id;
331 info.Name = new_name;
332 }
333 }
334
335 private string ToFullPath (string name, Guid parent_id)
336 {
337 // This is the correct behavior for roots.
338 if (parent_id == Guid.Empty)
339 return name;
340
341 string parent_name;
342 parent_name = UniqueIdToDirectoryName (parent_id);
343 if (parent_name == null)
344 return null;
345
346 return Path.Combine (parent_name, name);
347 }
348
349 // This works for both files and directories.
350 private string UniqueIdToFullPath (Guid id)
351 {
352 // First, check if it is a directory.
353 string path;
354 path = UniqueIdToDirectoryName (id);
355 if (path != null)
356 return path;
357
358 // If not, try to pull name information out of the index.
359 LuceneNameResolver.NameInfo info;
360 info = name_resolver.GetNameInfoById (id);
361 if (info == null)
362 return null;
363 return ToFullPath (info.Name, info.ParentId);
364 }
365
366 private void RegisterId (string name, DirectoryModel dir, Guid id)
367 {
368 cached_uid_by_path [Path.Combine (dir.FullName, name)] = id;
369 }
370
371 private void ForgetId (string path)
372 {
373 cached_uid_by_path.Remove (path);
374 }
375
376 // This works for files. (It probably works for directories
377 // too, but you should use one of the more efficient means
378 // above if you know it is a directory.)
379 private Guid NameAndParentToId (string name, DirectoryModel dir)
380 {
381 string path;
382 path = Path.Combine (dir.FullName, name);
383
384 Guid unique_id;
385 if (cached_uid_by_path.Contains (path))
386 unique_id = (Guid) cached_uid_by_path [path];
387 else
388 unique_id = name_resolver.GetIdByNameAndParentId (name, dir.UniqueId);
389
390 return unique_id;
391 }
392
393 //////////////////////////////////////////////////////////////////////////
394
395 //
396 // Directory-related methods
397 //
398
399 private Hashtable dir_models_by_path = new Hashtable ();
400
401 private DirectoryModel GetDirectoryModelByPath (string path)
402 {
403 DirectoryModel dir;
404
405 lock (dir_models_by_path) {
406 dir = dir_models_by_path [path] as DirectoryModel;
407 if (dir != null)
408 return dir;
409 }
410
411 // Walk each root until we find the correct path
412 foreach (DirectoryModel root in roots) {
413 dir = root.WalkTree (path);
414 if (dir != null) {
415 lock (dir_models_by_path)
416 dir_models_by_path [path] = dir;
417 break;
418 }
419 }
420
421 return dir;
422 }
423
424 private void ExpireDirectoryPath (string expired_path, Guid unique_id)
425 {
426 if (Debug)
427 Logger.Log.Debug ("Expired '{0}'", expired_path);
428
429 lock (dir_models_by_path)
430 dir_models_by_path.Remove (expired_path);
431 }
432
433 public void AddDirectory (DirectoryModel parent, string name)
434 {
435 // Ignore the stuff we want to ignore.
436 if (filter.Ignore (parent, name, true))
437 return;
438
439 if (parent != null && parent.HasChildWithName (name))
440 return;
441
442 string path;
443 path = (parent == null) ? name : Path.Combine (parent.FullName, name);
444
445 if (Debug)
446 Logger.Log.Debug ("Adding directory '{0}'", path, name);
447
448 if (! Directory.Exists (path)) {
449 Logger.Log.Error ("Can't add directory: '{0}' does not exist", path);
450 return;
451 }
452
453 FileAttributes attr;
454 attr = FileAttributesStore.Read (path);
455
456 // Note that we don't look at the mtime of a directory when
457 // deciding whether or not to index it.
458 bool needs_indexing = false;
459 if (attr == null) {
460 // If it has no attributes, it definitely needs
461 // indexing.
462 needs_indexing = true;
463 } else {
464 // Make sure that it still has the same name as before.
465 // If not, we need to re-index it.
466 // We can do this since we preloaded all of the name
467 // info in the directory via PreloadDirectoryNameInfo.
468 string last_known_name;
469 last_known_name = UniqueIdToDirectoryName (attr.UniqueId);
470 if (last_known_name != path) {
471 Logger.Log.Debug ("'{0}' now seems to be called '{1}'", last_known_name, path);
472 needs_indexing = true;
473 }
474 }
475
476 // If we can't descend into this directory, we want to
477 // index it but not build a DirectoryModel for it.
478 // FIXME: We should do the right thing when a
479 // directory's permissions change.
480 bool is_walkable;
481 is_walkable = DirectoryWalker.IsWalkable (path);
482 if (! is_walkable)
483 Logger.Log.Debug ("Can't walk '{0}'", path);
484
485 if (needs_indexing)
486 ScheduleDirectory (name, parent, attr, is_walkable);
487 else if (is_walkable)
488 RegisterDirectory (name, parent, attr);
489 }
490
491 public void AddRoot (string path)
492 {
493 path = StringFu.SanitizePath (path);
494 Logger.Log.Debug ("Adding root: {0}", path);
495
496 if (roots_by_path.Contains (path)) {
497 Logger.Log.Error ("Trying to add an existing root: {0}", path);
498 return;
499 }
500
501 // We need to have the path key in the roots hashtable
502 // for the filtering to work as we'd like before the root
503 // is actually added.
504 roots_by_path.Add (path);
505
506 AddDirectory (null, path);
507 }
508
509 public void RemoveRoot (string path)
510 {
511 Logger.Log.Debug ("Removing root: {0}", path);
512
513 if (! roots_by_path.Contains (path)) {
514 Logger.Log.Error ("Trying to remove a non-existing root: {0}", path);
515 return;
516 }
517
518 // Find our directory model for the root
519 DirectoryModel dir;
520 dir = GetDirectoryModelByPath (path);
521
522 if (dir == null) {
523 Logger.Log.Error ("Could not find directory-model for root: {0}", path);
524 return;
525 }
526
527 // FIXME: Make sure we're emptying the crawler task of any sub-directories
528 // to the root we're removing. It's not a big deal since we do an Ignore-check
529 // in there, but it would be nice.
530
531 roots_by_path.Remove (path);
532 roots.Remove (dir);
533
534 // Clean out the root from our directory cache.
535 RemoveDirectory (dir);
536 }
537
538 private void ScheduleDirectory (string name,
539 DirectoryModel parent,
540 FileAttributes attr,
541 bool is_walkable)
542 {
543 string path;
544 path = (parent == null) ? name : Path.Combine (parent.FullName, name);
545
546 Guid id;
547 id = (attr == null) ? Guid.NewGuid () : attr.UniqueId;
548
549 DateTime last_crawl;
550 last_crawl = (attr == null) ? DateTime.MinValue : attr.LastWriteTime;
551
552 Indexable indexable;
553 indexable = DirectoryToIndexable (path, id, parent);
554
555 if (indexable != null) {
556 indexable.LocalState ["Name"] = name;
557 indexable.LocalState ["LastCrawl"] = last_crawl;
558 indexable.LocalState ["IsWalkable"] = is_walkable;
559
560 Scheduler.Task task;
561 task = NewAddTask (indexable);
562 task.Priority = Scheduler.Priority.Delayed;
563 ThisScheduler.Add (task);
564 }
565 }
566
567 private bool RegisterDirectory (string name, DirectoryModel parent, FileAttributes attr)
568 {
569 string path;
570 path = (parent == null) ? name : Path.Combine (parent.FullName, name);
571
572 if (Debug)
573 Logger.Log.Debug ("Registered directory '{0}' ({1})", path, attr.UniqueId);
574
575 DateTime mtime;
576
577 try {
578 mtime = Directory.GetLastWriteTimeUtc (path);
579 } catch (IOException) {
580 Log.Debug ("Directory '{0}' ({1}) appears to have gone away", path, attr.UniqueId);
581 return false;
582 }
583
584 DirectoryModel dir;
585 if (parent == null)
586 dir = DirectoryModel.NewRoot (big_lock, path, attr);
587 else
588 dir = parent.AddChild (name, attr);
589
590 if (mtime > attr.LastWriteTime) {
591 dir.State = DirectoryState.Dirty;
592 if (Debug)
593 Logger.Log.Debug ("'{0}' is dirty", path);
594 }
595
596 if (Debug) {
597 if (dir.IsRoot)
598 Logger.Log.Debug ("Created model '{0}'", dir.FullName);
599 else
600 Logger.Log.Debug ("Created model '{0}' with parent '{1}'", dir.FullName, dir.Parent.FullName);
601 }
602
603 // Add any roots we create to the list of roots
604 if (dir.IsRoot)
605 roots.Add (dir);
606
607 // Add the directory to our by-id hash, and remove any NameInfo
608 // we might have cached about it.
609 dir_models_by_id [dir.UniqueId] = dir;
610 name_info_by_id.Remove (dir.UniqueId);
611
612 // Start watching the directory.
613 dir.WatchHandle = event_backend.CreateWatch (path);
614
615 // Schedule this directory for crawling.
616 if (tree_crawl_task.Add (dir))
617 ThisScheduler.Add (tree_crawl_task);
618
619 // Make sure that our file crawling task is active,
620 // since presumably we now have something new to crawl.
621 ActivateFileCrawling ();
622
623 return true;
624 }
625
626 private void ForgetDirectoryRecursively (DirectoryModel dir)
627 {
628 foreach (DirectoryModel child in dir.Children)
629 ForgetDirectoryRecursively (child);
630
631 if (dir.WatchHandle != null)
632 event_backend.ForgetWatch (dir.WatchHandle);
633 dir_models_by_id.Remove (dir.UniqueId);
634 // We rely on the expire event to remove it from dir_models_by_path
635 }
636
637 private void RemoveDirectory (DirectoryModel dir)
638 {
639 Uri uri;
640 uri = GuidFu.ToUri (dir.UniqueId);
641
642 Indexable indexable;
643 indexable = new Indexable (IndexableType.Remove, uri);
644
645 // Remember a copy of our external Uri, so that we can
646 // easily remap it in the PostRemoveHook.
647 indexable.LocalState ["RemovedUri"] = UriFu.PathToFileUri (dir.FullName);
648
649 // Forget watches and internal references
650 ForgetDirectoryRecursively (dir);
651
652 // Calling Remove will expire the path names,
653 // so name caches will be cleaned up accordingly.
654 dir.Remove ();
655
656 Scheduler.Task task;
657 task = NewAddTask (indexable); // We *add* the indexable to *remove* the index item
658 task.Priority = Scheduler.Priority.Immediate;
659 ThisScheduler.Add (task);
660 }
661
662 public void RemoveDirectory (string path)
663 {
664 DirectoryModel dir = GetDirectoryModelByPath (path);
665 if (dir != null)
666 RemoveDirectory (dir);
667 }
668
669 private void MoveDirectory (DirectoryModel dir,
670 DirectoryModel new_parent, // or null if we are just renaming
671 string new_name)
672 {
673 if (dir == null) {
674 Logger.Log.Warn ("Couldn't find DirectoryModel for directory moving to '{0}' in '{1}', so it was hopefully never there.",
675 new_name, new_parent.FullName);
676 AddDirectory (new_parent, new_name);
677 return;
678 }
679
680 if (dir.IsRoot)
681 throw new Exception ("Can't move root " + dir.FullName);
682
683 // We'll need this later in order to generate the
684 // right change notification.
685 string old_path;
686 old_path = dir.FullName;
687
688 if (new_parent != null && new_parent != dir.Parent)
689 dir.MoveTo (new_parent, new_name);
690 else
691 dir.Name = new_name;
692
693 // Remember this by path
694 lock (dir_models_by_path)
695 dir_models_by_path [dir.FullName] = dir;
696
697 CacheDirectoryNameChange (dir.UniqueId, dir.Parent.UniqueId, new_name);
698
699 Indexable indexable;
700 indexable = NewRenamingIndexable (new_name,
701 dir.UniqueId,
702 dir.Parent, // == new_parent
703 old_path);
704 indexable.LocalState ["OurDirectoryModel"] = dir;
705
706 Scheduler.Task task;
707 task = NewAddTask (indexable);
708 task.Priority = Scheduler.Priority.Immediate;
709 // Danger Will Robinson!
710 // We need to use BlockUntilNoCollision to get the correct notifications
711 // in a mv a b; mv b c; mv c a situation.
712 // FIXME: And now that type no longer exists!
713 ThisScheduler.Add (task);
714 }
715
716 //////////////////////////////////////////////////////////////////////////
717
718 //
719 // This code controls the directory crawl order
720 //
721
722 private DirectoryModel StupidWalk (DirectoryModel prev_best, DirectoryModel contender)
723 {
724 if (contender.NeedsCrawl) {
725 if (prev_best == null || prev_best.CompareTo (contender) < 0)
726 prev_best = contender;
727 }
728
729 foreach (DirectoryModel child in contender.Children)
730 prev_best = StupidWalk (prev_best, child);
731
732 return prev_best;
733 }
734
735 public DirectoryModel GetNextDirectoryToCrawl ()
736 {
737 DirectoryModel next_dir = null;
738
739 foreach (DirectoryModel root in roots)
740 next_dir = StupidWalk (next_dir, root);
741
742 return next_dir;
743 }
744
745 public void DoneCrawlingOneDirectory (DirectoryModel dir)
746 {
747 if (! dir.IsAttached)
748 return;
749
750 FileAttributes attr;
751 attr = FileAttributesStore.Read (dir.FullName);
752
753 // Don't mark ourselves; let the crawler redo us
754 if (attr == null)
755 return;
756
757 // We don't have to be super-careful about this since
758 // we only use the FileAttributes mtime on a directory
759 // to determine its initial state, not whether or not
760 // its index record is up-to-date.
761 attr.LastWriteTime = DateTime.UtcNow;
762
763 // ...but we do use this to decide which order directories get
764 // crawled in.
765 dir.LastCrawlTime = DateTime.UtcNow;
766
767 FileAttributesStore.Write (attr);
768 dir.MarkAsClean ();
769 }
770
771 public void MarkDirectoryAsUncrawlable (DirectoryModel dir)
772 {
773 if (! dir.IsAttached)
774 return;
775
776 // If we managed to get set up a watch on this directory,
777 // drop it.
778 if (dir.WatchHandle != null) {
779 event_backend.ForgetWatch (dir.WatchHandle);
780 dir.WatchHandle = null;
781 }
782
783 dir.MarkAsUncrawlable ();
784 }
785
786 public void Recrawl (string path)
787 {
788 // Try to find a directory model for the path specified
789 // so that we can re-crawl it.
790 DirectoryModel dir;
791 dir = GetDirectoryModelByPath (path);
792
793 bool path_is_registered = true;
794
795 if (dir == null) {
796 dir = GetDirectoryModelByPath (FileSystem.GetDirectoryNameRootOk (path));
797 path_is_registered = false;
798
799 if (dir == null) {
800 Logger.Log.Debug ("Unable to get directory-model for path: {0}", path);
801 return;
802 }
803 }
804
805 Logger.Log.Debug ("Re-crawling {0}", dir.FullName);
806
807 if (tree_crawl_task.Add (dir))
808 ThisScheduler.Add (tree_crawl_task);
809
810 if (path_is_registered)
811 Recrawl_Recursive (dir, DirectoryState.PossiblyClean);
812
813 ActivateFileCrawling ();
814 ActivateDirectoryCrawling ();
815 }
816
817 public void RecrawlEverything ()
818 {
819 Logger.Log.Debug ("Re-crawling all directories");
820
821 foreach (DirectoryModel root in roots)
822 Recrawl_Recursive (root, DirectoryState.PossiblyClean);
823
824 ActivateFileCrawling ();
825 ActivateDirectoryCrawling ();
826 }
827
828 private void Recrawl_Recursive (DirectoryModel dir, DirectoryState state)
829 {
830 dir.State = state;
831 tree_crawl_task.Add (dir);
832 foreach (DirectoryModel sub_dir in dir.Children)
833 Recrawl_Recursive (sub_dir, state);
834 }
835
836 private void ActivateFileCrawling ()
837 {
838 if (! file_crawl_task.IsActive)
839 ThisScheduler.Add (file_crawl_task);
840 }
841
842 private void ActivateDirectoryCrawling ()
843 {
844 if (! tree_crawl_task.IsActive)
845 ThisScheduler.Add (tree_crawl_task);
846 }
847
848 //////////////////////////////////////////////////////////////////////////
849
850 //
851 // File-related methods
852 //
853
854 private enum RequiredAction {
855 None,
856 Index,
857 Rename,
858 Forget
859 }
860
861 static DateTime epoch = new DateTime (1970, 1, 1, 0, 0, 0);
862
863 static DateTime ToDateTimeUtc (long time_t)
864 {
865 return epoch.AddSeconds (time_t);
866 }
867
868 private RequiredAction DetermineRequiredAction (DirectoryModel dir,
869 string name,
870 FileAttributes attr,
871 out string last_known_path)
872 {
873 last_known_path = null;
874
875 string path;
876 path = Path.Combine (dir.FullName, name);
877
878 if (Debug)
879 Logger.Log.Debug ("*** What should we do with {0}?", path);
880
881 if (filter.Ignore (dir, name, false)) {
882 // If there are attributes on the file, we must have indexed
883 // it previously. Since we are ignoring it now, we should strip
884 // any file attributes from it.
885 if (attr != null) {
886 if (Debug)
887 Logger.Log.Debug ("*** Forget it: File is ignored but has attributes");
888 return RequiredAction.Forget;
889 }
890 if (Debug)
891 Logger.Log.Debug ("*** Do nothing: File is ignored");
892 return RequiredAction.None;
893 }
894
895 if (attr == null) {
896 if (Debug)
897 Logger.Log.Debug ("*** Index it: File has no attributes");
898 return RequiredAction.Index;
899 }
900
901 // FIXME: This does not take in to account that we might have a better matching filter to use now
902 // That, however, is kind of expensive to figure out since we'd have to do mime-sniffing and shit.
903 if (attr.FilterName != null && attr.FilterVersion > 0) {
904 int current_filter_version;
905 current_filter_version = FilterFactory.GetFilterVersion (attr.FilterName);
906
907 if (current_filter_version > attr.FilterVersion) {
908 if (Debug)
909 Logger.Log.Debug ("*** Index it: Newer filter version found for filter {0}", attr.FilterName);
910 return RequiredAction.Index;
911 }
912 }
913
914 Mono.Unix.Native.Stat stat;
915 try {
916 Mono.Unix.Native.Syscall.stat (path, out stat);
917 } catch (Exception ex) {
918 Logger.Log.Debug ("Caught exception stat-ing {0}", path);
919 Logger.Log.Debug (ex);
920 return RequiredAction.None;
921 }
922
923 DateTime last_write_time, last_attr_time;
924 last_write_time = ToDateTimeUtc (stat.st_mtime);
925 last_attr_time = ToDateTimeUtc (stat.st_ctime);
926
927 if (attr.LastWriteTime != last_write_time) {
928 if (Debug)
929 Logger.Log.Debug ("*** Index it: MTime has changed ({0} vs {1})", attr.LastWriteTime, last_write_time);
930
931 // If the file has been copied, it will have the
932 // original file's EAs. Thus we have to check to
933 // make sure that the unique id in the EAs actually
934 // belongs to this file. If not, replace it with a new one.
935 // (Thus touching & then immediately renaming a file can
936 // cause its unique id to change, which is less than
937 // optimal but probably can't be helped.)
938 last_known_path = UniqueIdToFullPath (attr.UniqueId);
939 if (path != last_known_path) {
940 if (Debug)
941 Logger.Log.Debug ("*** Name has also changed, assigning new unique id");
942 attr.UniqueId = Guid.NewGuid ();
943 }
944
945 return RequiredAction.Index;
946 }
947
948 // If the inode ctime is newer than the last time we last
949 // set file attributes, we might have been moved. We don't
950 // strictly compare times due to the fact that although
951 // setting xattrs changes the ctime, if we don't have write
952 // access our metadata will be stored in sqlite, and the
953 // ctime will be at some point in the past.
954 if (attr.LastAttrTime < last_attr_time) {
955 if (Debug)
956 Logger.Log.Debug ("*** CTime is newer, checking last known path ({0} vs {1})", attr.LastAttrTime, last_attr_time);
957
958 last_known_path = UniqueIdToFullPath (attr.UniqueId);
959
960 if (last_known_path == null) {
961 if (Debug)
962 Logger.Log.Debug ("*** Index it: CTime has changed, but can't determine last known path");
963 return RequiredAction.Index;
964 }
965
966 // If the name has changed but the mtime
967 // hasn't, the only logical conclusion is that
968 // the file has been renamed.
969 if (path != last_known_path) {
970 if (Debug)
971 Logger.Log.Debug ("*** Rename it: CTime and path has changed");
972 return RequiredAction.Rename;
973 }
974 }
975
976 // We don't have to do anything, which is always preferable.
977 if (Debug)
978 Logger.Log.Debug ("*** Do nothing");
979 return RequiredAction.None;
980 }
981
982 // Return an indexable that will do the right thing with a file
983 // (or null, if the right thing is to do nothing)
984 public Indexable GetCrawlingFileIndexable (DirectoryModel dir, string name)
985 {
986 string path;
987 path = Path.Combine (dir.FullName, name);
988
989 FileAttributes attr;
990 attr = FileAttributesStore.Read (path);
991
992 RequiredAction action;
993 string last_known_path;
994 action = DetermineRequiredAction (dir, name, attr, out last_known_path);
995
996 if (action == RequiredAction.None)
997 return null;
998
999 Guid unique_id;
1000 if (attr != null)
1001 unique_id = attr.UniqueId;
1002 else
1003 unique_id = Guid.NewGuid ();
1004
1005 Indexable indexable = null;
1006
1007 switch (action) {
1008
1009 case RequiredAction.Index:
1010 indexable = FileToIndexable (path, unique_id, dir, true);
1011 break;
1012
1013 case RequiredAction.Rename:
1014 indexable = NewRenamingIndexable (name, unique_id, dir,
1015 last_known_path);
1016 break;
1017
1018 case RequiredAction.Forget:
1019 FileAttributesStore.Drop (path);
1020
1021 break;
1022 }
1023
1024 return indexable;
1025 }
1026
1027 public void AddFile (DirectoryModel dir, string name)
1028 {
1029 string path;
1030 path = Path.Combine (dir.FullName, name);
1031
1032 if (! File.Exists (path))
1033 return;
1034
1035 if (filter.Ignore (dir, name, false))
1036 return;
1037
1038 // If this file already has extended attributes,
1039 // make sure that the name matches the file
1040 // that is in the index. If not, it could be
1041 // a copy of an already-indexed file and should
1042 // be assigned a new unique id.
1043 Guid unique_id = Guid.Empty;
1044 FileAttributes attr;
1045 attr = FileAttributesStore.Read (path);
1046 if (attr != null) {
1047 LuceneNameResolver.NameInfo info;
1048 info = name_resolver.GetNameInfoById (attr.UniqueId);
1049 if (info != null
1050 && info.Name == name
1051 && info.ParentId == dir.UniqueId)
1052 unique_id = attr.UniqueId;
1053 }
1054
1055 if (unique_id == Guid.Empty)
1056 unique_id = Guid.NewGuid ();
1057
1058 RegisterId (name, dir, unique_id);
1059
1060 Indexable indexable;
1061 indexable = FileToIndexable (path, unique_id, dir, false);
1062
1063 if (indexable != null) {
1064 Scheduler.Task task;
1065 task = NewAddTask (indexable);
1066 task.Priority = Scheduler.Priority.Immediate;
1067 ThisScheduler.Add (task);
1068 }
1069 }
1070
1071 public void RemoveFile (DirectoryModel dir, string name)
1072 {
1073 // FIXME: We might as well remove it, even if it was being ignore.
1074 // Right?
1075
1076 Guid unique_id;
1077 unique_id = NameAndParentToId (name, dir);
1078 if (unique_id == Guid.Empty) {
1079 Logger.Log.Info ("Could not resolve unique id of '{0}' in '{1}' for removal, it is probably already gone",
1080 name, dir.FullName);
1081 return;
1082 }
1083
1084 Uri uri, file_uri;
1085 uri = GuidFu.ToUri (unique_id);
1086 file_uri = UriFu.PathToFileUri (Path.Combine (dir.FullName, name));
1087
1088 Indexable indexable;
1089 indexable = new Indexable (IndexableType.Remove, uri);
1090 indexable.LocalState ["RemovedUri"] = file_uri;
1091
1092 Scheduler.Task task;
1093 task = NewAddTask (indexable);
1094 task.Priority = Scheduler.Priority.Immediate;
1095 ThisScheduler.Add (task);
1096 }
1097
1098 public void MoveFile (DirectoryModel old_dir, string old_name,
1099 DirectoryModel new_dir, string new_name)
1100 {
1101 bool old_ignore, new_ignore;
1102 old_ignore = filter.Ignore (old_dir, old_name, false);
1103 new_ignore = filter.Ignore (new_dir, new_name, false);
1104
1105 if (old_ignore && new_ignore)
1106 return;
1107
1108 // If our ignore-state is changing, synthesize the appropriate
1109 // action.
1110
1111 if (old_ignore && ! new_ignore) {
1112 AddFile (new_dir, new_name);
1113 return;
1114 }
1115
1116 if (! old_ignore && new_ignore) {
1117 RemoveFile (new_dir, new_name);
1118 return;
1119 }
1120
1121 // We need to find the file's unique id.
1122 // We can't look at the extended attributes w/o making
1123 // assumptions about whether they follow around the
1124 // file (EAs) or the path (sqlite)...
1125 Guid unique_id;
1126 unique_id = NameAndParentToId (old_name, old_dir);
1127 if (unique_id == Guid.Empty) {
1128 // If we can't find the unique ID, we have to
1129 // assume that the original file never made it
1130 // into the index --- thus we treat this as
1131 // an Add.
1132 AddFile (new_dir, new_name);
1133 return;
1134 }
1135
1136 RegisterId (new_name, new_dir, unique_id);
1137
1138 string old_path;
1139 old_path = Path.Combine (old_dir.FullName, old_name);
1140
1141 ForgetId (old_path);
1142
1143 // FIXME: I think we need to be more conservative when we seen
1144 // events in a directory that has not been fully scanned, just to
1145 // avoid races. i.e. what if we are in the middle of crawling that
1146 // directory and haven't reached this file yet? Then the rename
1147 // will fail.
1148 Indexable indexable;
1149 indexable = NewRenamingIndexable (new_name,
1150 unique_id,
1151 new_dir,
1152 old_path);
1153
1154 Scheduler.Task task;
1155 task = NewAddTask (indexable);
1156 task.Priority = Scheduler.Priority.Immediate;
1157 // Danger Will Robinson!
1158 // We need to use BlockUntilNoCollision to get the correct notifications
1159 // in a mv a b; mv b c; mv c a situation.
1160 // FIXME: And now AddType no longer exists
1161 ThisScheduler.Add (task);
1162 }
1163
1164 //////////////////////////////////////////////////////////////////////////
1165
1166 // Configuration stuff
1167
1168 public IList Roots {
1169 get {
1170 return roots_by_path;
1171 }
1172 }
1173
1174 private void LoadConfiguration ()
1175 {
1176 if (Conf.Indexing.IndexHomeDir)
1177 AddRoot (PathFinder.HomeDir);
1178
1179 foreach (string root in Conf.Indexing.Roots)
1180 AddRoot (root);
1181
1182 Conf.Subscribe (typeof (Conf.IndexingConfig), OnConfigurationChanged);
1183 }
1184
1185 private void OnConfigurationChanged (Conf.Section section)
1186 {
1187 ArrayList roots_wanted = new ArrayList (Conf.Indexing.Roots);
1188
1189 if (Conf.Indexing.IndexHomeDir)
1190 roots_wanted.Add (PathFinder.HomeDir);
1191
1192 IList roots_to_add, roots_to_remove;
1193 ArrayFu.IntersectListChanges (roots_wanted, Roots, out roots_to_add, out roots_to_remove);
1194
1195 foreach (string root in roots_to_remove)
1196 RemoveRoot (root);
1197
1198 foreach (string root in roots_to_add)
1199 AddRoot (root);
1200 }
1201
1202 //////////////////////////////////////////////////////////////////////////
1203
1204 //
1205 // Our magic LuceneQueryable hooks
1206 //
1207
1208 override protected bool PreChildAddHook (Indexable child)
1209 {
1210 // FIXME: Handling Uri remapping of children is tricky, and there
1211 // is also the issue of properly serializing file: uris that
1212 // contain fragments. For now we just punt it all by dropping
1213 // any child indexables of file system objects.
1214 return false;
1215 }
1216
1217 override protected void PostAddHook (Indexable indexable, IndexerAddedReceipt receipt)
1218 {
1219 // If we just changed properties, remap to our *old* external Uri
1220 // to make notification work out property.
1221 if (indexable.Type == IndexableType.PropertyChange) {
1222
1223 string last_known_path;
1224 last_known_path = (string) indexable.LocalState ["LastKnownPath"];
1225 receipt.Uri = UriFu.PathToFileUri (last_known_path);
1226 Logger.Log.Debug ("Last known path is {0}", last_known_path);
1227
1228 // This rename is now in the index, so we no longer need to keep
1229 // track of the uid in memory.
1230 ForgetId (last_known_path);
1231
1232 return;
1233 }
1234
1235 string path;
1236 path = (string) indexable.LocalState ["Path"];
1237 ForgetId (path);
1238
1239 DirectoryModel parent;
1240 parent = indexable.LocalState ["Parent"] as DirectoryModel;
1241
1242 // The parent directory might have run away since we were indexed
1243 if (parent != null && ! parent.IsAttached)
1244 return;
1245
1246 Guid unique_id;
1247 unique_id = GuidFu.FromUri (receipt.Uri);
1248
1249 FileAttributes attr;
1250 attr = FileAttributesStore.ReadOrCreate (path, unique_id);
1251 attr.Path = path;
1252 attr.LastWriteTime = indexable.Timestamp;
1253
1254 attr.FilterName = receipt.FilterName;
1255 attr.FilterVersion = receipt.FilterVersion;
1256
1257 if (indexable.LocalState ["IsWalkable"] != null) {
1258 string name;
1259 name = (string) indexable.LocalState ["Name"];
1260
1261 if (! RegisterDirectory (name, parent, attr))
1262 return;
1263 }
1264
1265 FileAttributesStore.Write (attr);
1266
1267 // Remap the Uri so that change notification will work properly
1268 receipt.Uri = UriFu.PathToFileUri (path);
1269 }
1270
1271 override protected void PostRemoveHook (Indexable indexable, IndexerRemovedReceipt receipt)
1272 {
1273 // Find the cached external Uri and remap the Uri in the receipt.
1274 // We have to do this to make change notification work.
1275 Uri external_uri;
1276 external_uri = indexable.LocalState ["RemovedUri"] as Uri;
1277 if (external_uri == null)
1278 throw new Exception ("No cached external Uri for " + receipt.Uri);
1279 receipt.Uri = external_uri;
1280 ForgetId (external_uri.LocalPath);
1281 }
1282
1283 private bool RemapUri (Hit hit)
1284 {
1285 // Store the hit's internal uri in a property
1286 Property prop;
1287 prop = Property.NewUnsearched ("beagle:InternalUri",
1288 UriFu.UriToSerializableString (hit.Uri));
1289 hit.AddProperty (prop);
1290
1291 // Now assemble the path by looking at the parent and name
1292 string name, path;
1293 name = hit [ExactFilenamePropKey];
1294 if (name == null) {
1295 // If we don't have the filename property, we have to do a lookup
1296 // based on the guid. This happens with synthetic hits produced by
1297 // index listeners.
1298 Guid hit_id;
1299 hit_id = GuidFu.FromUri (hit.Uri);
1300 path = UniqueIdToFullPath (hit_id);
1301 } else {
1302 string parent_id_uri;
1303 parent_id_uri = hit [ParentDirUriPropKey];
1304 if (parent_id_uri == null)
1305 return false;
1306
1307 Guid parent_id;
1308 parent_id = GuidFu.FromUriString (parent_id_uri);
1309
1310 path = ToFullPath (name, parent_id);
1311 if (path == null)
1312 Logger.Log.Debug ("Couldn't find path of file with name '{0}' and parent '{1}'",
1313 name, GuidFu.ToShortString (parent_id));
1314 }
1315
1316 if (path != null) {
1317 hit.Uri = UriFu.PathToFileUri (path);
1318 return true;
1319 }
1320
1321 return false;
1322 }
1323
1324 // Hit filter: this handles our mapping from internal->external uris,
1325 // and checks to see if the file is still there.
1326 override protected bool HitFilter (Hit hit)
1327 {
1328 Uri old_uri = hit.Uri;
1329
1330 if (! RemapUri (hit))
1331 return false;
1332
1333 string path;
1334 path = hit.Uri.LocalPath;
1335
1336 bool is_directory;
1337 bool exists = false;
1338
1339 is_directory = hit.MimeType == "inode/directory";
1340
1341 if (hit.MimeType == null && hit.Uri.IsFile && Directory.Exists (path)) {
1342 is_directory = true;
1343 exists = true;
1344 }
1345
1346 if (! exists) {
1347 if (is_directory)
1348 exists = Directory.Exists (path);
1349 else
1350 exists = File.Exists (path);
1351 }
1352
1353 // If the file doesn't exist, we do not schedule a removal and
1354 // return false. This is to avoid "losing" files if they are
1355 // in a directory that has been renamed but which we haven't
1356 // scanned yet... if we dropped them from the index, they would
1357 // never get re-indexed (or at least not until the next time they
1358 // were touched) since they would still be stamped with EAs
1359 // indicating they were up-to-date. And that would be bad.
1360 // FIXME: It would be safe if we were in a known state, right?
1361 // i.e. every DirectoryModel is clean.
1362 if (! exists)
1363 return false;
1364
1365 // Fetch the parent directory model from our cache to do clever
1366 // filtering to determine if we're ignoring it or not.
1367 DirectoryModel parent;
1368 parent = GetDirectoryModelByPath (Path.GetDirectoryName (path));
1369
1370 // Check the ignore status of the hit
1371 if (filter.Ignore (parent, Path.GetFileName (path), is_directory))
1372 return false;
1373
1374 return true;
1375 }
1376
1377 override public string GetSnippet (string [] query_terms, Hit hit)
1378 {
1379 // Uri remapping from a hit is easy: the internal uri
1380 // is stored in a property.
1381 Uri uri;
1382 uri = UriFu.UriStringToUri (hit ["beagle:InternalUri"]);
1383
1384 string path;
1385 path = TextCache.UserCache.LookupPathRaw (uri);
1386
1387 if (path == null)
1388 return null;
1389
1390 // If this is self-cached, use the remapped Uri
1391 if (path == TextCache.SELF_CACHE_TAG)
1392 path = hit.Uri.LocalPath;
1393
1394 return SnippetFu.GetSnippetFromFile (query_terms, path);
1395 }
1396
1397 override public void Start ()
1398 {
1399 base.Start ();
1400
1401 event_backend.Start (this);
1402
1403 LoadConfiguration ();
1404
1405 Logger.Log.Debug ("Done starting FileSystemQueryable");
1406 }
1407
1408 //////////////////////////////////////////////////////////////////////////
1409
1410 // These are the methods that the IFileEventBackend implementations should
1411 // call in response to events.
1412
1413 public void ReportEventInDirectory (string directory_name)
1414 {
1415 DirectoryModel dir;
1416 dir = GetDirectoryModelByPath (directory_name);
1417
1418 // If something goes wrong, just fail silently.
1419 if (dir == null)
1420 return;
1421
1422 // We only use this information to prioritize the order in which
1423 // we crawl directories --- so if this directory doesn't
1424 // actually need to be crawled, we can safely ignore it.
1425 if (! dir.NeedsCrawl)
1426 return;
1427
1428 dir.LastActivityTime = DateTime.Now;
1429
1430 Logger.Log.Debug ("Saw event in '{0}'", directory_name);
1431 }
1432
1433 public void HandleAddEvent (string directory_name, string file_name, bool is_directory)
1434 {
1435 Logger.Log.Debug ("*** Add '{0}' '{1}' {2}", directory_name, file_name,
1436 is_directory ? "(dir)" : "(file)");
1437
1438 DirectoryModel dir;
1439 dir = GetDirectoryModelByPath (directory_name);
1440 if (dir == null) {
1441 Logger.Log.Warn ("HandleAddEvent failed: Couldn't find DirectoryModel for '{0}'", directory_name);
1442 return;
1443 }
1444
1445 if (is_directory)
1446 AddDirectory (dir, file_name);
1447 else
1448 AddFile (dir, file_name);
1449 }
1450
1451 public void HandleRemoveEvent (string directory_name, string file_name, bool is_directory)
1452 {
1453 Logger.Log.Debug ("*** Remove '{0}' '{1}' {2}", directory_name, file_name,
1454 is_directory ? "(dir)" : "(file)");
1455
1456 if (is_directory) {
1457 string path;
1458 path = Path.Combine (directory_name, file_name);
1459
1460 DirectoryModel dir;
1461 dir = GetDirectoryModelByPath (path);
1462 if (dir == null) {
1463 Logger.Log.Warn ("HandleRemoveEvent failed: Couldn't find DirectoryModel for '{0}'", path);
1464 return;
1465 }
1466
1467 dir.WatchHandle = null;
1468 RemoveDirectory (dir);
1469 } else {
1470 DirectoryModel dir;
1471 dir = GetDirectoryModelByPath (directory_name);
1472 if (dir == null) {
1473 Logger.Log.Warn ("HandleRemoveEvent failed: Couldn't find DirectoryModel for '{0}'", directory_name);
1474 return;
1475 }
1476
1477 RemoveFile (dir, file_name);
1478 }
1479 }
1480
1481 public void HandleMoveEvent (string old_directory_name, string old_file_name,
1482 string new_directory_name, string new_file_name,
1483 bool is_directory)
1484 {
1485 Logger.Log.Debug ("*** Move '{0}' '{1}' -> '{2}' '{3}' {4}",
1486 old_directory_name, old_file_name,
1487 new_directory_name, new_file_name,
1488 is_directory ? "(dir)" : "(file)");
1489
1490 if (is_directory) {
1491 DirectoryModel dir, new_parent;
1492 dir = GetDirectoryModelByPath (Path.Combine (old_directory_name, old_file_name));
1493 new_parent = GetDirectoryModelByPath (new_directory_name);
1494 MoveDirectory (dir, new_parent, new_file_name);
1495 return;
1496 } else {
1497 DirectoryModel old_dir, new_dir;
1498 old_dir = GetDirectoryModelByPath (old_directory_name);
1499 new_dir = GetDirectoryModelByPath (new_directory_name);
1500 MoveFile (old_dir, old_file_name, new_dir, new_file_name);
1501 }
1502 }
1503
1504 public void HandleOverflowEvent ()
1505 {
1506 Logger.Log.Debug ("Queue overflows suck");
1507 }
1508
1509 }
1510 }
1511
A Beagle Git Repo