remoteserver.h

Go to the documentation of this file.

 
/* Copyright (C) 2006-2024 Olly Betts
 * Copyright (C) 2007,2009,2010 Lemur Consulting Ltd
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see
 * <https://www.gnu.org/licenses/>.
 */
 
#ifndef XAPIAN_INCLUDED_REMOTESERVER_H
#define XAPIAN_INCLUDED_REMOTESERVER_H
 
#include "xapian/database.h"
#include "xapian/postingsource.h"
#include "xapian/registry.h"
#include "xapian/visibility.h"
#include "xapian/weight.h"
 
#include "remoteconnection.h"
 
#include <string>
 
class XAPIAN_VISIBILITY_DEFAULT RemoteServer : private RemoteConnection {
    void operator=(const RemoteServer &);
 
    RemoteServer(const RemoteServer &);
 
    Xapian::Database* db = nullptr;
 
    Xapian::WritableDatabase* wdb = nullptr;
 
    bool writable;
 
    double active_timeout;
 
    double idle_timeout;
 
    Xapian::Registry reg;
 
    XAPIAN_VISIBILITY_INTERNAL
    message_type get_message(double timeout, std::string & result,
                             message_type required_type = MSG_MAX);
 
    XAPIAN_VISIBILITY_INTERNAL
    void send_message(reply_type type, std::string_view message);
 
    XAPIAN_VISIBILITY_INTERNAL
    void send_message(reply_type type, std::string_view message,
                      double end_time) {
        unsigned char type_as_char = static_cast<unsigned char>(type);
        RemoteConnection::send_message(type_as_char, message, end_time);
    }
 
    // all terms
    XAPIAN_VISIBILITY_INTERNAL
    void msg_allterms(const std::string & message);
 
    // get document
    XAPIAN_VISIBILITY_INTERNAL
    void msg_document(const std::string & message);
 
    // term exists?
    XAPIAN_VISIBILITY_INTERNAL
    void msg_termexists(const std::string & message);
 
    // get collection freq
    XAPIAN_VISIBILITY_INTERNAL
    void msg_collfreq(const std::string & message);
 
    // get termfreq
    XAPIAN_VISIBILITY_INTERNAL
    void msg_termfreq(const std::string & message);
 
    // get termfreq and collection freq
    XAPIAN_VISIBILITY_INTERNAL
    void msg_freqs(const std::string & message);
 
    // get value statistics
    XAPIAN_VISIBILITY_INTERNAL
    void msg_valuestats(const std::string & message);
 
    // keep alive
    XAPIAN_VISIBILITY_INTERNAL
    void msg_keepalive(const std::string & message);
 
    // get doclength
    XAPIAN_VISIBILITY_INTERNAL
    void msg_doclength(const std::string & message);
 
    // set the query; return the mset
    XAPIAN_VISIBILITY_INTERNAL
    void msg_query(const std::string & message);
 
    // get termlist
    XAPIAN_VISIBILITY_INTERNAL
    void msg_termlist(const std::string & message);
 
    // get postlist
    XAPIAN_VISIBILITY_INTERNAL
    void msg_postlist(const std::string & message);
 
    // get positionlist
    XAPIAN_VISIBILITY_INTERNAL
    void msg_positionlist(const std::string &message);
 
    // get positionlist count
    XAPIAN_VISIBILITY_INTERNAL
    void msg_positionlistcount(const std::string &message);
 
    // get write access
    XAPIAN_VISIBILITY_INTERNAL
    void msg_writeaccess(const std::string & message);
 
    // reopen
    XAPIAN_VISIBILITY_INTERNAL
    void msg_reopen(const std::string & message);
 
    // get updated doccount and avlength
    XAPIAN_VISIBILITY_INTERNAL
    void msg_update(const std::string &message);
 
    // commit
    XAPIAN_VISIBILITY_INTERNAL
    void msg_commit(const std::string & message);
 
    // cancel
    XAPIAN_VISIBILITY_INTERNAL
    void msg_cancel(const std::string &message);
 
    // add document
    XAPIAN_VISIBILITY_INTERNAL
    void msg_adddocument(const std::string & message);
 
    // delete document
    XAPIAN_VISIBILITY_INTERNAL
    void msg_deletedocument(const std::string & message);
 
    // delete document with unique term
    XAPIAN_VISIBILITY_INTERNAL
    void msg_deletedocumentterm(const std::string & message);
 
    // replace document
    XAPIAN_VISIBILITY_INTERNAL
    void msg_replacedocument(const std::string & message);
 
    // replace document with unique term
    XAPIAN_VISIBILITY_INTERNAL
    void msg_replacedocumentterm(const std::string & message);
 
    // get metadata
    XAPIAN_VISIBILITY_INTERNAL
    void msg_getmetadata(const std::string & message);
 
    // read metadata key list
    XAPIAN_VISIBILITY_INTERNAL
    void msg_metadatakeylist(const std::string & message);
 
    // set metadata
    XAPIAN_VISIBILITY_INTERNAL
    void msg_setmetadata(const std::string & message);
 
    // request a document (pre-fetch hint)
    XAPIAN_VISIBILITY_INTERNAL
    void msg_requestdocument(const std::string& message);
 
    // add a spelling
    XAPIAN_VISIBILITY_INTERNAL
    void msg_addspelling(const std::string & message);
 
    // remove a spelling
    XAPIAN_VISIBILITY_INTERNAL
    void msg_removespelling(const std::string & message);
 
    // get number of unique terms
    XAPIAN_VISIBILITY_INTERNAL
    void msg_uniqueterms(const std::string & message);
 
    // get max_wdf
    XAPIAN_VISIBILITY_INTERNAL
    void msg_wdfdocmax(const std::string& message);
 
    // reconstruct document text
    XAPIAN_VISIBILITY_INTERNAL
    void msg_reconstructtext(const std::string& message);
 
    // get synonyms for a term
    XAPIAN_VISIBILITY_INTERNAL
    void msg_synonymtermlist(const std::string& message);
 
    // get terms with an entry in synonym table, starting with a prefix
    XAPIAN_VISIBILITY_INTERNAL
    void msg_synonymkeylist(const std::string& message);
 
    // add a synonym
    XAPIAN_VISIBILITY_INTERNAL
    void msg_addsynonym(const std::string& message);
 
    // remove a synonym
    XAPIAN_VISIBILITY_INTERNAL
    void msg_removesynonym(const std::string& message);
 
    // clear synonyms for a term
    XAPIAN_VISIBILITY_INTERNAL
    void msg_clearsynonyms(const std::string& message);
 
  public:
    RemoteServer(const std::vector<std::string> &dbpaths,
                 int fdin, int fdout,
                 double active_timeout_,
                 double idle_timeout_,
                 bool writable = false);
 
    ~RemoteServer();
 
    void run();
 
    void set_registry(const Xapian::Registry & reg_) { reg = reg_; }
};
 
#endif // XAPIAN_INCLUDED_REMOTESERVER_H