Implemented convenience methods to desync/pause, resume/resync.

include/wsrep/server_state.hpp

@@ -371,6 +371,21 @@ namespace wsrep
 
         void resume();
 
+        /**
+         * Desync and pause the provider on one go. Will return
+         * pause seqno if successful. In case of failure,
+         * undefined seqno will be returned.
+         */
+        wsrep::seqno desync_and_pause();
+
+        /**
+         * Resume and resync the provider on one go. Prior this
+         * call the provider must have been both desynced and paused,
+         * by either desync_and_pause() or separate calls to desync()
+         * and pause().
+         */
+        void resume_and_resync();
+
         /**
          * Prepares server state for SST.
          *
@@ -508,7 +523,6 @@ namespace wsrep
             , desync_count_()
             , pause_count_()
             , pause_seqno_()
-            , desynced_on_pause_()
             , streaming_appliers_()
             , provider_()
             , name_(name)
@@ -548,7 +562,6 @@ namespace wsrep
         size_t desync_count_;
         size_t pause_count_;
         wsrep::seqno pause_seqno_;
-        bool desynced_on_pause_;
         typedef std::map<std::pair<wsrep::id, wsrep::transaction_id>, wsrep::high_priority_service*> streaming_appliers_map;
         streaming_appliers_map streaming_appliers_;
         wsrep::provider* provider_;

src/server_state.cpp

@@ -272,28 +272,19 @@ wsrep::seqno wsrep::server_state::pause()
     wsrep::unique_lock<wsrep::mutex> lock(mutex_);
     // Disallow concurrent calls to pause to in order to have non-concurrent
     // access to desynced_on_pause_ which is checked in resume() call.
+    wsrep::log_info() << "pause";
     while (pause_count_ > 0)
     {
         cond_.wait(lock);
     }
     ++pause_count_;
     assert(pause_seqno_.is_undefined());
-    if (state_ == s_synced)
-    {
-        if (desync(lock))
-        {
-            return wsrep::seqno::undefined();
-        }
-        desynced_on_pause_ = true;
-    }
     lock.unlock();
     pause_seqno_ = provider_->pause();
     lock.lock();
     if (pause_seqno_.is_undefined())
     {
         --pause_count_;
-        resync();
-        desynced_on_pause_ = false;
     }
     return pause_seqno_;
 }
@@ -301,13 +292,9 @@ wsrep::seqno wsrep::server_state::pause()
 void wsrep::server_state::resume()
 {
     wsrep::unique_lock<wsrep::mutex> lock(mutex_);
+    wsrep::log_info() << "resume";
     assert(pause_seqno_.is_undefined() == false);
     assert(pause_count_ == 1);
-    if (desynced_on_pause_)
-    {
-        resync(lock);
-        desynced_on_pause_ = false;
-    }
     if (provider_->resume())
     {
         throw wsrep::runtime_error("Failed to resume provider");
@@ -317,6 +304,40 @@ void wsrep::server_state::resume()
     cond_.notify_all();
 }
 
+wsrep::seqno wsrep::server_state::desync_and_pause()
+{
+    wsrep::log_info() << "desync_and_pause";
+    if (desync())
+    {
+        wsrep::log_warning() << "Failed to desync server";
+        return wsrep::seqno::undefined();
+    }
+    wsrep::seqno ret(pause());
+    if (ret.is_undefined())
+    {
+        wsrep::log_warning() << "Failed to pause provider";
+        resync();
+        return wsrep::seqno::undefined();
+    }
+    wsrep::log_info() << "Provider paused at: " << ret;
+    return ret;
+}
+
+void wsrep::server_state::resume_and_resync()
+{
+    wsrep::log_info() << "resume_and_resync";
+    try
+    {
+        resume();
+        resync();
+    }
+    catch (const wsrep::runtime_error& e)
+    {
+        wsrep::log_warning()
+            << "Resume and resync failed, server may have to be restarted";
+    }
+}
+
 std::string wsrep::server_state::prepare_for_sst()
 {
     wsrep::unique_lock<wsrep::mutex> lock(mutex_);