private void OnInotifyEvent(
Inotify.Watch watch,
string path,
string subitem,
string srcpath,
Inotify.EventType type)
{
// Stop watching if we are deleted. We should unsubscribe to the Inotify watcher
// here to, but that gives an exception. Why?
if ((type & Inotify.EventType.DeleteSelf) != 0)
{
CancelIndexable();
return;
}
// We need to have a filename
if (subitem == null)
{
return;
}
// If the running indexable generator has more items, we don't have to care here.
// Otherwise launch a new indexable generator.
if (indexable_generator != null && !indexable_generator.Done)
{
return;
}
LaunchIndexable();
}
private void OnInotify(Inotify.Watch watch,
string path, string subitem, string srcpath,
Inotify.EventType type)
{
long offset = 0;
path = Path.Combine(path, subitem);
if (ThisScheduler.ContainsByTag(path))
{
Log.Debug("Not adding task for already running task: {0}", path);
return;
}
lock (initial_log_files) {
if (initial_log_files.Contains(path))
{
Log.Debug("{0} is already scheduled for initial indexing", path);
return;
}
}
if (session_offset_table.ContainsKey(path))
{
offset = session_offset_table [path];
}
SessionIndexableGenerator generator = new SessionIndexableGenerator(this, path, offset);
Scheduler.Task task = NewAddTask(generator);
task.Tag = path;
task.Source = this;
ThisScheduler.Add(task);
}
/////////////////////////////////////////////////
// Modified/Created/Deleted event using Inotify
private void OnInotifyEvent(Inotify.Watch watch,
string path,
string subitem,
string srcpath,
Inotify.EventType type)
{
if (subitem == "")
{
return;
}
if (Path.GetExtension(subitem) != ".note")
{
return;
}
if ((type & Inotify.EventType.MovedTo) != 0)
{
IndexNote(new FileInfo(Path.Combine(path, subitem)), Scheduler.Priority.Immediate);
}
if ((type & Inotify.EventType.MovedFrom) != 0 ||
((type & Inotify.EventType.Delete) != 0 &&
(type & Inotify.EventType.IsDirectory) == 0))
{
RemoveNote(subitem);
}
}
/////////////////////////////////////////////////
private void OnInotifyEvent(Inotify.Watch watch,
string path,
string subitem,
string srcpath,
Inotify.EventType type)
{
if (subitem == "")
{
return;
}
string full_path = Path.Combine(path, subitem);
if ((type & Inotify.EventType.Create) != 0 && (type & Inotify.EventType.IsDirectory) != 0)
{
Watch(full_path);
return;
}
if ((type & Inotify.EventType.Modify) != 0)
{
IndexLog(full_path, Scheduler.Priority.Immediate);
return;
}
}
private void OnInotifyEvent(Inotify.Watch watch, string path, string subitem,
string srcpath, Inotify.EventType type)
{
/*
* Console.WriteLine ("Got event ({03}) {0}: {1}/{2}", type, path, subitem,
* srcpath);
*/
string fullPath = Path.Combine(path, subitem);
lock (this)
{
if (HasFlag(type, Inotify.EventType.MovedTo) ||
HasFlag(type, Inotify.EventType.CloseWrite))
{
if (HasFlag(type, Inotify.EventType.IsDirectory) &&
!HasFlag(type, Inotify.EventType.CloseWrite))
{
foldersToAdd.Add(fullPath);
if (srcpath != null)
{
foldersToRemove.Add(srcpath);
}
}
else
{
filesToAdd.Add(fullPath);
if (srcpath != null)
{
filesToRemove.Add(srcpath);
}
}
}
else if (HasFlag(type, Inotify.EventType.Create) &&
HasFlag(type, Inotify.EventType.IsDirectory))
{
Watch(fullPath);
}
else if (HasFlag(type, Inotify.EventType.Delete) ||
HasFlag(type, Inotify.EventType.MovedFrom))
{
if (HasFlag(type, Inotify.EventType.IsDirectory))
{
foldersToRemove.Add(fullPath);
}
else
{
filesToRemove.Add(fullPath);
}
}
notify.WakeupMain();
}
}
public Event(Inotify.Watch watch, string path, string subitem,
string srcpath, Inotify.EventType type, long old_size, long current_size)
{
this.Watch = watch;
this.Path = path;
this.Subitem = subitem;
this.Srcpath = srcpath;
this.Type = type;
this.OldFileSize = old_size;
this.CurrentFileSize = current_size;
}
private void OnInotifyNewRemote(Inotify.Watch watch,
string path, string subitem, string srcpath,
Inotify.EventType type)
{
if (subitem.Length == 0 || (type & Inotify.EventType.IsDirectory) == 0)
{
return;
}
CrawlRemoteDirectory(Path.Combine(path, subitem), true);
}
public Event (Inotify.Watch watch, string path, string subitem,
string srcpath, Inotify.EventType type, long old_size, long current_size)
{
this.Watch = watch;
this.Path = path;
this.Subitem = subitem;
this.Srcpath = srcpath;
this.Type = type;
this.OldFileSize = old_size;
this.CurrentFileSize = current_size;
}
private void OnInotify(Inotify.Watch watch,
string path,
string subitem,
string srcpath,
Inotify.EventType event_type)
{
if ((event_type & Inotify.EventType.MovedTo) != 0 && subitem == "dcache4.url")
{
IndexDirectory(path);
return;
}
}
/////////////////////////////////////////////////
// Modified event using Inotify
private void OnInotifyEvent(Inotify.Watch watch,
string path,
string subitem,
string srcpath,
Inotify.EventType type)
{
if (subitem != blam_file.Name)
{
return;
}
Index();
}
/////////////////////////////////////////////////
// Modified event using Inotify
private void OnInotifyEvent(Inotify.Watch watch,
string path,
string subitem,
string srcpath,
Inotify.EventType type)
{
if (Path.Combine(path, subitem) != korganizer_file)
{
return;
}
Index();
}
private void OnInotifyNewConversation(Inotify.Watch watch,
string path, string subitem, string srcpath,
Inotify.EventType type)
{
if (subitem.Length == 0 || (type & Inotify.EventType.IsDirectory) != 0)
{
return;
}
if (FileIsInteresting(subitem))
{
IndexLog(Path.Combine(path, subitem), Scheduler.Priority.Immediate);
}
}
/////////////////////////////////////////////////
private void OnInotifyNewNote(Inotify.Watch watch,
string path, string subitem, string srcpath,
Inotify.EventType type)
{
if (subitem.Length == 0 || (type & Inotify.EventType.IsDirectory) != 0)
{
return;
}
if (subitem.EndsWith("map"))
{
IndexNote(new FileInfo(Path.Combine(path, subitem)), Scheduler.Priority.Immediate);
}
}
private void OnInotifyEvent(Inotify.Watch watch,
string path,
string subitem,
string srcpath,
Inotify.EventType type)
{
if (subitem == "")
{
return;
}
string full_path = Path.Combine(path, subitem);
if ((type & Inotify.EventType.Create) != 0 && (type & Inotify.EventType.IsDirectory) != 0)
{
Watch(full_path);
return;
}
if ((type & Inotify.EventType.Delete) != 0 && (type & Inotify.EventType.IsDirectory) != 0)
{
watch.Unsubscribe();
return;
}
if ((type & Inotify.EventType.MovedTo) != 0)
{
if (subitem == "summary")
{
// IMAP summary
if (SummaryAddedEvent != null && File.Exists(full_path))
{
Logger.Log.Info("Reindexing updated IMAP summary: {0}", full_path);
SummaryAddedEvent(new FileInfo(full_path), true);
}
}
else if (Path.GetExtension(full_path) == ".ev-summary")
{
// mbox summary
string mbox_file = Path.ChangeExtension(full_path, null);
if (MboxAddedEvent != null && File.Exists(mbox_file))
{
Logger.Log.Info("Reindexing updated mbox: {0}", mbox_file);
MboxAddedEvent(new FileInfo(mbox_file), true);
}
}
}
}
/////////////////////////////////////////////////
// Modified/Created event using Inotify
private void OnInotifyEvent(Inotify.Watch watch,
string path,
string subitem,
string srcpath,
Inotify.EventType type)
{
if (subitem == "" || !subitem.EndsWith(".xml"))
{
return;
}
if ((type & Inotify.EventType.CloseWrite) != 0)
{
IndexSingleFeed(Path.Combine(path, subitem), false);
}
else if ((type & Inotify.EventType.Delete) != 0)
{
RemoveFeedFile(Path.Combine(path, subitem));
}
}
private void OnInotify(Inotify.Watch watch,
string path,
string subitem,
string srcpath,
Inotify.EventType type)
{
if (subitem == null)
{
return;
}
// Unsubscribe to directories that have been removed
if ((type & Inotify.EventType.Delete) != 0 && (type & Inotify.EventType.IsDirectory) != 0)
{
watch.Unsubscribe();
}
lock (queue.SyncRoot) {
bool found = false;
for (int i = 0; i < queue.Count; i++)
{
Event ev = (Event)queue.Dequeue();
if (ev.Path == path && ev.Subitem == subitem && ev.Srcpath == srcpath)
{
found = true;
ev.Type = (ev.Type | type);
queue.Enqueue(ev);
break;
}
queue.Enqueue(ev);
}
if (!found)
{
queue.Enqueue(new Event(watch, path, subitem, srcpath,
type, -1, Thunderbird.GetFileSize(Path.Combine(path, subitem))));
}
}
}
private void OnInotifyEvent(
Inotify.Watch watch,
string path,
string subitem,
string srcpath,
Inotify.EventType type)
{
// Stop watching if we were deleted
if ((type & Inotify.EventType.DeleteSelf) != 0)
{
watch.Unsubscribe();
return;
}
// We want a directory
if ((type & Inotify.EventType.IsDirectory) == 0)
{
return;
}
// We are only watching one directory, so we only have to check for ToIndex
// as subitem
if (subitem != "ToIndex")
{
return;
}
// We only have to watch for creation of the ToIndex directory here, so that
// the indexing process can be started. The Indexer will automatically clean
// up if the ToIndex diretory is deleted (we still display a status message
// here though)
if ((type & Inotify.EventType.Create) != 0)
{
ExceptionHandlingThread.Start(new ThreadStart(StartWorker));
}
else if ((type & Inotify.EventType.Delete) != 0)
{
Logger.Log.Debug("Stopping the Thunderbird indexing process; ToIndex disappeared");
}
}
/////////////////////////////////////////////////
private void OnInotifyEvent(Inotify.Watch watch,
string path,
string subitem,
string srcpath,
Inotify.EventType type)
{
if (subitem == "")
{
return;
}
if (Path.GetExtension(subitem) != ".xml")
{
return;
}
// We're only handling MovedTo events here.
string file = Path.Combine(path, subitem);
DateTime last_checked = DateTime.MinValue;
FileAttributes attr;
attr = FileAttributesStore.Read(file);
if (attr != null)
{
last_checked = attr.LastWriteTime;
}
foreach (NautilusTools.NautilusMetadata nm in NautilusTools.GetMetadata(file, last_checked))
{
Indexable indexable = GetIndexable(nm);
Scheduler.Task task;
task = this.target_queryable.NewAddTask(indexable);
task.Priority = Scheduler.Priority.Immediate;
ThisScheduler.Add(task);
}
}
/////////////////////////////////////////////////
// Modified/Created event using Inotify
private void OnInotifyEvent(Inotify.Watch watch,
string path,
string subitem,
string srcpath,
Inotify.EventType type)
{
// someone reported that backup files with abcd~
// were being generated
if (subitem == "" || subitem.EndsWith("~"))
{
return;
}
if ((type & Inotify.EventType.CloseWrite) != 0)
{
IndexSingleFeed(Path.Combine(path, subitem));
}
else if ((type & Inotify.EventType.Delete) != 0)
{
Removefeed_file(Path.Combine(path, subitem));
}
}
private void OnInotifyEvent(Inotify.Watch watch,
string path,
string subitem,
string srcpath,
Inotify.EventType type)
{
if (subitem == "")
{
return;
}
if (subitem[0] == '.')
{
string data_file = Path.Combine(path, subitem.Substring(1));
lock (pending_files) {
if (File.Exists(data_file) && !pending_files.Contains(data_file))
{
pending_files.Add(data_file);
IndexFile(new FileInfo(data_file));
}
}
}
else
{
string meta_file = Path.Combine(path, "." + subitem);
string data_file = Path.Combine(path, subitem);
lock (pending_files) {
if (File.Exists(meta_file) && !pending_files.Contains(data_file))
{
pending_files.Add(data_file);
IndexFile(new FileInfo(data_file));
}
}
}
}
/////////////////////////////////////////////////
// Modified/Created event using Inotify
private void OnInotifyEvent(Inotify.Watch watch,
string path,
string subitem,
string srcpath,
Inotify.EventType type)
{
if (subitem == "")
{
return;
}
// Watch konq_cache_dir for new directory creation
// Watch its subdirectories for new file creation
// If any file in created in konq_cache_dir, ignore it
// Its a Konq error otherwise
if ((type & Inotify.EventType.IsDirectory) == 0)
{
IndexSingleFile(Path.Combine(path, subitem));
}
else if ((type & Inotify.EventType.IsDirectory) != 0)
{
Inotify.Subscribe(konq_cache_dir, OnInotifyEvent, Inotify.EventType.CloseWrite);
}
}
private void OnInotifyEvent(Inotify.Watch watch,
string path,
string subitem,
string srcpath,
Inotify.EventType type)
{
bool is_directory;
is_directory = (type & Inotify.EventType.IsDirectory) != 0;
queryable.ReportEventInDirectory(path);
// The case of matched move events
if ((type & Inotify.EventType.MovedTo) != 0 && srcpath != null)
{
queryable.HandleMoveEvent(Path.GetDirectoryName(srcpath),
Path.GetFileName(srcpath),
path, subitem, is_directory);
return;
}
// Then this must be an unmatched moveto
// An unmatched MovedTo is like a create
if ((type & Inotify.EventType.MovedTo) != 0)
{
// Synthesize the appropriate Create event. Note that we could check for the
// IsDirectory event here, but this also shrinks the race window.
if (is_directory)
{
type |= Inotify.EventType.Create;
}
else
{
type |= Inotify.EventType.CloseWrite;
}
Logger.Log.Debug("Synthesizing event on unpaired MoveTo", type);
}
// An unmatched MovedFrom is like a delete
if ((type & Inotify.EventType.MovedFrom) != 0)
{
type |= Inotify.EventType.Delete;
Logger.Log.Debug("Synthesizing event on unpaired MoveFrom", type);
}
if ((type & Inotify.EventType.Delete) != 0)
{
queryable.HandleRemoveEvent(path, subitem, is_directory);
return;
}
if ((type & Inotify.EventType.Create) != 0)
{
if (is_directory)
{
queryable.HandleAddEvent(path, subitem, is_directory);
}
return;
}
if ((type & Inotify.EventType.CloseWrite) != 0)
{
queryable.HandleAddEvent(path, subitem, is_directory);
return;
}
if ((type & Inotify.EventType.Attrib) != 0)
{
queryable.HandleAttribEvent(path, subitem, is_directory);
return;
}
if ((type & Inotify.EventType.QueueOverflow) != 0)
{
Logger.Log.Warn("Inotify queue overflowed: file system is in an unknown state");
queryable.HandleOverflowEvent();
return;
}
}
/**
* inotify callback
*/
private void OnInotifyEvent(Inotify.Watch watch,
string path,
string subitem,
string srcpath,
Inotify.EventType type)
{
if (subitem == "")
{
return;
}
string fullPath = Path.Combine(path, subitem);
// we need to watch for all kinds of events - this is tricky
// Case: new file is created
// - if it is one of the folder_directories, index it
// - if is in one of the mail_directories, index it if it is an mbox file
if ((type & Inotify.EventType.Create) != 0 && (type & Inotify.EventType.IsDirectory) == 0)
{
if (IsMailDir(path))
{
Indexable indexable = MaildirMessageToIndexable(fullPath, false);
AddIndexableTask(indexable, fullPath);
}
else
{
// add mbox file to mbox_files
string mbox = GetMboxFile(path, subitem);
if (mbox != null)
{
mbox_files.Add(mbox);
IndexMbox(mbox, true);
}
}
return;
}
// Case: file is deleted
// - if it is a mail file, we might like it to be deleted
if ((type & Inotify.EventType.MovedFrom) != 0 ||
((type & Inotify.EventType.Delete) != 0 &&
(type & Inotify.EventType.IsDirectory) == 0))
{
if (IsMailDir(path))
{
RemoveMail(fullPath);
}
else if (mbox_files.Contains(fullPath))
{
RemoveMbox(fullPath);
mbox_files.Remove(fullPath);
}
return;
}
// Case: file is moved
// - files are moved from tmp/new to cur
// - need to delete from the source
if ((type & Inotify.EventType.MovedTo) != 0 && (type & Inotify.EventType.IsDirectory) == 0)
{
if (IsMailDir(path))
{
Indexable indexable = MaildirMessageToIndexable(fullPath, false);
AddIndexableTask(indexable, fullPath);
}
if (IsMailDir(srcpath))
{
RemoveMail(srcpath);
}
if (mbox_files.Contains(fullPath))
{
// check if this because of compaction, in which case need to delete previous mbox
if (srcpath != null && srcpath.EndsWith("." + subitem + ".compacted"))
{
RemoveMbox(fullPath);
}
// FIXME need to ensure IndexMbox is scheduled *after* RemoveMbox finishes
// RemoveMbox creates a job with immediate priority while
// IndexMbox creates a job with the default priority of a generator
// Is there a better way to ensure the order ?
IndexMbox(fullPath, true);
}
return;
}
// Case: file is modified i.e. there was no create event but closewrite event
// - possibly some mbox was changed
// FIXME kmail doesnt physically delete the deleted mails from mbox files unless compacted
// - which means one has to read the .index files to find deleted messages...
// - need to find the format of the .index/.index.ids etc files and parse them
if ((type & Inotify.EventType.Modify) != 0 && (type & Inotify.EventType.IsDirectory) == 0)
{
if (mbox_files.Contains(fullPath))
{
IndexMbox(fullPath, false);
}
return;
}
// Case: a directory is created:
// well watch it anyway but also make sure its a maildir directory
// if it a maildir directory, then add it to maildir_dirs
if ((type & Inotify.EventType.Create) != 0 && (type & Inotify.EventType.IsDirectory) != 0)
{
if (!IgnoreFolder(fullPath))
{
Watch(fullPath);
UpdateDirectories(fullPath);
}
return;
}
// Case: if a directory is deleted:
// remove watch
if ((type & Inotify.EventType.Delete) != 0 && (type & Inotify.EventType.IsDirectory) != 0)
{
watch.Unsubscribe();
mail_directories.Remove(fullPath);
folder_directories.Remove(fullPath);
return;
}
// Case: directory is moved
// FIXME: implement renaming of mail folders
}
private void OnInotifyEvent(Inotify.Watch watch,
string path,
string subitem,
string srcpath,
Inotify.EventType type)
{
if (subitem == null)
{
return;
}
string full_path = Path.Combine(path, subitem);
// If prefs.js is deleted... then we have nothing at all to index
if (((type & Inotify.EventType.MovedTo) != 0 && srcpath == Path.Combine(path, "prefs.js")) ||
((type & Inotify.EventType.Delete) != 0 && subitem == "prefs.js"))
{
foreach (TB.Account account in account_list)
{
RemoveAccount(account);
}
return;
}
// Update in case an account was removed or added
// Thunderbird saves prefs.js with a different name and then replacing the old one
// by "moving" it over the existing prefs.js. That's why MoveTo is used as inotfy type.
if ((((type & Inotify.EventType.Modify) != 0 || (type & Inotify.EventType.MovedTo) != 0 ||
(type & Inotify.EventType.Create) != 0) && subitem == "prefs.js"))
{
UpdateAccounts(path);
return;
}
// In case the address book file have been moved or deleted, we have to stop indexing it
if (((type & Inotify.EventType.MovedTo) != 0 && srcpath == Path.Combine(path, "abook.mab")) ||
((type & Inotify.EventType.Delete) != 0 && subitem == "abook.mab"))
{
TB.Account account = GetParentAccount(full_path);
if (account != null)
{
RemoveAccount(account);
}
return;
}
// In case of a newly created addressbook, the current address book is modified or an old
// address book is moved to where the address book can be found: either start indexing
// or restart an already indexing IndeaxbleGenerator.
if ((((type & Inotify.EventType.Modify) != 0 || (type & Inotify.EventType.MovedTo) != 0 ||
(type & Inotify.EventType.Create) != 0) && subitem == "abook.mab"))
{
TB.Account account = GetParentAccount(full_path);
if (account == null && File.Exists(full_path))
{
UpdateAccounts(path);
return;
}
else if (account == null)
{
return;
}
// Tell any running indexable about this or start a new one
if (queryable.ThisScheduler.ContainsByTag(full_path))
{
OnNotification(new NotificationEventArgs(NotificationType.RestartIndexing, account));
}
else
{
IndexFile(full_path);
}
return;
}
// Re-index files when needed
if ((type & Inotify.EventType.Modify) != 0)
{
TB.Account account = GetParentAccount(full_path);
if (account == null || !Thunderbird.IsMorkFile(path, subitem))
{
return;
}
// In case we have a running IndexableGenerator, tell it that we have a file that needs to
// be re-indexed.
if (queryable.ThisScheduler.ContainsByTag(full_path))
{
OnNotification(new NotificationEventArgs(NotificationType.RestartIndexing, account));
}
else
{
IndexFile(full_path);
}
return;
}
// Index newly created directories
if ((type & Inotify.EventType.Create) != 0 && (type & Inotify.EventType.IsDirectory) != 0)
{
if (GetParentAccount(full_path) != null && Inotify.Enabled)
{
Inotify.Subscribe(full_path, OnInotifyEvent, Inotify.EventType.All);
}
return;
}
}
