DBMS simulator is now able to start and stop one server

Other:
* Added trrep::condition_variable
* Added trrep::view

src/dbms_simulator.cpp

@@ -10,6 +10,9 @@
 
 #include "server_context.hpp"
 #include "client_context.hpp"
+#include "provider.hpp"
+#include "condition_variable.hpp"
+#include "view.hpp"
 
 #include <boost/program_options.hpp>
 
@@ -17,6 +20,7 @@
 #include <memory>
 #include <map>
 #include <atomic>
+#include <thread>
 
 class dbms_server;
 
@@ -36,6 +40,7 @@ public:
     void start();
     void stop();
 private:
+    std::string build_cluster_address() const;
     std::map<size_t, std::unique_ptr<dbms_server>> servers_;
     size_t n_servers_;
     size_t n_clients_;
@@ -48,20 +53,101 @@ class dbms_client;
 class dbms_server : public trrep::server_context
 {
 public:
+    enum state
+    {
+        s_disconnected,
+        s_connected,
+        s_synced
+    };
     dbms_server(const std::string& name, const std::string& id)
         : trrep::server_context(name, id, trrep::server_context::rm_async)
         , mutex_()
+        , cond_()
+        , state_(s_disconnected)
         , last_client_id_(0)
+        , appliers_()
         , clients_()
     { }
 
-    void on_connect() { }
-    void on_view() { }
-    void on_sync() { }
+    // Provider management
+
+    void applier_thread();
+
+    void start_applier()
+    {
+        trrep::unique_lock<trrep::mutex> lock(mutex_);
+        appliers_.push_back(std::thread(&dbms_server::applier_thread, this));
+    }
+
+    void stop_applier()
+    {
+        trrep::unique_lock<trrep::mutex> lock(mutex_);
+        appliers_.front().join();
+        appliers_.erase(appliers_.begin());
+    }
+
+    void on_connect()
+    {
+        std::cerr << "dbms_server: connected" << "\n";
+        trrep::unique_lock<trrep::mutex> lock(mutex_);
+        state_ = s_connected;
+        cond_.notify_all();
+    }
+
+    void on_view(const trrep::view& view)
+    {
+        std::cerr << "================================================\nView:\n"
+                  << "id: " << view.id() << "\n"
+                  << "status: " << view.status() << "\n"
+                  << "own_index: " << view.own_index() << "\n"
+                  << "final: " << view.final() << "\n"
+                  << "members: \n";
+        auto members(view.members());
+        for (const auto& m : members)
+        {
+            std::cerr << "id: " << m.id() << " "
+                      << "name: " << m.name() << "\n";
+
+        }
+        std::cerr << "=================================================\n";
+        trrep::unique_lock<trrep::mutex> lock(mutex_);
+        if (view.final())
+        {
+            state_ = s_disconnected;
+            cond_.notify_all();
+        }
+    }
+
+    void on_sync()
+    {
+        std::cerr << "Synced with group" << "\n";
+    }
+
+    void wait_until_connected()
+    {
+        trrep::unique_lock<trrep::mutex> lock(mutex_);
+        while (state_ != s_connected)
+        {
+            cond_.wait(lock);
+        }
+    }
+    void wait_until_disconnected()
+    {
+        trrep::unique_lock<trrep::mutex> lock(mutex_);
+        while (state_ != s_disconnected)
+        {
+            cond_.wait(lock);
+        }
+    }
+
+    // Client context management
     trrep::client_context* local_client_context();
 private:
     trrep::default_mutex mutex_;
+    trrep::default_condition_variable cond_;
+    enum state state_;
     std::atomic<size_t> last_client_id_;
+    std::vector<std::thread> appliers_;
     std::map<size_t, std::unique_ptr<dbms_client>> clients_;
 };
 
@@ -90,6 +176,16 @@ private:
     trrep::default_mutex mutex_;
 };
 
+
+// Server methods
+void dbms_server::applier_thread()
+{
+    dbms_client applier(*this, ++last_client_id_,
+                        trrep::client_context::m_applier);
+    wsrep_status_t ret(provider().run_applier(&applier));
+    std::cerr << "Applier thread exited with error code " << ret << "\n";
+}
+
 trrep::client_context* dbms_server::local_client_context()
 {
     std::ostringstream id_os;
@@ -105,6 +201,9 @@ trrep::client_context* dbms_server::local_client_context()
 void dbms_simulator::start()
 {
     std::cout << "Provider: " << wsrep_provider_ << "\n";
+
+    std::string cluster_address(build_cluster_address());
+    std::cout << "Cluster address: " << cluster_address << "\n";
     for (size_t i(0); i < n_servers_; ++i)
     {
         std::ostringstream name_os;
@@ -114,10 +213,44 @@ void dbms_simulator::start()
         auto it(servers_.insert(std::make_pair((i + 1),
                                                std::make_unique<dbms_server>(
                                                    name_os.str(), id_os.str()))));
-        it.first->second->load_provider(wsrep_provider_, wsrep_provider_options_);
+        if (it.second == false)
+        {
+            throw trrep::runtime_error("Failed to add server");
+        }
+        dbms_server& server(*it.first->second);
+        server.load_provider(wsrep_provider_, wsrep_provider_options_);
+        server.provider().connect("sim_cluster", cluster_address, "",
+                                  i == 0);
+        server.start_applier();
+        server.wait_until_connected();
     }
 }
 
+void dbms_simulator::stop()
+{
+    for (auto& i : servers_)
+    {
+        dbms_server& server(*i.second);
+        server.provider().disconnect();
+        server.wait_until_disconnected();
+        server.stop_applier();
+    }
+}
+
+std::string dbms_simulator::build_cluster_address() const
+{
+    std::string ret("gcomm://");
+    for (size_t i(0); i < n_servers_; ++i)
+    {
+        std::ostringstream sa_os;
+        sa_os << "127.0.0.1:";
+        sa_os << (10000 + (i + 1)*10);
+        ret += sa_os.str();
+        if (i < n_servers_ - 1) ret += ",";
+    }
+    return ret;
+}
+
 namespace po = boost::program_options;
 
 int main(int argc, char** argv)
@@ -153,6 +286,8 @@ int main(int argc, char** argv)
 
         dbms_simulator sim(n_servers, n_clients, wsrep_provider, wsrep_provider_options);
         sim.start();
+        std::this_thread::sleep_for(std::chrono::seconds(5));
+        sim.stop();
     }
     catch (const std::exception& e)
     {