beagled/FilterFactory.cs

   1 //
   2 // FilterFactory.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
  32 using System.Xml;
  33 using System.Xml.Serialization;
  34
  35 using Beagle.Util;
  36
  37 namespace Beagle.Daemon {
  38
  39         public class FilterFactory {
  40
  41                 static private bool Debug = false;
  42
  43                 static FilterFactory ()
  44                 {
  45                         ReflectionFu.ScanEnvironmentForAssemblies ("BEAGLE_FILTER_PATH", PathFinder.FilterDir,
  46                                                                    delegate (Assembly a) {
  47                                                                            int n = ScanAssemblyForFilters (a);
  48                                                                            Logger.Log.Debug ("Loaded {0} filter{1} from {2}",
  49                                                                                              n, n == 1 ? "" : "s", a.Location);
  50                                                                    });
  51                 }
  52
  53                 /////////////////////////////////////////////////////////////////////////
  54
  55
  56                 static private ICollection CreateFilters (Uri uri, string extension, string mime_type)
  57                 {
  58                         Hashtable matched_filters_by_flavor = FilterFlavor.NewHashtable ();
  59
  60                         foreach (FilterFlavor flavor in filter_types_by_flavor.Keys) {
  61                                 if (flavor.IsMatch (uri, extension, mime_type)) {
  62                                         Filter matched_filter = null;
  63
  64                                         try {
  65                                                 matched_filter = (Filter) Activator.CreateInstance ((Type) filter_types_by_flavor [flavor]);
  66
  67                                                 if (flavor.MimeType != null)
  68                                                         matched_filter.MimeType = flavor.MimeType;
  69                                                 if (flavor.Extension != null)
  70                                                         matched_filter.Extension = flavor.Extension;
  71
  72                                         } catch (Exception e) {
  73                                                 continue;
  74                                         }
  75                                         matched_filters_by_flavor [flavor] = matched_filter;
  76                                 }
  77                         }
  78
  79                         if (Debug) {
  80                                 foreach (DictionaryEntry entry in matched_filters_by_flavor) {
  81                                         FilterFlavor flav = (FilterFlavor) entry.Key;
  82                                         Filter filter = (Filter) entry.Value;
  83
  84                                         Logger.Log.Debug ("Found matching filter: {0}, Weight: {1}", filter, flav.Weight);
  85                                 }
  86                         }
  87
  88                         return matched_filters_by_flavor.Values;
  89                 }
  90
  91                 static public int GetFilterVersion (string filter_name)
  92                 {
  93                         if (filter_versions_by_name.Contains (filter_name)) {
  94                                 return (int) filter_versions_by_name [filter_name];
  95                         } else {
  96                                 return -1;
  97                         }
  98                 }
  99
 100                 /////////////////////////////////////////////////////////////////////////
 101
 102                 static public ICollection CreateFiltersFromMimeType (string mime_type)
 103                 {
 104                         return CreateFilters (null, null, mime_type);
 105                 }
 106
 107                 static public ICollection CreateFilterFromExtension (string extension)
 108                 {
 109                         return CreateFilters (null, extension, null);
 110                 }
 111
 112                 static public ICollection CreateFiltersFromPath (string path)
 113                 {
 114                         string guessed_mime_type = XdgMime.GetMimeType (path);
 115                         string extension = Path.GetExtension (path);
 116                         return CreateFilters (UriFu.PathToFileUri (path), extension, guessed_mime_type);
 117                 }
 118
 119                 static public ICollection CreateFiltersFromUri (Uri uri)
 120                 {
 121                         if (uri.IsFile)
 122                                 return CreateFiltersFromPath (uri.LocalPath);
 123                         else
 124                                 return CreateFilters (uri, null, null);
 125                 }
 126
 127                 static public ICollection CreateFiltersFromIndexable (Indexable indexable)
 128                 {
 129                         string path = indexable.ContentUri.LocalPath;
 130                         string extension = Path.GetExtension (path);
 131                         string mime_type = indexable.MimeType;
 132                         return CreateFilters (UriFu.PathToFileUri (path), extension, mime_type);
 133                 }
 134
 135                 /////////////////////////////////////////////////////////////////////////
 136
 137                 static private bool ShouldWeFilterThis (Indexable indexable)
 138                 {
 139                         if (indexable.Filtering == IndexableFiltering.Never
 140                             || indexable.NoContent)
 141                                 return false;
 142
 143                         if (indexable.Filtering == IndexableFiltering.Always)
 144                                 return true;
 145
 146                         // Our default behavior is to try to filter non-transient file
 147                         // indexable and indexables with a specific mime type attached.
 148                         if (indexable.IsNonTransient || indexable.MimeType != null)
 149                                 return true;
 150
 151                         return false;
 152                 }
 153
 154                 static public bool FilterIndexable (Indexable indexable, TextCache text_cache, out Filter filter)
 155                 {
 156                         filter = null;
 157                         ICollection filters = null;
 158
 159                         if (indexable.Filtering == IndexableFiltering.AlreadyFiltered)
 160                                 return false;
 161
 162                         if (! ShouldWeFilterThis (indexable)) {
 163                                 indexable.NoContent = true;
 164                                 return false;
 165                         }
 166
 167                         string path = null;
 168
 169                         // First, figure out which filter we should use to deal with
 170                         // the indexable.
 171
 172                         // If a specific mime type is specified, try to index as that type.
 173                         if (indexable.MimeType != null)
 174                                 filters = CreateFiltersFromMimeType (indexable.MimeType);
 175
 176                         if (indexable.ContentUri.IsFile) {
 177                                 path = indexable.ContentUri.LocalPath;
 178
 179                                 // Otherwise sniff the mime-type from the file
 180                                 if (indexable.MimeType == null)
 181                                         indexable.MimeType = XdgMime.GetMimeType (path);
 182
 183                                 if (filters == null || filters.Count == 0) {
 184                                         filters = CreateFiltersFromIndexable (indexable);
 185                                 }
 186
 187                                 if (Directory.Exists (path)) {
 188                                         indexable.MimeType = "inode/directory";
 189                                         indexable.NoContent = true;
 190                                         if (! indexable.ValidTimestamp && indexable.IsNonTransient)
 191                                                 indexable.Timestamp = Directory.GetLastWriteTimeUtc (path);
 192                                 } else if (File.Exists (path)) {
 193                                         // Set the timestamp to the best possible estimate (if no timestamp was set by the backend)
 194                                         if (! indexable.ValidTimestamp && indexable.IsNonTransient)
 195                                                 indexable.Timestamp = File.GetLastWriteTimeUtc (path);
 196                                 } else {
 197                                         Logger.Log.Warn ("No such file: {0}", path);
 198                                         return false;
 199                                 }
 200                         }
 201
 202                         // We don't know how to filter this, so there is nothing else to do.
 203                         if (filters.Count == 0) {
 204                                 if (! indexable.NoContent) {
 205                                         indexable.NoContent = true;
 206
 207                                         Logger.Log.Debug ("No filter for {0} ({1}) [{2}]", indexable.DisplayUri, path, indexable.MimeType);
 208                                         return false;
 209                                 }
 210
 211                                 return true;
 212                         }
 213
 214                         foreach (Filter candidate_filter in filters) {
 215                                 if (Debug)
 216                                         Logger.Log.Debug ("Testing filter: {0}", candidate_filter);
 217
 218                                 // Hook up the snippet writer.
 219                                 if (candidate_filter.SnippetMode && text_cache != null) {
 220                                         if (candidate_filter.OriginalIsText && indexable.IsNonTransient) {
 221                                                 text_cache.MarkAsSelfCached (indexable.Uri);
 222                                         } else if (indexable.CacheContent) {
 223                                                 TextWriter writer = text_cache.GetWriter (indexable.Uri);
 224                                                 candidate_filter.AttachSnippetWriter (writer);
 225                                         }
 226                                 }
 227
 228                                 if (indexable.Crawled)
 229                                         candidate_filter.EnableCrawlMode ();
 230
 231                                 // Set the filter's URIs
 232                                 candidate_filter.Uri = indexable.Uri;
 233                                 candidate_filter.DisplayUri = indexable.DisplayUri;
 234
 235                                 // allow the filter access to the indexable's properties
 236                                 candidate_filter.IndexableProperties = indexable.Properties;
 237
 238                                 // Open the filter, copy the file's properties to the indexable,
 239                                 // and hook up the TextReaders.
 240
 241                                 bool succesful_open = false;
 242                                 TextReader text_reader;
 243                                 Stream binary_stream;
 244
 245                                 if (path != null)
 246                                         succesful_open = candidate_filter.Open (path);
 247                                 else if ((text_reader = indexable.GetTextReader ()) != null)
 248                                         succesful_open = candidate_filter.Open (text_reader);
 249                                 else if ((binary_stream = indexable.GetBinaryStream ()) != null)
 250                                         succesful_open = candidate_filter.Open (binary_stream);
 251
 252                                 if (succesful_open) {
 253                                         if (candidate_filter.Timestamp != DateTime.MinValue)
 254                                                 indexable.Timestamp = candidate_filter.Timestamp;
 255                                         foreach (Property prop in candidate_filter.Properties)
 256                                                 indexable.AddProperty (prop);
 257                                         indexable.SetTextReader (candidate_filter.GetTextReader ());
 258                                         indexable.SetHotTextReader (candidate_filter.GetHotTextReader ());
 259
 260                                         if (Debug)
 261                                                 Logger.Log.Debug ("Successfully filtered {0} with {1}", path, candidate_filter);
 262
 263                                         filter = candidate_filter;
 264                                         return true;
 265                                 } else if (Debug) {
 266                                         Logger.Log.Debug ("Unsuccessfully filtered {0} with {1}, falling back", path, candidate_filter);
 267                                         candidate_filter.Cleanup ();
 268                                 }
 269                         }
 270
 271                         if (Debug)
 272                                 Logger.Log.Debug ("None of the matching filters could process the file: {0}", path);
 273
 274                         return false;
 275                 }
 276
 277                 static public bool FilterIndexable (Indexable indexable, out Filter filter)
 278                 {
 279                         return FilterIndexable (indexable, null, out filter);
 280                 }
 281
 282                 static public bool FilterIndexable (Indexable indexable)
 283                 {
 284                         Filter filter = null;
 285
 286                         return FilterIndexable (indexable, null, out filter);
 287                 }
 288
 289                 /////////////////////////////////////////////////////////////////////////
 290
 291                 private static Hashtable filter_types_by_flavor = new Hashtable ();
 292                 private static Hashtable filter_versions_by_name = new Hashtable ();
 293
 294                 static private int ScanAssemblyForFilters (Assembly assembly)
 295                 {
 296                         int count = 0;
 297
 298                         foreach (Type t in ReflectionFu.GetTypesFromAssemblyAttribute (assembly, typeof (FilterTypesAttribute))) {
 299                                 Filter filter = null;
 300
 301                                 try {
 302                                         filter = (Filter) Activator.CreateInstance (t);
 303                                 } catch (Exception ex) {
 304                                         Logger.Log.Error (ex, "Caught exception while instantiating {0}", t);
 305                                 }
 306
 307                                 if (filter == null)
 308                                         continue;
 309
 310                                 filter_versions_by_name [t.ToString ()] = filter.Version;
 311
 312                                 foreach (FilterFlavor flavor in filter.SupportedFlavors) {
 313                                         filter_types_by_flavor [flavor] = t;
 314                                         FilterFlavor.Flavors.Add (flavor);
 315                                 }
 316
 317                                 ++count;
 318                         }
 319
 320                         return count;
 321                 }
 322
 323         }
 324
 325         /////////////////////////////////////////////////////////////////////////
 326
 327         public class FilteredStatus
 328         {
 329                 private Uri uri;
 330                 private string filter_name;
 331                 private int filter_version;
 332
 333                 [XmlIgnore]
 334                 public Uri Uri {
 335                         get { return uri; }
 336                         set { uri = value; }
 337                 }
 338
 339                 [XmlAttribute ("Uri")]
 340                 public string UriAsString {
 341                         get {
 342                                 return UriFu.UriToEscapedString (uri);
 343                         }
 344
 345                         set {
 346                                 uri = UriFu.EscapedStringToUri (value);
 347                         }
 348                 }
 349
 350                 public string FilterName {
 351                         get { return filter_name; }
 352                         set { filter_name = value; }
 353                 }
 354
 355                 public int FilterVersion {
 356                         get { return filter_version; }
 357                         set { filter_version = value; }
 358                 }
 359
 360                 public static FilteredStatus New (Indexable indexable, Filter filter)
 361                 {
 362                         FilteredStatus status = new FilteredStatus ();
 363
 364                         status.Uri = indexable.Uri;
 365                         status.FilterName = filter.GetType ().ToString ();
 366                         status.FilterVersion = filter.Version;
 367
 368                         return status;
 369                 }
 370         }
 371 }