Initial implementation of client_state TOI mode.

src/client_state.cpp

@@ -231,6 +231,47 @@ int wsrep::client_state::enable_streaming(
     return 0;
 }
 
+int wsrep::client_state::enter_toi(const wsrep::key_array& keys,
+                                   const wsrep::const_buffer& buffer,
+                                   int flags)
+{
+    assert(state_ == s_exec);
+    int ret;
+    switch (provider().enter_toi(id_, keys, buffer, toi_meta_, flags))
+    {
+    case wsrep::provider::success:
+    {
+        wsrep::unique_lock<wsrep::mutex> lock(mutex_);
+        mode(lock, m_toi);
+        ret = 0;
+        break;
+    }
+    default:
+        override_error(wsrep::e_error_during_commit);
+        ret = 1;
+        break;
+    }
+    return ret;
+}
+
+int wsrep::client_state::leave_toi()
+{
+    int ret;
+    switch (provider().leave_toi(id_))
+    {
+    case wsrep::provider::success:
+        ret = 0;
+        break;
+    default:
+        assert(0);
+        override_error(wsrep::e_error_during_commit);
+        ret = 1;
+        break;
+    }
+    wsrep::unique_lock<wsrep::mutex> lock(mutex_);
+    mode(lock, m_replicating);
+    return ret;
+}
 // Private
 
 void wsrep::client_state::debug_log_state(const char* context) const
@@ -271,3 +312,29 @@ void wsrep::client_state::state(
         throw wsrep::runtime_error(os.str());
     }
 }
+
+void wsrep::client_state::mode(
+    wsrep::unique_lock<wsrep::mutex>& lock WSREP_UNUSED,
+    enum mode mode)
+{
+    assert(lock.owns_lock());
+    static const char allowed[mode_max_][mode_max_] =
+        {
+            { 0, 0, 0, 0}, /* local */
+            { 0, 0, 1, 1}, /* repl */
+            { 0, 1, 0, 0}, /* high prio */
+            { 0, 1, 0, 0} /* toi */
+        };
+    if (allowed[mode_][mode])
+    {
+        mode_ = mode;
+    }
+    else
+    {
+        std::ostringstream os;
+        os << "client_state: Unallowed mode transition: "
+           << mode_ << " -> " << mode;
+        throw wsrep::runtime_error(os.str());
+    }
+
+}

src/wsrep_provider_v26.cpp

@@ -633,6 +633,50 @@ wsrep::wsrep_provider_v26::replay(const wsrep::ws_handle& ws_handle,
         wsrep_->replay_trx(wsrep_, mwsh.native(), applier_ctx));
 }
 
+enum wsrep::provider::status
+wsrep::wsrep_provider_v26::enter_toi(
+    wsrep::client_id client_id,
+    const wsrep::key_array& keys,
+    const wsrep::const_buffer& buffer,
+    wsrep::ws_meta& ws_meta,
+    int flags)
+{
+    mutable_ws_meta mmeta(ws_meta, flags);
+    std::vector<wsrep_buf_t> key_parts;
+    size_t key_parts_offset(0);
+    std::vector<wsrep_key_t> wsrep_keys;
+    wsrep_buf_t wsrep_buf = {buffer.data(), buffer.size()};
+    for (wsrep::key_array::const_iterator i(keys.begin());
+         i != keys.end(); ++i)
+    {
+        for (size_t kp(0); kp < i->size(); ++kp)
+        {
+            wsrep_buf_t buf = {i->key_parts()[kp].data(),
+                               i->key_parts()[kp].size()};
+            key_parts.push_back(buf);
+        }
+        wsrep_key_t key = {&key_parts[0] + key_parts_offset, i->size()};
+        wsrep_keys.push_back(key);
+        key_parts_offset += i->size();
+    }
+    return map_return_value(wsrep_->to_execute_start(
+                                wsrep_,
+                                client_id.get(),
+                                &wsrep_keys[0],
+                                wsrep_keys.size(),
+                                &wsrep_buf,
+                                1,
+                                mmeta.native_flags(),
+                                mmeta.native()));
+}
+
+enum wsrep::provider::status
+wsrep::wsrep_provider_v26::leave_toi(wsrep::client_id client_id)
+{
+    return map_return_value(wsrep_->to_execute_end(
+                                wsrep_, client_id.get(), 0));
+}
+
 enum wsrep::provider::status
 wsrep::wsrep_provider_v26::causal_read(int timeout) const
 {

src/wsrep_provider_v26.hpp

@@ -49,7 +49,12 @@ namespace wsrep
                                const wsrep::ws_meta&);
         int release(wsrep::ws_handle&);
         enum wsrep::provider::status replay(const wsrep::ws_handle&, void*);
-
+        enum wsrep::provider::status enter_toi(wsrep::client_id,
+                                               const wsrep::key_array&,
+                                               const wsrep::const_buffer&,
+                                               wsrep::ws_meta&,
+                                               int);
+        enum wsrep::provider::status leave_toi(wsrep::client_id);
         enum wsrep::provider::status causal_read(int) const;
 
         int sst_sent(const wsrep::gtid&,int);