tursom/memgraph
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Migrate cereal to boost_serialization

Browse Source 
Reviewers: teon.banek

Reviewed By: teon.banek

Subscribers: pullbot

Differential Revision: https://phabricator.memgraph.io/D1077
This commit is contained in:
Mislav Bradac 2017-12-22 14:36:25 +01:00
parent 7b3d298741
commit d3623585e7
38 changed files with 476 additions and 504 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
libs/CMakeLists.txt
View File

@ -164,9 +164,3 @@ import_header_library(cppitertools ${CMAKE_CURRENT_SOURCE_DIR})
# Setup json # Setup json
import_header_library(json ${CMAKE_CURRENT_SOURCE_DIR}) import_header_library(json ${CMAKE_CURRENT_SOURCE_DIR})
# Setup cereal
import_header_library(cereal "${CMAKE_CURRENT_SOURCE_DIR}/cereal/include")
# Make cereal multithreaded by passing -DCEREAL_THREAD_SAFE=1 (note that -D is omitted below).
set_property(TARGET cereal PROPERTY
INTERFACE_COMPILE_DEFINITIONS CEREAL_THREAD_SAFE=1)

4
libs/setup.sh
View File

@ -123,7 +123,3 @@ cd ..
# git clone https://github.com/r-lyeh/ltalloc.git # git clone https://github.com/r-lyeh/ltalloc.git
ltalloc_tag="43b51c14857111f993f277c46151fdfac91525a2" # Nov 16, 2017 ltalloc_tag="43b51c14857111f993f277c46151fdfac91525a2" # Nov 16, 2017
clone git://deps.memgraph.io/ltalloc.git ltalloc $ltalloc_tag clone git://deps.memgraph.io/ltalloc.git ltalloc $ltalloc_tag
# cereal
#git clone https://github.com/USCiLab/cereal.git
clone git://deps.memgraph.io/cereal.git cereal v1.2.2

5
src/CMakeLists.txt
View File

@ -10,8 +10,8 @@ set(memgraph_src_files
communication/rpc/rpc.cpp communication/rpc/rpc.cpp
data_structures/concurrent/skiplist_gc.cpp data_structures/concurrent/skiplist_gc.cpp
database/graph_db.cpp database/graph_db.cpp
database/graph_db_config.cpp
database/graph_db_accessor.cpp database/graph_db_accessor.cpp
database/graph_db_config.cpp
database/state_delta.cpp database/state_delta.cpp
distributed/coordination_master.cpp distributed/coordination_master.cpp
distributed/coordination_worker.cpp distributed/coordination_worker.cpp
@ -50,7 +50,7 @@ set(memgraph_src_files
# ----------------------------------------------------------------------------- # -----------------------------------------------------------------------------
# memgraph_lib depend on these libraries # memgraph_lib depend on these libraries
set(MEMGRAPH_ALL_LIBS stdc++fs Threads::Threads fmt cppitertools cereal set(MEMGRAPH_ALL_LIBS stdc++fs Threads::Threads fmt cppitertools
antlr_opencypher_parser_lib dl glog gflags ${Boost_SERIALIZATION_LIBRARY_RELEASE}) antlr_opencypher_parser_lib dl glog gflags ${Boost_SERIALIZATION_LIBRARY_RELEASE})
if (USE_LTALLOC) if (USE_LTALLOC)
@ -124,4 +124,3 @@ set(examples ${CMAKE_SOURCE_DIR}/release/examples)
install(CODE "execute_process(COMMAND ${examples}/build_examples install(CODE "execute_process(COMMAND ${examples}/build_examples
WORKING_DIRECTORY ${examples})") WORKING_DIRECTORY ${examples})")
install(DIRECTORY ${examples}/build/ DESTINATION share/memgraph/examples) install(DIRECTORY ${examples}/build/ DESTINATION share/memgraph/examples)

8
src/communication/messaging/distributed.hpp
View File

@ -18,14 +18,6 @@
#include "data_structures/queue.hpp" #include "data_structures/queue.hpp"
#include "protocol.hpp" #include "protocol.hpp"
#include "cereal/archives/binary.hpp"
#include "cereal/types/base_class.hpp"
#include "cereal/types/memory.hpp"
#include "cereal/types/polymorphic.hpp"
#include "cereal/types/string.hpp"
#include "cereal/types/utility.hpp"
#include "cereal/types/vector.hpp"
#include "communication/server.hpp" #include "communication/server.hpp"
#include "io/network/network_endpoint.hpp" #include "io/network/network_endpoint.hpp"
#include "threading/sync/spinlock.hpp" #include "threading/sync/spinlock.hpp"

3
src/communication/messaging/local.cpp
View File

@ -58,4 +58,5 @@ std::unique_ptr<Message> EventStream::Await(
}; };
void EventStream::Shutdown() { queue_.Shutdown(); } void EventStream::Shutdown() { queue_.Shutdown(); }
}
} // namespace communication::messaging

13
src/communication/messaging/local.hpp
View File

@ -4,8 +4,9 @@
#include <string> #include <string>
#include <type_traits> #include <type_traits>
#include <typeindex> #include <typeindex>
#include <unordered_map>
#include "cereal/types/memory.hpp" #include "boost/serialization/access.hpp"
#include "data_structures/queue.hpp" #include "data_structures/queue.hpp"
@ -18,9 +19,6 @@ class Message {
public: public:
virtual ~Message() {} virtual ~Message() {}
template <class Archive>
void serialize(Archive &) {}
/** /**
* Run-time type identification that is used for callbacks. * Run-time type identification that is used for callbacks.
* *
@ -28,6 +26,12 @@ class Message {
* this class * this class
*/ */
std::type_index type_index() const { return typeid(*this); } std::type_index type_index() const { return typeid(*this); }
private:
friend boost::serialization::access;
template <class TArchive>
void serialize(TArchive &, unsigned int) {}
}; };
class EventStream; class EventStream;
@ -106,4 +110,5 @@ class EventStream {
std::string name_; std::string name_;
Queue<std::unique_ptr<Message>> queue_; Queue<std::unique_ptr<Message>> queue_;
}; };
} // namespace communication::messaging } // namespace communication::messaging

22
src/communication/messaging/protocol.cpp
View File

@ -1,11 +1,15 @@
#include <sstream> #include <sstream>
#include "boost/archive/binary_iarchive.hpp"
#include "boost/archive/binary_oarchive.hpp"
#include "boost/serialization/unique_ptr.hpp"
#include "fmt/format.h"
#include "glog/logging.h"
#include "communication/messaging/distributed.hpp" #include "communication/messaging/distributed.hpp"
#include "communication/messaging/local.hpp" #include "communication/messaging/local.hpp"
#include "communication/messaging/protocol.hpp" #include "communication/messaging/protocol.hpp"
#include "communication/rpc/messages-inl.hpp"
#include "fmt/format.h"
#include "glog/logging.h"
namespace communication::messaging { namespace communication::messaging {
@ -33,11 +37,11 @@ void Session::Execute() {
buffer_.Shift(sizeof(SizeT)); buffer_.Shift(sizeof(SizeT));
// TODO: check for exceptions // TODO: check for exceptions
std::istringstream stream; std::stringstream stream;
stream.str(std::string(reinterpret_cast<char *>(buffer_.data()), len_data)); stream.str(std::string(reinterpret_cast<char *>(buffer_.data()), len_data));
::cereal::BinaryInputArchive iarchive{stream}; boost::archive::binary_iarchive archive(stream);
std::unique_ptr<Message> message{nullptr}; std::unique_ptr<Message> message{nullptr};
iarchive(message); archive >> message;
buffer_.Shift(len_data); buffer_.Shift(len_data);
LocalWriter writer(system_, channel); LocalWriter writer(system_, channel);
@ -86,9 +90,9 @@ void SendMessage(const std::string &address, uint16_t port,
} }
// Serialize and send message // Serialize and send message
std::ostringstream stream; std::stringstream stream;
::cereal::BinaryOutputArchive oarchive(stream); boost::archive::binary_oarchive archive(stream);
oarchive(message); archive << message;
const std::string &buffer = stream.str(); const std::string &buffer = stream.str();
int64_t message_size = 2 * sizeof(SizeT) + buffer.size() + channel.size(); int64_t message_size = 2 * sizeof(SizeT) + buffer.size() + channel.size();

29
src/communication/raft/network_common.hpp
View File

@ -1,6 +1,7 @@
#pragma once #pragma once
#include "cereal/cereal.hpp" #include "boost/serialization/access.hpp"
#include "boost/serialization/base_object.hpp"
#include "communication/messaging/distributed.hpp" #include "communication/messaging/distributed.hpp"
#include "communication/raft/raft.hpp" #include "communication/raft/raft.hpp"
@ -15,10 +16,15 @@ struct PeerRpcRequest : public messaging::Message {
RequestVoteRequest request_vote; RequestVoteRequest request_vote;
AppendEntriesRequest<State> append_entries; AppendEntriesRequest<State> append_entries;
template <class Archive> private:
void serialize(Archive &ar) { friend class boost::serialization::access;
ar(cereal::virtual_base_class<messaging::Message>(this), type, request_vote,
append_entries); template <class TArchive>
void serialize(TArchive &ar, unsigned int) {
ar &boost::serialization::base_object<messaging::Message>(*this);
ar &type;
ar &request_vote;
ar &append_entries;
} }
}; };
@ -27,10 +33,15 @@ struct PeerRpcReply : public messaging::Message {
RequestVoteReply request_vote; RequestVoteReply request_vote;
AppendEntriesReply append_entries; AppendEntriesReply append_entries;
template <class Archive> private:
void serialize(Archive &ar) { friend class boost::serialization::access;
ar(cereal::virtual_base_class<messaging::Message>(this), type, request_vote,
append_entries); template <class TArchive>
void serialize(TArchive &ar, unsigned int) {
ar &boost::serialization::base_object<messaging::Message>(*this);
ar &type;
ar &request_vote;
ar &append_entries;
} }
}; };

