lib/wsrep-lib
1
0
Fork 0
mirror of https://github.com/codership/wsrep-lib.git synced 2025-07-30 07:23:07 +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
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&,