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