45
src/communication/raft/raft.hpp
View File

@ -10,9 +10,10 @@
#include <thread> #include <thread>
#include <vector> #include <vector>
#include "boost/serialization/vector.hpp"
#include "glog/logging.h" #include "glog/logging.h"
#include "utils/cereal_optional.hpp" #include "utils/serialization_optional.hpp"
namespace communication::raft { namespace communication::raft {
@ -43,9 +44,10 @@ struct LogEntry {
} }
bool operator!=(const LogEntry &rhs) const { return !(*this == rhs); } bool operator!=(const LogEntry &rhs) const { return !(*this == rhs); }
template <class Archive> template <class TArchive>
void serialize(Archive &ar) { void serialize(TArchive &ar, unsigned int) {
ar(term, command); ar &term;
ar &command;
} }
}; };
@ -56,9 +58,12 @@ struct RequestVoteRequest {
LogIndex last_log_index; LogIndex last_log_index;
TermId last_log_term; TermId last_log_term;
template <class Archive> template <class TArchive>
void serialize(Archive &ar) { void serialize(TArchive &ar, unsigned int) {
ar(candidate_term, candidate_id, last_log_index, last_log_term); ar &candidate_term;
ar &candidate_id;
ar &last_log_index;
ar &last_log_term;
} }
}; };
@ -66,9 +71,10 @@ struct RequestVoteReply {
TermId term; TermId term;
bool vote_granted; bool vote_granted;
template <class Archive> template <class TArchive>
void serialize(Archive &ar) { void serialize(TArchive &ar, unsigned int) {
ar(term, vote_granted); ar &term;
ar &vote_granted;
} }
}; };
@ -81,10 +87,14 @@ struct AppendEntriesRequest {
std::vector<LogEntry<State>> entries; std::vector<LogEntry<State>> entries;
LogIndex leader_commit; LogIndex leader_commit;
template <class Archive> template <class TArchive>
void serialize(Archive &ar) { void serialize(TArchive &ar, unsigned int) {
ar(leader_term, leader_id, prev_log_index, prev_log_term, entries, ar &leader_term;
leader_commit); ar &leader_id;
ar &prev_log_index;
ar &prev_log_term;
ar &entries;
ar &leader_commit;
} }
}; };
@ -92,9 +102,10 @@ struct AppendEntriesReply {
TermId term; TermId term;
bool success; bool success;
template <class Archive> template <class TArchive>
void serialize(Archive &ar) { void serialize(TArchive &ar, unsigned int) {
ar(term, success); ar &term;
ar &success;
} }
}; };

48
src/communication/raft/test_utils.hpp
View File

