beagled/BackendDriver.cs

   1 //
   2 // BackendDriver.cs
   3 //
   4 // Copyright (C) 2004-2006 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.Collections.Generic;
  30 using System.IO;
  31 using System.Reflection;
  32 using System.Threading;
  33
  34 using Beagle.Util;
  35
  36 namespace Beagle.Daemon {
  37
  38         public static class BackendDriver {
  39
  40                 // Contains list of backends explicitly asked by --allow-backend or --backend name
  41                 // These backends are exclusive, and the list of allowed backends isn't read from
  42                 // the configuration.
  43                 private static List <string> excl_allowed_backends = new List <string> ();
  44
  45                 // Contains list of disable backends, either from the configuration or through
  46                 // --deny-baceknd or --backend -name.
  47                 private static List <string> denied_backends = new List <string> ();
  48
  49                 public static void OnlyAllow (string name)
  50                 {
  51                         excl_allowed_backends.Add (name.ToLower ());
  52                 }
  53
  54                 public static void Allow (string name)
  55                 {
  56                         ReadBackendsFromConf ();
  57
  58                         denied_backends.Remove (name.ToLower ());
  59                 }
  60
  61                 public static void Deny (string name)
  62                 {
  63                         ReadBackendsFromConf ();
  64
  65                         name = name.ToLower ();
  66                         if (!denied_backends.Contains (name))
  67                                 denied_backends.Add (name);
  68                 }
  69
  70                 private static bool UseBackend (string name)
  71                 {
  72                         name = name.ToLower ();
  73
  74                         // Check if this is an exclusively allowed backend
  75                         if (excl_allowed_backends.Contains (name))
  76                                 return true;
  77
  78                         // If it's not, and we have *any* exclusively allowed
  79                         // backends, then we can't use this backend.
  80                         if (excl_allowed_backends.Count > 0)
  81                                 return false;
  82
  83                         // Next, check to see if we're in the denied backends
  84                         // list.
  85                         if (denied_backends.Contains (name))
  86                                 return false;
  87
  88                         // Otherwise, we're good.
  89                         return true;
  90                 }
  91
  92                 ///////////////////////////////////////////////////////////////
  93
  94                 // Paths to static backends
  95                 private static List <string> static_backend_paths = new List <string> ();
  96
  97                 public static void AddStaticBackendPath (string path)
  98                 {
  99                         if (! static_backend_paths.Contains (path))
 100                                 static_backend_paths.Add (path);
 101                 }
 102
 103                 ///////////////////////////////////////////////////////////////
 104
 105                 private static bool done_reading_conf = false;
 106
 107                 private static void ReadBackendsFromConf ()
 108                 {
 109                         if (done_reading_conf)
 110                                 return;
 111
 112                         done_reading_conf = true;
 113
 114                         // If we have exclusively allowed backends, don't read
 115                         // from our configuration.
 116                         if (excl_allowed_backends.Count > 0)
 117                                 return;
 118
 119                         // To allow static indexes, "static" should be in
 120                         // allowed_backends
 121                         if (Conf.Daemon.AllowStaticBackend)
 122                                 Allow ("static");
 123
 124                         if (Conf.Daemon.DeniedBackends == null)
 125                                 return;
 126
 127                         foreach (string name in Conf.Daemon.DeniedBackends)
 128                                 denied_backends.Add (name.ToLower ());
 129                 }
 130
 131                 ///////////////////////////////////////////////////////////////
 132
 133                 private static List <IBackend> backends = null;
 134
 135                 private static void ScanAssemblyForBackends (Assembly assembly)
 136                 {
 137                         int count = 0;
 138
 139                         foreach (Type type in ReflectionFu.GetTypesFromAssemblyAttribute (assembly, typeof (IBackendTypesAttribute))) {
 140                                 foreach (BackendFlavor flavor in ReflectionFu.ScanTypeForAttribute (type, typeof (BackendFlavor))) {
 141                                         if (! UseBackend (flavor.Name))
 142                                                 continue;
 143
 144                                         IBackend backend = null;
 145
 146                                         try {
 147                                                 backend = Activator.CreateInstance (type) as IBackend;
 148                                         } catch (Exception e) {
 149                                                 Log.Error (e, "Unable to instantiate backend {0}", flavor.Name);
 150                                         }
 151
 152                                         if (backend == null)
 153                                                 continue;
 154
 155                                         backend.Name = flavor.Name;
 156                                         backend.Domain = flavor.Domain;
 157
 158                                         if (backends == null)
 159                                                 backends = new List <IBackend> ();
 160
 161                                         backends.Add (backend);
 162                                         count++;
 163                                 }
 164                         }
 165
 166                         Log.Debug ("Found {0} backends in {1}", count, assembly.Location);
 167                 }
 168
 169                 ///////////////////////////////////////////////////////////////
 170
 171                 // Delay before starting the indexing process
 172
 173                 static int indexing_delay = 60;  // Default to 60 seconds
 174
 175                 public static int IndexingDelay {
 176                         set { indexing_delay = value; }
 177                 }
 178
 179                 ///////////////////////////////////////////////////////////////
 180
 181                 private static ArrayList assemblies = null;
 182
 183                 private static void PopulateAssemblies ()
 184                 {
 185                         if (assemblies != null)
 186                                 return;
 187
 188                         assemblies = ReflectionFu.ScanEnvironmentForAssemblies ("BEAGLE_BACKEND_PATH", PathFinder.BackendDir);
 189
 190                         // Only add the executing assembly if we haven't already loaded it.
 191                         if (assemblies.IndexOf (Assembly.GetExecutingAssembly ()) == -1)
 192                                 assemblies.Add (Assembly.GetExecutingAssembly ());
 193                 }
 194
 195                 public static void Init ()
 196                 {
 197                         ReadBackendsFromConf ();
 198                         PopulateAssemblies ();
 199                 }
 200
 201                 public static void LoadBackends ()
 202                 {
 203                         if (assemblies == null)
 204                                 throw new Exception ("BackendDriver.Init() must be called before BackendDriver.LoadBackends ()");
 205
 206                         foreach (Assembly assembly in assemblies) {
 207                                 ScanAssemblyForBackends (assembly);
 208
 209                                 // This allows backends to define their own
 210                                 // executors.
 211                                 Server.ScanAssemblyForExecutors (assembly);
 212                         }
 213
 214                         // No reason to keep around the assemblies list
 215                         assemblies = null;
 216
 217                         // XXX: Move this into the filter loading code; it makes a lot more sense there
 218                         //ReadKeywordMappings ();
 219
 220                         LoadSystemIndexes ();
 221                 }
 222
 223                 public static void StartBackends ()
 224                 {
 225                         foreach (IBackend backend in backends)
 226                                 Log.Debug (" - {0}", backend.Name);
 227
 228                         if (indexing_delay <= 0 || Environment.GetEnvironmentVariable ("BEAGLE_EXERCISE_THE_DOG") != null)
 229                                 ReallyStartBackends ();
 230                         else {
 231                                 Log.Debug ("Waiting {0} seconds before starting backends", indexing_delay);
 232                                 GLib.Timeout.Add ((uint) indexing_delay * 1000, ReallyStartBackends);
 233                         }
 234                 }
 235
 236                 private static bool ReallyStartBackends ()
 237                 {
 238                         foreach (IBackend backend in backends)
 239                                 backend.Start ();
 240
 241                         return false;
 242                 }
 243
 244                 public static ICollection <IBackend> Backends {
 245                         get {
 246                                 if (backends == null)
 247                                         throw new Exception ("BackendManager.LoadBackends() must be called before accessing BackendManager.Backends");
 248
 249                                 return backends;
 250                         }
 251                 }
 252
 253                 ///////////////////////////////////////////////////////////////
 254
 255                 private static void LoadSystemIndexes ()
 256                 {
 257                         if (! Directory.Exists (PathFinder.SystemIndexesDir))
 258                                 return;
 259
 260                         Log.Info ("Loading system-wide indexes.");
 261
 262                         int count = 0;
 263
 264                         foreach (DirectoryInfo index_dir in new DirectoryInfo (PathFinder.SystemIndexesDir).GetDirectories ()) {
 265                                 if (! UseBackend (index_dir.Name))
 266                                         continue;
 267
 268                                 if (LoadStaticBackend (index_dir, QueryDomain.System))
 269                                         count++;
 270                         }
 271
 272                         Log.Info ("Found {0} system-wide indexes.", count);
 273                 }
 274
 275                 private static void LoadStaticBackends ()
 276                 {
 277                         int count = 0;
 278
 279                         if (UseBackend ("static")) {
 280                                 Log.Info ("Loading user-configured static indexes.");
 281
 282                                 foreach (string path in Conf.Daemon.StaticQueryables)
 283                                         static_backend_paths.Add (path);
 284                         }
 285
 286                         foreach (string path in static_backend_paths) {
 287                                 DirectoryInfo index_dir = new DirectoryInfo (StringFu.SanitizePath (path));
 288
 289                                 if (!index_dir.Exists)
 290                                         continue;
 291
 292                                 // FIXME: QueryDomain might be other than local
 293                                 if (LoadStaticBackend (index_dir, QueryDomain.Local))
 294                                         count++;
 295                         }
 296
 297                         Log.Info ("Found {0} user-configured static indexes.", count);
 298                 }
 299
 300                 // Instantiates and loads a StaticLuceneBackend from an index directory
 301                 private static bool LoadStaticBackend (DirectoryInfo index_dir, QueryDomain query_domain)
 302                 {
 303                         StaticQueryable static_backend = null;
 304
 305                         if (!index_dir.Exists)
 306                                 return false;
 307
 308                         try {
 309                                 static_backend = new StaticQueryable (index_dir.FullName);
 310                         } catch (InvalidOperationException) {
 311                                 Logger.Log.Warn ("Unable to create read-only index (likely due to index version mismatch): {0}", index_dir.FullName);
 312                                 return false;
 313                         } catch (Exception e) {
 314                                 Logger.Log.Error (e, "Caught exception while instantiating static queryable: {0}", index_dir.Name);
 315                                 return false;
 316                         }
 317
 318                         if (static_backend != null) {
 319                                 static_backend.Name = index_dir.Name;
 320                                 static_backend.Domain = query_domain;
 321
 322                                 backends.Add (static_backend);
 323
 324                                 return true;
 325                         }
 326
 327                         return false;
 328                 }
 329
 330                 ///////////////////////////////////////////////////////////////
 331
 332                 static public IBackend GetBackend (string name)
 333                 {
 334                         foreach (IBackend backend in backends) {
 335                                 if (name == backend.Name)
 336                                         return backend;
 337                         }
 338
 339                         return null;
 340                 }
 341
 342                 ///////////////////////////////////////////////////////////////
 343
 344                 static public string ListBackends ()
 345                 {
 346                         string ret = "User:\n";
 347
 348                         PopulateAssemblies ();
 349
 350                         foreach (Assembly assembly in assemblies) {
 351                                 foreach (Type type in ReflectionFu.GetTypesFromAssemblyAttribute (assembly, typeof (IBackendTypesAttribute))) {
 352                                         foreach (BackendFlavor flavor in ReflectionFu.ScanTypeForAttribute (type, typeof (BackendFlavor)))
 353                                                 ret += String.Format (" - {0}\n", flavor.Name);
 354                                 }
 355                         }
 356
 357                         if (!Directory.Exists (PathFinder.SystemIndexesDir))
 358                                 return ret;
 359
 360                         ret += "System:\n";
 361                         foreach (DirectoryInfo index_dir in new DirectoryInfo (PathFinder.SystemIndexesDir).GetDirectories ()) {
 362                                 ret += String.Format (" - {0}\n", index_dir.Name);
 363                         }
 364
 365                         return ret;
 366                 }
 367         }
 368 }