lib/wsrep-lib
1
0
Fork 0
mirror of https://github.com/codership/wsrep-lib.git synced 2025-07-28 20:02:00 +03:00
Code Activity

Made client_service, transaction independent of provider.

Browse Source 
Provider may not be loaded when client_service and
transaction are constructed.
This commit is contained in:
Teemu Ollakka
2018-06-19 14:54:58 +03:00
parent 94f77eacf0
commit 779f84e5df
8 changed files with 36 additions and 34 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
dbsim/db_client.cpp
View File

@ -16,7 +16,7 @@ db::client::client(db::server& server,
, server_(server)
, server_state_(server.server_state())
, client_state_(mutex_, this, server_state_, client_service_, client_id, mode)
, client_service_(server_state_.provider(), client_state_)
, client_service_(client_state_)
, se_trx_(server.storage_engine())
, stats_()
{ }

3
dbsim/db_client_service.cpp
View File

@ -38,7 +38,8 @@ enum wsrep::provider::status
db::client_service::replay()
{
wsrep::high_priority_context high_priority_context(client_state_);
auto ret(provider_.replay(client_state_.transaction().ws_handle(),
auto ret(client_state_.provider().replay(
client_state_.transaction().ws_handle(),
&client_state_));
if (ret == wsrep::provider::success)
{

5
dbsim/db_client_service.hpp
View File

@ -15,9 +15,8 @@ namespace db
class client_service : public wsrep::client_service
{
public:
client_service(wsrep::provider& provider,
db::client_state& client_state)
: wsrep::client_service(provider)
client_service(db::client_state& client_state)
: wsrep::client_service()
, client_state_(client_state)
{ }

7
include/wsrep/client_service.hpp
View File

@ -27,8 +27,8 @@ namespace wsrep
class client_service : public wsrep::transaction_termination_service
{
public:
client_service(wsrep::provider& provider)
: provider_(provider) { }
client_service() { }
/**
*
*/
@ -145,9 +145,6 @@ namespace wsrep
* been enabled.
*/
virtual void debug_crash(const char* crash_point) = 0;
protected:
wsrep::provider& provider_;
};
/**

2
include/wsrep/transaction.hpp
View File

@ -129,6 +129,7 @@ namespace wsrep
transaction(const transaction&);
transaction operator=(const transaction&);
wsrep::provider& provider();
void flags(int flags) { flags_ = flags; }
int certify_fragment(wsrep::unique_lock<wsrep::mutex>&);
int certify_commit(wsrep::unique_lock<wsrep::mutex>&);
@ -137,7 +138,6 @@ namespace wsrep
void cleanup();
void debug_log_state(const char*) const;
wsrep::provider& provider_;
wsrep::server_service& server_service_;
wsrep::client_service& client_service_;
wsrep::client_state& client_state_;

40
src/transaction.cpp
View File

@ -23,8 +23,7 @@
wsrep::transaction::transaction(
wsrep::client_state& client_state)
: provider_(client_state.provider())
, server_service_(client_state.server_state().server_service())
: server_service_(client_state.server_state().server_service())
, client_service_(client_state.client_service())
, client_state_(client_state)
, id_(transaction_id::invalid())
@ -60,7 +59,7 @@ int wsrep::transaction::start_transaction(
case wsrep::client_state::m_high_priority:
return 0;
case wsrep::client_state::m_replicating:
return provider_.start_transaction(ws_handle_);
return provider().start_transaction(ws_handle_);
default:
assert(0);
return 1;
@ -98,13 +97,13 @@ int wsrep::transaction::start_replaying(const wsrep::ws_meta& ws_meta)
int wsrep::transaction::append_key(const wsrep::key& key)
{
/** @todo Collect table level keys for SR commit */
return provider_.append_key(ws_handle_, key);
return provider().append_key(ws_handle_, key);
}
int wsrep::transaction::append_data(const wsrep::const_buffer& data)
{
return provider_.append_data(ws_handle_, data);
return provider().append_data(ws_handle_, data);
}
int wsrep::transaction::after_row()
@ -252,7 +251,7 @@ int wsrep::transaction::before_commit()
case wsrep::client_state::m_local:
if (ordered())
{
ret = provider_.commit_order_enter(ws_handle_, ws_meta_);
ret = provider().commit_order_enter(ws_handle_, ws_meta_);
}
break;
case wsrep::client_state::m_replicating:
@ -289,7 +288,7 @@ int wsrep::transaction::before_commit()
assert(ordered());
lock.unlock();
enum wsrep::provider::status
status(provider_.commit_order_enter(ws_handle_, ws_meta_));
status(provider().commit_order_enter(ws_handle_, ws_meta_));
lock.lock();
switch (status)
{
@ -321,7 +320,7 @@ int wsrep::transaction::before_commit()
{
ret = 0;
}
ret = ret || provider_.commit_order_enter(ws_handle_, ws_meta_);
ret = ret || provider().commit_order_enter(ws_handle_, ws_meta_);
if (ret)
{
state(lock, s_must_abort);
@ -341,7 +340,7 @@ int wsrep::transaction::ordered_commit()
debug_log_state("ordered_commit_enter");
assert(state() == s_committing);
assert(ordered());
int ret(provider_.commit_order_leave(ws_handle_, ws_meta_));
int ret(provider().commit_order_leave(ws_handle_, ws_meta_));
// Should always succeed
assert(ret == 0);
state(lock, s_ordered_commit);
@ -370,7 +369,7 @@ int wsrep::transaction::after_commit()
// Nothing to do
break;
case wsrep::client_state::m_replicating:
ret = provider_.release(ws_handle_);
ret = provider().release(ws_handle_);
break;
case wsrep::client_state::m_high_priority:
break;
@ -428,7 +427,7 @@ int wsrep::transaction::before_rollback()
case s_aborting:
if (is_streaming())
{
provider_.rollback(id_.get());
provider().rollback(id_.get());
}
break;
case s_must_replay:
@ -515,7 +514,7 @@ int wsrep::transaction::after_statement()
switch (replay_ret)
{
case wsrep::provider::success:
provider_.release(ws_handle_);
provider().release(ws_handle_);
break;
case wsrep::provider::error_certification_failed:
client_state_.override_error(
@ -550,10 +549,10 @@ int wsrep::transaction::after_statement()
{
if (ordered())
{
ret = provider_.commit_order_enter(ws_handle_, ws_meta_);
if (ret == 0) provider_.commit_order_leave(ws_handle_, ws_meta_);
ret = provider().commit_order_enter(ws_handle_, ws_meta_);
if (ret == 0) provider().commit_order_leave(ws_handle_, ws_meta_);
}
provider_.release(ws_handle_);
provider().release(ws_handle_);
}
if (state() != s_executing)
@ -647,6 +646,11 @@ bool wsrep::transaction::bf_abort(
// Private //
////////////////////////////////////////////////////////////////////////////////
inline wsrep::provider& wsrep::transaction::provider()
{
return client_state_.server_state().provider();
}
void wsrep::transaction::state(
wsrep::unique_lock<wsrep::mutex>& lock __attribute__((unused)),
enum wsrep::transaction::state next_state)
@ -745,7 +749,7 @@ int wsrep::transaction::certify_fragment(
}
enum wsrep::provider::status
cert_ret(provider_.certify(client_state_.id().get(),
cert_ret(provider().certify(client_state_.id().get(),
sr_transaction.ws_handle_,
flags_,
sr_transaction.ws_meta_));
@ -826,7 +830,7 @@ int wsrep::transaction::certify_commit(
client_service_.debug_sync("wsrep_before_certification");
enum wsrep::provider::status
cert_ret(provider_.certify(client_state_.id().get(),
cert_ret(provider().certify(client_state_.id().get(),
ws_handle_,
flags(),
ws_meta_));
@ -935,7 +939,7 @@ void wsrep::transaction::streaming_rollback()
sac->adopt_transaction(*this);
streaming_context_.cleanup();
// Replicate rollback fragment
provider_.rollback(id_.get());
provider().rollback(id_.get());
}
void wsrep::transaction::clear_fragments()

5
test/mock_client_state.hpp
View File

@ -43,7 +43,7 @@ namespace wsrep
{
public:
mock_client_service(wsrep::mock_client_state& client_state)
: wsrep::client_service(client_state.provider())
: wsrep::client_service()
, is_autocommit_()
, do_2pc_()
, fail_next_applying_()
@ -89,7 +89,8 @@ namespace wsrep
replay() WSREP_OVERRIDE
{
enum wsrep::provider::status ret(
provider_.replay(client_state_.transaction().ws_handle(),
client_state_.provider().replay(
client_state_.transaction().ws_handle(),
&client_state_));
++replays_;
return ret;

2
wsrep

Submodule wsrep updated: e12a9dd89c...eb7d6b8dd1