@ -10,12 +10,12 @@ struct DummyState {
bool operator==(const Change &) const { return true; } bool operator==(const Change &) const { return true; }
bool operator!=(const Change &) const { return false; } bool operator!=(const Change &) const { return false; }
template <class Archive> template <class TArchive>
void serialize(Archive &ar) {} void serialize(TArchive &, unsigned int) {}
}; };
template <class Archive> template <class TArchive>
void serialize(Archive &ar) {} void serialize(TArchive &, unsigned int) {}
}; };
struct IntState { struct IntState {
@ -31,15 +31,16 @@ struct IntState {
} }
bool operator!=(const Change &rhs) const { return !(*this == rhs); }; bool operator!=(const Change &rhs) const { return !(*this == rhs); };
template <class Archive> template <class TArchive>
void serialize(Archive &ar) { void serialize(TArchive &ar, unsigned int) {
ar(t, d); ar &t;
ar &d;
} }
}; };
template <class Archive> template <class TArchive>
void serialize(Archive &ar) { void serialize(TArchive &ar, unsigned int) {
ar(x); ar &x;
} }
}; };
@ -52,21 +53,20 @@ class NoOpNetworkInterface : public RaftNetworkInterface<State> {
public: public:
~NoOpNetworkInterface() {} ~NoOpNetworkInterface() {}
virtual bool SendRequestVote(const MemberId &recipient, virtual bool SendRequestVote(const MemberId &, const RequestVoteRequest &,
const RequestVoteRequest &request, RequestVoteReply &,
RequestVoteReply &reply, std::chrono::milliseconds) override {
std::chrono::milliseconds timeout) override {
return false; return false;
} }
virtual bool SendAppendEntries(const MemberId &recipient, virtual bool SendAppendEntries(const MemberId &,
const AppendEntriesRequest<State> &request, const AppendEntriesRequest<State> &,
AppendEntriesReply &reply, AppendEntriesReply &,
std::chrono::milliseconds timeout) override { std::chrono::milliseconds) override {
return false; return false;
} }
virtual void Start(RaftMember<State> &member) override {} virtual void Start(RaftMember<State> &) override {}
virtual void Shutdown() override {} virtual void Shutdown() override {}
}; };
@ -80,10 +80,10 @@ class NextReplyNetworkInterface : public RaftNetworkInterface<State> {
public: public:
~NextReplyNetworkInterface() {} ~NextReplyNetworkInterface() {}
virtual bool SendRequestVote(const MemberId &recipient, virtual bool SendRequestVote(const MemberId &,
const RequestVoteRequest &request, const RequestVoteRequest &request,
RequestVoteReply &reply, RequestVoteReply &reply,
std::chrono::milliseconds timeout) override { std::chrono::milliseconds) override {
PeerRpcRequest<State> req; PeerRpcRequest<State> req;
req.type = RpcType::REQUEST_VOTE; req.type = RpcType::REQUEST_VOTE;
req.request_vote = request; req.request_vote = request;
@ -97,10 +97,10 @@ class NextReplyNetworkInterface : public RaftNetworkInterface<State> {
return true; return true;
} }
virtual bool SendAppendEntries(const MemberId &recipient, virtual bool SendAppendEntries(const MemberId &,
const AppendEntriesRequest<State> &request, const AppendEntriesRequest<State> &request,
AppendEntriesReply &reply, AppendEntriesReply &reply,
std::chrono::milliseconds timeout) override { std::chrono::milliseconds) override {
PeerRpcRequest<State> req; PeerRpcRequest<State> req;
req.type = RpcType::APPEND_ENTRIES; req.type = RpcType::APPEND_ENTRIES;
req.append_entries = request; req.append_entries = request;
@ -114,7 +114,7 @@ class NextReplyNetworkInterface : public RaftNetworkInterface<State> {
return true; return true;
} }
virtual void Start(RaftMember<State> &member) override {} virtual void Start(RaftMember<State> &) override {}
virtual void Shutdown() override {} virtual void Shutdown() override {}

35
src/communication/rpc/messages-inl.hpp Normal file
View File

@ -0,0 +1,35 @@
#include "boost/archive/binary_iarchive.hpp"
#include "boost/archive/binary_oarchive.hpp"
#include "boost/serialization/export.hpp"
#include "distributed/coordination_rpc_messages.hpp"
#include "storage/concurrent_id_mapper_rpc_messages.hpp"
#include "transactions/engine_rpc_messages.hpp"
BOOST_CLASS_EXPORT(tx::SnapshotReq);
BOOST_CLASS_EXPORT(tx::SnapshotRes);
BOOST_CLASS_EXPORT(tx::GcSnapshotReq);
BOOST_CLASS_EXPORT(tx::ClogInfoReq);
BOOST_CLASS_EXPORT(tx::ClogInfoRes);
BOOST_CLASS_EXPORT(tx::ActiveTransactionsReq);
BOOST_CLASS_EXPORT(tx::IsActiveReq);
BOOST_CLASS_EXPORT(tx::IsActiveRes);
#define ID_VALUE_EXPORT_BOOST_TYPE(type) \
BOOST_CLASS_EXPORT(storage::type##IdReq); \
BOOST_CLASS_EXPORT(storage::type##IdRes); \
BOOST_CLASS_EXPORT(storage::Id##type##Req); \
BOOST_CLASS_EXPORT(storage::Id##type##Res);
ID_VALUE_EXPORT_BOOST_TYPE(Label)
ID_VALUE_EXPORT_BOOST_TYPE(EdgeType)
ID_VALUE_EXPORT_BOOST_TYPE(Property)
#undef ID_VALUE_EXPORT_BOOST_TYPE
BOOST_CLASS_EXPORT(distributed::RegisterWorkerReq);
BOOST_CLASS_EXPORT(distributed::RegisterWorkerRes);
BOOST_CLASS_EXPORT(distributed::GetEndpointReq);
BOOST_CLASS_EXPORT(distributed::GetEndpointRes);
BOOST_CLASS_EXPORT(distributed::StopWorkerReq);
BOOST_CLASS_EXPORT(distributed::StopWorkerRes);

53
src/communication/rpc/rpc.cpp
View File

@ -1,6 +1,13 @@
#include <iterator> #include <iterator>
#include <random> #include <random>
#include "boost/archive/binary_iarchive.hpp"
#include "boost/archive/binary_oarchive.hpp"
#include "boost/serialization/access.hpp"
#include "boost/serialization/base_object.hpp"
#include "boost/serialization/export.hpp"
#include "boost/serialization/unique_ptr.hpp"
#include "communication/rpc/rpc.hpp" #include "communication/rpc/rpc.hpp"
#include "utils/string.hpp" #include "utils/string.hpp"
@ -24,15 +31,19 @@ class Request : public messaging::Message {
const std::string &message_id() const { return message_id_; } const std::string &message_id() const { return message_id_; }
const messaging::Message &message() const { return *message_; } const messaging::Message &message() const { return *message_; }
template <class Archive> private:
void serialize(Archive &ar) { friend class boost::serialization::access;
ar(cereal::virtual_base_class<messaging::Message>(this), address_, port_, Request() {} // Needed for serialization.
stream_, message_id_, message_);
}
protected: template <class TArchive>
friend class cereal::access; void serialize(TArchive &ar, unsigned int) {
Request() {} // Cereal needs access to a default constructor. ar &boost::serialization::base_object<messaging::Message>(*this);
ar &address_;
ar &port_;
ar &stream_;
ar &message_id_;
ar &message_;
}
std::string address_; std::string address_;
uint16_t port_; uint16_t port_;
@ -47,18 +58,20 @@ class Response : public messaging::Message {
std::unique_ptr<messaging::Message> message) std::unique_ptr<messaging::Message> message)
: message_id_(message_id), message_(std::move(message)) {} : message_id_(message_id), message_(std::move(message)) {}
template <class Archive>
void serialize(Archive &ar) {
ar(cereal::virtual_base_class<messaging::Message>(this), message_id_,
message_);
}
const auto &message_id() const { return message_id_; } const auto &message_id() const { return message_id_; }
auto &message() { return message_; } auto &message() { return message_; }
protected: private:
Response() {} // Cereal needs access to a default constructor. friend class boost::serialization::access;
friend class cereal::access; Response() {} // Needed for serialization.
template <class TArchive>
void serialize(TArchive &ar, unsigned int) {
ar &boost::serialization::base_object<Message>(*this);
ar &message_id_;
ar &message_;
}
std::string message_id_; std::string message_id_;
std::unique_ptr<messaging::Message> message_; std::unique_ptr<messaging::Message> message_;
}; };
@ -138,6 +151,8 @@ void Server::Shutdown() {
stream_->Shutdown(); stream_->Shutdown();
if (running_thread_.joinable()) running_thread_.join(); if (running_thread_.joinable()) running_thread_.join();
} }
} // namespace communication::rpc } // namespace communication::rpc
CEREAL_REGISTER_TYPE(communication::rpc::Request);
CEREAL_REGISTER_TYPE(communication::rpc::Response); BOOST_CLASS_EXPORT(communication::rpc::Request);
BOOST_CLASS_EXPORT(communication::rpc::Response);

6
src/communication/rpc/rpc.hpp
View File

@ -73,9 +73,8 @@ class Server {
typename TRequestResponse::Response>::value, typename TRequestResponse::Response>::value,
"TRequestResponse::Response must be derived from Message"); "TRequestResponse::Response must be derived from Message");
auto got = callbacks_.emplace( auto got = callbacks_.emplace(
typeid(typename TRequestResponse::Request), [callback = callback]( typeid(typename TRequestResponse::Request),
const messaging::Message [callback = callback](const messaging::Message &base_message) {
&base_message) {
const auto &message = const auto &message =
dynamic_cast<const typename TRequestResponse::Request &>( dynamic_cast<const typename TRequestResponse::Request &>(
base_message); base_message);
@ -99,4 +98,5 @@ class Server {
std::thread running_thread_; std::thread running_thread_;
bool started_{false}; bool started_{false};
}; };
} // namespace communication::rpc } // namespace communication::rpc

44
src/database/graph_db_datatypes.hpp
View File

@ -3,7 +3,6 @@
#include <string> #include <string>
#include "boost/serialization/base_object.hpp" #include "boost/serialization/base_object.hpp"
#include "cereal/types/base_class.hpp"
#include "utils/total_ordering.hpp" #include "utils/total_ordering.hpp"
@ -28,21 +27,15 @@ class Common : TotalOrdering<TSpecificType> {
size_t operator()(const TSpecificType &t) const { return hash(t.storage_); } size_t operator()(const TSpecificType &t) const { return hash(t.storage_); }
}; };
/** Required for cereal serialization. */
template <class Archive>
void serialize(Archive &archive) {
archive(storage_);
}
private: private:
StorageT storage_{0};
friend class boost::serialization::access; friend class boost::serialization::access;
template <class TArchive> template <class TArchive>
void serialize(TArchive &ar, const unsigned int) { void serialize(TArchive &ar, const unsigned int) {
ar & storage_; ar &storage_;
} }
StorageT storage_{0};
}; };
class Label : public Common<Label> { class Label : public Common<Label> {
@ -52,14 +45,7 @@ class Label : public Common<Label> {
template <class TArchive> template <class TArchive>
void serialize(TArchive &ar, const unsigned int) { void serialize(TArchive &ar, const unsigned int) {
ar & boost::serialization::base_object<Common<Label>>(*this); ar &boost::serialization::base_object<Common<Label>>(*this);
}
public:
/** Required for cereal serialization. */
template <class Archive>
void serialize(Archive &archive) {
archive(cereal::base_class<Common<Label>>(this));
} }
}; };
@ -70,14 +56,7 @@ class EdgeType : public Common<EdgeType> {
template <class TArchive> template <class TArchive>
void serialize(TArchive &ar, const unsigned int) { void serialize(TArchive &ar, const unsigned int) {
ar & boost::serialization::base_object<Common<EdgeType>>(*this); ar &boost::serialization::base_object<Common<EdgeType>>(*this);
}
public:
/** Required for cereal serialization. */
template <class Archive>
void serialize(Archive &archive) {
archive(cereal::base_class<Common<EdgeType>>(this));
} }
}; };
@ -88,20 +67,14 @@ class Property : public Common<Property> {
template <class TArchive> template <class TArchive>
void serialize(TArchive &ar, const unsigned int) { void serialize(TArchive &ar, const unsigned int) {
ar & boost::serialization::base_object<Common<Property>>(*this); ar &boost::serialization::base_object<Common<Property>>(*this);
}
public:
/** Required for cereal serialization. */
template <class Archive>
void serialize(Archive &archive) {
archive(cereal::base_class<Common<Property>>(this));
} }
}; };
}; // namespace GraphDbTypes }; // namespace GraphDbTypes
namespace std { namespace std {
template <> template <>
struct hash<GraphDbTypes::Label> struct hash<GraphDbTypes::Label>
: public GraphDbTypes::Common<GraphDbTypes::Label>::Hash {}; : public GraphDbTypes::Common<GraphDbTypes::Label>::Hash {};
@ -111,4 +84,5 @@ struct hash<GraphDbTypes::EdgeType>
template <> template <>
struct hash<GraphDbTypes::Property> struct hash<GraphDbTypes::Property>
: public GraphDbTypes::Common<GraphDbTypes::Property>::Hash {}; : public GraphDbTypes::Common<GraphDbTypes::Property>::Hash {};
}; // namespace std
} // namespace std

21
src/distributed/coordination_rpc_messages.hpp
View File

