lib/wsrep-lib
1
0
Fork 0
mirror of https://github.com/codership/wsrep-lib.git synced 2025-07-24 10:42:31 +03:00
Code Activity

Renamed server_context to server_state.

Browse Source
This commit is contained in:
Teemu Ollakka
2018-06-17 10:07:48 +03:00
parent 790c2bec4e
commit ef4baa9f9d
29 changed files with 212 additions and 297 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
dbsim/CMakeLists.txt
View File

@ -7,7 +7,7 @@ add_executable(dbsim
db_client_service.cpp
db_params.cpp
db_server.cpp
db_server_context.cpp
db_server_state.cpp
db_simulator.cpp
db_storage_engine.cpp
dbsim.cpp

6
dbsim/db_client.cpp
View File

@ -12,9 +12,9 @@ db::client::client(db::server& server,
: mutex_()
, params_(params)
, server_(server)
, server_context_(server.server_context())
, client_state_(mutex_, this, server_context_, client_service_, client_id, mode)
, client_service_(server_context_.provider(), client_state_)
, server_state_(server.server_state())
, client_state_(mutex_, this, server_state_, client_service_, client_id, mode)
, client_service_(server_state_.provider(), client_state_)
, se_trx_(server.storage_engine())
, stats_()
{ }

6
dbsim/db_client.hpp
View File

@ -5,7 +5,7 @@
#ifndef WSREP_DB_CLIENT_HPP
#define WSREP_DB_CLIENT_HPP
#include "db_server_context.hpp"
#include "db_server_state.hpp"
#include "db_storage_engine.hpp"
#include "db_client_state.hpp"
#include "db_client_service.hpp"
@ -43,7 +43,7 @@ namespace db
void start();
wsrep::client_state& client_state() { return client_state_; }
private:
friend class db::server_context;
friend class db::server_state;
friend class db::client_service;
template <class F> int client_command(F f);
void run_one_transaction();
@ -52,7 +52,7 @@ namespace db
wsrep::default_mutex mutex_;
const db::params& params_;
db::server& server_;
db::server_context& server_context_;
db::server_state& server_state_;
db::client_state client_state_;
db::client_service client_service_;
db::storage_engine::transaction se_trx_;

6
dbsim/db_client_state.hpp
View File

@ -6,7 +6,7 @@
#define WSREP_DB_CLIENT_CONTEXT_HPP
#include "wsrep/client_state.hpp"
#include "db_server_context.hpp"
#include "db_server_state.hpp"
namespace db
{
@ -16,12 +16,12 @@ namespace db
public:
client_state(wsrep::mutex& mutex,
db::client* client,
db::server_context& server_context,
db::server_state& server_state,
wsrep::client_service& client_service,
const wsrep::client_id& client_id,
enum wsrep::client_state::mode mode)
: wsrep::client_state(mutex,
server_context,
server_state,
client_service,
client_id,
mode)

4
dbsim/db_server.cpp
View File

@ -14,7 +14,7 @@ db::server::server(simulator& simulator,
, storage_engine_(simulator_.params())
, mutex_()
, cond_()
, server_context_(*this, name, server_id, address, "dbsim_" + name + "_data")
, server_state_(*this, name, server_id, address, "dbsim_" + name + "_data")
, last_client_id_(0)
, last_transaction_id_(0)
, appliers_()
@ -31,7 +31,7 @@ void db::server::applier_thread()
wsrep::client_state* cc(static_cast<wsrep::client_state*>(
&applier.client_state()));
enum wsrep::provider::status ret(
server_context_.provider().run_applier(cc));
server_state_.provider().run_applier(cc));
wsrep::log() << "Applier thread exited with error code " << ret;
}

6
dbsim/db_server.hpp
View File

@ -9,7 +9,7 @@
#include "wsrep/client_state.hpp"
#include "db_storage_engine.hpp"
#include "db_server_context.hpp"
#include "db_server_state.hpp"
#include <boost/thread.hpp>
@ -34,7 +34,7 @@ namespace db
void stop_clients();
void client_thread(const std::shared_ptr<db::client>& client);
db::storage_engine& storage_engine() { return storage_engine_; }
db::server_context& server_context() { return server_context_; }
db::server_state& server_state() { return server_state_; }
wsrep::transaction_id next_transaction_id()
{
return (last_transaction_id_.fetch_add(1) + 1);
@ -51,7 +51,7 @@ namespace db
db::storage_engine storage_engine_;
wsrep::default_mutex mutex_;
wsrep::default_condition_variable cond_;
db::server_context server_context_;
db::server_state server_state_;
std::atomic<size_t> last_client_id_;
std::atomic<size_t> last_transaction_id_;
std::vector<boost::thread> appliers_;

18
dbsim/db_server_context.cpp → dbsim/db_server_state.cpp
View File

@ -2,46 +2,46 @@
// Copyright (C) 2018 Codership Oy <info@codership.com>
//
#include "db_server_context.hpp"
#include "db_server_state.hpp"
#include "db_server.hpp"
wsrep::client_state* db::server_context::local_client_state()
wsrep::client_state* db::server_state::local_client_state()
{
return server_.local_client_state();
}
wsrep::client_state* db::server_context::streaming_applier_client_state()
wsrep::client_state* db::server_state::streaming_applier_client_state()
{
return server_.streaming_applier_client_state();
}
void db::server_context::release_client_state(
void db::server_state::release_client_state(
wsrep::client_state* client_state)
{
server_.release_client_state(client_state);
}
bool db::server_context::sst_before_init() const
bool db::server_state::sst_before_init() const
{
return false;
}
std::string db::server_context::on_sst_required()
std::string db::server_state::on_sst_required()
{
return id();
}
void db::server_context::on_sst_request(
void db::server_state::on_sst_request(
const std::string& request, const wsrep::gtid& gtid, bool bypass)
{
server_.donate_sst(request, gtid, bypass);
}
void db::server_context::background_rollback(wsrep::client_state&)
void db::server_state::background_rollback(wsrep::client_state&)
{
}
void db::server_context::log_dummy_write_set(
void db::server_state::log_dummy_write_set(
wsrep::client_state&, const wsrep::ws_meta& meta)
{
wsrep::log_info() << "Dummy write set: " << meta.seqno();

10
dbsim/db_server_context.hpp → dbsim/db_server_state.hpp
View File

@ -5,7 +5,7 @@
#ifndef WSREP_DB_SERVER_CONTEXT_HPP
#define WSREP_DB_SERVER_CONTEXT_HPP
#include "wsrep/server_context.hpp"
#include "wsrep/server_state.hpp"
#include "wsrep/client_state.hpp"
#include <atomic>
@ -13,22 +13,22 @@
namespace db
{
class server;
class server_context : public wsrep::server_context
class server_state : public wsrep::server_state
{
public:
server_context(db::server& server,
server_state(db::server& server,
const std::string& name,
const std::string& server_id,
const std::string& address,
const std::string& working_dir)
: wsrep::server_context(
: wsrep::server_state(
mutex_,
cond_,
name,
server_id,
address,
working_dir,
wsrep::server_context::rm_async)
wsrep::server_state::rm_async)
, mutex_()
, cond_()
, server_(server)

28
dbsim/db_simulator.cpp
View File

@ -31,10 +31,10 @@ void db::simulator::sst(db::server& server,
}
if (bypass == false)
{
wsrep::log_info() << "SST " << server.server_context().id() << " -> " << id;
wsrep::log_info() << "SST " << server.server_state().id() << " -> " << id;
}
i->second->server_context().sst_received(gtid, 0);
server.server_context().sst_sent(gtid, 0);
i->second->server_state().sst_received(gtid, 0);
server.server_state().sst_sent(gtid, 0);
}
std::string db::simulator::stats() const
@ -99,22 +99,22 @@ void db::simulator::start()
boost::filesystem::create_directory(dir);
db::server& server(*it.first->second);
server.server_context().debug_log_level(params_.debug_log_level);
server.server_state().debug_log_level(params_.debug_log_level);
std::string server_options(params_.wsrep_provider_options);
if (server.server_context().load_provider(
if (server.server_state().load_provider(
params_.wsrep_provider, server_options))
{
throw wsrep::runtime_error("Failed to load provider");
}
if (server.server_context().connect("sim_cluster", cluster_address, "",
if (server.server_state().connect("sim_cluster", cluster_address, "",
i == 0))
{
throw wsrep::runtime_error("Failed to connect");
}
server.start_applier();
server.server_context().wait_until_state(
wsrep::server_context::s_synced);
server.server_state().wait_until_state(
wsrep::server_state::s_synced);
}
// Start client threads
@ -150,18 +150,18 @@ void db::simulator::stop()
{
db::server& server(*i.second);
wsrep::log_info() << "Status for server: "
<< server.server_context().id();
auto status(server.server_context().provider().status());
<< server.server_state().id();
auto status(server.server_state().provider().status());
for_each(status.begin(), status.end(),
[](const wsrep::provider::status_variable& sv)
{
wsrep::log() << sv.name() << " = " << sv.value();
});
server.server_context().disconnect();
server.server_context().wait_until_state(
wsrep::server_context::s_disconnected);
server.server_state().disconnect();
server.server_state().wait_until_state(
wsrep::server_state::s_disconnected);
server.stop_applier();
server.server_context().unload_provider();
server.server_state().unload_provider();
}
}

16
include/wsrep/client_state.hpp
View File

@ -38,7 +38,7 @@
#ifndef WSREP_CLIENT_CONTEXT_HPP
#define WSREP_CLIENT_CONTEXT_HPP
#include "server_context.hpp"
#include "server_state.hpp"
#include "provider.hpp"
#include "transaction.hpp"
#include "client_id.hpp"
@ -51,7 +51,7 @@
namespace wsrep
{
class server_context;
class server_state;
class provider;
enum client_error
@ -475,8 +475,8 @@ namespace wsrep
*
* @return Reference to server context.
*/
wsrep::server_context& server_context() const
{ return server_context_; }
wsrep::server_state& server_state() const
{ return server_state_; }
/**
* Get reference to the Provider which is associated
@ -521,7 +521,7 @@ namespace wsrep
int debug_log_level() const
{
return std::max(debug_log_level_,
server_context_.debug_log_level());
server_state_.debug_log_level());
}
void reset_error()
@ -539,13 +539,13 @@ namespace wsrep
* can be called from derived class constructors only.
*/
client_state(wsrep::mutex& mutex,
wsrep::server_context& server_context,
wsrep::server_state& server_state,
wsrep::client_service& client_service,
const client_id& id,
enum mode mode)
: thread_id_(wsrep::this_thread::get_id())
, mutex_(mutex)
, server_context_(server_context)
, server_state_(server_state)
, client_service_(client_service)
, id_(id)
, mode_(mode)
@ -575,7 +575,7 @@ namespace wsrep
wsrep::thread::id thread_id_;
wsrep::mutex& mutex_;
wsrep::server_context& server_context_;
wsrep::server_state& server_state_;
wsrep::client_service& client_service_;
client_id id_;
enum mode mode_;

10
include/wsrep/provider.hpp
View File

@ -21,7 +21,7 @@
namespace wsrep
{
class server_context;
class server_state;
class stid
{
@ -195,8 +195,8 @@ namespace wsrep
static const int snapshot = (1 << 7);
};
provider(wsrep::server_context& server_context)
: server_context_(server_context)
provider(wsrep::server_state& server_state)
: server_state_(server_state)
{ }
virtual ~provider() { }
// Provider state management
@ -260,11 +260,11 @@ namespace wsrep
* @param provider_options Initial options to provider
*/
static provider* make_provider(
wsrep::server_context&,
wsrep::server_state&,
const std::string& provider_spec,
const std::string& provider_options);
protected:
wsrep::server_context& server_context_;
wsrep::server_state& server_state_;
};
static inline std::string flags_to_string(int flags)

42
include/wsrep/server_context.hpp → include/wsrep/server_state.hpp
View File

@ -2,7 +2,7 @@
// Copyright (C) 2018 Codership Oy <info@codership.com>
//
/** @file server_context.hpp
/** @file server_state.hpp
*
* Server Context Abstraction
* ==========================
@ -86,7 +86,7 @@ namespace wsrep
*
*
*/
class server_context
class server_state
{
public:
/**
@ -155,7 +155,7 @@ namespace wsrep
};
virtual ~server_context();
virtual ~server_state();
/**
* Return human readable server name.
*
@ -292,7 +292,7 @@ namespace wsrep
/**
* Wait until server reaches given state.
*/
void wait_until_state(wsrep::server_context::state) const;
void wait_until_state(wsrep::server_state::state) const;
/**
* Virtual method to return true if the configured SST
@ -403,7 +403,7 @@ namespace wsrep
* data files.
* @param rollback_mode Rollback mode which server operates on.
*/
server_context(wsrep::mutex& mutex,
server_state(wsrep::mutex& mutex,
wsrep::condition_variable& cond,
const std::string& name,
const std::string& id,
@ -426,8 +426,8 @@ namespace wsrep
private:
server_context(const server_context&);
server_context& operator=(const server_context&);
server_state(const server_state&);
server_state& operator=(const server_state&);
void state(wsrep::unique_lock<wsrep::mutex>&, enum state);
@ -449,30 +449,30 @@ namespace wsrep
class client_deleter
{
public:
client_deleter(wsrep::server_context& server_context)
: server_context_(server_context)
client_deleter(wsrep::server_state& server_state)
: server_state_(server_state)
{ }
void operator()(wsrep::client_state* client_state)
{
server_context_.release_client_state(client_state);
server_state_.release_client_state(client_state);
}
private:
wsrep::server_context& server_context_;
wsrep::server_state& server_state_;
};
static inline std::string to_string(enum wsrep::server_context::state state)
static inline std::string to_string(enum wsrep::server_state::state state)
{
switch (state)
{
case wsrep::server_context::s_disconnected: return "disconnected";
case wsrep::server_context::s_initializing: return "initilizing";
case wsrep::server_context::s_initialized: return "initilized";
case wsrep::server_context::s_connected: return "connected";
case wsrep::server_context::s_joiner: return "joiner";
case wsrep::server_context::s_joined: return "joined";
case wsrep::server_context::s_donor: return "donor";
case wsrep::server_context::s_synced: return "synced";
case wsrep::server_context::s_disconnecting: return "disconnecting";
case wsrep::server_state::s_disconnected: return "disconnected";
case wsrep::server_state::s_initializing: return "initilizing";
case wsrep::server_state::s_initialized: return "initilized";
case wsrep::server_state::s_connected: return "connected";
case wsrep::server_state::s_joiner: return "joiner";
case wsrep::server_state::s_joined: return "joined";
case wsrep::server_state::s_donor: return "donor";
case wsrep::server_state::s_synced: return "synced";
case wsrep::server_state::s_disconnecting: return "disconnecting";
}
return "unknown";
}

2
include/wsrep/transaction.hpp
View File

@ -6,7 +6,7 @@
#define WSREP_TRANSACTION_CONTEXT_HPP
#include "provider.hpp"
#include "server_context.hpp"
#include "server_state.hpp"
#include "transaction_id.hpp"
#include "streaming_context.hpp"
#include "lock.hpp"

2
src/CMakeLists.txt
View File

@ -7,7 +7,7 @@ add_library(wsrep-lib
id.cpp
logger.cpp
provider.cpp
server_context.cpp
server_state.cpp
transaction.cpp
wsrep_provider_v26.cpp)
target_link_libraries(wsrep-lib wsrep_api_v26 pthread dl)

14
src/client_state.cpp
View File

@ -12,7 +12,7 @@
wsrep::provider& wsrep::client_state::provider() const
{
return server_context_.provider();
return server_state_.provider();
}
void wsrep::client_state::override_error(enum wsrep::client_error error)
@ -32,7 +32,7 @@ int wsrep::client_state::before_command()
wsrep::unique_lock<wsrep::mutex> lock(mutex_);
debug_log_state("before_command: enter");
assert(state_ == s_idle);
if (server_context_.rollback_mode() == wsrep::server_context::rm_sync)
if (server_state_.rollback_mode() == wsrep::server_state::rm_sync)
{
/**
* @todo Wait until the possible synchronous rollback
@ -48,14 +48,14 @@ int wsrep::client_state::before_command()
(transaction_.state() == wsrep::transaction::s_executing ||
transaction_.state() == wsrep::transaction::s_aborted ||
(transaction_.state() == wsrep::transaction::s_must_abort &&
server_context_.rollback_mode() == wsrep::server_context::rm_async)));
server_state_.rollback_mode() == wsrep::server_state::rm_async)));
if (transaction_.active())
{
if (transaction_.state() == wsrep::transaction::s_must_abort)
{
assert(server_context_.rollback_mode() ==
wsrep::server_context::rm_async);
assert(server_state_.rollback_mode() ==
wsrep::server_state::rm_async);
override_error(wsrep::e_deadlock_error);
lock.unlock();
client_service_.rollback(*this);
@ -139,7 +139,7 @@ int wsrep::client_state::before_statement()
* server synced state.
*/
if (allow_dirty_reads_ == false &&
server_context_.state() != wsrep::server_context::s_synced)
server_state_.state() != wsrep::server_state::s_synced)
{
return 1;
}
@ -192,7 +192,7 @@ void wsrep::client_state::debug_log_state(const char* context) const
if (debug_log_level() >= 1)
{
wsrep::log_debug() << "client_state: " << context
<< ": server: " << server_context_.name()
<< ": server: " << server_state_.name()
<< " client: " << id_.get()
<< " current_error: " << current_error_;
}

4
src/provider.cpp
View File

@ -8,14 +8,14 @@
#include "wsrep_provider_v26.hpp"
wsrep::provider* wsrep::provider::make_provider(
wsrep::server_context& server_context,
wsrep::server_state& server_state,
const std::string& provider_spec,
const std::string& provider_options)
{
try
{
return new wsrep::wsrep_provider_v26(
server_context, provider_options, provider_spec);
server_state, provider_options, provider_spec);
}
catch (const wsrep::runtime_error& e)
{

85
src/server_context_test.cpp
View File

@ -1,85 +0,0 @@
//
// Copyright (C) 2018 Codership Oy <info@codership.com>
//
#include "mock_server_context.hpp"
#include <boost/test/unit_test.hpp>
namespace
{
struct applying_server_fixture
{
applying_server_fixture()
: sc("s1", "s1",
wsrep::server_context::rm_sync)
, cc(sc,
wsrep::client_id(1),
wsrep::client_state::m_applier,
false)
, ws_handle(1, (void*)1)
, ws_meta(wsrep::gtid(wsrep::id("1"), wsrep::seqno(1)),
wsrep::stid(wsrep::id("1"), 1, 1),
wsrep::seqno(0),
wsrep::provider::flag::start_transaction |
wsrep::provider::flag::commit)
{
cc.start_transaction(ws_handle, ws_meta);
}
wsrep::mock_server_context sc;
wsrep::mock_client_state cc;
wsrep::ws_handle ws_handle;
wsrep::ws_meta ws_meta;
};
}
// Test on_apply() method for 1pc
BOOST_FIXTURE_TEST_CASE(server_context_applying_1pc,
applying_server_fixture)
{
char buf[1] = { 1 };
BOOST_REQUIRE(sc.on_apply(cc, ws_handle, ws_meta,
wsrep::const_buffer(buf, 1)) == 0);
const wsrep::transaction& txc(cc.transaction());
// ::abort();
BOOST_REQUIRE_MESSAGE(
txc.state() == wsrep::transaction::s_committed,
"Transaction state " << txc.state() << " not committed");
}
// Test on_apply() method for 2pc
BOOST_FIXTURE_TEST_CASE(server_context_applying_2pc,
applying_server_fixture)
{
char buf[1] = { 1 };
BOOST_REQUIRE(sc.on_apply(cc, ws_handle, ws_meta,
wsrep::const_buffer(buf, 1)) == 0);
const wsrep::transaction& txc(cc.transaction());
BOOST_REQUIRE(txc.state() == wsrep::transaction::s_committed);
}
// Test on_apply() method for 1pc transaction which
// fails applying and rolls back
BOOST_FIXTURE_TEST_CASE(server_context_applying_1pc_rollback,
applying_server_fixture)
{
cc.fail_next_applying_ = true;
char buf[1] = { 1 };
BOOST_REQUIRE(sc.on_apply(cc, ws_handle, ws_meta,
wsrep::const_buffer(buf, 1)) == 1);
const wsrep::transaction& txc(cc.transaction());
BOOST_REQUIRE(txc.state() == wsrep::transaction::s_aborted);
}
// Test on_apply() method for 2pc transaction which
// fails applying and rolls back
BOOST_FIXTURE_TEST_CASE(server_context_applying_2pc_rollback,
applying_server_fixture)
{
cc.fail_next_applying_ = true;
char buf[1] = { 1 };
BOOST_REQUIRE(sc.on_apply(cc, ws_handle, ws_meta,
wsrep::const_buffer(buf, 1)) == 1);
const wsrep::transaction& txc(cc.transaction());
BOOST_REQUIRE(txc.state() == wsrep::transaction::s_aborted);
}

40
src/server_context.cpp → src/server_state.cpp
View File

@ -2,7 +2,7 @@
// Copyright (C) 2018 Codership Oy <info@codership.com>
//
#include "wsrep/server_context.hpp"
#include "wsrep/server_state.hpp"
#include "wsrep/client_state.hpp"
#include "wsrep/transaction.hpp"
#include "wsrep/view.hpp"
@ -18,7 +18,7 @@ namespace
}
int wsrep::server_context::load_provider(const std::string& provider_spec,
int wsrep::server_state::load_provider(const std::string& provider_spec,
const std::string& provider_options)
{
wsrep::log_info() << "Loading provider " << provider_spec;
@ -26,13 +26,13 @@ int wsrep::server_context::load_provider(const std::string& provider_spec,
return (provider_ ? 0 : 1);
}
void wsrep::server_context::unload_provider()
void wsrep::server_state::unload_provider()
{
delete provider_;
provider_ = 0;
}
int wsrep::server_context::connect(const std::string& cluster_name,
int wsrep::server_state::connect(const std::string& cluster_name,
const std::string& cluster_address,
const std::string& state_donor,
bool bootstrap)
@ -41,7 +41,7 @@ int wsrep::server_context::connect(const std::string& cluster_name,
bootstrap);
}
int wsrep::server_context::disconnect()
int wsrep::server_state::disconnect()
{
{
wsrep::unique_lock<wsrep::mutex> lock(mutex_);
@ -50,22 +50,22 @@ int wsrep::server_context::disconnect()
return provider().disconnect();
}
wsrep::server_context::~server_context()
wsrep::server_state::~server_state()
{
delete provider_;
}
void wsrep::server_context::sst_sent(const wsrep::gtid& gtid, int error)
void wsrep::server_state::sst_sent(const wsrep::gtid& gtid, int error)
{
provider_->sst_sent(gtid, error);
}
void wsrep::server_context::sst_received(const wsrep::gtid& gtid, int error)
void wsrep::server_state::sst_received(const wsrep::gtid& gtid, int error)
{
provider_->sst_received(gtid, error);
}
void wsrep::server_context::wait_until_state(
enum wsrep::server_context::state state) const
void wsrep::server_state::wait_until_state(
enum wsrep::server_state::state state) const
{
wsrep::unique_lock<wsrep::mutex> lock(mutex_);
++state_waiters_[state];
@ -77,14 +77,14 @@ void wsrep::server_context::wait_until_state(
cond_.notify_all();
}
void wsrep::server_context::on_connect()
void wsrep::server_state::on_connect()
{
wsrep::log() << "Server " << name_ << " connected to cluster";
wsrep::unique_lock<wsrep::mutex> lock(mutex_);
state(lock, s_connected);
}
void wsrep::server_context::on_view(const wsrep::view& view)
void wsrep::server_state::on_view(const wsrep::view& view)
{
wsrep::log() << "================================================\nView:\n"
<< "id: " << view.id() << "\n"
@ -107,7 +107,7 @@ void wsrep::server_context::on_view(const wsrep::view& view)
}
}
void wsrep::server_context::on_sync()
void wsrep::server_state::on_sync()
{
wsrep::log() << "Server " << name_ << " synced with group";
wsrep::unique_lock<wsrep::mutex> lock(mutex_);
@ -117,7 +117,7 @@ void wsrep::server_context::on_sync()
}
}
int wsrep::server_context::on_apply(
int wsrep::server_state::on_apply(
wsrep::client_state& client_state,
const wsrep::ws_handle& ws_handle,
const wsrep::ws_meta& ws_meta,
@ -273,7 +273,7 @@ int wsrep::server_context::on_apply(
return ret;
}
bool wsrep::server_context::statement_allowed_for_streaming(
bool wsrep::server_state::statement_allowed_for_streaming(
const wsrep::client_state&,
const wsrep::transaction&) const
{
@ -281,7 +281,7 @@ bool wsrep::server_context::statement_allowed_for_streaming(
return false;
}
void wsrep::server_context::start_streaming_applier(
void wsrep::server_state::start_streaming_applier(
const wsrep::id& server_id,
const wsrep::transaction_id& transaction_id,
wsrep::client_state* client_state)
@ -296,7 +296,7 @@ void wsrep::server_context::start_streaming_applier(
}
}
void wsrep::server_context::stop_streaming_applier(
void wsrep::server_state::stop_streaming_applier(
const wsrep::id& server_id,
const wsrep::transaction_id& transaction_id)
{
@ -314,7 +314,7 @@ void wsrep::server_context::stop_streaming_applier(
}
}
wsrep::client_state* wsrep::server_context::find_streaming_applier(
wsrep::client_state* wsrep::server_state::find_streaming_applier(
const wsrep::id& server_id,
const wsrep::transaction_id& transaction_id) const
{
@ -325,9 +325,9 @@ wsrep::client_state* wsrep::server_context::find_streaming_applier(
// Private
void wsrep::server_context::state(
void wsrep::server_state::state(
wsrep::unique_lock<wsrep::mutex>& lock WSREP_UNUSED,
enum wsrep::server_context::state state)
enum wsrep::server_state::state state)
{
assert(lock.owns_lock());
static const char allowed[n_states_][n_states_] =

24
src/transaction.cpp
View File

@ -4,7 +4,7 @@
#include "wsrep/transaction.hpp"
#include "wsrep/client_state.hpp"
#include "wsrep/server_context.hpp"
#include "wsrep/server_state.hpp"
#include "wsrep/key.hpp"
#include "wsrep/logger.hpp"
#include "wsrep/compiler.hpp"
@ -163,7 +163,7 @@ int wsrep::transaction::before_prepare(
client_state_.debug_crash(
"crash_last_fragment_commit_before_fragment_removal");
lock.unlock();
if (client_state_.server_context().statement_allowed_for_streaming(
if (client_state_.server_state().statement_allowed_for_streaming(
client_state_, *this))
{
client_state_.override_error(wsrep::e_error_during_commit);
@ -626,8 +626,8 @@ bool wsrep::transaction::bf_abort(
{
bf_abort_client_state_ = client_state_.state();
if (client_state_.state() == wsrep::client_state::s_idle &&
client_state_.server_context().rollback_mode() ==
wsrep::server_context::rm_sync)
client_state_.server_state().rollback_mode() ==
wsrep::server_state::rm_sync)
{
// We need to change the state to aborting under the
// lock protection to avoid a race between client thread,
@ -636,7 +636,7 @@ bool wsrep::transaction::bf_abort(
// rollbacker gets control.
state(lock, wsrep::transaction::s_aborting);
lock.unlock();
client_state_.server_context().background_rollback(client_state_);
client_state_.server_state().background_rollback(client_state_);
}
}
return ret;
@ -720,10 +720,10 @@ int wsrep::transaction::certify_fragment(
// Switch temporarily to sr_transaction, switch back
// to original when this goes out of scope
// std::auto_ptr<wsrep::client_state> sr_client_state(
// client_state_.server_context().local_client_state());
// client_state_.server_state().local_client_state());
wsrep::scoped_client_state<wsrep::client_deleter> sr_client_state_scope(
client_state_.server_context().local_client_state(),
wsrep::client_deleter(client_state_.server_context()));
client_state_.server_state().local_client_state(),
wsrep::client_deleter(client_state_.server_state()));
wsrep::client_state& sr_client_state(
sr_client_state_scope.client_state());
wsrep::client_state_switch client_state_switch(
@ -929,9 +929,9 @@ void wsrep::transaction::streaming_rollback()
{
assert(streaming_context_.rolled_back() == false);
wsrep::client_state* sac(
client_state_.server_context().streaming_applier_client_state());
client_state_.server_context().start_streaming_applier(
client_state_.server_context().id(), id(), sac);
client_state_.server_state().streaming_applier_client_state());
client_state_.server_state().start_streaming_applier(
client_state_.server_state().id(), id(), sac);
sac->adopt_transaction(*this);
streaming_context_.cleanup();
// Replicate rollback fragment
@ -963,7 +963,7 @@ void wsrep::transaction::debug_log_state(
{
WSREP_TC_LOG_DEBUG(
1, context
<< ": server: " << client_state_.server_context().name()
<< ": server: " << client_state_.server_state().name()
<< " client: " << client_state_.id().get()
<< " trx: " << int64_t(id_.get())
<< " state: " << wsrep::to_string(state_)

46
src/wsrep_provider_v26.cpp
View File

@ -4,7 +4,7 @@
#include "wsrep_provider_v26.hpp"
#include "wsrep/server_context.hpp"
#include "wsrep/server_state.hpp"
#include "wsrep/client_state.hpp"
#include "wsrep/view.hpp"
#include "wsrep/exception.hpp"
@ -240,14 +240,14 @@ namespace
const wsrep_view_info_t* view __attribute((unused)))
{
assert(app_ctx);
wsrep::server_context& server_context(
*reinterpret_cast<wsrep::server_context*>(app_ctx));
wsrep::server_state& server_state(
*reinterpret_cast<wsrep::server_state*>(app_ctx));
//
// TODO: Fetch server id and group id from view infor
//
try
{
server_context.on_connect();
server_state.on_connect();
return WSREP_CB_SUCCESS;
}
catch (const wsrep::runtime_error& e)
@ -265,12 +265,12 @@ namespace
{
assert(app_ctx);
assert(view_info);
wsrep::server_context& server_context(
*reinterpret_cast<wsrep::server_context*>(app_ctx));
wsrep::server_state& server_state(
*reinterpret_cast<wsrep::server_state*>(app_ctx));
try
{
wsrep::view view(*view_info);
server_context.on_view(view);
server_state.on_view(view);
return WSREP_CB_SUCCESS;
}
catch (const wsrep::runtime_error& e)
@ -284,12 +284,12 @@ namespace
void **sst_req, size_t* sst_req_len)
{
assert(app_ctx);
wsrep::server_context& server_context(
*reinterpret_cast<wsrep::server_context*>(app_ctx));
wsrep::server_state& server_state(
*reinterpret_cast<wsrep::server_state*>(app_ctx));
try
{
std::string req(server_context.on_sst_required());
std::string req(server_state.on_sst_required());
*sst_req = ::strdup(req.c_str());
*sst_req_len = strlen(req.c_str());
return WSREP_CB_SUCCESS;
@ -326,7 +326,7 @@ namespace
meta->stid.conn), wsrep::seqno(seqno_from_native(meta->depends_on)),
map_flags_from_native(flags));
if (ret == WSREP_CB_SUCCESS &&
client_state->server_context().on_apply(
client_state->server_state().on_apply(
*client_state, ws_handle, ws_meta, data))
{
ret = WSREP_CB_FAILURE;
@ -337,11 +337,11 @@ namespace
wsrep_cb_status_t synced_cb(void* app_ctx)
{
assert(app_ctx);
wsrep::server_context& server_context(
*reinterpret_cast<wsrep::server_context*>(app_ctx));
wsrep::server_state& server_state(
*reinterpret_cast<wsrep::server_state*>(app_ctx));
try
{
server_context.on_sync();
server_state.on_sync();
return WSREP_CB_SUCCESS;
}
catch (const wsrep::runtime_error& e)
@ -360,8 +360,8 @@ namespace
bool bypass)
{
assert(app_ctx);
wsrep::server_context& server_context(
*reinterpret_cast<wsrep::server_context*>(app_ctx));
wsrep::server_state& server_state(
*reinterpret_cast<wsrep::server_state*>(app_ctx));
try
{
std::string req(reinterpret_cast<const char*>(req_buf->ptr),
@ -369,7 +369,7 @@ namespace
wsrep::gtid gtid(wsrep::id(req_gtid->uuid.data,
sizeof(req_gtid->uuid.data)),
wsrep::seqno(req_gtid->seqno));
server_context.on_sst_request(req, gtid, bypass);
server_state.on_sst_request(req, gtid, bypass);
return WSREP_CB_SUCCESS;
}
catch (const wsrep::runtime_error& e)
@ -380,19 +380,19 @@ namespace
}
wsrep::wsrep_provider_v26::wsrep_provider_v26(
wsrep::server_context& server_context,
wsrep::server_state& server_state,
const std::string& provider_options,
const std::string& provider_spec)
: provider(server_context)
: provider(server_state)
, wsrep_()
{
struct wsrep_init_args init_args;
memset(&init_args, 0, sizeof(init_args));
init_args.app_ctx = &server_context;
init_args.node_name = server_context_.name().c_str();
init_args.node_address = server_context_.address().c_str();
init_args.app_ctx = &server_state;
init_args.node_name = server_state_.name().c_str();
init_args.node_address = server_state_.address().c_str();
init_args.node_incoming = "";
init_args.data_dir = server_context_.working_dir().c_str();
init_args.data_dir = server_state_.working_dir().c_str();
init_args.options = provider_options.c_str();
init_args.proto_ver = 1;
init_args.state_id = 0;

2
src/wsrep_provider_v26.hpp
View File

@ -15,7 +15,7 @@ namespace wsrep
{
public:
wsrep_provider_v26(wsrep::server_context&, const std::string&,
wsrep_provider_v26(wsrep::server_state&, const std::string&,
const std::string&);
~wsrep_provider_v26();
int connect(const std::string&, const std::string&, const std::string&,

38
test/client_state_fixture.hpp
View File

@ -5,7 +5,7 @@
#ifndef WSREP_TEST_CLIENT_CONTEXT_FIXTURE_HPP
#define WSREP_TEST_CLIENT_CONTEXT_FIXTURE_HPP
#include "mock_server_context.hpp"
#include "mock_server_state.hpp"
#include "mock_client_state.hpp"
@ -16,7 +16,7 @@ namespace
struct replicating_client_fixture_sync_rm
{
replicating_client_fixture_sync_rm()
: sc("s1", "s1", wsrep::server_context::rm_sync)
: sc("s1", "s1", wsrep::server_state::rm_sync)
, cc(sc, sc.client_service(), wsrep::client_id(1),
wsrep::client_state::m_replicating)
, tc(cc.transaction())
@ -27,7 +27,7 @@ namespace
BOOST_REQUIRE(tc.active() == false);
BOOST_REQUIRE(tc.state() == wsrep::transaction::s_executing);
}
wsrep::mock_server_context sc;
wsrep::mock_server_state sc;
wsrep::mock_client_state cc;
const wsrep::transaction& tc;
};
@ -35,7 +35,7 @@ namespace
struct replicating_client_fixture_async_rm
{
replicating_client_fixture_async_rm()
: sc("s1", "s1", wsrep::server_context::rm_async)
: sc("s1", "s1", wsrep::server_state::rm_async)
, cc(sc, sc.client_service(), wsrep::client_id(1),
wsrep::client_state::m_replicating)
, tc(cc.transaction())
@ -46,7 +46,7 @@ namespace
BOOST_REQUIRE(tc.active() == false);
BOOST_REQUIRE(tc.state() == wsrep::transaction::s_executing);
}
wsrep::mock_server_context sc;
wsrep::mock_server_state sc;
wsrep::mock_client_state cc;
const wsrep::transaction& tc;
};
@ -54,7 +54,7 @@ namespace
struct replicating_client_fixture_2pc
{
replicating_client_fixture_2pc()
: sc("s1", "s1", wsrep::server_context::rm_sync)
: sc("s1", "s1", wsrep::server_state::rm_sync)
, cc(sc, sc.client_service(), wsrep::client_id(1),
wsrep::client_state::m_replicating)
, tc(cc.transaction())
@ -66,7 +66,7 @@ namespace
BOOST_REQUIRE(tc.active() == false);
BOOST_REQUIRE(tc.state() == wsrep::transaction::s_executing);
}
wsrep::mock_server_context sc;
wsrep::mock_server_state sc;
wsrep::mock_client_state cc;
const wsrep::transaction& tc;
};
@ -74,7 +74,7 @@ namespace
struct replicating_client_fixture_autocommit
{
replicating_client_fixture_autocommit()
: sc("s1", "s1", wsrep::server_context::rm_sync)
: sc("s1", "s1", wsrep::server_state::rm_sync)
, cc(sc, sc.client_service(), wsrep::client_id(1),
wsrep::client_state::m_replicating)
, tc(cc.transaction())
@ -86,7 +86,7 @@ namespace
BOOST_REQUIRE(tc.active() == false);
BOOST_REQUIRE(tc.state() == wsrep::transaction::s_executing);
}
wsrep::mock_server_context sc;
wsrep::mock_server_state sc;
wsrep::mock_client_state cc;
const wsrep::transaction& tc;
};
@ -95,7 +95,7 @@ namespace
{
applying_client_fixture()
: sc("s1", "s1",
wsrep::server_context::rm_async)
wsrep::server_state::rm_async)
, cc(sc, sc.client_service(),
wsrep::client_id(1),
wsrep::client_state::m_high_priority)
@ -114,7 +114,7 @@ namespace
BOOST_REQUIRE(tc.certified() == true);
BOOST_REQUIRE(tc.ordered() == true);
}
wsrep::mock_server_context sc;
wsrep::mock_server_state sc;
wsrep::mock_client_state cc;
const wsrep::transaction& tc;
};
@ -123,7 +123,7 @@ namespace
{
applying_client_fixture_2pc()
: sc("s1", "s1",
wsrep::server_context::rm_async)
wsrep::server_state::rm_async)
, cc(sc, sc.client_service(),
wsrep::client_id(1),
wsrep::client_state::m_high_priority)
@ -143,7 +143,7 @@ namespace
BOOST_REQUIRE(tc.certified() == true);
BOOST_REQUIRE(tc.ordered() == true);
}
wsrep::mock_server_context sc;
wsrep::mock_server_state sc;
wsrep::mock_client_state cc;
const wsrep::transaction& tc;
};
@ -151,7 +151,7 @@ namespace
struct streaming_client_fixture_row
{
streaming_client_fixture_row()
: sc("s1", "s1", wsrep::server_context::rm_sync)
: sc("s1", "s1", wsrep::server_state::rm_sync)
, cc(sc, sc.client_service(), wsrep::client_id(1),
wsrep::client_state::m_replicating)
, tc(cc.transaction())
@ -163,7 +163,7 @@ namespace
BOOST_REQUIRE(tc.state() == wsrep::transaction::s_executing);
cc.enable_streaming(wsrep::streaming_context::row, 1);
}
wsrep::mock_server_context sc;
wsrep::mock_server_state sc;
wsrep::mock_client_state cc;
const wsrep::transaction& tc;
};
@ -171,7 +171,7 @@ namespace
struct streaming_client_fixture_byte
{
streaming_client_fixture_byte()
: sc("s1", "s1", wsrep::server_context::rm_sync)
: sc("s1", "s1", wsrep::server_state::rm_sync)
, cc(sc, sc.client_service(), wsrep::client_id(1),
wsrep::client_state::m_replicating)
, tc(cc.transaction())
@ -183,7 +183,7 @@ namespace
BOOST_REQUIRE(tc.state() == wsrep::transaction::s_executing);
cc.enable_streaming(wsrep::streaming_context::bytes, 1);
}
wsrep::mock_server_context sc;
wsrep::mock_server_state sc;
wsrep::mock_client_state cc;
const wsrep::transaction& tc;
};
@ -191,7 +191,7 @@ namespace
struct streaming_client_fixture_statement
{
streaming_client_fixture_statement()
: sc("s1", "s1", wsrep::server_context::rm_sync)
: sc("s1", "s1", wsrep::server_state::rm_sync)
, cc(sc, sc.client_service(), wsrep::client_id(1),
wsrep::client_state::m_replicating)
, tc(cc.transaction())
@ -204,7 +204,7 @@ namespace
cc.enable_streaming(wsrep::streaming_context::row, 1);
}
wsrep::mock_server_context sc;
wsrep::mock_server_state sc;
wsrep::mock_client_state cc;
const wsrep::transaction& tc;
};

4
test/mock_client_state.hpp
View File

@ -16,11 +16,11 @@ namespace wsrep
class mock_client_state : public wsrep::client_state
{
public:
mock_client_state(wsrep::server_context& server_context,
mock_client_state(wsrep::server_state& server_state,
wsrep::client_service& client_service,
const wsrep::client_id& id,
enum wsrep::client_state::mode mode)
: wsrep::client_state(mutex_, server_context, client_service, id, mode)
: wsrep::client_state(mutex_, server_state, client_service, id, mode)
// Note: Mutex is initialized only after passed
// to client_state constructor.
, mutex_()

6
test/mock_provider.hpp
View File

@ -22,8 +22,8 @@ namespace wsrep
public:
typedef std::map<wsrep::transaction_id, wsrep::seqno> bf_abort_map;
mock_provider(wsrep::server_context& server_context)
: provider(server_context)
mock_provider(wsrep::server_state& server_state)
: provider(server_state)
, certify_result_()
, commit_order_enter_result_()
, commit_order_leave_result_()
@ -183,7 +183,7 @@ namespace wsrep
return replay_result_;
}
if (server_context_.on_apply(cc, tc.ws_handle(), ws_meta,
if (server_state_.on_apply(cc, tc.ws_handle(), ws_meta,
wsrep::const_buffer()))
{
return wsrep::provider::error_fatal;

10
test/mock_server_context.hpp → test/mock_server_state.hpp
View File

@ -5,7 +5,7 @@
#ifndef WSREP_MOCK_SERVER_CONTEXT_HPP
#define WSREP_MOCK_SERVER_CONTEXT_HPP
#include "wsrep/server_context.hpp"
#include "wsrep/server_state.hpp"
#include "mock_client_state.hpp"
#include "mock_provider.hpp"
@ -13,13 +13,13 @@
namespace wsrep
{
class mock_server_context : public wsrep::server_context
class mock_server_state : public wsrep::server_state
{
public:
mock_server_context(const std::string& name,
mock_server_state(const std::string& name,
const std::string& id,
enum wsrep::server_context::rollback_mode rollback_mode)
: wsrep::server_context(mutex_, cond_,
enum wsrep::server_state::rollback_mode rollback_mode)
: wsrep::server_state(mutex_, cond_,
name, id, "", "./", rollback_mode)
, mutex_()
, cond_()

42
test/server_context_test.cpp
View File

@ -2,7 +2,7 @@
// Copyright (C) 2018 Codership Oy <info@codership.com>
//
#include "mock_server_context.hpp"
#include "mock_server_state.hpp"
#include <boost/test/unit_test.hpp>
@ -12,7 +12,7 @@ namespace
{
applying_server_fixture()
: sc("s1", "s1",
wsrep::server_context::rm_sync)
wsrep::server_state::rm_sync)
, cc(sc, sc.client_service(),
wsrep::client_id(1),
wsrep::client_state::m_high_priority)
@ -24,7 +24,7 @@ namespace
wsrep::provider::flag::commit)
{
}
wsrep::mock_server_context sc;
wsrep::mock_server_state sc;
wsrep::mock_client_state cc;
wsrep::ws_handle ws_handle;
wsrep::ws_meta ws_meta;
@ -32,7 +32,7 @@ namespace
}
// Test on_apply() method for 1pc
BOOST_FIXTURE_TEST_CASE(server_context_applying_1pc,
BOOST_FIXTURE_TEST_CASE(server_state_applying_1pc,
applying_server_fixture)
{
char buf[1] = { 1 };
@ -46,7 +46,7 @@ BOOST_FIXTURE_TEST_CASE(server_context_applying_1pc,
}
// Test on_apply() method for 2pc
BOOST_FIXTURE_TEST_CASE(server_context_applying_2pc,
BOOST_FIXTURE_TEST_CASE(server_state_applying_2pc,
applying_server_fixture)
{
char buf[1] = { 1 };
@ -58,7 +58,7 @@ BOOST_FIXTURE_TEST_CASE(server_context_applying_2pc,
// Test on_apply() method for 1pc transaction which
// fails applying and rolls back
BOOST_FIXTURE_TEST_CASE(server_context_applying_1pc_rollback,
BOOST_FIXTURE_TEST_CASE(server_state_applying_1pc_rollback,
applying_server_fixture)
{
sc.client_service().fail_next_applying_ = true;
@ -71,7 +71,7 @@ BOOST_FIXTURE_TEST_CASE(server_context_applying_1pc_rollback,
// Test on_apply() method for 2pc transaction which
// fails applying and rolls back
BOOST_FIXTURE_TEST_CASE(server_context_applying_2pc_rollback,
BOOST_FIXTURE_TEST_CASE(server_state_applying_2pc_rollback,
applying_server_fixture)
{
sc.client_service().fail_next_applying_ = true;
@ -82,10 +82,10 @@ BOOST_FIXTURE_TEST_CASE(server_context_applying_2pc_rollback,
BOOST_REQUIRE(txc.state() == wsrep::transaction::s_aborted);
}
BOOST_AUTO_TEST_CASE(server_context_streaming)
BOOST_AUTO_TEST_CASE(server_state_streaming)
{
wsrep::mock_server_context sc("s1", "s1",
wsrep::server_context::rm_sync);
wsrep::mock_server_state sc("s1", "s1",
wsrep::server_state::rm_sync);
wsrep::mock_client_state cc(sc,
sc.client_service(),
wsrep::client_id(1),
@ -116,26 +116,26 @@ BOOST_AUTO_TEST_CASE(server_context_streaming)
}
BOOST_AUTO_TEST_CASE(server_context_state_strings)
BOOST_AUTO_TEST_CASE(server_state_state_strings)
{
BOOST_REQUIRE(wsrep::to_string(
wsrep::server_context::s_disconnected) == "disconnected");
wsrep::server_state::s_disconnected) == "disconnected");
BOOST_REQUIRE(wsrep::to_string(
wsrep::server_context::s_initializing) == "initilizing");
wsrep::server_state::s_initializing) == "initilizing");
BOOST_REQUIRE(wsrep::to_string(
wsrep::server_context::s_initialized) == "initilized");
wsrep::server_state::s_initialized) == "initilized");
BOOST_REQUIRE(wsrep::to_string(
wsrep::server_context::s_connected) == "connected");
wsrep::server_state::s_connected) == "connected");
BOOST_REQUIRE(wsrep::to_string(
wsrep::server_context::s_joiner) == "joiner");
wsrep::server_state::s_joiner) == "joiner");
BOOST_REQUIRE(wsrep::to_string(
wsrep::server_context::s_joined) == "joined");
wsrep::server_state::s_joined) == "joined");
BOOST_REQUIRE(wsrep::to_string(
wsrep::server_context::s_donor) == "donor");
wsrep::server_state::s_donor) == "donor");
BOOST_REQUIRE(wsrep::to_string(
wsrep::server_context::s_synced) == "synced");
wsrep::server_state::s_synced) == "synced");
BOOST_REQUIRE(wsrep::to_string(
wsrep::server_context::s_disconnecting) == "disconnecting");
wsrep::server_state::s_disconnecting) == "disconnecting");
BOOST_REQUIRE(wsrep::to_string(
static_cast<enum wsrep::server_context::state>(0xff)) == "unknown");
static_cast<enum wsrep::server_state::state>(0xff)) == "unknown");
}

4
test/test_utils.cpp
View File

@ -4,7 +4,7 @@
#include "test_utils.hpp"
#include "wsrep/client_state.hpp"
#include "mock_server_context.hpp"
#include "mock_server_state.hpp"
// Simple BF abort method to BF abort unordered transasctions
@ -20,7 +20,7 @@ void wsrep_test::bf_abort_ordered(wsrep::client_state& cc)
cc.bf_abort(wsrep::seqno(0));
}
// BF abort method to abort transactions via provider
void wsrep_test::bf_abort_provider(wsrep::mock_server_context& sc,
void wsrep_test::bf_abort_provider(wsrep::mock_server_state& sc,
const wsrep::transaction& tc,
wsrep::seqno bf_seqno)
{

4
test/test_utils.hpp
View File

@ -6,7 +6,7 @@
namespace wsrep
{
class client_state;
class mock_server_context;
class mock_server_state;
}
#include "wsrep/transaction.hpp"
@ -25,7 +25,7 @@ namespace wsrep_test
void bf_abort_ordered(wsrep::client_state& cc);
// BF abort method to abort transactions via provider
void bf_abort_provider(wsrep::mock_server_context& sc,
void bf_abort_provider(wsrep::mock_server_state& sc,
const wsrep::transaction& tc,
wsrep::seqno bf_seqno);

28
test/transaction_test.cpp
View File

@ -158,7 +158,7 @@ BOOST_FIXTURE_TEST_CASE_TEMPLATE(
transaction_1pc_bf_during_before_commit_uncertified, T,
replicating_fixtures, T)
{
wsrep::mock_server_context& sc(T::sc);
wsrep::mock_server_state& sc(T::sc);
wsrep::client_state& cc(T::cc);
const wsrep::transaction& tc(T::tc);
@ -198,7 +198,7 @@ BOOST_FIXTURE_TEST_CASE_TEMPLATE(
transaction_1pc_bf_during_commit_wait_for_replayers, T,
replicating_fixtures, T)
{
wsrep::mock_server_context& sc(T::sc);
wsrep::mock_server_state& sc(T::sc);
wsrep::mock_client_state& cc(T::cc);
const wsrep::transaction& tc(T::tc);
@ -237,7 +237,7 @@ BOOST_FIXTURE_TEST_CASE_TEMPLATE(
transaction_1pc_error_during_prepare_data, T,
replicating_fixtures, T)
{
wsrep::mock_server_context& sc(T::sc);
wsrep::mock_server_state& sc(T::sc);
wsrep::mock_client_state& cc(T::cc);
const wsrep::transaction& tc(T::tc);
@ -277,7 +277,7 @@ BOOST_FIXTURE_TEST_CASE_TEMPLATE(
transaction_1pc_killed_before_certify, T,
replicating_fixtures, T)
{
wsrep::mock_server_context& sc(T::sc);
wsrep::mock_server_state& sc(T::sc);
wsrep::mock_client_state& cc(T::cc);
const wsrep::transaction& tc(T::tc);
@ -359,7 +359,7 @@ BOOST_FIXTURE_TEST_CASE_TEMPLATE(
transaction_1pc_bf_during_before_commit_certified, T,
replicating_fixtures, T)
{
wsrep::mock_server_context& sc(T::sc);
wsrep::mock_server_state& sc(T::sc);
wsrep::mock_client_state& cc(T::cc);
const wsrep::transaction& tc(T::tc);
@ -402,7 +402,7 @@ BOOST_FIXTURE_TEST_CASE_TEMPLATE(
transaction_1pc_bf_before_unordered_cert_failure, T,
replicating_fixtures, T)
{
wsrep::mock_server_context& sc(T::sc);
wsrep::mock_server_state& sc(T::sc);
wsrep::mock_client_state& cc(T::cc);
const wsrep::transaction& tc(T::tc);
@ -435,7 +435,7 @@ BOOST_FIXTURE_TEST_CASE_TEMPLATE(
transaction_1pc_warning_error_from_certify, T,
replicating_fixtures, T)
{
wsrep::mock_server_context& sc(T::sc);
wsrep::mock_server_state& sc(T::sc);
wsrep::client_state& cc(T::cc);
const wsrep::transaction& tc(T::tc);
@ -476,7 +476,7 @@ BOOST_FIXTURE_TEST_CASE_TEMPLATE(
transaction_1pc_transaction_missing_from_certify, T,
replicating_fixtures, T)
{
wsrep::mock_server_context& sc(T::sc);
wsrep::mock_server_state& sc(T::sc);
wsrep::client_state& cc(T::cc);
const wsrep::transaction& tc(T::tc);
@ -517,7 +517,7 @@ BOOST_FIXTURE_TEST_CASE_TEMPLATE(
transaction_1pc_size_exceeded_from_certify, T,
replicating_fixtures, T)
{
wsrep::mock_server_context& sc(T::sc);
wsrep::mock_server_state& sc(T::sc);
wsrep::client_state& cc(T::cc);
const wsrep::transaction& tc(T::tc);
@ -558,7 +558,7 @@ BOOST_FIXTURE_TEST_CASE_TEMPLATE(
transaction_1pc_connection_failed_from_certify, T,
replicating_fixtures, T)
{
wsrep::mock_server_context& sc(T::sc);
wsrep::mock_server_state& sc(T::sc);
wsrep::client_state& cc(T::cc);
const wsrep::transaction& tc(T::tc);
@ -599,7 +599,7 @@ BOOST_FIXTURE_TEST_CASE_TEMPLATE(
transaction_1pc_no_allowed_from_certify, T,
replicating_fixtures, T)
{
wsrep::mock_server_context& sc(T::sc);
wsrep::mock_server_state& sc(T::sc);
wsrep::client_state& cc(T::cc);
const wsrep::transaction& tc(T::tc);
@ -640,7 +640,7 @@ BOOST_FIXTURE_TEST_CASE_TEMPLATE(
transaction_1pc_fatal_from_certify, T,
replicating_fixtures, T)
{
wsrep::mock_server_context& sc(T::sc);
wsrep::mock_server_state& sc(T::sc);
wsrep::mock_client_state& cc(T::cc);
const wsrep::transaction& tc(T::tc);
@ -682,7 +682,7 @@ BOOST_FIXTURE_TEST_CASE_TEMPLATE(
transaction_1pc_unknown_from_certify, T,
replicating_fixtures, T)
{
wsrep::mock_server_context& sc(T::sc);
wsrep::mock_server_state& sc(T::sc);
wsrep::mock_client_state& cc(T::cc);
const wsrep::transaction& tc(T::tc);
@ -724,7 +724,7 @@ BOOST_FIXTURE_TEST_CASE_TEMPLATE(
transaction_1pc_bf_abort_before_certify_regain_lock, T,
replicating_fixtures, T)
{
wsrep::mock_server_context& sc(T::sc);
wsrep::mock_server_state& sc(T::sc);
wsrep::mock_client_state& cc(T::cc);
const wsrep::transaction& tc(T::tc);