fork of https://github.com/oxigraph/rocksdb and https://github.com/facebook/rocksdb for nextgraph and oxigraph
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
593 lines
17 KiB
593 lines
17 KiB
/**
|
|
* Autogenerated by Thrift
|
|
*
|
|
* DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
|
|
* @generated
|
|
*/
|
|
#ifndef _Tleveldb_scribe_H
|
|
#define _Tleveldb_scribe_H
|
|
|
|
#include <TDispatchProcessor.h>
|
|
#include "scribe_types.h"
|
|
|
|
namespace Tleveldb {
|
|
|
|
class scribeIf {
|
|
public:
|
|
virtual ~scribeIf() {}
|
|
virtual ResultCode Log(const std::vector<LogEntry> & messages) = 0;
|
|
virtual void LogMulti(std::vector<ResultCode> & _return, const std::vector<LogEntry> & messages) = 0;
|
|
virtual ResultCode LogCompressedMsg(const std::string& compressedMessages) = 0;
|
|
};
|
|
|
|
class scribeIfFactory {
|
|
public:
|
|
typedef scribeIf Handler;
|
|
|
|
virtual ~scribeIfFactory() {}
|
|
|
|
virtual scribeIf* getHandler(::apache::thrift::server::TConnectionContext* ctx) = 0;
|
|
virtual void releaseHandler(scribeIf* handler) = 0;
|
|
};
|
|
|
|
class scribeIfSingletonFactory : virtual public scribeIfFactory {
|
|
public:
|
|
scribeIfSingletonFactory(const boost::shared_ptr<scribeIf>& iface) : iface_(iface) {}
|
|
virtual ~scribeIfSingletonFactory() {}
|
|
|
|
virtual scribeIf* getHandler(::apache::thrift::server::TConnectionContext*) {
|
|
return iface_.get();
|
|
}
|
|
virtual void releaseHandler(scribeIf* handler) {}
|
|
|
|
protected:
|
|
boost::shared_ptr<scribeIf> iface_;
|
|
};
|
|
|
|
class scribeNull : virtual public scribeIf {
|
|
public:
|
|
virtual ~scribeNull() {}
|
|
ResultCode Log(const std::vector<LogEntry> & /* messages */) {
|
|
ResultCode _return = (ResultCode)0;
|
|
return _return;
|
|
}
|
|
void LogMulti(std::vector<ResultCode> & /* _return */, const std::vector<LogEntry> & /* messages */) {
|
|
return;
|
|
}
|
|
ResultCode LogCompressedMsg(const std::string& /* compressedMessages */) {
|
|
ResultCode _return = (ResultCode)0;
|
|
return _return;
|
|
}
|
|
};
|
|
|
|
class scribe_Log_args {
|
|
public:
|
|
|
|
static const uint64_t _reflection_id = 5902265217339133004U;
|
|
static void _reflection_register(::apache::thrift::reflection::Schema&);
|
|
scribe_Log_args() {
|
|
}
|
|
|
|
scribe_Log_args(const scribe_Log_args&) = default;
|
|
scribe_Log_args& operator=(const scribe_Log_args&) = default;
|
|
scribe_Log_args(scribe_Log_args&&) = default;
|
|
scribe_Log_args& operator=(scribe_Log_args&&) = default;
|
|
|
|
void __clear() {
|
|
messages.clear();
|
|
__isset.__clear();
|
|
}
|
|
|
|
virtual ~scribe_Log_args() throw() {}
|
|
|
|
std::vector<LogEntry> messages;
|
|
|
|
struct __isset {
|
|
__isset() { __clear(); }
|
|
void __clear() {
|
|
messages = false;
|
|
}
|
|
bool messages;
|
|
} __isset;
|
|
|
|
bool operator == (const scribe_Log_args & rhs) const
|
|
{
|
|
if (!(this->messages == rhs.messages))
|
|
return false;
|
|
return true;
|
|
}
|
|
bool operator != (const scribe_Log_args &rhs) const {
|
|
return !(*this == rhs);
|
|
}
|
|
|
|
bool operator < (const scribe_Log_args & ) const;
|
|
|
|
uint32_t read(apache::thrift::protocol::TProtocol* iprot);
|
|
uint32_t write(apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
class scribe_Log_pargs {
|
|
public:
|
|
|
|
static const uint64_t _reflection_id = 5555604010648986412U;
|
|
static void _reflection_register(::apache::thrift::reflection::Schema&);
|
|
|
|
virtual ~scribe_Log_pargs() throw() {}
|
|
|
|
const std::vector<LogEntry> * messages;
|
|
|
|
uint32_t write(apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
class scribe_Log_result {
|
|
public:
|
|
|
|
static const uint64_t _reflection_id = 18205781396971565932U;
|
|
static void _reflection_register(::apache::thrift::reflection::Schema&);
|
|
scribe_Log_result() : success(static_cast<ResultCode>(0)) {
|
|
}
|
|
|
|
scribe_Log_result(const scribe_Log_result&) = default;
|
|
scribe_Log_result& operator=(const scribe_Log_result&) = default;
|
|
scribe_Log_result(scribe_Log_result&&) = default;
|
|
scribe_Log_result& operator=(scribe_Log_result&&) = default;
|
|
|
|
void __clear() {
|
|
success = static_cast<ResultCode>(0);
|
|
__isset.__clear();
|
|
}
|
|
|
|
virtual ~scribe_Log_result() throw() {}
|
|
|
|
ResultCode success;
|
|
|
|
struct __isset {
|
|
__isset() { __clear(); }
|
|
void __clear() {
|
|
success = false;
|
|
}
|
|
bool success;
|
|
} __isset;
|
|
|
|
bool operator == (const scribe_Log_result & rhs) const
|
|
{
|
|
if (!(this->success == rhs.success))
|
|
return false;
|
|
return true;
|
|
}
|
|
bool operator != (const scribe_Log_result &rhs) const {
|
|
return !(*this == rhs);
|
|
}
|
|
|
|
bool operator < (const scribe_Log_result & ) const;
|
|
|
|
uint32_t read(apache::thrift::protocol::TProtocol* iprot);
|
|
uint32_t write(apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
class scribe_Log_presult {
|
|
public:
|
|
|
|
static const uint64_t _reflection_id = 12945584136895385836U;
|
|
static void _reflection_register(::apache::thrift::reflection::Schema&);
|
|
|
|
virtual ~scribe_Log_presult() throw() {}
|
|
|
|
ResultCode* success;
|
|
|
|
struct __isset {
|
|
__isset() { __clear(); }
|
|
void __clear() {
|
|
success = false;
|
|
}
|
|
bool success;
|
|
} __isset;
|
|
|
|
uint32_t read(apache::thrift::protocol::TProtocol* iprot);
|
|
|
|
};
|
|
|
|
class scribe_LogMulti_args {
|
|
public:
|
|
|
|
static const uint64_t _reflection_id = 7590876486278061516U;
|
|
static void _reflection_register(::apache::thrift::reflection::Schema&);
|
|
scribe_LogMulti_args() {
|
|
}
|
|
|
|
scribe_LogMulti_args(const scribe_LogMulti_args&) = default;
|
|
scribe_LogMulti_args& operator=(const scribe_LogMulti_args&) = default;
|
|
scribe_LogMulti_args(scribe_LogMulti_args&&) = default;
|
|
scribe_LogMulti_args& operator=(scribe_LogMulti_args&&) = default;
|
|
|
|
void __clear() {
|
|
messages.clear();
|
|
__isset.__clear();
|
|
}
|
|
|
|
virtual ~scribe_LogMulti_args() throw() {}
|
|
|
|
std::vector<LogEntry> messages;
|
|
|
|
struct __isset {
|
|
__isset() { __clear(); }
|
|
void __clear() {
|
|
messages = false;
|
|
}
|
|
bool messages;
|
|
} __isset;
|
|
|
|
bool operator == (const scribe_LogMulti_args & rhs) const
|
|
{
|
|
if (!(this->messages == rhs.messages))
|
|
return false;
|
|
return true;
|
|
}
|
|
bool operator != (const scribe_LogMulti_args &rhs) const {
|
|
return !(*this == rhs);
|
|
}
|
|
|
|
bool operator < (const scribe_LogMulti_args & ) const;
|
|
|
|
uint32_t read(apache::thrift::protocol::TProtocol* iprot);
|
|
uint32_t write(apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
class scribe_LogMulti_pargs {
|
|
public:
|
|
|
|
static const uint64_t _reflection_id = 9124384543551655628U;
|
|
static void _reflection_register(::apache::thrift::reflection::Schema&);
|
|
|
|
virtual ~scribe_LogMulti_pargs() throw() {}
|
|
|
|
const std::vector<LogEntry> * messages;
|
|
|
|
uint32_t write(apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
class scribe_LogMulti_result {
|
|
public:
|
|
|
|
static const uint64_t _reflection_id = 4828367046341273164U;
|
|
static void _reflection_register(::apache::thrift::reflection::Schema&);
|
|
scribe_LogMulti_result() {
|
|
}
|
|
|
|
scribe_LogMulti_result(const scribe_LogMulti_result&) = default;
|
|
scribe_LogMulti_result& operator=(const scribe_LogMulti_result&) = default;
|
|
scribe_LogMulti_result(scribe_LogMulti_result&&) = default;
|
|
scribe_LogMulti_result& operator=(scribe_LogMulti_result&&) = default;
|
|
|
|
void __clear() {
|
|
success.clear();
|
|
__isset.__clear();
|
|
}
|
|
|
|
virtual ~scribe_LogMulti_result() throw() {}
|
|
|
|
std::vector<ResultCode> success;
|
|
|
|
struct __isset {
|
|
__isset() { __clear(); }
|
|
void __clear() {
|
|
success = false;
|
|
}
|
|
bool success;
|
|
} __isset;
|
|
|
|
bool operator == (const scribe_LogMulti_result & rhs) const
|
|
{
|
|
if (!(this->success == rhs.success))
|
|
return false;
|
|
return true;
|
|
}
|
|
bool operator != (const scribe_LogMulti_result &rhs) const {
|
|
return !(*this == rhs);
|
|
}
|
|
|
|
bool operator < (const scribe_LogMulti_result & ) const;
|
|
|
|
uint32_t read(apache::thrift::protocol::TProtocol* iprot);
|
|
uint32_t write(apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
class scribe_LogMulti_presult {
|
|
public:
|
|
|
|
static const uint64_t _reflection_id = 5642041737363050316U;
|
|
static void _reflection_register(::apache::thrift::reflection::Schema&);
|
|
|
|
virtual ~scribe_LogMulti_presult() throw() {}
|
|
|
|
std::vector<ResultCode> * success;
|
|
|
|
struct __isset {
|
|
__isset() { __clear(); }
|
|
void __clear() {
|
|
success = false;
|
|
}
|
|
bool success;
|
|
} __isset;
|
|
|
|
uint32_t read(apache::thrift::protocol::TProtocol* iprot);
|
|
|
|
};
|
|
|
|
class scribe_LogCompressedMsg_args {
|
|
public:
|
|
|
|
static const uint64_t _reflection_id = 12705053036625273964U;
|
|
static void _reflection_register(::apache::thrift::reflection::Schema&);
|
|
scribe_LogCompressedMsg_args() : compressedMessages("") {
|
|
}
|
|
|
|
scribe_LogCompressedMsg_args(const scribe_LogCompressedMsg_args&) = default;
|
|
scribe_LogCompressedMsg_args& operator=(const scribe_LogCompressedMsg_args&) = default;
|
|
scribe_LogCompressedMsg_args(scribe_LogCompressedMsg_args&&) = default;
|
|
scribe_LogCompressedMsg_args& operator=(scribe_LogCompressedMsg_args&&) = default;
|
|
|
|
void __clear() {
|
|
compressedMessages = "";
|
|
__isset.__clear();
|
|
}
|
|
|
|
virtual ~scribe_LogCompressedMsg_args() throw() {}
|
|
|
|
std::string compressedMessages;
|
|
|
|
struct __isset {
|
|
__isset() { __clear(); }
|
|
void __clear() {
|
|
compressedMessages = false;
|
|
}
|
|
bool compressedMessages;
|
|
} __isset;
|
|
|
|
bool operator == (const scribe_LogCompressedMsg_args & rhs) const
|
|
{
|
|
if (!(this->compressedMessages == rhs.compressedMessages))
|
|
return false;
|
|
return true;
|
|
}
|
|
bool operator != (const scribe_LogCompressedMsg_args &rhs) const {
|
|
return !(*this == rhs);
|
|
}
|
|
|
|
bool operator < (const scribe_LogCompressedMsg_args & ) const;
|
|
|
|
uint32_t read(apache::thrift::protocol::TProtocol* iprot);
|
|
uint32_t write(apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
class scribe_LogCompressedMsg_pargs {
|
|
public:
|
|
|
|
static const uint64_t _reflection_id = 13645577436870531500U;
|
|
static void _reflection_register(::apache::thrift::reflection::Schema&);
|
|
|
|
virtual ~scribe_LogCompressedMsg_pargs() throw() {}
|
|
|
|
const std::string* compressedMessages;
|
|
|
|
uint32_t write(apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
class scribe_LogCompressedMsg_result {
|
|
public:
|
|
|
|
static const uint64_t _reflection_id = 15026639991904524972U;
|
|
static void _reflection_register(::apache::thrift::reflection::Schema&);
|
|
scribe_LogCompressedMsg_result() : success(static_cast<ResultCode>(0)) {
|
|
}
|
|
|
|
scribe_LogCompressedMsg_result(const scribe_LogCompressedMsg_result&) = default;
|
|
scribe_LogCompressedMsg_result& operator=(const scribe_LogCompressedMsg_result&) = default;
|
|
scribe_LogCompressedMsg_result(scribe_LogCompressedMsg_result&&) = default;
|
|
scribe_LogCompressedMsg_result& operator=(scribe_LogCompressedMsg_result&&) = default;
|
|
|
|
void __clear() {
|
|
success = static_cast<ResultCode>(0);
|
|
__isset.__clear();
|
|
}
|
|
|
|
virtual ~scribe_LogCompressedMsg_result() throw() {}
|
|
|
|
ResultCode success;
|
|
|
|
struct __isset {
|
|
__isset() { __clear(); }
|
|
void __clear() {
|
|
success = false;
|
|
}
|
|
bool success;
|
|
} __isset;
|
|
|
|
bool operator == (const scribe_LogCompressedMsg_result & rhs) const
|
|
{
|
|
if (!(this->success == rhs.success))
|
|
return false;
|
|
return true;
|
|
}
|
|
bool operator != (const scribe_LogCompressedMsg_result &rhs) const {
|
|
return !(*this == rhs);
|
|
}
|
|
|
|
bool operator < (const scribe_LogCompressedMsg_result & ) const;
|
|
|
|
uint32_t read(apache::thrift::protocol::TProtocol* iprot);
|
|
uint32_t write(apache::thrift::protocol::TProtocol* oprot) const;
|
|
|
|
};
|
|
|
|
class scribe_LogCompressedMsg_presult {
|
|
public:
|
|
|
|
static const uint64_t _reflection_id = 5311776576442573772U;
|
|
static void _reflection_register(::apache::thrift::reflection::Schema&);
|
|
|
|
virtual ~scribe_LogCompressedMsg_presult() throw() {}
|
|
|
|
ResultCode* success;
|
|
|
|
struct __isset {
|
|
__isset() { __clear(); }
|
|
void __clear() {
|
|
success = false;
|
|
}
|
|
bool success;
|
|
} __isset;
|
|
|
|
uint32_t read(apache::thrift::protocol::TProtocol* iprot);
|
|
|
|
};
|
|
|
|
class scribeClient : virtual public scribeIf, virtual public apache::thrift::TClientBase {
|
|
public:
|
|
scribeClient(boost::shared_ptr<apache::thrift::protocol::TProtocol> prot) :
|
|
checkSeqid_(true),
|
|
nextSendSequenceId_(1),
|
|
nextRecvSequenceId_(1),
|
|
piprot_(prot),
|
|
poprot_(prot) {
|
|
iprot_ = prot.get();
|
|
oprot_ = prot.get();
|
|
}
|
|
scribeClient(boost::shared_ptr<apache::thrift::protocol::TProtocol> iprot, boost::shared_ptr<apache::thrift::protocol::TProtocol> oprot) :
|
|
checkSeqid_(true),
|
|
nextSendSequenceId_(1),
|
|
nextRecvSequenceId_(1),
|
|
piprot_(iprot),
|
|
poprot_(oprot) {
|
|
iprot_ = iprot.get();
|
|
oprot_ = oprot.get();
|
|
}
|
|
boost::shared_ptr<apache::thrift::protocol::TProtocol> getInputProtocol() {
|
|
return piprot_;
|
|
}
|
|
boost::shared_ptr<apache::thrift::protocol::TProtocol> getOutputProtocol() {
|
|
return poprot_;
|
|
}
|
|
ResultCode Log(const std::vector<LogEntry> & messages);
|
|
void send_Log(const std::vector<LogEntry> & messages);
|
|
ResultCode recv_Log();
|
|
void LogMulti(std::vector<ResultCode> & _return, const std::vector<LogEntry> & messages);
|
|
void send_LogMulti(const std::vector<LogEntry> & messages);
|
|
void recv_LogMulti(std::vector<ResultCode> & _return);
|
|
ResultCode LogCompressedMsg(const std::string& compressedMessages);
|
|
void send_LogCompressedMsg(const std::string& compressedMessages);
|
|
ResultCode recv_LogCompressedMsg();
|
|
|
|
/**
|
|
* Disable checking the seqid field in server responses.
|
|
*
|
|
* This should only be used with broken servers that return incorrect seqid values.
|
|
*/
|
|
void _disableSequenceIdChecks() {
|
|
checkSeqid_ = false;
|
|
}
|
|
|
|
protected:
|
|
bool checkSeqid_;
|
|
int32_t nextSendSequenceId_;
|
|
int32_t nextRecvSequenceId_;
|
|
int32_t getNextSendSequenceId();
|
|
int32_t getNextRecvSequenceId();
|
|
boost::shared_ptr<apache::thrift::protocol::TProtocol> piprot_;
|
|
boost::shared_ptr<apache::thrift::protocol::TProtocol> poprot_;
|
|
apache::thrift::protocol::TProtocol* iprot_;
|
|
apache::thrift::protocol::TProtocol* oprot_;
|
|
};
|
|
|
|
class scribeProcessor : public ::apache::thrift::TDispatchProcessor {
|
|
protected:
|
|
boost::shared_ptr<scribeIf> iface_;
|
|
virtual bool dispatchCall(apache::thrift::protocol::TProtocol* iprot, apache::thrift::protocol::TProtocol* oprot, const std::string& fname, int32_t seqid, apache::thrift::server::TConnectionContext* connectionContext);
|
|
private:
|
|
typedef void (scribeProcessor::*ProcessFunction)(int32_t, apache::thrift::protocol::TProtocol*, apache::thrift::protocol::TProtocol*, apache::thrift::server::TConnectionContext*);
|
|
typedef std::map<std::string, ProcessFunction> ProcessMap;
|
|
ProcessMap processMap_;
|
|
void process_Log(int32_t seqid, apache::thrift::protocol::TProtocol* iprot, apache::thrift::protocol::TProtocol* oprot, apache::thrift::server::TConnectionContext* connectionContext);
|
|
void process_LogMulti(int32_t seqid, apache::thrift::protocol::TProtocol* iprot, apache::thrift::protocol::TProtocol* oprot, apache::thrift::server::TConnectionContext* connectionContext);
|
|
void process_LogCompressedMsg(int32_t seqid, apache::thrift::protocol::TProtocol* iprot, apache::thrift::protocol::TProtocol* oprot, apache::thrift::server::TConnectionContext* connectionContext);
|
|
public:
|
|
scribeProcessor(boost::shared_ptr<scribeIf> iface) :
|
|
iface_(iface) {
|
|
processMap_["Log"] = &scribeProcessor::process_Log;
|
|
processMap_["LogMulti"] = &scribeProcessor::process_LogMulti;
|
|
processMap_["LogCompressedMsg"] = &scribeProcessor::process_LogCompressedMsg;
|
|
}
|
|
|
|
virtual ~scribeProcessor() {}
|
|
|
|
boost::shared_ptr<std::set<std::string> > getProcessFunctions() {
|
|
boost::shared_ptr<std::set<std::string> > rSet(new std::set<std::string>());
|
|
rSet->insert("scribe.Log");
|
|
rSet->insert("scribe.LogMulti");
|
|
rSet->insert("scribe.LogCompressedMsg");
|
|
return rSet;
|
|
}
|
|
};
|
|
|
|
class scribeProcessorFactory : public ::apache::thrift::TProcessorFactory {
|
|
public:
|
|
scribeProcessorFactory(const ::boost::shared_ptr< scribeIfFactory >& handlerFactory) :
|
|
handlerFactory_(handlerFactory) {}
|
|
|
|
::boost::shared_ptr< ::apache::thrift::TProcessor > getProcessor(::apache::thrift::server::TConnectionContext* ctx);
|
|
|
|
protected:
|
|
::boost::shared_ptr< scribeIfFactory > handlerFactory_;
|
|
};
|
|
|
|
class scribeMultiface : virtual public scribeIf {
|
|
public:
|
|
scribeMultiface(std::vector<boost::shared_ptr<scribeIf> >& ifaces) : ifaces_(ifaces) {
|
|
}
|
|
virtual ~scribeMultiface() {}
|
|
protected:
|
|
std::vector<boost::shared_ptr<scribeIf> > ifaces_;
|
|
scribeMultiface() {}
|
|
void add(boost::shared_ptr<scribeIf> iface) {
|
|
ifaces_.push_back(iface);
|
|
}
|
|
public:
|
|
ResultCode Log(const std::vector<LogEntry> & messages) {
|
|
uint32_t i;
|
|
uint32_t sz = ifaces_.size();
|
|
for (i = 0; i < sz - 1; ++i) {
|
|
ifaces_[i]->Log(messages);
|
|
}
|
|
return ifaces_[i]->Log(messages);
|
|
}
|
|
|
|
void LogMulti(std::vector<ResultCode> & _return, const std::vector<LogEntry> & messages) {
|
|
uint32_t i;
|
|
uint32_t sz = ifaces_.size();
|
|
for (i = 0; i < sz; ++i) {
|
|
ifaces_[i]->LogMulti(_return, messages);
|
|
}
|
|
}
|
|
|
|
ResultCode LogCompressedMsg(const std::string& compressedMessages) {
|
|
uint32_t i;
|
|
uint32_t sz = ifaces_.size();
|
|
for (i = 0; i < sz - 1; ++i) {
|
|
ifaces_[i]->LogCompressedMsg(compressedMessages);
|
|
}
|
|
return ifaces_[i]->LogCompressedMsg(compressedMessages);
|
|
}
|
|
|
|
};
|
|
|
|
} // namespace
|
|
|
|
#endif
|
|
|