@ -1,5 +1,8 @@
#pragma once #pragma once
#include "boost/serialization/access.hpp"
#include "boost/serialization/base_object.hpp"
#include "communication/messaging/local.hpp" #include "communication/messaging/local.hpp"
#include "communication/rpc/rpc.hpp" #include "communication/rpc/rpc.hpp"
#include "io/network/network_endpoint.hpp" #include "io/network/network_endpoint.hpp"
@ -20,9 +23,14 @@ struct RegisterWorkerReq : public Message {
int desired_worker_id; int desired_worker_id;
Endpoint endpoint; Endpoint endpoint;
template <class Archive> private:
void serialize(Archive &ar) { friend class boost::serialization::access;
ar(cereal::virtual_base_class<Message>(this), desired_worker_id, endpoint);
template <class TArchive>
void serialize(TArchive &ar, unsigned int) {
ar &boost::serialization::base_object<Message>(*this);
ar &desired_worker_id;
ar &endpoint;
} }
}; };
@ -40,10 +48,3 @@ using StopWorkerRpc =
communication::rpc::RequestResponse<StopWorkerReq, StopWorkerRes>; communication::rpc::RequestResponse<StopWorkerReq, StopWorkerRes>;
} // namespace distributed } // namespace distributed
CEREAL_REGISTER_TYPE(distributed::RegisterWorkerReq);
CEREAL_REGISTER_TYPE(distributed::RegisterWorkerRes);
CEREAL_REGISTER_TYPE(distributed::GetEndpointReq);
CEREAL_REGISTER_TYPE(distributed::GetEndpointRes);
CEREAL_REGISTER_TYPE(distributed::StopWorkerReq);
CEREAL_REGISTER_TYPE(distributed::StopWorkerRes);

1
src/io/network/network_endpoint.cpp
View File

@ -49,4 +49,5 @@ bool NetworkEndpoint::operator==(const NetworkEndpoint &other) const {
std::begin(other.address_)) && std::begin(other.address_)) &&
port_ == other.port_ && family_ == other.family_; port_ == other.port_ && family_ == other.family_;
} }
} // namespace io::network } // namespace io::network

21
src/io/network/network_endpoint.hpp
View File

@ -4,6 +4,8 @@
#include <cstdint> #include <cstdint>
#include <string> #include <string>
#include "boost/serialization/access.hpp"
#include "utils/exceptions.hpp" #include "utils/exceptions.hpp"
namespace io::network { namespace io::network {
@ -25,18 +27,23 @@ class NetworkEndpoint {
uint16_t port() const { return port_; } uint16_t port() const { return port_; }
unsigned char family() const { return family_; } unsigned char family() const { return family_; }
/** Required for cereal serialization. */
template <class Archive>
void serialize(Archive &archive) {
archive(address_, port_str_, port_, family_);
}
bool operator==(const NetworkEndpoint &other) const; bool operator==(const NetworkEndpoint &other) const;
private: private:
friend class boost::serialization::access;
template <class TArchive>
void serialize(TArchive &ar, unsigned int) {
ar &address_;
ar &port_str_;
ar &port_;
ar &family_;
}
char address_[INET6_ADDRSTRLEN]; char address_[INET6_ADDRSTRLEN];
char port_str_[6]; char port_str_[6];
uint16_t port_; uint16_t port_;
unsigned char family_; unsigned char family_;
}; };
}
} // namespace io::network

117
src/query/frontend/ast/ast.cpp
View File

