Renamed client_context to client_state.

dbsim/db_client.cpp

@@ -7,14 +7,14 @@
 
 db::client::client(db::server& server,
                    wsrep::client_id client_id,
-                   enum wsrep::client_context::mode mode,
+                   enum wsrep::client_state::mode mode,
                    const db::params& params)
     : mutex_()
     , params_(params)
     , server_(server)
     , server_context_(server.server_context())
-    , client_context_(mutex_, this, server_context_, client_service_, client_id, mode)
-    , client_service_(server_context_.provider(), client_context_)
+    , client_state_(mutex_, this, server_context_, client_service_, client_id, mode)
+    , client_service_(server_context_.provider(), client_state_)
     , se_trx_(server.storage_engine())
     , stats_()
 { }
@@ -30,7 +30,7 @@ void db::client::start()
 
 bool db::client::bf_abort(wsrep::seqno seqno)
 {
-    return client_context_.bf_abort(seqno);
+    return client_state_.bf_abort(seqno);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -40,39 +40,39 @@ bool db::client::bf_abort(wsrep::seqno seqno)
 template <class F>
 int db::client::client_command(F f)
 {
-    int err(client_context_.before_command());
+    int err(client_state_.before_command());
     // wsrep::log_debug() << "before_command: " << err;
     // If err != 0, transaction was BF aborted while client idle
     if (err == 0)
     {
-        err = client_context_.before_statement();
+        err = client_state_.before_statement();
         if (err == 0)
         {
             err = f();
         }
-        client_context_.after_statement();
+        client_state_.after_statement();
     }
-    client_context_.after_command_before_result();
-    if (client_context_.current_error())
+    client_state_.after_command_before_result();
+    if (client_state_.current_error())
     {
         // wsrep::log_info() << "Current error";
-        assert(client_context_.transaction().state() ==
+        assert(client_state_.transaction().state() ==
                wsrep::transaction_context::s_aborted);
         err = 1;
     }
-    client_context_.after_command_after_result();
+    client_state_.after_command_after_result();
     // wsrep::log_info() << "client_command(): " << err;
     return err;
 }
 
 void db::client::run_one_transaction()
 {
-    client_context_.reset_error();
+    client_state_.reset_error();
     int err = client_command(
         [&]()
         {
             // wsrep::log_debug() << "Start transaction";
-            err = client_context_.start_transaction(
+            err = client_state_.start_transaction(
                 server_.next_transaction_id());
             assert(err == 0);
             se_trx_.start(this);
@@ -80,7 +80,7 @@ void db::client::run_one_transaction()
         });
 
     const wsrep::transaction_context& transaction(
-        client_context_.transaction());
+        client_state_.transaction());
 
     err = err || client_command(
         [&]()
@@ -93,11 +93,11 @@ void db::client::run_one_transaction()
             os << data;
             wsrep::key key(wsrep::key::exclusive);
             key.append_key_part("dbms", 4);
-            unsigned long long client_key(client_context_.id().get());
+            unsigned long long client_key(client_state_.id().get());
             key.append_key_part(&client_key, sizeof(client_key));
             key.append_key_part(&data, sizeof(data));
-            err = client_context_.append_key(key);
-            err = err || client_context_.append_data(
+            err = client_state_.append_key(key);
+            err = err || client_state_.append_data(
                 wsrep::const_buffer(os.str().c_str(),
                                     os.str().size()));
             return err;
@@ -108,18 +108,18 @@ void db::client::run_one_transaction()
         {
             // wsrep::log_debug() << "Commit";
             assert(err == 0);
-            if (client_context_.do_2pc())
+            if (client_state_.do_2pc())
             {
-                err = err || client_context_.before_prepare();
-                err = err || client_context_.after_prepare();
+                err = err || client_state_.before_prepare();
+                err = err || client_state_.after_prepare();
             }
-            err = err || client_context_.before_commit();
+            err = err || client_state_.before_commit();
             if (err == 0) se_trx_.commit();
-            err = err || client_context_.ordered_commit();
-            err = err || client_context_.after_commit();
+            err = err || client_state_.ordered_commit();
+            err = err || client_state_.after_commit();
             if (err)
             {
-                client_context_.rollback();
+                client_state_.rollback();
             }
             return err;
         });
@@ -147,7 +147,7 @@ void db::client::report_progress(size_t i) const
 {
     if ((i % 1000) == 0)
     {
-        wsrep::log_info() << "client: " << client_context_.id().get()
+        wsrep::log_info() << "client: " << client_state_.id().get()
                           << " transactions: " << i
                           << " " << 100*double(i)/params_.n_transactions << "%";
     }

dbsim/db_client.hpp

@@ -7,7 +7,7 @@
 
 #include "db_server_context.hpp"
 #include "db_storage_engine.hpp"
-#include "db_client_context.hpp"
+#include "db_client_state.hpp"
 #include "db_client_service.hpp"
 
 
@@ -30,18 +30,18 @@ namespace db
         };
         client(db::server&,
                wsrep::client_id,
-               enum wsrep::client_context::mode,
+               enum wsrep::client_state::mode,
                const db::params&);
         bool bf_abort(wsrep::seqno);
         const struct stats stats() const { return stats_; }
         void store_globals()
         {
-            client_context_.store_globals();
+            client_state_.store_globals();
         }
         void reset_globals()
         { }
         void start();
-        wsrep::client_context& client_context() { return client_context_; }
+        wsrep::client_state& client_state() { return client_state_; }
     private:
         friend class db::server_context;
         friend class db::client_service;
@@ -53,7 +53,7 @@ namespace db
         const db::params& params_;
         db::server& server_;
         db::server_context& server_context_;
-        db::client_context client_context_;
+        db::client_state client_state_;
         db::client_service client_service_;
         db::storage_engine::transaction se_trx_;
         struct stats stats_;

dbsim/db_client_service.cpp

@@ -5,47 +5,47 @@
 #include "db_client_service.hpp"
 #include "db_client.hpp"
 
-int db::client_service::apply(wsrep::client_context&,
+int db::client_service::apply(wsrep::client_state&,
                               const wsrep::const_buffer&)
 {
-    db::client* client(client_context_.client());
+    db::client* client(client_state_.client());
     client->se_trx_.start(client);
-    client->se_trx_.apply(client_context_.transaction());
+    client->se_trx_.apply(client_state_.transaction());
     return 0;
 }
 
-int db::client_service::commit(wsrep::client_context&,
+int db::client_service::commit(wsrep::client_state&,
                                const wsrep::ws_handle&,
                                const wsrep::ws_meta&)
 {
-    db::client* client(client_context_.client());
-    int ret(client_context_.before_commit());
+    db::client* client(client_state_.client());
+    int ret(client_state_.before_commit());
     if (ret == 0) client->se_trx_.commit();
-    ret = ret || client_context_.ordered_commit();
-    ret = ret || client_context_.after_commit();
+    ret = ret || client_state_.ordered_commit();
+    ret = ret || client_state_.after_commit();
     return ret;
 }
 
-int db::client_service::rollback(wsrep::client_context&)
+int db::client_service::rollback(wsrep::client_state&)
 {
-    db::client* client(client_context_.client());
-    int ret(client_context_.before_rollback());
+    db::client* client(client_state_.client());
+    int ret(client_state_.before_rollback());
     assert(ret == 0);
     client->se_trx_.rollback();
-    ret = client_context_.after_rollback();
+    ret = client_state_.after_rollback();
     assert(ret == 0);
     return ret;
 }
 enum wsrep::provider::status
-db::client_service::replay(wsrep::client_context&,
+db::client_service::replay(wsrep::client_state&,
                            wsrep::transaction_context& transaction_context)
 {
-    wsrep::high_priority_context high_priority_context(client_context_);
+    wsrep::high_priority_context high_priority_context(client_state_);
     auto ret(provider_.replay(transaction_context.ws_handle(),
-                              &client_context_));
+                              &client_state_));
     if (ret == wsrep::provider::success)
     {
-        ++client_context_.client()->stats_.replays;
+        ++client_state_.client()->stats_.replays;
     }
     return ret;
 }

dbsim/db_client_service.hpp

@@ -8,7 +8,7 @@
 #include "wsrep/client_service.hpp"
 #include "wsrep/transaction_context.hpp"
 
-#include "db_client_context.hpp"
+#include "db_client_state.hpp"
 
 namespace db
 {
@@ -16,19 +16,19 @@ namespace db
     {
     public:
         client_service(wsrep::provider& provider,
-                       db::client_context& client_context)
+                       db::client_state& client_state)
             : wsrep::client_service(provider)
-            , client_context_(client_context)
+            , client_state_(client_state)
         { }
 
         bool is_autocommit() const override
         {
-            return client_context_.is_autocommit();
+            return client_state_.is_autocommit();
         }
 
         bool do_2pc() const override
         {
-            return client_context_.do_2pc();
+            return client_state_.do_2pc();
         }
 
         bool interrupted() const override
@@ -38,15 +38,15 @@ namespace db
 
         void reset_globals() override
         {
-            client_context_.reset_globals();
+            client_state_.reset_globals();
         }
 
         void store_globals() override
         {
-            client_context_.store_globals();
+            client_state_.store_globals();
         }
 
-        int prepare_data_for_replication(wsrep::client_context&, const wsrep::transaction_context&) override
+        int prepare_data_for_replication(wsrep::client_state&, const wsrep::transaction_context&) override
         {
             return 0;
         }
@@ -56,7 +56,7 @@ namespace db
             return 0;
         }
 
-        int prepare_fragment_for_replication(wsrep::client_context&,
+        int prepare_fragment_for_replication(wsrep::client_state&,
                                              const wsrep::transaction_context&,
                                              wsrep::mutable_buffer&) override
         {
@@ -66,19 +66,19 @@ namespace db
         void remove_fragments(const wsrep::transaction_context&) override
         { }
 
-        int apply(wsrep::client_context&, const wsrep::const_buffer&) override;
+        int apply(wsrep::client_state&, const wsrep::const_buffer&) override;
 
-        int commit(wsrep::client_context&,
+        int commit(wsrep::client_state&,
                    const wsrep::ws_handle&, const wsrep::ws_meta&) override;
 
-        int rollback(wsrep::client_context&) override;
+        int rollback(wsrep::client_state&) override;
 
         void will_replay(const wsrep::transaction_context&) override
         { }
 
-        void wait_for_replayers(wsrep::client_context&,
+        void wait_for_replayers(wsrep::client_state&,
                                 wsrep::unique_lock<wsrep::mutex>&) override { }
-        enum wsrep::provider::status replay(wsrep::client_context&,
+        enum wsrep::provider::status replay(wsrep::client_state&,
                                             wsrep::transaction_context&)
             override;
 
@@ -89,10 +89,10 @@ namespace db
         }
 
         void emergency_shutdown() { ::abort(); }
-        void debug_sync(wsrep::client_context&, const char*) override { }
+        void debug_sync(wsrep::client_state&, const char*) override { }
         void debug_crash(const char*) override { }
     private:
-        db::client_context& client_context_;
+        db::client_state& client_state_;
     };
 }
 

dbsim/db_client_state.hpp

@@ -5,22 +5,22 @@
 #ifndef WSREP_DB_CLIENT_CONTEXT_HPP
 #define WSREP_DB_CLIENT_CONTEXT_HPP
 
-#include "wsrep/client_context.hpp"
+#include "wsrep/client_state.hpp"
 #include "db_server_context.hpp"
 
 namespace db
 {
     class client;
-    class client_context : public wsrep::client_context
+    class client_state : public wsrep::client_state
     {
     public:
-        client_context(wsrep::mutex& mutex,
+        client_state(wsrep::mutex& mutex,
                        db::client* client,
                        db::server_context& server_context,
                        wsrep::client_service& client_service,
                        const wsrep::client_id& client_id,
-                       enum wsrep::client_context::mode mode)
-            : wsrep::client_context(mutex,
+                       enum wsrep::client_state::mode mode)
+            : wsrep::client_state(mutex,
                                     server_context,
                                     client_service,
                                     client_id,
@@ -31,13 +31,13 @@ namespace db
         { }
         db::client* client() { return client_; }
         void reset_globals() { }
-        void store_globals() { wsrep::client_context::store_globals(); }
+        void store_globals() { wsrep::client_state::store_globals(); }
         bool is_autocommit() const { return is_autocommit_; }
         bool do_2pc() const { return do_2pc_; }
 
     private:
-        client_context(const client_context&);
-        client_context& operator=(const client_context&);
+        client_state(const client_state&);
+        client_state& operator=(const client_state&);
         db::client* client_;
         bool is_autocommit_;
         bool do_2pc_;

dbsim/db_server.cpp

@@ -26,10 +26,10 @@ void db::server::applier_thread()
 {
     wsrep::client_id client_id(last_client_id_.fetch_add(1) + 1);
     db::client applier(*this, client_id,
-                       wsrep::client_context::m_high_priority,
+                       wsrep::client_state::m_high_priority,
                        simulator_.params());
-    wsrep::client_context* cc(static_cast<wsrep::client_context*>(
-                                  &applier.client_context()));
+    wsrep::client_state* cc(static_cast<wsrep::client_state*>(
+                                  &applier.client_state()));
     enum wsrep::provider::status ret(
         server_context_.provider().run_applier(cc));
     wsrep::log() << "Applier thread exited with error code " << ret;
@@ -83,7 +83,7 @@ void db::server::start_client(size_t id)
 {
     auto client(std::make_shared<db::client>(
                     *this, id,
-                    wsrep::client_context::m_replicating,
+                    wsrep::client_state::m_replicating,
                     simulator_.params()));
     clients_.push_back(client);
     client_threads_.push_back(
@@ -97,24 +97,24 @@ void db::server::donate_sst(const std::string& req,
     simulator_.sst(*this, req, gtid, bypass);
 }
 
-wsrep::client_context* db::server::local_client_context()
+wsrep::client_state* db::server::local_client_state()
 {
     std::ostringstream id_os;
     size_t client_id(++last_client_id_);
     db::client* client(new db::client(*this, client_id,
-                                      wsrep::client_context::m_replicating,
+                                      wsrep::client_state::m_replicating,
                                       simulator_.params()));
-    return &client->client_context();
+    return &client->client_state();
 }
 
-wsrep::client_context* db::server::streaming_applier_client_context()
+wsrep::client_state* db::server::streaming_applier_client_state()
 {
     throw wsrep::not_implemented_error();
 }
 
-void db::server::release_client_context(wsrep::client_context* client_context)
+void db::server::release_client_state(wsrep::client_state* client_state)
 {
-    db::client_context* db_client_context(
-        dynamic_cast<db::client_context*>(client_context));
-    delete db_client_context->client();
+    db::client_state* db_client_state(
+        dynamic_cast<db::client_state*>(client_state));
+    delete db_client_state->client();
 }

dbsim/db_server.hpp

@@ -6,7 +6,7 @@
 #define WSREP_DB_SERVER_HPP
 
 #include "wsrep/gtid.hpp"
-#include "wsrep/client_context.hpp"
+#include "wsrep/client_state.hpp"
 
 #include "db_storage_engine.hpp"
 #include "db_server_context.hpp"
@@ -40,9 +40,9 @@ namespace db
             return (last_transaction_id_.fetch_add(1) + 1);
         }
         void donate_sst(const std::string&, const  wsrep::gtid&, bool);
-        wsrep::client_context* local_client_context();
-        wsrep::client_context* streaming_applier_client_context();
-        void release_client_context(wsrep::client_context*);
+        wsrep::client_state* local_client_state();
+        wsrep::client_state* streaming_applier_client_state();
+        void release_client_state(wsrep::client_state*);
 
     private:
         void start_client(size_t id);

dbsim/db_server_context.cpp

@@ -5,20 +5,20 @@
 #include "db_server_context.hpp"
 #include "db_server.hpp"
 
-wsrep::client_context* db::server_context::local_client_context()
+wsrep::client_state* db::server_context::local_client_state()
 {
-    return server_.local_client_context();
+    return server_.local_client_state();
 }
 
-wsrep::client_context* db::server_context::streaming_applier_client_context()
+wsrep::client_state* db::server_context::streaming_applier_client_state()
 {
-    return server_.streaming_applier_client_context();
+    return server_.streaming_applier_client_state();
 }
 
-void db::server_context::release_client_context(
-    wsrep::client_context* client_context)
+void db::server_context::release_client_state(
+    wsrep::client_state* client_state)
 {
-    server_.release_client_context(client_context);
+    server_.release_client_state(client_state);
 }
 
 bool db::server_context::sst_before_init() const
@@ -37,12 +37,12 @@ void db::server_context::on_sst_request(
     server_.donate_sst(request, gtid, bypass);
 }
 
-void db::server_context::background_rollback(wsrep::client_context&)
+void db::server_context::background_rollback(wsrep::client_state&)
 {
 }
 
 void db::server_context::log_dummy_write_set(
-    wsrep::client_context&, const wsrep::ws_meta& meta)
+    wsrep::client_state&, const wsrep::ws_meta& meta)
 {
     wsrep::log_info() << "Dummy write set: " << meta.seqno();
 }

dbsim/db_server_context.hpp

@@ -6,7 +6,7 @@
 #define WSREP_DB_SERVER_CONTEXT_HPP
 
 #include "wsrep/server_context.hpp"
-#include "wsrep/client_context.hpp"
+#include "wsrep/client_state.hpp"
 
 #include <atomic>
 
@@ -33,14 +33,14 @@ namespace db
             , cond_()
             , server_(server)
         { }
-        wsrep::client_context* local_client_context() override;
-        wsrep::client_context* streaming_applier_client_context() override;
-        void release_client_context(wsrep::client_context*) override;
+        wsrep::client_state* local_client_state() override;
+        wsrep::client_state* streaming_applier_client_state() override;
+        void release_client_state(wsrep::client_state*) override;
         bool sst_before_init() const override;
         void on_sst_request(const std::string&, const wsrep::gtid&, bool) override;
         std::string on_sst_required() override;
-        void background_rollback(wsrep::client_context&) override;
-        void log_dummy_write_set(wsrep::client_context&, const wsrep::ws_meta&)
+        void background_rollback(wsrep::client_state&) override;
+        void log_dummy_write_set(wsrep::client_state&, const wsrep::ws_meta&)
             override;
     private:
         wsrep::default_mutex mutex_;

dbsim/db_storage_engine.cpp

@@ -52,8 +52,8 @@ void db::storage_engine::bf_abort_some(const wsrep::transaction_context& txc)
         {
             for (auto victim : transactions_)
             {
-                wsrep::client_context& cc(victim->client_context());
-                if (cc.mode() == wsrep::client_context::m_replicating)
+                wsrep::client_state& cc(victim->client_state());
+                if (cc.mode() == wsrep::client_state::m_replicating)
                 {
                     if (victim->bf_abort(txc.seqno()))
                     {

dbsim/db_storage_engine.hpp

@@ -8,7 +8,7 @@
 #include "db_params.hpp"
 
 #include "wsrep/mutex.hpp"
-#include "wsrep/client_context.hpp"
+#include "wsrep/client_state.hpp"
 
 #include <atomic>
 #include <unordered_set>