beagled/BlamQueryable/BlamQueryable.cs

   1 //
   2 // BlamQueryable.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.IO;
  29 using System.Collections;
  30 using System.Threading;
  31
  32 using System.Xml;
  33 using System.Xml.Serialization;
  34
  35 using Beagle.Daemon;
  36 using Beagle.Util;
  37
  38 namespace Beagle.Daemon.BlamQueryable {
  39
  40         [QueryableFlavor (Name="Blam", Domain=QueryDomain.Local, RequireInotify=false)]
  41         public class BlamQueryable : LuceneFileQueryable, IIndexableGenerator {
  42
  43                 private static Logger log = Logger.Get ("BlamQueryable");
  44
  45                 string blam_dir;
  46                 FileInfo blam_file;
  47
  48                 public BlamQueryable () : base ("BlamIndex")
  49                 {
  50                         blam_dir = Path.Combine (Path.Combine (PathFinder.HomeDir, ".gnome2"), "blam");
  51                         blam_file = new FileInfo (Path.Combine (blam_dir, "collection.xml"));
  52                 }
  53
  54                 /////////////////////////////////////////////////
  55
  56                 public override void Start ()
  57                 {
  58                         base.Start ();
  59
  60                         ExceptionHandlingThread.Start (new ThreadStart (StartWorker));
  61                 }
  62
  63                 private void StartWorker ()
  64                 {
  65                         if (!Directory.Exists (blam_dir)) {
  66                                 GLib.Timeout.Add (60000, new GLib.TimeoutHandler (CheckForExistence));
  67                                 return;
  68                         }
  69
  70                         if (Inotify.Enabled) {
  71                                 Inotify.EventType mask = Inotify.EventType.CloseWrite;
  72                                 Inotify.Subscribe (blam_dir, OnInotifyEvent, mask);
  73                         } else {
  74                                 FileSystemWatcher fsw = new FileSystemWatcher ();
  75                                 fsw.Path = blam_dir;
  76                                 fsw.Filter = blam_file.Name;
  77
  78                                 fsw.Changed += new FileSystemEventHandler (OnChangedEvent);
  79                                 fsw.Created += new FileSystemEventHandler (OnChangedEvent);
  80
  81                                 fsw.EnableRaisingEvents = true;
  82                         }
  83
  84                         if (File.Exists (blam_file.FullName))
  85                                 Index ();
  86                 }
  87
  88                 private bool CheckForExistence ()
  89                 {
  90                         if (!Directory.Exists (blam_dir))
  91                                 return true;
  92
  93                         this.Start ();
  94
  95                         return false;
  96                 }
  97
  98                 /////////////////////////////////////////////////
  99
 100                 // Modified event using Inotify
 101                 private void OnInotifyEvent (Inotify.Watch watch,
 102                                              string path,
 103                                              string subitem,
 104                                              string srcpath,
 105                                              Inotify.EventType type)
 106                 {
 107                         if (subitem != blam_file.Name)
 108                                 return;
 109
 110                         Index ();
 111                 }
 112
 113                 // Modified/Created event using FSW
 114                 private void OnChangedEvent (object o, FileSystemEventArgs args)
 115                 {
 116                         Index ();
 117                 }
 118
 119                 /////////////////////////////////////////////////
 120
 121                 private void Index ()
 122                 {
 123                         log.Debug ("Creating blam indexable generator");
 124                         Scheduler.Task task = NewAddTask (this);
 125                         task.Tag = "Blam";
 126                         ThisScheduler.Add (task);
 127                 }
 128
 129                 /////////////////////////////////////////////////
 130
 131                 // IIndexableGenerator implementation
 132
 133                 private ChannelCollection collection = null;
 134                 private IEnumerator channel_enumerator = null;
 135                 private IEnumerator item_enumerator = null;
 136
 137                 public Indexable GetNextIndexable ()
 138                 {
 139                         Channel channel = (Channel) this.channel_enumerator.Current;
 140                         Item item = (Item) this.item_enumerator.Current;
 141
 142                         Uri uri = new Uri (String.Format ("feed:{0};item={1}", channel.Url, item.Id));
 143
 144                         Indexable indexable = new Indexable (uri);
 145                         indexable.ParentUri = UriFu.PathToFileUri (blam_file.FullName);
 146                         indexable.MimeType = "text/html";
 147                         indexable.Type = "FeedItem";
 148                         indexable.Timestamp = item.PubDate;
 149
 150                         indexable.AddProperty (Property.New ("dc:title", item.Title));
 151                         indexable.AddProperty (Property.New ("fixme:author", item.Author));
 152                         indexable.AddProperty (Property.NewDate ("fixme:published", item.PubDate));
 153                         indexable.AddProperty (Property.NewKeyword ("fixme:itemuri", item.Link));
 154                         indexable.AddProperty (Property.NewKeyword ("fixme:webloguri", channel.Url));
 155
 156                         string img = null;
 157                         int i = item.Text.IndexOf ("<img src=\"");
 158                         if (i != -1) {
 159                                 i += "<img src=\"".Length;
 160                                 int j = item.Text.IndexOf ("\"", i);
 161                                 if (j != -1)
 162                                         img = item.Text.Substring (i, j-i);
 163                         }
 164
 165                         if (img != null) {
 166                                 string path = Path.Combine (Path.Combine (blam_dir, "Cache"),
 167                                                             img.GetHashCode ().ToString ());
 168                                 indexable.AddProperty (Property.NewUnsearched ("fixme:cachedimg", path));
 169                         }
 170
 171                         StringReader reader = new StringReader (item.Text);
 172                         indexable.SetTextReader (reader);
 173
 174                         return indexable;
 175                 }
 176
 177                 public bool HasNextIndexable ()
 178                 {
 179                         if (this.collection == null) {
 180                                 if (IsUpToDate (blam_file.FullName))
 181                                         return false;
 182
 183                                 try {
 184                                         this.collection = ChannelCollection.LoadFromFile (blam_file.FullName);
 185                                 } catch (Exception e) {
 186                                         log.Warn ("Could not open Blam! channel list: " + e);
 187                                         return false;
 188                                 }
 189
 190                                 if (this.collection.Channels == null || this.collection.Channels.Count == 0) {
 191                                         this.collection = null;
 192                                         return false;
 193                                 }
 194
 195                                 this.channel_enumerator = this.collection.Channels.GetEnumerator ();
 196                         }
 197
 198                         while (this.item_enumerator == null || !this.item_enumerator.MoveNext ()) {
 199                                 Channel channel;
 200
 201                                 do {
 202                                         if (!this.channel_enumerator.MoveNext ()) {
 203                                                 this.collection = null;
 204                                                 this.channel_enumerator = null;
 205                                                 return false;
 206                                         }
 207
 208                                         channel = (Channel) this.channel_enumerator.Current;
 209                                 } while (channel.Items == null || channel.Items.Count == 0);
 210
 211                                 this.item_enumerator = channel.Items.GetEnumerator ();
 212                         }
 213
 214                         return true;
 215                 }
 216
 217                 public string StatusName {
 218                         get { return null; }
 219                 }
 220         }
 221
 222         /////////////////////////////////////////////////
 223
 224         // Classes from Blam! sources for deserialization
 225
 226         public class ChannelCollection {
 227
 228                 private ArrayList mChannels;
 229
 230                 [XmlElement ("Channel", typeof (Channel))]
 231                 public ArrayList Channels {
 232                         get { return mChannels; }
 233                         set { mChannels = value; }
 234                 }
 235
 236                 public static ChannelCollection LoadFromFile (string filename)
 237                 {
 238                         XmlSerializer serializer = new XmlSerializer (typeof (ChannelCollection));
 239                         ChannelCollection collection;
 240
 241                         Stream stream = new FileStream (filename,
 242                                                         FileMode.Open,
 243                                                         FileAccess.Read,
 244                                                         FileShare.ReadWrite);
 245                         XmlTextReader reader = new XmlTextReader (stream);
 246
 247                         collection = (ChannelCollection) serializer.Deserialize (reader);
 248                         reader.Close ();
 249                         stream.Close ();
 250
 251                         return collection;
 252                 }
 253         }
 254
 255         public class Channel
 256         {
 257                 [XmlAttribute] public string Name = "";
 258                 [XmlAttribute] public string Url = "";
 259
 260                 [XmlAttribute] public string LastModified = "";
 261                 [XmlAttribute] public string ETag = "";
 262
 263                 ArrayList mItems;
 264
 265                 [XmlElement ("Item", typeof (Item))]
 266                 public ArrayList Items {
 267                         get { return mItems; }
 268                         set { mItems = value; }
 269                 }
 270         }
 271
 272         public class Item
 273         {
 274                 [XmlAttribute] public string   Id = "";
 275                 [XmlAttribute] public bool     Unread = true;
 276                 [XmlAttribute] public string   Title = "";
 277                 [XmlAttribute] public string   Text = "";
 278                 [XmlAttribute] public string   Link = "";
 279                 [XmlAttribute] public DateTime PubDate;
 280                 [XmlAttribute] public string   Author = "";
 281         }
 282 }