@ -1,5 +1,10 @@
#include "query/frontend/ast/ast.hpp" #include "query/frontend/ast/ast.hpp"
// Include archives before registering most derived types.
#include "boost/archive/binary_iarchive.hpp"
#include "boost/archive/binary_oarchive.hpp"
#include "boost/serialization/export.hpp"
namespace query { namespace query {
AstTreeStorage::AstTreeStorage() { AstTreeStorage::AstTreeStorage() {
@ -35,62 +40,56 @@ ReturnBody CloneReturnBody(AstTreeStorage &storage, const ReturnBody &body) {
} // namespace query } // namespace query
// Include archives before registering most derived types. BOOST_CLASS_EXPORT(query::Query);
#include "boost/archive/binary_iarchive.hpp" BOOST_CLASS_EXPORT(query::SingleQuery);
#include "boost/archive/binary_oarchive.hpp" BOOST_CLASS_EXPORT(query::CypherUnion);
#include "boost/archive/text_iarchive.hpp" BOOST_CLASS_EXPORT(query::NamedExpression);
#include "boost/archive/text_oarchive.hpp" BOOST_CLASS_EXPORT(query::OrOperator);
BOOST_CLASS_EXPORT(query::XorOperator);
BOOST_CLASS_EXPORT_IMPLEMENT(query::Query); BOOST_CLASS_EXPORT(query::AndOperator);
BOOST_CLASS_EXPORT_IMPLEMENT(query::SingleQuery); BOOST_CLASS_EXPORT(query::NotOperator);
BOOST_CLASS_EXPORT_IMPLEMENT(query::CypherUnion); BOOST_CLASS_EXPORT(query::AdditionOperator);
BOOST_CLASS_EXPORT_IMPLEMENT(query::NamedExpression); BOOST_CLASS_EXPORT(query::SubtractionOperator);
BOOST_CLASS_EXPORT_IMPLEMENT(query::OrOperator); BOOST_CLASS_EXPORT(query::MultiplicationOperator);
BOOST_CLASS_EXPORT_IMPLEMENT(query::XorOperator); BOOST_CLASS_EXPORT(query::DivisionOperator);
BOOST_CLASS_EXPORT_IMPLEMENT(query::AndOperator); BOOST_CLASS_EXPORT(query::ModOperator);
BOOST_CLASS_EXPORT_IMPLEMENT(query::NotOperator); BOOST_CLASS_EXPORT(query::NotEqualOperator);
BOOST_CLASS_EXPORT_IMPLEMENT(query::AdditionOperator); BOOST_CLASS_EXPORT(query::EqualOperator);
BOOST_CLASS_EXPORT_IMPLEMENT(query::SubtractionOperator); BOOST_CLASS_EXPORT(query::LessOperator);
BOOST_CLASS_EXPORT_IMPLEMENT(query::MultiplicationOperator); BOOST_CLASS_EXPORT(query::GreaterOperator);
BOOST_CLASS_EXPORT_IMPLEMENT(query::DivisionOperator); BOOST_CLASS_EXPORT(query::LessEqualOperator);
BOOST_CLASS_EXPORT_IMPLEMENT(query::ModOperator); BOOST_CLASS_EXPORT(query::GreaterEqualOperator);
BOOST_CLASS_EXPORT_IMPLEMENT(query::NotEqualOperator); BOOST_CLASS_EXPORT(query::InListOperator);
BOOST_CLASS_EXPORT_IMPLEMENT(query::EqualOperator); BOOST_CLASS_EXPORT(query::ListMapIndexingOperator);
BOOST_CLASS_EXPORT_IMPLEMENT(query::LessOperator); BOOST_CLASS_EXPORT(query::ListSlicingOperator);
BOOST_CLASS_EXPORT_IMPLEMENT(query::GreaterOperator); BOOST_CLASS_EXPORT(query::IfOperator);
BOOST_CLASS_EXPORT_IMPLEMENT(query::LessEqualOperator); BOOST_CLASS_EXPORT(query::UnaryPlusOperator);
BOOST_CLASS_EXPORT_IMPLEMENT(query::GreaterEqualOperator); BOOST_CLASS_EXPORT(query::UnaryMinusOperator);
BOOST_CLASS_EXPORT_IMPLEMENT(query::InListOperator); BOOST_CLASS_EXPORT(query::IsNullOperator);
BOOST_CLASS_EXPORT_IMPLEMENT(query::ListMapIndexingOperator); BOOST_CLASS_EXPORT(query::ListLiteral);
BOOST_CLASS_EXPORT_IMPLEMENT(query::ListSlicingOperator); BOOST_CLASS_EXPORT(query::MapLiteral);
BOOST_CLASS_EXPORT_IMPLEMENT(query::IfOperator); BOOST_CLASS_EXPORT(query::PropertyLookup);
BOOST_CLASS_EXPORT_IMPLEMENT(query::UnaryPlusOperator); BOOST_CLASS_EXPORT(query::LabelsTest);
BOOST_CLASS_EXPORT_IMPLEMENT(query::UnaryMinusOperator); BOOST_CLASS_EXPORT(query::Aggregation);
BOOST_CLASS_EXPORT_IMPLEMENT(query::IsNullOperator); BOOST_CLASS_EXPORT(query::Function);
BOOST_CLASS_EXPORT_IMPLEMENT(query::ListLiteral); BOOST_CLASS_EXPORT(query::All);
BOOST_CLASS_EXPORT_IMPLEMENT(query::MapLiteral); BOOST_CLASS_EXPORT(query::ParameterLookup);
BOOST_CLASS_EXPORT_IMPLEMENT(query::PropertyLookup); BOOST_CLASS_EXPORT(query::Create);
BOOST_CLASS_EXPORT_IMPLEMENT(query::LabelsTest); BOOST_CLASS_EXPORT(query::Match);
BOOST_CLASS_EXPORT_IMPLEMENT(query::Aggregation); BOOST_CLASS_EXPORT(query::Return);
BOOST_CLASS_EXPORT_IMPLEMENT(query::Function); BOOST_CLASS_EXPORT(query::With);
BOOST_CLASS_EXPORT_IMPLEMENT(query::All); BOOST_CLASS_EXPORT(query::Pattern);
BOOST_CLASS_EXPORT_IMPLEMENT(query::ParameterLookup); BOOST_CLASS_EXPORT(query::NodeAtom);
BOOST_CLASS_EXPORT_IMPLEMENT(query::Create); BOOST_CLASS_EXPORT(query::EdgeAtom);
BOOST_CLASS_EXPORT_IMPLEMENT(query::Match); BOOST_CLASS_EXPORT(query::Delete);
BOOST_CLASS_EXPORT_IMPLEMENT(query::Return); BOOST_CLASS_EXPORT(query::Where);
BOOST_CLASS_EXPORT_IMPLEMENT(query::With); BOOST_CLASS_EXPORT(query::SetProperty);
BOOST_CLASS_EXPORT_IMPLEMENT(query::Pattern); BOOST_CLASS_EXPORT(query::SetProperties);
BOOST_CLASS_EXPORT_IMPLEMENT(query::NodeAtom); BOOST_CLASS_EXPORT(query::SetLabels);
BOOST_CLASS_EXPORT_IMPLEMENT(query::EdgeAtom); BOOST_CLASS_EXPORT(query::RemoveProperty);
BOOST_CLASS_EXPORT_IMPLEMENT(query::Delete); BOOST_CLASS_EXPORT(query::RemoveLabels);
BOOST_CLASS_EXPORT_IMPLEMENT(query::Where); BOOST_CLASS_EXPORT(query::Merge);
BOOST_CLASS_EXPORT_IMPLEMENT(query::SetProperty); BOOST_CLASS_EXPORT(query::Unwind);
BOOST_CLASS_EXPORT_IMPLEMENT(query::SetProperties); BOOST_CLASS_EXPORT(query::Identifier);
BOOST_CLASS_EXPORT_IMPLEMENT(query::SetLabels); BOOST_CLASS_EXPORT(query::PrimitiveLiteral);
BOOST_CLASS_EXPORT_IMPLEMENT(query::RemoveProperty); BOOST_CLASS_EXPORT(query::CreateIndex);
BOOST_CLASS_EXPORT_IMPLEMENT(query::RemoveLabels);
BOOST_CLASS_EXPORT_IMPLEMENT(query::Merge);
BOOST_CLASS_EXPORT_IMPLEMENT(query::Unwind);
BOOST_CLASS_EXPORT_IMPLEMENT(query::Identifier);
BOOST_CLASS_EXPORT_IMPLEMENT(query::PrimitiveLiteral);
BOOST_CLASS_EXPORT_IMPLEMENT(query::CreateIndex);

107
src/query/frontend/ast/ast.hpp
View File

@ -6,7 +6,6 @@
#include <vector> #include <vector>
#include "boost/serialization/base_object.hpp" #include "boost/serialization/base_object.hpp"
#include "boost/serialization/export.hpp"
#include "boost/serialization/split_member.hpp" #include "boost/serialization/split_member.hpp"
#include "boost/serialization/string.hpp" #include "boost/serialization/string.hpp"
#include "boost/serialization/vector.hpp" #include "boost/serialization/vector.hpp"
@ -39,23 +38,23 @@ namespace query {
#define CLONE_BINARY_EXPRESSION \ #define CLONE_BINARY_EXPRESSION \
auto Clone(AstTreeStorage &storage) const->std::remove_const< \ auto Clone(AstTreeStorage &storage) const->std::remove_const< \
std::remove_pointer<decltype(this)>::type>::type *override { \ std::remove_pointer<decltype(this)>::type>::type * override { \
return storage.Create< \ return storage.Create< \
std::remove_cv<std::remove_reference<decltype(*this)>::type>::type>( \ std::remove_cv<std::remove_reference<decltype(*this)>::type>::type>( \
expression1_->Clone(storage), expression2_->Clone(storage)); \ expression1_->Clone(storage), expression2_->Clone(storage)); \
} }
#define CLONE_UNARY_EXPRESSION \ #define CLONE_UNARY_EXPRESSION \
auto Clone(AstTreeStorage &storage) const->std::remove_const< \ auto Clone(AstTreeStorage &storage) const->std::remove_const< \
std::remove_pointer<decltype(this)>::type>::type *override { \ std::remove_pointer<decltype(this)>::type>::type * override { \
return storage.Create< \ return storage.Create< \
std::remove_cv<std::remove_reference<decltype(*this)>::type>::type>( \ std::remove_cv<std::remove_reference<decltype(*this)>::type>::type>( \
expression_->Clone(storage)); \ expression_->Clone(storage)); \
} }
#define SERIALIZE_USING_BASE(BaseClass) \ #define SERIALIZE_USING_BASE(BaseClass) \
template <class TArchive> \ template <class TArchive> \
void serialize(TArchive &ar, const unsigned int) { \ void serialize(TArchive &ar, const unsigned int) { \
ar & boost::serialization::base_object<BaseClass>(*this); \ ar &boost::serialization::base_object<BaseClass>(*this); \
} }
class Tree; class Tree;
@ -173,7 +172,7 @@ class Tree : public ::utils::Visitable<HierarchicalTreeVisitor>,
template <class TArchive> template <class TArchive>
void serialize(TArchive &ar, const unsigned int) { void serialize(TArchive &ar, const unsigned int) {
ar & uid_; ar &uid_;
} }
}; };
@ -1244,9 +1243,9 @@ class Identifier : public Expression {
template <class TArchive> template <class TArchive>
void serialize(TArchive &ar, const unsigned int) { void serialize(TArchive &ar, const unsigned int) {
ar & boost::serialization::base_object<Expression>(*this); ar &boost::serialization::base_object<Expression>(*this);
ar & name_; ar &name_;
ar & user_declared_; ar &user_declared_;
} }
template <class TArchive> template <class TArchive>
@ -1482,8 +1481,8 @@ class Aggregation : public BinaryOperator {
template <class TArchive> template <class TArchive>
void serialize(TArchive &ar, const unsigned int) { void serialize(TArchive &ar, const unsigned int) {
ar & boost::serialization::base_object<BinaryOperator>(*this); ar &boost::serialization::base_object<BinaryOperator>(*this);
ar & op_; ar &op_;
} }
template <class TArchive> template <class TArchive>
@ -1575,8 +1574,8 @@ class ParameterLookup : public Expression {
template <class TArchive> template <class TArchive>
void serialize(TArchive &ar, const unsigned int) { void serialize(TArchive &ar, const unsigned int) {
ar & boost::serialization::base_object<Expression>(*this); ar &boost::serialization::base_object<Expression>(*this);
ar & token_position_; ar &token_position_;
} }
template <class TArchive> template <class TArchive>
@ -2361,8 +2360,8 @@ class Return : public Clause {
template <class TArchive> template <class TArchive>
void serialize(TArchive &ar, const unsigned int) { void serialize(TArchive &ar, const unsigned int) {
ar & boost::serialization::base_object<Clause>(*this); ar &boost::serialization::base_object<Clause>(*this);
ar & body_; ar &body_;
} }
template <class TArchive> template <class TArchive>
@ -2890,9 +2889,9 @@ class CreateIndex : public Clause {
template <class TArchive> template <class TArchive>
void serialize(TArchive &ar, const unsigned int) { void serialize(TArchive &ar, const unsigned int) {
ar & boost::serialization::base_object<Clause>(*this); ar &boost::serialization::base_object<Clause>(*this);
ar & label_; ar &label_;
ar & property_; ar &property_;
} }
template <class TArchive> template <class TArchive>
@ -2904,72 +2903,20 @@ class CreateIndex : public Clause {
#undef CLONE_BINARY_EXPRESSION #undef CLONE_BINARY_EXPRESSION
#undef CLONE_UNARY_EXPRESSION #undef CLONE_UNARY_EXPRESSION
#undef SERIALIZE_USING_BASE #undef SERIALIZE_USING_BASE
} // namespace query } // namespace query
// All of the serialization cruft follows // All of the serialization cruft follows
BOOST_CLASS_EXPORT_KEY(query::Query); #define LOAD_AND_CONSTRUCT(DerivedClass, ...) \
BOOST_CLASS_EXPORT_KEY(query::SingleQuery); template <class TArchive> \
BOOST_CLASS_EXPORT_KEY(query::CypherUnion); void load_construct_data(TArchive &, DerivedClass *cls, \
BOOST_CLASS_EXPORT_KEY(query::NamedExpression); const unsigned int) { \
BOOST_CLASS_EXPORT_KEY(query::OrOperator); ::new (cls) DerivedClass(__VA_ARGS__); \
BOOST_CLASS_EXPORT_KEY(query::XorOperator);
BOOST_CLASS_EXPORT_KEY(query::AndOperator);
BOOST_CLASS_EXPORT_KEY(query::NotOperator);
BOOST_CLASS_EXPORT_KEY(query::AdditionOperator);
BOOST_CLASS_EXPORT_KEY(query::SubtractionOperator);
BOOST_CLASS_EXPORT_KEY(query::MultiplicationOperator);
BOOST_CLASS_EXPORT_KEY(query::DivisionOperator);
BOOST_CLASS_EXPORT_KEY(query::ModOperator);
BOOST_CLASS_EXPORT_KEY(query::NotEqualOperator);
BOOST_CLASS_EXPORT_KEY(query::EqualOperator);
BOOST_CLASS_EXPORT_KEY(query::LessOperator);
BOOST_CLASS_EXPORT_KEY(query::GreaterOperator);
BOOST_CLASS_EXPORT_KEY(query::LessEqualOperator);
BOOST_CLASS_EXPORT_KEY(query::GreaterEqualOperator);
BOOST_CLASS_EXPORT_KEY(query::InListOperator);
BOOST_CLASS_EXPORT_KEY(query::ListMapIndexingOperator);
BOOST_CLASS_EXPORT_KEY(query::ListSlicingOperator);
BOOST_CLASS_EXPORT_KEY(query::IfOperator);
BOOST_CLASS_EXPORT_KEY(query::UnaryPlusOperator);
BOOST_CLASS_EXPORT_KEY(query::UnaryMinusOperator);
BOOST_CLASS_EXPORT_KEY(query::IsNullOperator);
BOOST_CLASS_EXPORT_KEY(query::ListLiteral);
BOOST_CLASS_EXPORT_KEY(query::MapLiteral);
BOOST_CLASS_EXPORT_KEY(query::PropertyLookup);
BOOST_CLASS_EXPORT_KEY(query::LabelsTest);
BOOST_CLASS_EXPORT_KEY(query::Aggregation);
BOOST_CLASS_EXPORT_KEY(query::Function);
BOOST_CLASS_EXPORT_KEY(query::All);
BOOST_CLASS_EXPORT_KEY(query::ParameterLookup);
BOOST_CLASS_EXPORT_KEY(query::Create);
BOOST_CLASS_EXPORT_KEY(query::Match);
BOOST_CLASS_EXPORT_KEY(query::Return);
BOOST_CLASS_EXPORT_KEY(query::With);
BOOST_CLASS_EXPORT_KEY(query::Pattern);
BOOST_CLASS_EXPORT_KEY(query::NodeAtom);
BOOST_CLASS_EXPORT_KEY(query::EdgeAtom);
BOOST_CLASS_EXPORT_KEY(query::Delete);
BOOST_CLASS_EXPORT_KEY(query::Where);
BOOST_CLASS_EXPORT_KEY(query::SetProperty);
BOOST_CLASS_EXPORT_KEY(query::SetProperties);
BOOST_CLASS_EXPORT_KEY(query::SetLabels);
BOOST_CLASS_EXPORT_KEY(query::RemoveProperty);
BOOST_CLASS_EXPORT_KEY(query::RemoveLabels);
BOOST_CLASS_EXPORT_KEY(query::Merge);
BOOST_CLASS_EXPORT_KEY(query::Unwind);
BOOST_CLASS_EXPORT_KEY(query::Identifier);
BOOST_CLASS_EXPORT_KEY(query::PrimitiveLiteral);
BOOST_CLASS_EXPORT_KEY(query::CreateIndex);
#define LOAD_AND_CONSTRUCT(DerivedClass, ...) \
template <class TArchive> \
void load_construct_data(TArchive &ar, DerivedClass *cls, \
const unsigned int) { \
::new (cls) DerivedClass(__VA_ARGS__); \
} }
namespace boost::serialization { namespace boost::serialization {
LOAD_AND_CONSTRUCT(query::Where, 0); LOAD_AND_CONSTRUCT(query::Where, 0);
LOAD_AND_CONSTRUCT(query::OrOperator, 0); LOAD_AND_CONSTRUCT(query::OrOperator, 0);
LOAD_AND_CONSTRUCT(query::XorOperator, 0); LOAD_AND_CONSTRUCT(query::XorOperator, 0);
@ -3026,7 +2973,7 @@ LOAD_AND_CONSTRUCT(query::RemoveLabels, 0);
LOAD_AND_CONSTRUCT(query::Merge, 0); LOAD_AND_CONSTRUCT(query::Merge, 0);
LOAD_AND_CONSTRUCT(query::Unwind, 0); LOAD_AND_CONSTRUCT(query::Unwind, 0);
LOAD_AND_CONSTRUCT(query::CreateIndex, 0); LOAD_AND_CONSTRUCT(query::CreateIndex, 0);
} // namespace boost::serialization } // namespace boost::serialization
#undef LOAD_AND_CONSTRUCT #undef LOAD_AND_CONSTRUCT

1
src/storage/concurrent_id_mapper.hpp
View File

@ -19,4 +19,5 @@ class ConcurrentIdMapper {
virtual const std::string &id_to_value(const TId &id) = 0; virtual const std::string &id_to_value(const TId &id) = 0;
virtual ~ConcurrentIdMapper() {} virtual ~ConcurrentIdMapper() {}
}; };
} // namespace storage } // namespace storage

12
src/storage/concurrent_id_mapper_rpc_messages.hpp
View File

@ -31,15 +31,3 @@ ID_VALUE_RPC(Property)
#undef ID_VALUE_RPC #undef ID_VALUE_RPC
} // namespace storage } // namespace storage
#define ID_VALUE_REGISTER_CEREAL_TYPE(type) \
CEREAL_REGISTER_TYPE(storage::type##IdReq); \
CEREAL_REGISTER_TYPE(storage::type##IdRes); \
CEREAL_REGISTER_TYPE(storage::Id##type##Req); \
CEREAL_REGISTER_TYPE(storage::Id##type##Res);
ID_VALUE_REGISTER_CEREAL_TYPE(Label)
ID_VALUE_REGISTER_CEREAL_TYPE(EdgeType)
ID_VALUE_REGISTER_CEREAL_TYPE(Property)
#undef ID_VALUE_REGISTER_CEREAL_TYPE

16
src/transactions/commit_log.hpp
View File

@ -1,5 +1,7 @@
#pragma once #pragma once
#include "boost/serialization/access.hpp"
#include "data_structures/bitset/dynamic_bitset.hpp" #include "data_structures/bitset/dynamic_bitset.hpp"
#include "type.hpp" #include "type.hpp"
@ -33,13 +35,13 @@ class CommitLog {
class Info { class Info {
public: public:
Info() {} // Needed for serialization.
enum Status { enum Status {
ACTIVE = 0, // 00 ACTIVE = 0, // 00
COMMITTED = 1, // 01 COMMITTED = 1, // 01
ABORTED = 2, // 10 ABORTED = 2, // 10
}; };
Info() = default; // Required for cereal serialization
explicit Info(uint8_t flags) : flags_(flags) {} explicit Info(uint8_t flags) : flags_(flags) {}
bool is_active() const { return flags_ == ACTIVE; } bool is_active() const { return flags_ == ACTIVE; }
@ -50,13 +52,14 @@ class CommitLog {
operator uint8_t() const { return flags_; } operator uint8_t() const { return flags_; }
/** Required for cereal serialization. */ private:
template <class Archive> friend class boost::serialization::access;
void serialize(Archive &archive) {
archive(flags_); template <class TArchive>
void serialize(TArchive &ar, unsigned int) {
ar &flags_;
} }
private:
uint8_t flags_{0}; uint8_t flags_{0};
}; };
@ -65,4 +68,5 @@ class CommitLog {
private: private:
DynamicBitset<uint8_t, 32768> log; DynamicBitset<uint8_t, 32768> log;
}; };
} // namespace tx } // namespace tx

13
src/transactions/engine_rpc_messages.hpp
View File

@ -1,11 +1,10 @@
#pragma once #pragma once
#include "utils/rpc_pimp.hpp"
#include "communication/rpc/rpc.hpp" #include "communication/rpc/rpc.hpp"
#include "transactions/commit_log.hpp" #include "transactions/commit_log.hpp"
#include "transactions/snapshot.hpp" #include "transactions/snapshot.hpp"
#include "transactions/type.hpp" #include "transactions/type.hpp"
#include "utils/rpc_pimp.hpp"
namespace tx { namespace tx {
@ -30,13 +29,5 @@ using ActiveTransactionsRpc =
communication::rpc::RequestResponse<ActiveTransactionsReq, SnapshotRes>; communication::rpc::RequestResponse<ActiveTransactionsReq, SnapshotRes>;
using IsActiveRpc = using IsActiveRpc =
communication::rpc::RequestResponse<IsActiveReq, IsActiveRes>; communication::rpc::RequestResponse<IsActiveReq, IsActiveRes>;
} // namespace tx
CEREAL_REGISTER_TYPE(tx::SnapshotReq); } // namespace tx
CEREAL_REGISTER_TYPE(tx::SnapshotRes);
CEREAL_REGISTER_TYPE(tx::GcSnapshotReq);
CEREAL_REGISTER_TYPE(tx::ClogInfoReq);
CEREAL_REGISTER_TYPE(tx::ClogInfoRes);
CEREAL_REGISTER_TYPE(tx::ActiveTransactionsReq);
CEREAL_REGISTER_TYPE(tx::IsActiveReq);
CEREAL_REGISTER_TYPE(tx::IsActiveRes);

2
src/transactions/engine_worker.cpp
View File

@ -7,7 +7,7 @@
namespace tx { namespace tx {
namespace { namespace {
static const auto kRpcTimeout = 100ms; static const auto kRpcTimeout = 100ms;
} } // namespace
WorkerEngine::WorkerEngine(communication::messaging::System &system, WorkerEngine::WorkerEngine(communication::messaging::System &system,
const io::network::NetworkEndpoint &endpoint) const io::network::NetworkEndpoint &endpoint)

2
src/transactions/engine_worker.hpp
View File

@ -12,6 +12,7 @@
#include "transactions/transaction.hpp" #include "transactions/transaction.hpp"
namespace tx { namespace tx {
/** A transactional engine for the worker in a distributed system. */ /** A transactional engine for the worker in a distributed system. */
class WorkerEngine : public Engine { class WorkerEngine : public Engine {
public: public:
@ -38,4 +39,5 @@ class WorkerEngine : public Engine {
// Communication to the transactional master. // Communication to the transactional master.
mutable communication::rpc::Client rpc_client_; mutable communication::rpc::Client rpc_client_;
}; };
} // namespace tx } // namespace tx

14
src/transactions/snapshot.hpp
View File

@ -4,6 +4,9 @@
#include <iostream> #include <iostream>
#include <vector> #include <vector>
#include "boost/serialization/access.hpp"
#include "boost/serialization/vector.hpp"
#include "glog/logging.h" #include "glog/logging.h"
#include "transactions/type.hpp" #include "transactions/type.hpp"
#include "utils/algorithm.hpp" #include "utils/algorithm.hpp"
@ -84,13 +87,14 @@ class Snapshot {
return stream; return stream;
} }
/** Required for cereal serialization. */ private:
template <class Archive> friend class boost::serialization::access;
void serialize(Archive &archive) {
archive(transaction_ids_); template <class TArchive>
void serialize(TArchive &ar, unsigned int) {
ar &transaction_ids_;
} }
private:
std::vector<transaction_id_t> transaction_ids_; std::vector<transaction_id_t> transaction_ids_;
}; };
} // namespace tx } // namespace tx

28
src/utils/cereal_optional.hpp
View File

@ -1,28 +0,0 @@
#pragma once
#include <experimental/optional>
namespace cereal {
template <class Archive, class T>
void save(Archive &ar, const std::experimental::optional<T> &opt) {
ar(static_cast<bool>(opt));
if (opt) {
ar(*opt);
}
}
template <class Archive, class T>
void load(Archive &ar, std::experimental::optional<T> &opt) {
bool has_value;
ar(has_value);
if (has_value) {
T tmp;
ar(tmp);
opt = std::move(tmp);
} else {
opt = std::experimental::nullopt;
}
}
} // namespace cereal

54
src/utils/rpc_pimp.hpp
View File

@ -1,34 +1,36 @@
#pragma once #pragma once
#include "cereal/archives/binary.hpp" #include "boost/serialization/base_object.hpp"
#include "cereal/types/base_class.hpp"
#include "cereal/types/memory.hpp"
#include "cereal/types/polymorphic.hpp"
#include "cereal/types/string.hpp"
#include "cereal/types/utility.hpp"
#include "cereal/types/vector.hpp"
#include "communication/messaging/local.hpp" #include "communication/messaging/local.hpp"
#define RPC_NO_MEMBER_MESSAGE(name) \ #define RPC_NO_MEMBER_MESSAGE(name) \
using communication::messaging::Message; \ struct name : public communication::messaging::Message { \
struct name : public Message { \ name() {} \
name() {} \ \
template <class Archive> \ private: \
void serialize(Archive &ar) { \ friend class boost::serialization::access; \
ar(::cereal::virtual_base_class<Message>(this)); \ \
} \ template <class TArchive> \
void serialize(TArchive &ar, unsigned int) { \
ar &boost::serialization::base_object< \
communication::messaging::Message>(*this); \
} \
}; };
#define RPC_SINGLE_MEMBER_MESSAGE(name, type) \ #define RPC_SINGLE_MEMBER_MESSAGE(name, type) \
using communication::messaging::Message; \ struct name : public communication::messaging::Message { \
struct name : public Message { \ name() {} \
name() {} \ name(const type &member) : member(member) {} \
name(const type &member) : member(member) {} \ type member; \
type member; \ \
template <class Archive> \ private: \
void serialize(Archive &ar) { \ friend class boost::serialization::access; \
ar(::cereal::virtual_base_class<Message>(this), member); \ \
} \ template <class TArchive> \
void serialize(TArchive &ar, unsigned int) { \
ar &boost::serialization::base_object< \
communication::messaging::Message>(*this); \
ar &member; \
} \
}; };

35
src/utils/serialization_optional.hpp Normal file
View File

@ -0,0 +1,35 @@
#include <experimental/optional>
#include "boost/serialization/split_free.hpp"
namespace boost::serialization {
template <class TArchive, class T>
inline void serialize(TArchive &ar, std::experimental::optional<T> &opt,
unsigned int version) {
split_free(ar, opt, version);
}
template <class TArchive, class T>
void save(TArchive &ar, const std::experimental::optional<T> &opt,
unsigned int) {
ar << static_cast<bool>(opt);
if (opt) {
ar << *opt;
}
}
template <class TArchive, class T>
void load(TArchive &ar, std::experimental::optional<T> &opt, unsigned int) {
bool has_value;
ar >> has_value;
if (has_value) {
T tmp;
ar >> tmp;
opt = std::move(tmp);
} else {
opt = std::experimental::nullopt;
}
}
} // boost::serialization

17
tests/manual/raft_rpc.cpp
View File

@ -1,3 +1,11 @@
#include "boost/serialization/export.hpp"
#include "boost/archive/binary_iarchive.hpp"
#include "boost/archive/binary_oarchive.hpp"
#include "boost/archive/text_iarchive.hpp"
#include "boost/archive/text_oarchive.hpp"
#include "boost/serialization/export.hpp"
#include "communication/messaging/distributed.hpp" #include "communication/messaging/distributed.hpp"
#include "communication/raft/rpc.hpp" #include "communication/raft/rpc.hpp"
#include "communication/raft/test_utils.hpp" #include "communication/raft/test_utils.hpp"
@ -12,8 +20,8 @@ using raft::test_utils::InMemoryStorageInterface;
DEFINE_string(member_id, "", "id of RaftMember"); DEFINE_string(member_id, "", "id of RaftMember");
CEREAL_REGISTER_TYPE(raft::PeerRpcReply); BOOST_CLASS_EXPORT(raft::PeerRpcReply);
CEREAL_REGISTER_TYPE(raft::PeerRpcRequest<DummyState>); BOOST_CLASS_EXPORT(raft::PeerRpcRequest<DummyState>);
/* Start cluster members with: /* Start cluster members with:
* ./raft_rpc --member-id a * ./raft_rpc --member-id a
@ -42,8 +50,9 @@ int main(int argc, char *argv[]) {
{ {
raft::RaftMember<DummyState> raft_member(network, storage, FLAGS_member_id, raft::RaftMember<DummyState> raft_member(network, storage, FLAGS_member_id,
config); config);
while (true) while (true) {
; continue;
}
} }
my_system.Shutdown(); my_system.Shutdown();

29
tests/unit/cereal_optional.cpp
View File

@ -1,29 +0,0 @@
#include <sstream>
#include "cereal/archives/json.hpp"
#include "gtest/gtest.h"
#include "utils/cereal_optional.hpp"
using std::experimental::optional;
TEST(CerealOptionalTest, SerializeAndDeserialize) {
std::stringstream ss;
optional<int> x1 = {};
optional<int> x2 = 42;
optional<int> y1, y2;
{
cereal::JSONOutputArchive oarchive(ss);
oarchive(x1, x2);
}
{
cereal::JSONInputArchive iarchive(ss);
iarchive(y1, y2);
}
EXPECT_EQ(x1, y1);
EXPECT_EQ(x2, y2);
}

8
tests/unit/cypher_main_visitor.cpp
View File

@ -6,8 +6,8 @@
#include <vector> #include <vector>
#include "antlr4-runtime.h" #include "antlr4-runtime.h"
#include "boost/archive/text_iarchive.hpp" #include "boost/archive/binary_iarchive.hpp"
#include "boost/archive/text_oarchive.hpp" #include "boost/archive/binary_oarchive.hpp"
#include "gmock/gmock.h" #include "gmock/gmock.h"
#include "gtest/gtest.h" #include "gtest/gtest.h"
@ -121,12 +121,12 @@ class SerializedAstGenerator : public Base {
visitor.visit(parser.tree()); visitor.visit(parser.tree());
std::stringstream stream; std::stringstream stream;
{ {
boost::archive::text_oarchive out_archive(stream); boost::archive::binary_oarchive out_archive(stream);
out_archive << *visitor.query(); out_archive << *visitor.query();
} }
AstTreeStorage new_ast; AstTreeStorage new_ast;
{ {
boost::archive::text_iarchive in_archive(stream); boost::archive::binary_iarchive in_archive(stream);
new_ast.Load(in_archive); new_ast.Load(in_archive);
} }
return new_ast; return new_ast;

1
tests/unit/distributed_coordination.cpp
View File

@ -1,6 +1,7 @@
#include <experimental/optional> #include <experimental/optional>
#include <memory> #include <memory>
#include <thread> #include <thread>
#include <unordered_set>
#include <vector> #include <vector>
#include "gtest/gtest.h" #include "gtest/gtest.h"

24
tests/unit/messaging_distributed.cpp
View File

@ -7,23 +7,35 @@
#include <thread> #include <thread>
#include <vector> #include <vector>
#include "communication/messaging/distributed.hpp" #include "boost/archive/binary_iarchive.hpp"
#include "boost/archive/binary_oarchive.hpp"
#include "boost/archive/text_iarchive.hpp"
#include "boost/archive/text_oarchive.hpp"
#include "boost/serialization/access.hpp"
#include "boost/serialization/base_object.hpp"
#include "boost/serialization/export.hpp"
#include "gtest/gtest.h" #include "gtest/gtest.h"
#include "communication/messaging/distributed.hpp"
using namespace communication::messaging; using namespace communication::messaging;
using namespace std::literals::chrono_literals; using namespace std::literals::chrono_literals;
struct MessageInt : public Message { struct MessageInt : public Message {
MessageInt() {} // cereal needs this
MessageInt(int x) : x(x) {} MessageInt(int x) : x(x) {}
int x; int x;
template <class Archive> private:
void serialize(Archive &ar) { friend class boost::serialization::access;
ar(cereal::virtual_base_class<Message>(this), x); MessageInt() {} // Needed for serialization
template <class TArchive>
void serialize(TArchive &ar, unsigned int) {
ar &boost::serialization::base_object<Message>(*this);
ar &x;
} }
}; };
CEREAL_REGISTER_TYPE(MessageInt); BOOST_CLASS_EXPORT(MessageInt);
#define GET_X(p) dynamic_cast<MessageInt *>((p).get())->x #define GET_X(p) dynamic_cast<MessageInt *>((p).get())->x

40
tests/unit/rpc.cpp
View File

@ -1,8 +1,15 @@
#include <thread>
#include "boost/archive/binary_iarchive.hpp"
#include "boost/archive/binary_oarchive.hpp"
#include "boost/archive/text_iarchive.hpp"
#include "boost/archive/text_oarchive.hpp"
#include "boost/serialization/access.hpp"
#include "boost/serialization/base_object.hpp"
#include "boost/serialization/export.hpp"
#include "gmock/gmock.h" #include "gmock/gmock.h"
#include "gtest/gtest.h" #include "gtest/gtest.h"
#include <thread>
#include "communication/messaging/distributed.hpp" #include "communication/messaging/distributed.hpp"
#include "communication/rpc/rpc.hpp" #include "communication/rpc/rpc.hpp"
#include "gtest/gtest.h" #include "gtest/gtest.h"
@ -13,29 +20,38 @@ using namespace communication::rpc;
using namespace std::literals::chrono_literals; using namespace std::literals::chrono_literals;
struct SumReq : public Message { struct SumReq : public Message {
SumReq() {} // cereal needs this
SumReq(int x, int y) : x(x), y(y) {} SumReq(int x, int y) : x(x), y(y) {}
int x; int x;
int y; int y;
template <class Archive> private:
void serialize(Archive &ar) { friend class boost::serialization::access;
ar(cereal::virtual_base_class<Message>(this), x, y); SumReq() {} // Needed for serialization.
template <class TArchive>
void serialize(TArchive &ar, unsigned int) {
ar &boost::serialization::base_object<Message>(*this);
ar &x;
ar &y;
} }
}; };
CEREAL_REGISTER_TYPE(SumReq); BOOST_CLASS_EXPORT(SumReq);
struct SumRes : public Message { struct SumRes : public Message {
SumRes() {} // cereal needs this
SumRes(int sum) : sum(sum) {} SumRes(int sum) : sum(sum) {}
int sum; int sum;
template <class Archive> private:
void serialize(Archive &ar) { friend class boost::serialization::access;
ar(cereal::virtual_base_class<Message>(this), sum); SumRes() {} // Needed for serialization.
template <class TArchive>
void serialize(TArchive &ar, unsigned int) {
ar &boost::serialization::base_object<Message>(*this);
ar &sum;
} }
}; };
CEREAL_REGISTER_TYPE(SumRes); BOOST_CLASS_EXPORT(SumRes);
using Sum = RequestResponse<SumReq, SumRes>; using Sum = RequestResponse<SumReq, SumRes>;
TEST(Rpc, Call) { TEST(Rpc, Call) {

33
tests/unit/serialization_optional.cpp Normal file
View File

@ -0,0 +1,33 @@
#include <experimental/optional>
#include <sstream>
#include "gtest/gtest.h"
#include "boost/archive/binary_iarchive.hpp"
#include "boost/archive/binary_oarchive.hpp"
#include "utils/serialization_optional.hpp"
using std::experimental::optional;
TEST(SerializationOptionalTest, SerializeAndDeserialize) {
std::stringstream ss;
optional<int> x1 = {};
optional<int> x2 = 42;
optional<int> y1, y2;
{
boost::archive::binary_oarchive ar(ss);
ar << x1;
ar << x2;
}
{
boost::archive::binary_iarchive ar(ss);
ar >> y1;
ar >> y2;
}
EXPECT_EQ(x1, y1);
EXPECT_EQ(x2, y2);
}

1
tests/unit/transaction_engine_worker.cpp
View File

@ -5,6 +5,7 @@
#include "communication/messaging/distributed.hpp" #include "communication/messaging/distributed.hpp"
#include "io/network/network_endpoint.hpp" #include "io/network/network_endpoint.hpp"
#include "transactions/engine_master.hpp" #include "transactions/engine_master.hpp"
#include "transactions/engine_rpc_messages.hpp"
#include "transactions/engine_worker.hpp" #include "transactions/engine_worker.hpp"
using namespace tx; using namespace tx;

62
tools/rpcgen
View File

@ -1,62 +0,0 @@
#!/usr/bin/env python3
# To run from vim add to your .vimrc something similar to:
# command -nargs=* Rpcgen :r !/home/mislav/code/memgraph/tools/rpcgen <args>
import sys
USAGE = "\n\nUsage:\n" \
"./rpcgen request_response_name request_args -- response_args\n" \
"Arguments should be seperated with minus sign (-).\n" \
"Example: ./rpcgen Sum int x - int y -- int sum\n\n"
assert len(sys.argv) >= 3, "Too few arguments.\n" + USAGE
request_response_name = sys.argv[1]
args_string = " ".join(sys.argv[2:])
split = args_string.split("--")
assert len(split) == 2, "Arguments should contain one -- separator.\n" + USAGE
request_args, response_args = split
def generate(message_name, args):
def process_arg(arg):
arg = arg.strip()
assert arg, "Each arg should be non empty string.\n" + USAGE
for i in range(len(arg) - 1, -1, -1):
if not arg[i].isalpha() and arg[i] != "_": break
assert i != -1 and i != len(arg), "Each string separated with - " \
"should contain type and variable name.\n" + USAGE
typ = arg[:i+1].strip()
name = arg[i+1:].strip()
return typ, name
types, names = zip(*map(process_arg, args.split("-")))
return \
"""
struct {message_name} : public Message {{
{message_name}() {{}} // cereal needs this
{message_name}({constructor_args}): {init_list} {{}}
{members}
template <class Archive>
void serialize(Archive &ar) {{
ar(cereal::virtual_base_class<Message>(this), {serialize_args});
}}
}};
CEREAL_REGISTER_TYPE({message_name});""" \
.format(message_name=message_name,
constructor_args=",".join(
map(lambda x: x[0] + " " + x[1], zip(types, names))),
init_list=", ".join(map(lambda x: "{x}({x})".format(x=x), names)),
members="\n".join(map(lambda x:
"{} {};".format(x[0], x[1]), zip(types, names))),
serialize_args=", ".join(names))
request_name = request_response_name + "Req"
response_name = request_response_name + "Res"
req_class = generate(request_name, request_args)
res_class = generate(response_name, response_args)
print(req_class)
print(res_class)
print("using {} = RequestResponse<{}, {}>;".format(
request_response_name, request_name, response_name))