UrkLogQueryable.cs

   1 using System;
   2 using System.Collections;
   3 using System.IO;
   4 using System.Text;
   5 using System.Threading;
   6
   7 using Beagle.Daemon;
   8 using Beagle.Util;
   9
  10 namespace Beagle.Daemon.UrkLogQueryable {
  11
  12     [QueryableFlavor (Name="UrkLog", Domain=QueryDomain.Local, RequireInotify=false)]
  13     public class UrkLogQueryable : LuceneFileQueryable {
  14
  15         private static Logger log = Logger.Get ("UrkLogQueryable");
  16
  17         private string config_dir, log_dir, icons_dir;
  18
  19         private int polling_interval_in_seconds = 60;
  20
  21         //private GaimBuddyListReader list = new GaimBuddyListReader ();
  22
  23         public UrkLogQueryable () : base ("UrkLogIndex")
  24         {
  25             config_dir = Path.Combine (PathFinder.HomeDir, ".urk");
  26             log_dir = Path.Combine (config_dir, "logs");
  27             icons_dir = Path.Combine (config_dir, "icons");
  28         }
  29
  30         /////////////////////////////////////////////////
  31
  32         private void StartWorker()
  33         {
  34             if (! Directory.Exists (log_dir)) {
  35                 GLib.Timeout.Add (60000, new GLib.TimeoutHandler (CheckForExistence));
  36                 return;
  37             }
  38
  39             log.Info ("Starting urk log backend");
  40
  41             Stopwatch stopwatch = new Stopwatch ();
  42             stopwatch.Start ();
  43
  44             State = QueryableState.Crawling;
  45             Crawl ();
  46             State = QueryableState.Idle;
  47
  48             if (!Inotify.Enabled) {
  49                 Scheduler.Task task = Scheduler.TaskFromHook (new Scheduler.TaskHook (CrawlHook));
  50                 task.Tag = "Crawling ~/.urk/logs to find new logfiles";
  51                 task.Source = this;
  52                 ThisScheduler.Add (task);
  53             }
  54
  55             stopwatch.Stop ();
  56
  57             log.Info ("urk log backend worker thread done in {0}", stopwatch);
  58         }
  59
  60         public override void Start ()
  61         {
  62             base.Start ();
  63
  64             ExceptionHandlingThread.Start (new ThreadStart (StartWorker));
  65         }
  66
  67         /////////////////////////////////////////////////
  68
  69         private void CrawlHook (Scheduler.Task task)
  70         {
  71             Crawl ();
  72             task.Reschedule = true;
  73             task.TriggerTime = DateTime.Now.AddSeconds (polling_interval_in_seconds);
  74         }
  75
  76         private void Crawl ()
  77         {
  78             Inotify.Subscribe (log_dir, OnInotifyNewProtocol, Inotify.EventType.Create);
  79
  80             // Walk through protocol subdirs
  81             foreach (string proto_dir in DirectoryWalker.GetDirectories (log_dir))
  82                 CrawlProtocolDirectory (proto_dir);
  83         }
  84
  85         private void CrawlNetworkDirectory (string proto_dir)
  86         {
  87             Inotify.Subscribe (proto_dir, OnInotifyNewTarget, Inotify.EventType.Create);
  88
  89             // Walk through accounts
  90             foreach (string account_dir in DirectoryWalker.GetDirectories (proto_dir))
  91                 CrawlTargetDirectory (account_dir);
  92         }
  93
  94         private void CrawlTargetDirectory (string account_dir)
  95         {
  96             Inotify.Subscribe (account_dir, OnInotifyNewRemote, Inotify.EventType.Create);
  97
  98             // Walk through remote user conversations
  99             foreach (string remote_dir in DirectoryWalker.GetDirectories (account_dir))
 100                 CrawlRemoteDirectory (remote_dir);
 101         }
 102
 103         private void CrawlRemoteDirectory (string remote_dir)
 104         {
 105             Inotify.Subscribe (remote_dir, OnInotifyNewConversation, Inotify.EventType.CloseWrite);
 106
 107             foreach (FileInfo file in DirectoryWalker.GetFileInfos (remote_dir))
 108                 if (FileIsInteresting (file.Name))
 109                     IndexLog (file.FullName, Scheduler.Priority.Delayed);
 110         }
 111
 112         /////////////////////////////////////////////////
 113
 114         private bool CheckForExistence ()
 115         {
 116             if (!Directory.Exists (log_dir))
 117                 return true;
 118
 119             this.Start ();
 120
 121             return false;
 122         }
 123
 124         private bool FileIsInteresting (string filename)
 125         {
 126             // Filename must be fixed length, see below
 127             if (filename.Length < 21 || filename.Length > 22)
 128                 return false;
 129
 130             // Check match on regex: ^[0-9]{4}-[0-9]{2}-[0-9]{2}\\.[0-9]{6}\\.(txt|html)$
 131             // e.g. 2005-07-22.161521.txt
 132             // We'd use System.Text.RegularExpressions if they werent so much more expensive
 133             return Char.IsDigit (filename [0]) && Char.IsDigit (filename [1])
 134                 && Char.IsDigit (filename [2]) && Char.IsDigit (filename [3])
 135                 && filename [4] == '-'
 136                 && Char.IsDigit (filename [5]) && Char.IsDigit (filename [6])
 137                 && filename [7] == '-'
 138                 && Char.IsDigit (filename [8]) && Char.IsDigit (filename [9])
 139                 && filename [10] == '.'
 140                 && Char.IsDigit (filename [11]) && Char.IsDigit (filename [12])
 141                 && Char.IsDigit (filename [13]) && Char.IsDigit (filename [14])
 142                 && Char.IsDigit (filename [15]) && Char.IsDigit (filename [16])
 143                 && filename [17] == '.'
 144                 &&  (    (filename [18] == 't' && filename [19] == 'x' && filename [20] == 't')
 145                     ||    (filename [18] == 'h' && filename [19] == 't' && filename [20] == 'm' && filename [21] == 'l')
 146                     );
 147         }
 148
 149         /////////////////////////////////////////////////
 150
 151         private void OnInotifyNewNetwork (Inotify.Watch watch,
 152                         string path, string subitem, string srcpath,
 153                         Inotify.EventType type)
 154         {
 155             if (subitem.Length == 0 || (type & Inotify.EventType.IsDirectory) == 0)
 156                 return;
 157
 158             CrawlNetworkDirectory (Path.Combine (path, subitem));
 159         }
 160
 161         private void OnInotifyNewTarget (Inotify.Watch watch,
 162                         string path, string subitem, string srcpath,
 163                         Inotify.EventType type)
 164         {
 165             if (subitem.Length == 0 || (type & Inotify.EventType.IsDirectory) == 0)
 166                 return;
 167
 168             CrawlTargetDirectory (Path.Combine (path, subitem));
 169         }
 170
 171         private void OnInotifyNewRemote (Inotify.Watch watch,
 172                         string path, string subitem, string srcpath,
 173                         Inotify.EventType type)
 174         {
 175             if (subitem.Length == 0 || (type & Inotify.EventType.IsDirectory) == 0)
 176                 return;
 177
 178             CrawlRemoteDirectory (Path.Combine (path, subitem));
 179         }
 180
 181         private void OnInotifyNewConversation (Inotify.Watch watch,
 182                         string path, string subitem, string srcpath,
 183                         Inotify.EventType type)
 184         {
 185             if (subitem.Length == 0 || (type & Inotify.EventType.IsDirectory) != 0)
 186                 return;
 187
 188             if (FileIsInteresting (subitem))
 189                 IndexLog (Path.Combine (path, subitem), Scheduler.Priority.Immediate);
 190         }
 191
 192         /////////////////////////////////////////////////
 193
 194         private static Indexable IRCLogToIndexable (string filename)
 195         {
 196             Uri uri = UriFu.PathToFileUri (filename);
 197             Indexable indexable = new Indexable (uri);
 198             indexable.ContentUri = uri;
 199             indexable.Timestamp = File.GetLastWriteTimeUtc (filename);
 200             indexable.MimeType = GaimLog.MimeType; // XXX
 201             indexable.HitType = "IRCLog";
 202             indexable.CacheContent = false;
 203
 204             return indexable;
 205         }
 206
 207         private void IndexLog (string filename, Scheduler.Priority priority)
 208         {
 209             if (! File.Exists (filename))
 210                 return;
 211
 212             if (IsUpToDate (filename))
 213                 return;
 214
 215             Indexable indexable = IRCLogToIndexable (filename);
 216             Scheduler.Task task = NewAddTask (indexable);
 217             task.Priority = priority;
 218             task.SubPriority = 0;
 219             ThisScheduler.Add (task);
 220         }
 221
 222         override protected double RelevancyMultiplier (Hit hit)
 223         {
 224             return HalfLifeMultiplierFromProperty (hit, 0.25,
 225                                    "fixme:endtime", "fixme:starttime");
 226         }
 227
 228         override protected bool HitFilter (Hit hit)
 229         {
 230             /*ImBuddy buddy = list.Search (hit ["fixme:speakingto"]);
 231
 232             if (buddy != null) {
 233                 if (buddy.Alias != "")
 234                     hit ["fixme:speakingto_alias"] = buddy.Alias;
 235
 236                 //if (buddy.BuddyIconLocation != "")
 237                 //  hit ["fixme:speakingto_icon"] = Path.Combine (icons_dir, buddy.BuddyIconLocation);
 238             }*/
 239
 240             return true;
 241         }
 242
 243     }
 244 }
 245