xapian-core/tests/harness/backendmanager.cc

   1 /* backendmanager.cc: manage backends for testsuite
   2  *
   3  * Copyright 1999,2000,2001 BrightStation PLC
   4  * Copyright 2002 Ananova Ltd
   5  * Copyright 2002,2003,2004,2005,2006,2007,2008,2009,2010,2011,2012,2013,2016 Olly Betts
   6  *
   7  * This program is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License as
   9  * published by the Free Software Foundation; either version 2 of the
  10  * License, or (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301
  20  * USA
  21  */
  22
  23 #include <config.h>
  24
  25 #include <xapian.h>
  26
  27 #ifdef HAVE_VALGRIND
  28 # include <valgrind/memcheck.h>
  29 #endif
  30
  31 #include "safeerrno.h"
  32
  33 #include <cstdio>
  34 #include <fstream>
  35 #include <string>
  36 #include <vector>
  37
  38 #include <sys/types.h>
  39 #include "safesysstat.h"
  40
  41 #include "index_utils.h"
  42 #include "backendmanager.h"
  43 #include "unixcmds.h"
  44
  45 using namespace std;
  46
  47 void
  48 BackendManager::index_files_to_database(Xapian::WritableDatabase & database,
  49                                         const vector<string> & files)
  50 {
  51     FileIndexer(datadir, files).index_to(database);
  52 }
  53
  54 /** Create the directory dirname if needed.  Returns true if the
  55  *  directory was created and false if it was already there.  Throws
  56  *  an exception if there was an error (eg not a directory).
  57  */
  58 bool
  59 BackendManager::create_dir_if_needed(const string &dirname)
  60 {
  61     // create a directory if not present
  62     struct stat sbuf;
  63     int result = stat(dirname.c_str(), &sbuf);
  64     if (result < 0) {
  65         if (errno != ENOENT)
  66             throw Xapian::DatabaseOpeningError("Can't stat directory");
  67         if (mkdir(dirname.c_str(), 0700) < 0)
  68             throw Xapian::DatabaseOpeningError("Can't create directory");
  69         return true; // Successfully created a directory.
  70     }
  71     if (!S_ISDIR(sbuf.st_mode))
  72         throw Xapian::DatabaseOpeningError("Is not a directory.");
  73     return false; // Already a directory.
  74 }
  75
  76 #ifdef XAPIAN_HAS_INMEMORY_BACKEND
  77 Xapian::WritableDatabase
  78 BackendManager::getwritedb_inmemory(const vector<string> &files)
  79 {
  80     Xapian::WritableDatabase db(string(), Xapian::DB_BACKEND_INMEMORY);
  81     index_files_to_database(db, files);
  82     return db;
  83 }
  84 #endif
  85
  86 #ifdef XAPIAN_HAS_GLASS_BACKEND
  87 string
  88 BackendManager::createdb_glass(const vector<string> &files)
  89 {
  90     string parent_dir = ".glass";
  91     create_dir_if_needed(parent_dir);
  92
  93     string dbdir = parent_dir + "/db";
  94     for (vector<string>::const_iterator i = files.begin();
  95          i != files.end(); ++i) {
  96         dbdir += '=';
  97         dbdir += *i;
  98     }
  99     // If the database is readonly, we can reuse it if it exists.
 100     if (create_dir_if_needed(dbdir)) {
 101         // Directory was created, so do the indexing.
 102         Xapian::WritableDatabase db(dbdir,
 103                 Xapian::DB_CREATE|Xapian::DB_BACKEND_GLASS, 2048);
 104         index_files_to_database(db, files);
 105         db.commit();
 106     }
 107     return dbdir;
 108 }
 109
 110 Xapian::WritableDatabase
 111 BackendManager::getwritedb_glass(const string & name,
 112                                  const vector<string> & files)
 113 {
 114     string dbdir = getwritedb_glass_path(name);
 115
 116     // For a writable database we need to start afresh each time.
 117     rm_rf(dbdir);
 118     (void)create_dir_if_needed(dbdir);
 119
 120     // directory was created, so do the indexing.
 121     Xapian::WritableDatabase db(dbdir,
 122             Xapian::DB_CREATE|Xapian::DB_BACKEND_GLASS, 2048);
 123     index_files_to_database(db, files);
 124     return db;
 125 }
 126
 127 std::string
 128 BackendManager::getwritedb_glass_path(const string & name)
 129 {
 130     string parent_dir = ".glass";
 131     create_dir_if_needed(parent_dir);
 132
 133     string dbdir = parent_dir;
 134     dbdir += '/';
 135     dbdir += name;
 136     return dbdir;
 137 }
 138 #endif
 139
 140 #ifdef XAPIAN_HAS_CHERT_BACKEND
 141 string
 142 BackendManager::createdb_chert(const vector<string> &files)
 143 {
 144     string parent_dir = ".chert";
 145     create_dir_if_needed(parent_dir);
 146
 147     string dbdir = parent_dir + "/db";
 148     for (vector<string>::const_iterator i = files.begin();
 149          i != files.end(); ++i) {
 150         dbdir += '=';
 151         dbdir += *i;
 152     }
 153     // If the database is readonly, we can reuse it if it exists.
 154     if (create_dir_if_needed(dbdir)) {
 155         // Directory was created, so do the indexing.
 156         Xapian::WritableDatabase db(dbdir,
 157                 Xapian::DB_CREATE|Xapian::DB_BACKEND_CHERT, 2048);
 158         index_files_to_database(db, files);
 159         db.commit();
 160     }
 161     return dbdir;
 162 }
 163
 164 Xapian::WritableDatabase
 165 BackendManager::getwritedb_chert(const string & name,
 166                                  const vector<string> & files)
 167 {
 168     string dbdir = getwritedb_chert_path(name);
 169
 170     // For a writable database we need to start afresh each time.
 171     rm_rf(dbdir);
 172     (void)create_dir_if_needed(dbdir);
 173
 174     // directory was created, so do the indexing.
 175     Xapian::WritableDatabase db(dbdir,
 176             Xapian::DB_CREATE|Xapian::DB_BACKEND_CHERT, 2048);
 177     index_files_to_database(db, files);
 178     return db;
 179 }
 180
 181 std::string
 182 BackendManager::getwritedb_chert_path(const string & name)
 183 {
 184     string parent_dir = ".chert";
 185     create_dir_if_needed(parent_dir);
 186
 187     string dbdir = parent_dir;
 188     dbdir += '/';
 189     dbdir += name;
 190     return dbdir;
 191 }
 192
 193 #endif
 194
 195 BackendManager::~BackendManager() { }
 196
 197 std::string
 198 BackendManager::get_dbtype() const
 199 {
 200     return "none";
 201 }
 202
 203 string
 204 BackendManager::do_get_database_path(const vector<string> &)
 205 {
 206     throw Xapian::InvalidArgumentError("Path isn't meaningful for this database type");
 207 }
 208
 209 Xapian::Database
 210 BackendManager::do_get_database(const vector<string> & files)
 211 {
 212     return Xapian::Database(do_get_database_path(files));
 213 }
 214
 215 Xapian::Database
 216 BackendManager::get_database(const vector<string> & files)
 217 {
 218     return do_get_database(files);
 219 }
 220
 221 Xapian::Database
 222 BackendManager::get_database(const string & file)
 223 {
 224     return do_get_database(vector<string>(1, file));
 225 }
 226
 227 Xapian::Database
 228 BackendManager::get_database(const std::string &dbname,
 229                              void (*gen)(Xapian::WritableDatabase&,
 230                                          const std::string &),
 231                              const std::string &arg)
 232 {
 233     string dbleaf = "db__";
 234     dbleaf += dbname;
 235     const string & path = get_writable_database_path(dbleaf);
 236     try {
 237         return Xapian::Database(path);
 238     } catch (const Xapian::DatabaseOpeningError &) {
 239     }
 240     rm_rf(path);
 241
 242     string tmp_dbleaf(dbleaf);
 243     tmp_dbleaf += '~';
 244     string tmp_path(path);
 245     tmp_path += '~';
 246
 247     {
 248         Xapian::WritableDatabase wdb = get_writable_database(tmp_dbleaf,
 249                                                              string());
 250         gen(wdb, arg);
 251     }
 252     rename(tmp_path.c_str(), path.c_str());
 253
 254     return Xapian::Database(path);
 255 }
 256
 257 std::string
 258 BackendManager::get_database_path(const std::string &dbname,
 259                                   void (*gen)(Xapian::WritableDatabase&,
 260                                               const std::string &),
 261                                   const std::string &arg)
 262 {
 263     string dbleaf = "db__";
 264     dbleaf += dbname;
 265     const string & path = get_writable_database_path(dbleaf);
 266     try {
 267         (void)Xapian::Database(path);
 268         return path;
 269     } catch (const Xapian::DatabaseOpeningError &) {
 270     }
 271     rm_rf(path);
 272
 273     string tmp_dbleaf(dbleaf);
 274     tmp_dbleaf += '~';
 275     string tmp_path(path);
 276     tmp_path += '~';
 277
 278     {
 279         Xapian::WritableDatabase wdb = get_writable_database(tmp_dbleaf,
 280                                                              string());
 281         gen(wdb, arg);
 282     }
 283     rename(tmp_path.c_str(), path.c_str());
 284
 285     return path;
 286 }
 287
 288 string
 289 BackendManager::get_database_path(const vector<string> & files)
 290 {
 291     return do_get_database_path(files);
 292 }
 293
 294 string
 295 BackendManager::get_database_path(const string & file)
 296 {
 297     return do_get_database_path(vector<string>(1, file));
 298 }
 299
 300 Xapian::WritableDatabase
 301 BackendManager::get_writable_database(const string &, const string &)
 302 {
 303     throw Xapian::InvalidArgumentError("Attempted to open a disabled database");
 304 }
 305
 306 string
 307 BackendManager::get_writable_database_path(const std::string &)
 308 {
 309     throw Xapian::InvalidArgumentError("Path isn't meaningful for this database type");
 310 }
 311
 312 Xapian::Database
 313 BackendManager::get_remote_database(const vector<string> &, unsigned int)
 314 {
 315     string msg = "BackendManager::get_remote_database() called for non-remote database (type is ";
 316     msg += get_dbtype();
 317     msg += ')';
 318     throw Xapian::InvalidOperationError(msg);
 319 }
 320
 321 Xapian::Database
 322 BackendManager::get_writable_database_as_database()
 323 {
 324     string msg = "Backend ";
 325     msg += get_dbtype();
 326     msg += " doesn't support get_writable_database_as_database()";
 327     throw Xapian::InvalidOperationError(msg);
 328 }
 329
 330 Xapian::WritableDatabase
 331 BackendManager::get_writable_database_again()
 332 {
 333     string msg = "Backend ";
 334     msg += get_dbtype();
 335     msg += " doesn't support get_writable_database_again()";
 336     throw Xapian::InvalidOperationError(msg);
 337 }
 338
 339 void
 340 BackendManager::clean_up()
 341 {
 342 }
 343
 344 const char *
 345 BackendManager::get_xapian_progsrv_command()
 346 {
 347 #ifdef HAVE_VALGRIND
 348     if (RUNNING_ON_VALGRIND) {
 349         return "./runsrv " XAPIAN_PROGSRV;
 350     }
 351 #endif
 352     return XAPIAN_PROGSRV;
 353 }