LCOV - code coverage report
Current view: top level - tests/harness - backendmanager.cc (source / functions) Hit Total Coverage
Test: Test Coverage for xapian-core 7028d852e609 Lines: 65 94 69.1 %
Date: 2019-02-17 14:59:59 Functions: 14 23 60.9 %
Branches: 49 140 35.0 %

           Branch data     Line data    Source code
       1                 :            : /** @file backendmanager.cc
       2                 :            :  * @brief manage backends for testsuite
       3                 :            :  */
       4                 :            : /* Copyright 1999,2000,2001 BrightStation PLC
       5                 :            :  * Copyright 2002 Ananova Ltd
       6                 :            :  * Copyright 2002,2003,2004,2005,2006,2007,2008,2009,2010,2011,2012,2013,2016,2017,2018 Olly Betts
       7                 :            :  *
       8                 :            :  * This program is free software; you can redistribute it and/or
       9                 :            :  * modify it under the terms of the GNU General Public License as
      10                 :            :  * published by the Free Software Foundation; either version 2 of the
      11                 :            :  * License, or (at your option) any later version.
      12                 :            :  *
      13                 :            :  * This program is distributed in the hope that it will be useful,
      14                 :            :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      15                 :            :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      16                 :            :  * GNU General Public License for more details.
      17                 :            :  *
      18                 :            :  * You should have received a copy of the GNU General Public License
      19                 :            :  * along with this program; if not, write to the Free Software
      20                 :            :  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301
      21                 :            :  * USA
      22                 :            :  */
      23                 :            : 
      24                 :            : #include <config.h>
      25                 :            : 
      26                 :            : #include <xapian.h>
      27                 :            : 
      28                 :            : #ifdef HAVE_VALGRIND
      29                 :            : # include <valgrind/memcheck.h>
      30                 :            : #endif
      31                 :            : 
      32                 :            : #include <cerrno>
      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 "filetests.h"
      42                 :            : #include "index_utils.h"
      43                 :            : #include "backendmanager.h"
      44                 :            : #include "unixcmds.h"
      45                 :            : 
      46                 :            : using namespace std;
      47                 :            : 
      48                 :            : [[noreturn]]
      49                 :            : static void
      50                 :          0 : invalid_operation(const char* msg)
      51                 :            : {
      52 [ #  # ][ #  # ]:          0 :     throw Xapian::InvalidOperationError(msg);
                 [ #  # ]
      53                 :            : }
      54                 :            : 
      55                 :            : void
      56                 :        713 : BackendManager::index_files_to_database(Xapian::WritableDatabase & database,
      57                 :            :                                         const vector<string> & files)
      58                 :            : {
      59         [ +  - ]:        713 :     FileIndexer(datadir, files).index_to(database);
      60                 :        713 : }
      61                 :            : 
      62                 :            : /** Create the directory dirname if needed.  Returns true if the
      63                 :            :  *  directory was created and false if it was already there.  Throws
      64                 :            :  *  an exception if there was an error (eg not a directory).
      65                 :            :  */
      66                 :            : bool
      67                 :        299 : BackendManager::create_dir_if_needed(const string &dirname)
      68                 :            : {
      69         [ +  + ]:        299 :     if (mkdir(dirname.c_str(), 0700) == 0) {
      70                 :          4 :         return true;
      71                 :            :     }
      72                 :            : 
      73                 :        295 :     int mkdir_errno = errno;
      74         [ +  - ]:        295 :     if (mkdir_errno == EEXIST) {
      75                 :            :         // Something exists at dirname, but we need to check if it is a directory.
      76         [ +  - ]:        295 :         if (dir_exists(dirname)) {
      77                 :        295 :             return false;
      78                 :            :         }
      79                 :            :     }
      80                 :            : 
      81                 :            :     throw Xapian::DatabaseOpeningError("Failed to create directory",
      82 [ #  # ][ #  # ]:        299 :                                        mkdir_errno);
      83                 :            : }
      84                 :            : 
      85         [ -  + ]:         38 : BackendManager::~BackendManager() { }
      86                 :            : 
      87                 :            : std::string
      88                 :          2 : BackendManager::get_dbtype() const
      89                 :            : {
      90         [ +  - ]:          2 :     return "none";
      91                 :            : }
      92                 :            : 
      93                 :            : string
      94                 :          0 : BackendManager::do_get_database_path(const vector<string> &)
      95                 :            : {
      96                 :          0 :     invalid_operation("Path isn't meaningful for this database type");
      97                 :            : }
      98                 :            : 
      99                 :            : Xapian::Database
     100                 :       1099 : BackendManager::do_get_database(const vector<string> & files)
     101                 :            : {
     102         [ +  - ]:       1099 :     return Xapian::Database(do_get_database_path(files));
     103                 :            : }
     104                 :            : 
     105                 :            : Xapian::Database
     106                 :         53 : BackendManager::get_database(const vector<string> & files)
     107                 :            : {
     108                 :         53 :     return do_get_database(files);
     109                 :            : }
     110                 :            : 
     111                 :            : Xapian::Database
     112                 :       1822 : BackendManager::get_database(const string & file)
     113                 :            : {
     114 [ +  - ][ +  - ]:       1822 :     return do_get_database(vector<string>(1, file));
     115                 :            : }
     116                 :            : 
     117                 :            : Xapian::Database
     118                 :         68 : BackendManager::get_database(const std::string &dbname,
     119                 :            :                              void (*gen)(Xapian::WritableDatabase&,
     120                 :            :                                          const std::string &),
     121                 :            :                              const std::string &arg)
     122                 :            : {
     123         [ +  - ]:         68 :     string dbleaf = "db__";
     124         [ +  - ]:         68 :     dbleaf += dbname;
     125         [ +  - ]:        136 :     const string& path = get_generated_database_path(dbleaf);
     126         [ +  + ]:         68 :     if (path.empty()) {
     127                 :            :         // InMemory doesn't have a path but we want to support generated
     128                 :            :         // databases for it.
     129         [ +  - ]:         22 :         Xapian::WritableDatabase wdb = get_writable_database(path, path);
     130         [ +  - ]:         22 :         gen(wdb, arg);
     131 [ +  - ][ #  # ]:         22 :         return std::move(wdb);
     132                 :            :     }
     133                 :            : 
     134         [ +  + ]:         46 :     if (path_exists(path)) {
     135                 :            :         try {
     136         [ +  - ]:         10 :             return Xapian::Database(path);
     137                 :          0 :         } catch (const Xapian::DatabaseOpeningError &) {
     138                 :            :         }
     139                 :            :     }
     140         [ +  - ]:         36 :     rm_rf(path);
     141                 :            : 
     142         [ +  - ]:         72 :     string tmp_dbleaf(dbleaf);
     143         [ +  - ]:         36 :     tmp_dbleaf += '~';
     144         [ +  - ]:         72 :     string tmp_path(path);
     145         [ +  - ]:         36 :     tmp_path += '~';
     146                 :            : 
     147                 :            :     {
     148                 :            :         Xapian::WritableDatabase wdb = get_writable_database(tmp_dbleaf,
     149 [ +  - ][ +  - ]:         36 :                                                              string());
     150         [ +  - ]:         36 :         gen(wdb, arg);
     151                 :            :     }
     152                 :         36 :     rename(tmp_path.c_str(), path.c_str());
     153                 :            :     // For multi, the shards will use the temporary name, but that's not really
     154                 :            :     // a problem.
     155                 :            : 
     156         [ +  - ]:        104 :     return Xapian::Database(path);
     157                 :            : }
     158                 :            : 
     159                 :            : std::string
     160                 :         22 : BackendManager::get_database_path(const std::string &dbname,
     161                 :            :                                   void (*gen)(Xapian::WritableDatabase&,
     162                 :            :                                               const std::string &),
     163                 :            :                                   const std::string &arg)
     164                 :            : {
     165 [ +  - ][ #  # ]:         22 :     string dbleaf = "db__";
     166         [ +  - ]:         22 :     dbleaf += dbname;
     167         [ +  - ]:         44 :     const string & path = get_generated_database_path(dbleaf);
     168         [ +  + ]:         22 :     if (path_exists(path)) {
     169                 :            :         try {
     170         [ +  - ]:          4 :             (void)Xapian::Database(path);
     171         [ +  - ]:          4 :             return path;
     172                 :          0 :         } catch (const Xapian::DatabaseOpeningError &) {
     173                 :            :         }
     174                 :            :     }
     175         [ +  - ]:         18 :     rm_rf(path);
     176                 :            : 
     177         [ +  - ]:         36 :     string tmp_dbleaf(dbleaf);
     178         [ +  - ]:         18 :     tmp_dbleaf += '~';
     179         [ +  - ]:         36 :     string tmp_path(path);
     180         [ +  - ]:         18 :     tmp_path += '~';
     181                 :            : 
     182                 :            :     {
     183                 :            :         Xapian::WritableDatabase wdb = get_writable_database(tmp_dbleaf,
     184 [ +  - ][ +  - ]:         18 :                                                              string());
     185         [ +  - ]:         18 :         gen(wdb, arg);
     186                 :            :     }
     187                 :         18 :     rename(tmp_path.c_str(), path.c_str());
     188                 :            : 
     189         [ +  - ]:         40 :     return path;
     190                 :            : }
     191                 :            : 
     192                 :            : string
     193                 :        508 : BackendManager::get_database_path(const vector<string> & files)
     194                 :            : {
     195                 :        508 :     return do_get_database_path(files);
     196                 :            : }
     197                 :            : 
     198                 :            : string
     199                 :         57 : BackendManager::get_database_path(const string & file)
     200                 :            : {
     201 [ +  - ][ +  - ]:         57 :     return do_get_database_path(vector<string>(1, file));
     202                 :            : }
     203                 :            : 
     204                 :            : Xapian::WritableDatabase
     205                 :          0 : BackendManager::get_writable_database(const string &, const string &)
     206                 :            : {
     207                 :          0 :     invalid_operation("Attempted to open a disabled database");
     208                 :            : }
     209                 :            : 
     210                 :            : string
     211                 :          0 : BackendManager::get_writable_database_path(const std::string &)
     212                 :            : {
     213                 :          0 :     invalid_operation("Path isn't meaningful for this database type");
     214                 :            : }
     215                 :            : 
     216                 :            : string
     217                 :          0 : BackendManager::get_compaction_output_path(const std::string&)
     218                 :            : {
     219                 :          0 :     invalid_operation("Compaction not supported for this database type");
     220                 :            : }
     221                 :            : 
     222                 :            : string
     223                 :          0 : BackendManager::get_generated_database_path(const std::string &)
     224                 :            : {
     225                 :            :     invalid_operation("Generated databases aren't supported for this database "
     226                 :          0 :                       "type");
     227                 :            : }
     228                 :            : 
     229                 :            : Xapian::Database
     230                 :          0 : BackendManager::get_remote_database(const vector<string> &, unsigned int)
     231                 :            : {
     232                 :            :     string msg = "BackendManager::get_remote_database() called for non-remote "
     233         [ #  # ]:          0 :                  "database (type is ";
     234 [ #  # ][ #  # ]:          0 :     msg += get_dbtype();
     235         [ #  # ]:          0 :     msg += ')';
     236 [ #  # ][ #  # ]:          0 :     throw Xapian::InvalidOperationError(msg);
     237                 :            : }
     238                 :            : 
     239                 :            : Xapian::Database
     240                 :         25 : BackendManager::get_writable_database_as_database()
     241                 :            : {
     242         [ +  - ]:         25 :     return Xapian::Database(get_writable_database_path_again());
     243                 :            : }
     244                 :            : 
     245                 :            : Xapian::WritableDatabase
     246                 :          0 : BackendManager::get_writable_database_again()
     247                 :            : {
     248         [ #  # ]:          0 :     string msg = "Backend ";
     249 [ #  # ][ #  # ]:          0 :     msg += get_dbtype();
     250         [ #  # ]:          0 :     msg += " doesn't support get_writable_database_again()";
     251 [ #  # ][ #  # ]:          0 :     throw Xapian::InvalidOperationError(msg);
     252                 :            : }
     253                 :            : 
     254                 :            : string
     255                 :          0 : BackendManager::get_writable_database_path_again()
     256                 :            : {
     257         [ #  # ]:          0 :     string msg = "Backend ";
     258 [ #  # ][ #  # ]:          0 :     msg += get_dbtype();
     259         [ #  # ]:          0 :     msg += " doesn't support get_writable_database_path_again()";
     260 [ #  # ][ #  # ]:          0 :     throw Xapian::InvalidOperationError(msg);
     261                 :            : }
     262                 :            : 
     263                 :            : void
     264                 :       4078 : BackendManager::clean_up()
     265                 :            : {
     266                 :       4078 : }
     267                 :            : 
     268                 :            : const char *
     269                 :          4 : BackendManager::get_xapian_progsrv_command()
     270                 :            : {
     271                 :            : #ifdef HAVE_VALGRIND
     272                 :            :     if (RUNNING_ON_VALGRIND) {
     273                 :            :         return "./runsrv " XAPIAN_PROGSRV;
     274                 :            :     }
     275                 :            : #endif
     276                 :          4 :     return XAPIAN_PROGSRV;
     277                 :            : }

Generated by: LCOV version 1.11