LCOV - code coverage report
Current view: top level - net - remoteserver.h (source / functions) Hit Total Coverage
Test: Test Coverage for xapian-core 7028d852e609 Lines: 5 5 100.0 %
Date: 2019-02-17 14:59:59 Functions: 2 2 100.0 %
Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /** @file remoteserver.h
       2                 :            :  *  @brief Xapian remote backend server base class
       3                 :            :  */
       4                 :            : /* Copyright (C) 2006,2007,2008,2009,2010,2014,2017 Olly Betts
       5                 :            :  * Copyright (C) 2007,2009,2010 Lemur Consulting Ltd
       6                 :            :  *
       7                 :            :  * This program is free software; you can redistribute it and/or modify
       8                 :            :  * it under the terms of the GNU General Public License as published by
       9                 :            :  * the Free Software Foundation; either version 2 of the License, or
      10                 :            :  * (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 USA
      20                 :            :  */
      21                 :            : 
      22                 :            : #ifndef XAPIAN_INCLUDED_REMOTESERVER_H
      23                 :            : #define XAPIAN_INCLUDED_REMOTESERVER_H
      24                 :            : 
      25                 :            : #include "xapian/database.h"
      26                 :            : #include "xapian/postingsource.h"
      27                 :            : #include "xapian/registry.h"
      28                 :            : #include "xapian/visibility.h"
      29                 :            : #include "xapian/weight.h"
      30                 :            : 
      31                 :            : #include "remoteconnection.h"
      32                 :            : 
      33                 :            : #include <string>
      34                 :            : 
      35                 :            : /** Remote backend server base class. */
      36                 :            : class XAPIAN_VISIBILITY_DEFAULT RemoteServer : private RemoteConnection {
      37                 :            :     /// Don't allow assignment.
      38                 :            :     void operator=(const RemoteServer &);
      39                 :            : 
      40                 :            :     /// Don't allow copying.
      41                 :            :     RemoteServer(const RemoteServer &);
      42                 :            : 
      43                 :            :     /** The database we're using.
      44                 :            :      *
      45                 :            :      *  If we're writable, this is the same as wdb.
      46                 :            :      */
      47                 :            :     Xapian::Database * db;
      48                 :            : 
      49                 :            :     /// The WritableDatabase we're using, or NULL if we're read-only.
      50                 :            :     Xapian::WritableDatabase * wdb;
      51                 :            : 
      52                 :            :     /// Do we support writing?
      53                 :            :     bool writable;
      54                 :            : 
      55                 :            :     /** Timeout for actions during a conversation.
      56                 :            :      *
      57                 :            :      *  The timeout is specified in seconds.  If the timeout is exceeded then a
      58                 :            :      *  Xapian::NetworkTimeoutError is thrown.
      59                 :            :      */
      60                 :            :     double active_timeout;
      61                 :            : 
      62                 :            :     /** Timeout while waiting for a new action from the client.
      63                 :            :      *
      64                 :            :      *  The timeout is specified in seconds.  If the timeout is exceeded then a
      65                 :            :      *  Xapian::NetworkTimeoutError is thrown.
      66                 :            :      */
      67                 :            :     double idle_timeout;
      68                 :            : 
      69                 :            :     /// The registry, which allows unserialisation of user subclasses.
      70                 :            :     Xapian::Registry reg;
      71                 :            : 
      72                 :            :     /// Accept a message from the client.
      73                 :            :     XAPIAN_VISIBILITY_INTERNAL
      74                 :            :     message_type get_message(double timeout, std::string & result,
      75                 :            :                              message_type required_type = MSG_MAX);
      76                 :            : 
      77                 :            :     /// Send a message to the client.
      78                 :            :     XAPIAN_VISIBILITY_INTERNAL
      79                 :            :     void send_message(reply_type type, const std::string &message);
      80                 :            : 
      81                 :            :     /// Send a message to the client, with specific end_time.
      82                 :            :     XAPIAN_VISIBILITY_INTERNAL
      83                 :          2 :     void send_message(reply_type type, const std::string &message,
      84                 :            :                       double end_time) {
      85                 :          2 :         unsigned char type_as_char = static_cast<unsigned char>(type);
      86                 :          2 :         RemoteConnection::send_message(type_as_char, message, end_time);
      87                 :          2 :     }
      88                 :            : 
      89                 :            :     // all terms
      90                 :            :     XAPIAN_VISIBILITY_INTERNAL
      91                 :            :     void msg_allterms(const std::string & message);
      92                 :            : 
      93                 :            :     // get document
      94                 :            :     XAPIAN_VISIBILITY_INTERNAL
      95                 :            :     void msg_document(const std::string & message);
      96                 :            : 
      97                 :            :     // term exists?
      98                 :            :     XAPIAN_VISIBILITY_INTERNAL
      99                 :            :     void msg_termexists(const std::string & message);
     100                 :            : 
     101                 :            :     // get collection freq
     102                 :            :     XAPIAN_VISIBILITY_INTERNAL
     103                 :            :     void msg_collfreq(const std::string & message);
     104                 :            : 
     105                 :            :     // get termfreq
     106                 :            :     XAPIAN_VISIBILITY_INTERNAL
     107                 :            :     void msg_termfreq(const std::string & message);
     108                 :            : 
     109                 :            :     // get termfreq and collection freq
     110                 :            :     XAPIAN_VISIBILITY_INTERNAL
     111                 :            :     void msg_freqs(const std::string & message);
     112                 :            : 
     113                 :            :     // get value statistics
     114                 :            :     XAPIAN_VISIBILITY_INTERNAL
     115                 :            :     void msg_valuestats(const std::string & message);
     116                 :            : 
     117                 :            :     // keep alive
     118                 :            :     XAPIAN_VISIBILITY_INTERNAL
     119                 :            :     void msg_keepalive(const std::string & message);
     120                 :            : 
     121                 :            :     // get doclength
     122                 :            :     XAPIAN_VISIBILITY_INTERNAL
     123                 :            :     void msg_doclength(const std::string & message);
     124                 :            : 
     125                 :            :     // set the query; return the mset
     126                 :            :     XAPIAN_VISIBILITY_INTERNAL
     127                 :            :     void msg_query(const std::string & message);
     128                 :            : 
     129                 :            :     // get termlist
     130                 :            :     XAPIAN_VISIBILITY_INTERNAL
     131                 :            :     void msg_termlist(const std::string & message);
     132                 :            : 
     133                 :            :     // get postlist
     134                 :            :     XAPIAN_VISIBILITY_INTERNAL
     135                 :            :     void msg_postlist(const std::string & message);
     136                 :            : 
     137                 :            :     // get positionlist
     138                 :            :     XAPIAN_VISIBILITY_INTERNAL
     139                 :            :     void msg_positionlist(const std::string &message);
     140                 :            : 
     141                 :            :     // get positionlist count
     142                 :            :     XAPIAN_VISIBILITY_INTERNAL
     143                 :            :     void msg_positionlistcount(const std::string &message);
     144                 :            : 
     145                 :            :     // get write access
     146                 :            :     XAPIAN_VISIBILITY_INTERNAL
     147                 :            :     void msg_writeaccess(const std::string & message);
     148                 :            : 
     149                 :            :     // reopen
     150                 :            :     XAPIAN_VISIBILITY_INTERNAL
     151                 :            :     void msg_reopen(const std::string & message);
     152                 :            : 
     153                 :            :     // get updated doccount and avlength
     154                 :            :     XAPIAN_VISIBILITY_INTERNAL
     155                 :            :     void msg_update(const std::string &message);
     156                 :            : 
     157                 :            :     // commit
     158                 :            :     XAPIAN_VISIBILITY_INTERNAL
     159                 :            :     void msg_commit(const std::string & message);
     160                 :            : 
     161                 :            :     // cancel
     162                 :            :     XAPIAN_VISIBILITY_INTERNAL
     163                 :            :     void msg_cancel(const std::string &message);
     164                 :            : 
     165                 :            :     // add document
     166                 :            :     XAPIAN_VISIBILITY_INTERNAL
     167                 :            :     void msg_adddocument(const std::string & message);
     168                 :            : 
     169                 :            :     // delete document
     170                 :            :     XAPIAN_VISIBILITY_INTERNAL
     171                 :            :     void msg_deletedocument(const std::string & message);
     172                 :            : 
     173                 :            :     // delete document with unique term
     174                 :            :     XAPIAN_VISIBILITY_INTERNAL
     175                 :            :     void msg_deletedocumentterm(const std::string & message);
     176                 :            : 
     177                 :            :     // replace document
     178                 :            :     XAPIAN_VISIBILITY_INTERNAL
     179                 :            :     void msg_replacedocument(const std::string & message);
     180                 :            : 
     181                 :            :     // replace document with unique term
     182                 :            :     XAPIAN_VISIBILITY_INTERNAL
     183                 :            :     void msg_replacedocumentterm(const std::string & message);
     184                 :            : 
     185                 :            :     // get metadata
     186                 :            :     XAPIAN_VISIBILITY_INTERNAL
     187                 :            :     void msg_getmetadata(const std::string & message);
     188                 :            : 
     189                 :            :     // read metadata key list
     190                 :            :     XAPIAN_VISIBILITY_INTERNAL
     191                 :            :     void msg_metadatakeylist(const std::string & message);
     192                 :            : 
     193                 :            :     // set metadata
     194                 :            :     XAPIAN_VISIBILITY_INTERNAL
     195                 :            :     void msg_setmetadata(const std::string & message);
     196                 :            : 
     197                 :            :     // add a spelling
     198                 :            :     XAPIAN_VISIBILITY_INTERNAL
     199                 :            :     void msg_addspelling(const std::string & message);
     200                 :            : 
     201                 :            :     // remove a spelling
     202                 :            :     XAPIAN_VISIBILITY_INTERNAL
     203                 :            :     void msg_removespelling(const std::string & message);
     204                 :            : 
     205                 :            :     // get number of unique terms
     206                 :            :     XAPIAN_VISIBILITY_INTERNAL
     207                 :            :     void msg_uniqueterms(const std::string & message);
     208                 :            : 
     209                 :            :   public:
     210                 :            :     /** Construct a RemoteServer.
     211                 :            :      *
     212                 :            :      *  @param dbpaths  The paths to the Xapian databases to use.
     213                 :            :      *  @param fdin     The file descriptor to read from.
     214                 :            :      *  @param fdout    The file descriptor to write to (fdin and fdout may be
     215                 :            :      *                  the same).
     216                 :            :      *  @param active_timeout_  Timeout for actions during a conversation
     217                 :            :      *                  (specified in seconds).
     218                 :            :      *  @param idle_timeout_    Timeout while waiting for a new action from
     219                 :            :      *                  the client (specified in seconds).
     220                 :            :      *  @param writable Should the database be opened for writing?
     221                 :            :      */
     222                 :            :     RemoteServer(const std::vector<std::string> &dbpaths,
     223                 :            :                  int fdin, int fdout,
     224                 :            :                  double active_timeout_,
     225                 :            :                  double idle_timeout_,
     226                 :            :                  bool writable = false);
     227                 :            : 
     228                 :            :     /// Destructor.
     229                 :            :     ~RemoteServer();
     230                 :            : 
     231                 :            :     /** Repeatedly accept messages from the client and process them.
     232                 :            :      *
     233                 :            :      *  The loop continues until either the connection is closed, or a
     234                 :            :      *  non-Xapian exception is thrown.
     235                 :            :      */
     236                 :            :     void run();
     237                 :            : 
     238                 :            :     /// Get the registry used for (un)serialisation.
     239                 :            :     const Xapian::Registry & get_registry() const { return reg; }
     240                 :            : 
     241                 :            :     /// Set the registry used for (un)serialisation.
     242                 :        700 :     void set_registry(const Xapian::Registry & reg_) { reg = reg_; }
     243                 :            : };
     244                 :            : 
     245                 :            : #endif // XAPIAN_INCLUDED_REMOTESERVER_H

Generated by: LCOV version 1.11