summaryrefslogtreecommitdiffstats
path: root/wsrep-lib/test
diff options
context:
space:
mode:
Diffstat (limited to 'wsrep-lib/test')
-rw-r--r--wsrep-lib/test/CMakeLists.txt47
-rw-r--r--wsrep-lib/test/buffer_test.cpp28
-rw-r--r--wsrep-lib/test/client_state_fixture.hpp305
-rw-r--r--wsrep-lib/test/gtid_test.cpp62
-rw-r--r--wsrep-lib/test/id_test.cpp69
-rw-r--r--wsrep-lib/test/mock_client_state.cpp77
-rw-r--r--wsrep-lib/test/mock_client_state.hpp260
-rw-r--r--wsrep-lib/test/mock_high_priority_service.cpp170
-rw-r--r--wsrep-lib/test/mock_high_priority_service.hpp111
-rw-r--r--wsrep-lib/test/mock_provider.hpp356
-rw-r--r--wsrep-lib/test/mock_server_state.hpp315
-rw-r--r--wsrep-lib/test/mock_storage_service.cpp94
-rw-r--r--wsrep-lib/test/mock_storage_service.hpp63
-rw-r--r--wsrep-lib/test/nbo_test.cpp171
-rw-r--r--wsrep-lib/test/reporter_test.cpp655
-rw-r--r--wsrep-lib/test/rsu_test.cpp36
-rw-r--r--wsrep-lib/test/server_context_test.cpp960
-rw-r--r--wsrep-lib/test/test_utils.cpp75
-rw-r--r--wsrep-lib/test/test_utils.hpp55
-rw-r--r--wsrep-lib/test/toi_test.cpp66
-rw-r--r--wsrep-lib/test/transaction_test.cpp1763
-rw-r--r--wsrep-lib/test/transaction_test_2pc.cpp290
-rw-r--r--wsrep-lib/test/transaction_test_xa.cpp296
-rw-r--r--wsrep-lib/test/view_test.cpp105
-rw-r--r--wsrep-lib/test/wsrep-lib_test.cpp119
-rw-r--r--wsrep-lib/test/xid_test.cpp90
26 files changed, 6638 insertions, 0 deletions
diff --git a/wsrep-lib/test/CMakeLists.txt b/wsrep-lib/test/CMakeLists.txt
new file mode 100644
index 00000000..366cc478
--- /dev/null
+++ b/wsrep-lib/test/CMakeLists.txt
@@ -0,0 +1,47 @@
+#
+# Copyright (C) 2018 Codership Oy <info@codership.com>
+#
+
+
+set(TEST_SOURCES
+ mock_client_state.cpp
+ mock_high_priority_service.cpp
+ mock_storage_service.cpp
+ test_utils.cpp
+ buffer_test.cpp
+ gtid_test.cpp
+ id_test.cpp
+ nbo_test.cpp
+ rsu_test.cpp
+ server_context_test.cpp
+ toi_test.cpp
+ transaction_test.cpp
+ transaction_test_2pc.cpp
+ transaction_test_xa.cpp
+ view_test.cpp
+ xid_test.cpp
+ wsrep-lib_test.cpp
+ )
+
+if (WSREP_LIB_WITH_UNIT_TESTS_EXTRA)
+ set(TEST_SOURCES ${TEST_SOURCES}
+ reporter_test.cpp
+ )
+endif()
+
+add_executable(wsrep-lib_test ${TEST_SOURCES})
+
+target_link_libraries(wsrep-lib_test wsrep-lib)
+
+add_test(NAME wsrep-lib_test
+ COMMAND wsrep-lib_test)
+
+if (WSREP_LIB_WITH_AUTO_TEST)
+ set(UNIT_TEST wsrep-lib_test)
+ add_custom_command(
+ TARGET ${UNIT_TEST}
+ COMMENT "Run tests"
+ POST_BUILD
+ COMMAND ${UNIT_TEST}
+ )
+endif()
diff --git a/wsrep-lib/test/buffer_test.cpp b/wsrep-lib/test/buffer_test.cpp
new file mode 100644
index 00000000..84d4a483
--- /dev/null
+++ b/wsrep-lib/test/buffer_test.cpp
@@ -0,0 +1,28 @@
+/*
+ * Copyright (C) 2019 Codership Oy <info@codership.com>
+ *
+ * This file is part of wsrep-lib.
+ *
+ * Wsrep-lib is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * Wsrep-lib is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with wsrep-lib. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include "wsrep/buffer.hpp"
+#include <boost/test/unit_test.hpp>
+
+BOOST_AUTO_TEST_CASE(buffer_test_empty_access)
+{
+ wsrep::mutable_buffer buf;
+ BOOST_REQUIRE(buf.size() == 0);
+ (void)buf.data();
+}
diff --git a/wsrep-lib/test/client_state_fixture.hpp b/wsrep-lib/test/client_state_fixture.hpp
new file mode 100644
index 00000000..ab784f28
--- /dev/null
+++ b/wsrep-lib/test/client_state_fixture.hpp
@@ -0,0 +1,305 @@
+/*
+ * Copyright (C) 2018 Codership Oy <info@codership.com>
+ *
+ * This file is part of wsrep-lib.
+ *
+ * Wsrep-lib is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * Wsrep-lib is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with wsrep-lib. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#ifndef WSREP_TEST_CLIENT_CONTEXT_FIXTURE_HPP
+#define WSREP_TEST_CLIENT_CONTEXT_FIXTURE_HPP
+
+#include "mock_server_state.hpp"
+#include "mock_client_state.hpp"
+
+
+#include <boost/test/unit_test.hpp>
+
+namespace
+{
+ struct replicating_client_fixture_sync_rm
+ {
+ replicating_client_fixture_sync_rm()
+ : server_service(&sc)
+ , sc("s1", wsrep::server_state::rm_sync, server_service)
+ , cc(sc, wsrep::client_id(1),
+ wsrep::client_state::m_local)
+ , tc(cc.transaction())
+ {
+ sc.mock_connect();
+ cc.open(cc.id());
+ BOOST_REQUIRE(cc.before_command() == 0);
+ BOOST_REQUIRE(cc.before_statement() == 0);
+ // Verify initial state
+ BOOST_REQUIRE(tc.active() == false);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_executing);
+ }
+ wsrep::mock_server_service server_service;
+ wsrep::mock_server_state sc;
+ wsrep::mock_client cc;
+ const wsrep::transaction& tc;
+ };
+
+ struct replicating_two_clients_fixture_sync_rm
+ {
+ replicating_two_clients_fixture_sync_rm()
+ : server_service(&sc)
+ , sc("s1", wsrep::server_state::rm_sync, server_service)
+ , cc1(sc, wsrep::client_id(1),
+ wsrep::client_state::m_local)
+ , cc2(sc, wsrep::client_id(2),
+ wsrep::client_state::m_local)
+ , tc(cc1.transaction())
+ {
+ sc.mock_connect();
+ cc1.open(cc1.id());
+ BOOST_REQUIRE(cc1.before_command() == 0);
+ BOOST_REQUIRE(cc1.before_statement() == 0);
+ cc2.open(cc2.id());
+ BOOST_REQUIRE(cc2.before_command() == 0);
+ BOOST_REQUIRE(cc2.before_statement() == 0);
+ // Verify initial state
+ BOOST_REQUIRE(tc.active() == false);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_executing);
+ }
+ wsrep::mock_server_service server_service;
+ wsrep::mock_server_state sc;
+ wsrep::mock_client cc1;
+ wsrep::mock_client cc2;
+ const wsrep::transaction& tc;
+ };
+
+ struct replicating_client_fixture_async_rm
+ {
+ replicating_client_fixture_async_rm()
+ : server_service(&sc)
+ , sc("s1", wsrep::server_state::rm_async, server_service)
+ , cc(sc, wsrep::client_id(1),
+ wsrep::client_state::m_local)
+ , tc(cc.transaction())
+ {
+ sc.mock_connect();
+ cc.open(cc.id());
+ BOOST_REQUIRE(cc.before_command() == 0);
+ BOOST_REQUIRE(cc.before_statement() == 0);
+ // Verify initial state
+ BOOST_REQUIRE(tc.active() == false);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_executing);
+ }
+ wsrep::mock_server_service server_service;
+ wsrep::mock_server_state sc;
+ wsrep::mock_client cc;
+ const wsrep::transaction& tc;
+ };
+
+ struct replicating_client_fixture_2pc
+ {
+ replicating_client_fixture_2pc()
+ : server_service(&sc)
+ , sc("s1", wsrep::server_state::rm_sync, server_service)
+ , cc(sc, wsrep::client_id(1),
+ wsrep::client_state::m_local)
+ , tc(cc.transaction())
+ {
+ sc.mock_connect();
+ cc.open(cc.id());
+ cc.do_2pc_ = true;
+ BOOST_REQUIRE(cc.before_command() == 0);
+ BOOST_REQUIRE(cc.before_statement() == 0);
+ // Verify initial state
+ BOOST_REQUIRE(tc.active() == false);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_executing);
+ }
+ wsrep::mock_server_service server_service;
+ wsrep::mock_server_state sc;
+ wsrep::mock_client cc;
+ const wsrep::transaction& tc;
+ };
+
+ struct replicating_client_fixture_autocommit
+ {
+ replicating_client_fixture_autocommit()
+ : server_service(&sc)
+ , sc("s1", wsrep::server_state::rm_sync, server_service)
+ , cc(sc, wsrep::client_id(1),
+ wsrep::client_state::m_local)
+ , tc(cc.transaction())
+ {
+ sc.mock_connect();
+ cc.open(cc.id());
+ cc.is_autocommit_ = true;
+ BOOST_REQUIRE(cc.before_command() == 0);
+ BOOST_REQUIRE(cc.before_statement() == 0);
+ // Verify initial state
+ BOOST_REQUIRE(tc.active() == false);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_executing);
+ }
+ wsrep::mock_server_service server_service;
+ wsrep::mock_server_state sc;
+ wsrep::mock_client cc;
+ const wsrep::transaction& tc;
+ };
+
+ struct applying_client_fixture
+ {
+ applying_client_fixture()
+ : server_service(&sc)
+ , sc("s1",
+ wsrep::server_state::rm_async, server_service)
+ , cc(sc,
+ wsrep::client_id(1),
+ wsrep::client_state::m_high_priority)
+ , tc(cc.transaction())
+ {
+ sc.mock_connect();
+ cc.open(cc.id());
+ BOOST_REQUIRE(cc.before_command() == 0);
+ BOOST_REQUIRE(cc.before_statement() == 0);
+ }
+ void start_transaction(wsrep::transaction_id id,
+ wsrep::seqno seqno)
+ {
+ wsrep::ws_handle ws_handle(id, (void*)1);
+ wsrep::ws_meta ws_meta(wsrep::gtid(wsrep::id("1"), seqno),
+ wsrep::stid(sc.id(),
+ wsrep::transaction_id(1),
+ cc.id()),
+ wsrep::seqno(0),
+ wsrep::provider::flag::start_transaction |
+ wsrep::provider::flag::commit);
+ BOOST_REQUIRE(cc.start_transaction(ws_handle, ws_meta) == 0);
+ BOOST_REQUIRE(tc.active() == true);
+ BOOST_REQUIRE(tc.certified() == true);
+ BOOST_REQUIRE(tc.ordered() == true);
+ }
+
+ wsrep::mock_server_service server_service;
+ wsrep::mock_server_state sc;
+ wsrep::mock_client cc;
+ const wsrep::transaction& tc;
+ };
+
+ struct applying_client_fixture_2pc
+ {
+ applying_client_fixture_2pc()
+ : server_service(&sc)
+ , sc("s1",
+ wsrep::server_state::rm_async, server_service)
+ , cc(sc,
+ wsrep::client_id(1),
+ wsrep::client_state::m_high_priority)
+ , tc(cc.transaction())
+ {
+ sc.mock_connect();
+ cc.open(cc.id());
+ cc.do_2pc_ = true;
+ BOOST_REQUIRE(cc.before_command() == 0);
+ BOOST_REQUIRE(cc.before_statement() == 0);
+ wsrep::ws_handle ws_handle(wsrep::transaction_id(1), (void*)1);
+ wsrep::ws_meta ws_meta(wsrep::gtid(wsrep::id("1"), wsrep::seqno(1)),
+ wsrep::stid(sc.id(),
+ wsrep::transaction_id(1),
+ cc.id()),
+ wsrep::seqno(0),
+ wsrep::provider::flag::start_transaction |
+ wsrep::provider::flag::commit);
+ BOOST_REQUIRE(cc.start_transaction(ws_handle, ws_meta) == 0);
+ BOOST_REQUIRE(tc.active() == true);
+ BOOST_REQUIRE(tc.certified() == true);
+ BOOST_REQUIRE(tc.ordered() == true);
+ }
+ wsrep::mock_server_service server_service;
+ wsrep::mock_server_state sc;
+ wsrep::mock_client cc;
+ const wsrep::transaction& tc;
+ };
+
+ struct streaming_client_fixture_row
+ {
+ streaming_client_fixture_row()
+ : server_service(&sc)
+ , sc("s1", wsrep::server_state::rm_sync, server_service)
+ , cc(sc,
+ wsrep::client_id(1),
+ wsrep::client_state::m_local)
+ , tc(cc.transaction())
+ {
+ sc.mock_connect();
+ cc.open(cc.id());
+ BOOST_REQUIRE(cc.before_command() == 0);
+ BOOST_REQUIRE(cc.before_statement() == 0);
+ // Verify initial state
+ BOOST_REQUIRE(tc.active() == false);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_executing);
+ cc.enable_streaming(wsrep::streaming_context::row, 1);
+ }
+
+ wsrep::mock_server_service server_service;
+ wsrep::mock_server_state sc;
+ wsrep::mock_client cc;
+ const wsrep::transaction& tc;
+ };
+
+ struct streaming_client_fixture_byte
+ {
+ streaming_client_fixture_byte()
+ : server_service(&sc)
+ , sc("s1", wsrep::server_state::rm_sync, server_service)
+ , cc(sc,
+ wsrep::client_id(1),
+ wsrep::client_state::m_local)
+ , tc(cc.transaction())
+ {
+ sc.mock_connect();
+ cc.open(cc.id());
+ BOOST_REQUIRE(cc.before_command() == 0);
+ BOOST_REQUIRE(cc.before_statement() == 0);
+ // Verify initial state
+ BOOST_REQUIRE(tc.active() == false);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_executing);
+ cc.enable_streaming(wsrep::streaming_context::bytes, 1);
+ }
+ wsrep::mock_server_service server_service;
+ wsrep::mock_server_state sc;
+ wsrep::mock_client cc;
+ const wsrep::transaction& tc;
+ };
+
+ struct streaming_client_fixture_statement
+ {
+ streaming_client_fixture_statement()
+ : server_service(&sc)
+ , sc("s1", wsrep::server_state::rm_sync, server_service)
+ , cc(sc,
+ wsrep::client_id(1),
+ wsrep::client_state::m_local)
+ , tc(cc.transaction())
+ {
+ sc.mock_connect();
+ cc.open(cc.id());
+ BOOST_REQUIRE(cc.before_command() == 0);
+ BOOST_REQUIRE(cc.before_statement() == 0);
+ // Verify initial state
+ BOOST_REQUIRE(tc.active() == false);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_executing);
+ cc.enable_streaming(wsrep::streaming_context::statement, 1);
+ }
+
+ wsrep::mock_server_service server_service;
+ wsrep::mock_server_state sc;
+ wsrep::mock_client cc;
+ const wsrep::transaction& tc;
+ };
+}
+#endif // WSREP_TEST_CLIENT_CONTEXT_FIXTURE_HPP
diff --git a/wsrep-lib/test/gtid_test.cpp b/wsrep-lib/test/gtid_test.cpp
new file mode 100644
index 00000000..4f4d644b
--- /dev/null
+++ b/wsrep-lib/test/gtid_test.cpp
@@ -0,0 +1,62 @@
+/*
+ * Copyright (C) 2018 Codership Oy <info@codership.com>
+ *
+ * This file is part of wsrep-lib.
+ *
+ * Wsrep-lib is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * Wsrep-lib is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with wsrep-lib. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include "wsrep/gtid.hpp"
+#include <boost/test/unit_test.hpp>
+
+BOOST_AUTO_TEST_CASE(gtid_test_scan_from_string_uuid)
+{
+ std::string gtid_str("6a20d44a-6e17-11e8-b1e2-9061aec0cdad:123456");
+ wsrep::gtid gtid;
+ ssize_t ret(wsrep::scan_from_c_str(
+ gtid_str.c_str(),
+ gtid_str.size(), gtid));
+ BOOST_REQUIRE_MESSAGE(ret == ssize_t(gtid_str.size()),
+ "Expected " << gtid_str.size() << " got " << ret);
+ BOOST_REQUIRE(gtid.seqno().get() == 123456);
+}
+
+BOOST_AUTO_TEST_CASE(gtid_test_scan_from_string_uuid_too_long)
+{
+ std::string gtid_str("6a20d44a-6e17-11e8-b1e2-9061aec0cdadx:123456");
+ wsrep::gtid gtid;
+ ssize_t ret(wsrep::scan_from_c_str(
+ gtid_str.c_str(),
+ gtid_str.size(), gtid));
+ BOOST_REQUIRE_MESSAGE(ret == -EINVAL,
+ "Expected " << -EINVAL << " got " << ret);
+}
+
+BOOST_AUTO_TEST_CASE(gtid_test_scan_from_string_seqno_out_of_range)
+{
+ std::string gtid_str("6a20d44a-6e17-11e8-b1e2-9061aec0cdad:9223372036854775808");
+ wsrep::gtid gtid;
+ ssize_t ret(wsrep::scan_from_c_str(
+ gtid_str.c_str(),
+ gtid_str.size(), gtid));
+ BOOST_REQUIRE_MESSAGE(ret == -EINVAL,
+ "Expected " << -EINVAL << " got " << ret);
+
+ gtid_str = "6a20d44a-6e17-11e8-b1e2-9061aec0cdad:-9223372036854775809";
+ ret = wsrep::scan_from_c_str(
+ gtid_str.c_str(),
+ gtid_str.size(), gtid);
+ BOOST_REQUIRE_MESSAGE(ret == -EINVAL,
+ "Expected " << -EINVAL << " got " << ret);
+}
diff --git a/wsrep-lib/test/id_test.cpp b/wsrep-lib/test/id_test.cpp
new file mode 100644
index 00000000..5a87ba16
--- /dev/null
+++ b/wsrep-lib/test/id_test.cpp
@@ -0,0 +1,69 @@
+/*
+ * Copyright (C) 2018 Codership Oy <info@codership.com>
+ *
+ * This file is part of wsrep-lib.
+ *
+ * Wsrep-lib is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * Wsrep-lib is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with wsrep-lib. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include "wsrep/id.hpp"
+#include <boost/test/unit_test.hpp>
+
+#include <sstream>
+
+namespace
+{
+ bool exception_check(const wsrep::runtime_error&) { return true; }
+}
+
+BOOST_AUTO_TEST_CASE(id_test_uuid)
+{
+ std::string uuid_str("6a20d44a-6e17-11e8-b1e2-9061aec0cdad");
+ wsrep::id id(uuid_str);
+ std::ostringstream os;
+ os << id;
+ BOOST_REQUIRE(uuid_str == os.str());
+}
+
+BOOST_AUTO_TEST_CASE(id_test_string)
+{
+ std::string id_str("1234567890123456");
+ wsrep::id id(id_str);
+ std::ostringstream os;
+ os << id;
+ BOOST_REQUIRE(id_str == os.str());
+}
+
+BOOST_AUTO_TEST_CASE(id_test_string_too_long)
+{
+ std::string id_str("12345678901234567");
+ BOOST_REQUIRE_EXCEPTION(wsrep::id id(id_str), wsrep::runtime_error,
+ exception_check);
+}
+
+BOOST_AUTO_TEST_CASE(id_test_binary)
+{
+ char data[16] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4 ,5 ,6};
+ wsrep::id id(data, sizeof(data));
+ std::ostringstream os;
+ os << id;
+ BOOST_REQUIRE(os.str() == "01020304-0506-0708-0900-010203040506");
+}
+
+BOOST_AUTO_TEST_CASE(id_test_binary_too_long)
+{
+ char data[17] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4 ,5 ,6, 7};
+ BOOST_REQUIRE_EXCEPTION(wsrep::id id(data, sizeof(data)),
+ wsrep::runtime_error, exception_check);;
+}
diff --git a/wsrep-lib/test/mock_client_state.cpp b/wsrep-lib/test/mock_client_state.cpp
new file mode 100644
index 00000000..f98b512e
--- /dev/null
+++ b/wsrep-lib/test/mock_client_state.cpp
@@ -0,0 +1,77 @@
+/*
+ * Copyright (C) 2018 Codership Oy <info@codership.com>
+ *
+ * This file is part of wsrep-lib.
+ *
+ * Wsrep-lib is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * Wsrep-lib is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with wsrep-lib. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include "wsrep/transaction.hpp"
+#include "mock_client_state.hpp"
+#include "mock_high_priority_service.hpp"
+
+int wsrep::mock_client_service::bf_rollback()
+{
+ int ret(0);
+ if (client_state_->before_rollback())
+ {
+ ret = 1;
+ }
+ else if (client_state_->after_rollback())
+ {
+ ret = 1;
+ }
+ return ret;
+}
+
+struct replayer_context
+{
+ wsrep::mock_client_state state;
+ wsrep::mock_client_service service;
+ replayer_context(wsrep::server_state& server_state,
+ const wsrep::transaction& transaction,
+ const wsrep::client_id& id)
+ : state{server_state, service, id, wsrep::client_state::m_high_priority}
+ , service{&state}
+ {
+ state.open(id);
+ state.before_command();
+ state.clone_transaction_for_replay(transaction);
+ }
+
+ ~replayer_context() {
+ state.after_applying();
+ state.after_command_before_result();
+ state.after_command_after_result();
+ state.close();
+ }
+};
+
+enum wsrep::provider::status
+wsrep::mock_client_service::replay()
+{
+ /* Mimic application and allocate separate client state for replaying. */
+ wsrep::client_id replayer_id{ 1001 };
+ replayer_context replayer(client_state_->server_state(),
+ client_state_->transaction(), replayer_id);
+ wsrep::mock_high_priority_service hps{ client_state_->server_state(),
+ &replayer.state, true };
+
+ enum wsrep::provider::status ret(
+ client_state_->provider().replay(
+ replayer.state.transaction().ws_handle(),
+ &hps));
+ ++replays_;
+ return ret;
+}
diff --git a/wsrep-lib/test/mock_client_state.hpp b/wsrep-lib/test/mock_client_state.hpp
new file mode 100644
index 00000000..73b27755
--- /dev/null
+++ b/wsrep-lib/test/mock_client_state.hpp
@@ -0,0 +1,260 @@
+/*
+ * Copyright (C) 2018 Codership Oy <info@codership.com>
+ *
+ * This file is part of wsrep-lib.
+ *
+ * Wsrep-lib is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * Wsrep-lib is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with wsrep-lib. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#ifndef WSREP_MOCK_CLIENT_CONTEXT_HPP
+#define WSREP_MOCK_CLIENT_CONTEXT_HPP
+
+#include "wsrep/client_state.hpp"
+#include "wsrep/mutex.hpp"
+#include "wsrep/compiler.hpp"
+#include "wsrep/client_service.hpp"
+#include "wsrep/condition_variable.hpp"
+
+#include "test_utils.hpp"
+
+namespace wsrep
+{
+ class mock_client_state : public wsrep::client_state
+ {
+ public:
+ mock_client_state(wsrep::server_state& server_state,
+ wsrep::client_service& client_service,
+ const wsrep::client_id& id,
+ enum wsrep::client_state::mode mode)
+ : wsrep::client_state(mutex_, cond_, server_state, client_service,
+ id, mode)
+ , mutex_()
+ , cond_()
+ { }
+ ~mock_client_state() WSREP_OVERRIDE
+ {
+ if (transaction().active())
+ {
+ (void)client_service().bf_rollback();
+ }
+ }
+ private:
+ wsrep::default_mutex mutex_;
+ wsrep::default_condition_variable cond_;
+ public:
+ private:
+ };
+
+
+ class mock_client_service : public wsrep::client_service
+ {
+ public:
+ mock_client_service(wsrep::mock_client_state* client_state)
+ : wsrep::client_service()
+ , is_autocommit_()
+ , do_2pc_()
+ // , fail_next_applying_()
+ // , fail_next_toi_()
+ , bf_abort_during_wait_()
+ , bf_abort_during_fragment_removal_()
+ , error_during_prepare_data_()
+ , killed_before_certify_()
+ , sync_point_enabled_()
+ , sync_point_action_()
+ , bytes_generated_()
+ , client_state_(client_state)
+ , will_replay_called_()
+ , replays_()
+ , unordered_replays_()
+ , aborts_()
+ { }
+ mock_client_service(const mock_client_service&) = delete;
+ mock_client_service& operator=(const mock_client_service&) = delete;
+
+ int bf_rollback() WSREP_OVERRIDE;
+
+ bool interrupted(wsrep::unique_lock<wsrep::mutex>&)
+ const WSREP_OVERRIDE
+ { return killed_before_certify_; }
+
+
+ void emergency_shutdown() WSREP_OVERRIDE { ++aborts_; }
+
+ int remove_fragments() WSREP_OVERRIDE
+ {
+ if (bf_abort_during_fragment_removal_)
+ {
+ client_state_->before_rollback();
+ client_state_->after_rollback();
+ return 1;
+ }
+ else
+ {
+ return 0;
+ }
+ }
+
+ void will_replay() WSREP_OVERRIDE { will_replay_called_ = true; }
+
+ void signal_replayed() WSREP_OVERRIDE { }
+
+ enum wsrep::provider::status replay() WSREP_OVERRIDE;
+
+ enum wsrep::provider::status replay_unordered() WSREP_OVERRIDE
+ {
+ unordered_replays_++;
+ return wsrep::provider::success;
+ }
+
+ void wait_for_replayers(
+ wsrep::unique_lock<wsrep::mutex>& lock)
+ WSREP_OVERRIDE
+ {
+ lock.unlock();
+ if (bf_abort_during_wait_)
+ {
+ wsrep_test::bf_abort_unordered(*client_state_);
+ }
+ lock.lock();
+ }
+
+ int prepare_data_for_replication() WSREP_OVERRIDE
+ {
+ if (error_during_prepare_data_)
+ {
+ return 1;
+ }
+ static const char buf[1] = { 1 };
+ wsrep::const_buffer data = wsrep::const_buffer(buf, 1);
+ return client_state_->append_data(data);
+ }
+
+ void cleanup_transaction() WSREP_OVERRIDE { }
+
+ size_t bytes_generated() const WSREP_OVERRIDE
+ {
+ return bytes_generated_;
+ }
+
+ bool statement_allowed_for_streaming() const WSREP_OVERRIDE
+ { return true; }
+ int prepare_fragment_for_replication(wsrep::mutable_buffer& buffer, size_t& position)
+ WSREP_OVERRIDE
+ {
+ if (error_during_prepare_data_)
+ {
+ return 1;
+ }
+ static const char buf[1] = { 1 };
+ buffer.push_back(&buf[0], &buf[1]);
+ wsrep::const_buffer data(buffer.data(), buffer.size());
+ position = buffer.size();
+ return client_state_->append_data(data);
+ }
+
+ void store_globals() WSREP_OVERRIDE { }
+ void reset_globals() WSREP_OVERRIDE { }
+
+ enum wsrep::provider::status commit_by_xid() WSREP_OVERRIDE
+ {
+ return wsrep::provider::success;
+ }
+
+ bool is_explicit_xa() WSREP_OVERRIDE
+ {
+ return false;
+ }
+
+ bool is_xa_rollback() WSREP_OVERRIDE
+ {
+ return false;
+ }
+
+ void debug_sync(const char* sync_point) WSREP_OVERRIDE
+ {
+ if (sync_point_enabled_ == sync_point)
+ {
+ switch (sync_point_action_)
+ {
+ case spa_bf_abort_unordered:
+ wsrep_test::bf_abort_unordered(*client_state_);
+ break;
+ case spa_bf_abort_ordered:
+ wsrep_test::bf_abort_ordered(*client_state_);
+ break;
+ }
+ }
+ }
+
+ void debug_crash(const char*) WSREP_OVERRIDE
+ {
+ // Not going to do this while unit testing
+ }
+
+
+ //
+ // Knobs to tune the behavior
+ //
+ bool is_autocommit_;
+ bool do_2pc_;
+ // bool fail_next_applying_;
+ // bool fail_next_toi_;
+ bool bf_abort_during_wait_;
+ bool bf_abort_during_fragment_removal_;
+ bool error_during_prepare_data_;
+ bool killed_before_certify_;
+ std::string sync_point_enabled_;
+ enum sync_point_action
+ {
+ spa_bf_abort_unordered,
+ spa_bf_abort_ordered
+ } sync_point_action_;
+ size_t bytes_generated_;
+
+ //
+ // Verifying the state
+ //
+ bool will_replay_called() const { return will_replay_called_; }
+ size_t replays() const { return replays_; }
+ size_t unordered_replays() const { return unordered_replays_; }
+ size_t aborts() const { return aborts_; }
+ private:
+ wsrep::mock_client_state* client_state_;
+ bool will_replay_called_;
+ size_t replays_;
+ size_t unordered_replays_;
+ size_t aborts_;
+ };
+
+ class mock_client
+ : public mock_client_state
+ , public mock_client_service
+ {
+ public:
+ mock_client(wsrep::server_state& server_state,
+ const wsrep::client_id& id,
+ enum wsrep::client_state::mode mode)
+ : mock_client_state(server_state, *this, id, mode)
+ , mock_client_service(static_cast<mock_client_state*>(this))
+ { }
+
+ int after_row()
+ {
+ bytes_generated_++;
+ return wsrep::client_state::after_row();
+ }
+ };
+}
+
+#endif // WSREP_MOCK_CLIENT_CONTEXT_HPP
diff --git a/wsrep-lib/test/mock_high_priority_service.cpp b/wsrep-lib/test/mock_high_priority_service.cpp
new file mode 100644
index 00000000..bb67c9a9
--- /dev/null
+++ b/wsrep-lib/test/mock_high_priority_service.cpp
@@ -0,0 +1,170 @@
+/*
+ * Copyright (C) 2018-2019 Codership Oy <info@codership.com>
+ *
+ * This file is part of wsrep-lib.
+ *
+ * Wsrep-lib is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * Wsrep-lib is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with wsrep-lib. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include "mock_high_priority_service.hpp"
+#include "mock_server_state.hpp"
+#include <sstream>
+
+int wsrep::mock_high_priority_service::start_transaction(
+ const wsrep::ws_handle& ws_handle, const wsrep::ws_meta& ws_meta)
+{
+ return client_state_->start_transaction(ws_handle, ws_meta);
+}
+
+int wsrep::mock_high_priority_service::next_fragment(
+ const wsrep::ws_meta& ws_meta)
+{
+ return client_state_->next_fragment(ws_meta);
+}
+
+int wsrep::mock_high_priority_service::adopt_transaction(
+ const wsrep::transaction& transaction)
+{
+ client_state_->adopt_transaction(transaction);
+ if (transaction.state() == wsrep::transaction::s_prepared)
+ {
+ client_state_->restore_xid(transaction.xid());
+ }
+ return 0;
+}
+
+int wsrep::mock_high_priority_service::apply_write_set(
+ const wsrep::ws_meta& meta,
+ const wsrep::const_buffer&,
+ wsrep::mutable_buffer& err)
+{
+ assert(client_state_->toi_meta().seqno().is_undefined());
+ assert(client_state_->transaction().state() == wsrep::transaction::s_executing ||
+ client_state_->transaction().state() == wsrep::transaction::s_prepared ||
+ client_state_->transaction().state() == wsrep::transaction::s_replaying);
+ if (fail_next_applying_)
+ {
+ std::ostringstream os;
+ os << "failed " << meta;
+ err.push_back(os.str());
+ assert(err.size() > 0);
+ return 1;
+ }
+ else
+ {
+ int ret(0);
+ if (!(meta.flags() & wsrep::provider::flag::commit))
+ {
+ client_state_->fragment_applied(meta.seqno());
+ }
+ if ((meta.flags() & wsrep::provider::flag::prepare))
+ {
+ client_state_->assign_xid(wsrep::xid(1, 3, 1, "xid"));
+ ret = client_state_->before_prepare() ||
+ client_state_->after_prepare();
+ }
+ return ret;
+ };
+}
+
+int wsrep::mock_high_priority_service::commit(
+ const wsrep::ws_handle& ws_handle,
+ const wsrep::ws_meta& ws_meta)
+{
+ int ret(0);
+ client_state_->prepare_for_ordering(ws_handle, ws_meta, true);
+ if (do_2pc_)
+ {
+ ret = client_state_->before_prepare() ||
+ client_state_->after_prepare();
+ }
+ const bool is_ordered= !ws_meta.seqno().is_undefined();
+ if (!is_ordered)
+ {
+ client_state_->before_rollback();
+ client_state_->after_rollback();
+ return 0;
+ }
+ else
+ {
+ return (ret || client_state_->before_commit() ||
+ client_state_->ordered_commit() ||
+ client_state_->after_commit());
+ }
+}
+
+int wsrep::mock_high_priority_service::rollback(
+ const wsrep::ws_handle& ws_handle,
+ const wsrep::ws_meta& ws_meta)
+{
+ client_state_->prepare_for_ordering(ws_handle, ws_meta, false);
+ return (client_state_->before_rollback() ||
+ client_state_->after_rollback());
+}
+
+int wsrep::mock_high_priority_service::apply_toi(const wsrep::ws_meta&,
+ const wsrep::const_buffer&,
+ wsrep::mutable_buffer&)
+{
+ assert(client_state_->transaction().active() == false);
+ assert(client_state_->toi_meta().seqno().is_undefined() == false);
+ return (fail_next_toi_ ? 1 : 0);
+}
+
+int wsrep::mock_high_priority_service::apply_nbo_begin(
+ const wsrep::ws_meta& ws_meta,
+ const wsrep::const_buffer&,
+ wsrep::mutable_buffer&)
+{
+ const int nbo_begin_flags __attribute__((unused))
+ (wsrep::provider::flag::isolation |
+ wsrep::provider::flag::start_transaction);
+ assert(ws_meta.flags() & nbo_begin_flags);
+ assert((ws_meta.flags() & ~nbo_begin_flags) == 0);
+
+ if (fail_next_toi_)
+ {
+ return 1;
+ }
+ else
+ {
+ nbo_cs_ = std::unique_ptr<wsrep::mock_client>(
+ new wsrep::mock_client(client_state_->server_state(),
+ wsrep::client_id(1),
+ wsrep::client_state::m_local));
+ nbo_cs_->open(wsrep::client_id(1));
+ nbo_cs_->before_command();
+ nbo_cs_->before_statement();
+ return nbo_cs_->enter_nbo_mode(ws_meta);
+ }
+}
+
+void wsrep::mock_high_priority_service::adopt_apply_error(
+ wsrep::mutable_buffer& err)
+{
+ client_state_->adopt_apply_error(err);
+}
+
+void wsrep::mock_high_priority_service::after_apply()
+{
+ client_state_->after_applying();
+}
+
+int wsrep::mock_high_priority_service::log_dummy_write_set(
+ const wsrep::ws_handle&,
+ const wsrep::ws_meta&,
+ wsrep::mutable_buffer& err)
+{
+ return err.size() > 0;
+}
diff --git a/wsrep-lib/test/mock_high_priority_service.hpp b/wsrep-lib/test/mock_high_priority_service.hpp
new file mode 100644
index 00000000..615ba9db
--- /dev/null
+++ b/wsrep-lib/test/mock_high_priority_service.hpp
@@ -0,0 +1,111 @@
+/*
+ * Copyright (C) 2018-2019 Codership Oy <info@codership.com>
+ *
+ * This file is part of wsrep-lib.
+ *
+ * Wsrep-lib is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * Wsrep-lib is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with wsrep-lib. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#ifndef WSREP_MOCK_HIGH_PRIORITY_SERVICE_HPP
+#define WSREP_MOCK_HIGH_PRIORITY_SERVICE_HPP
+
+#include "wsrep/high_priority_service.hpp"
+#include "mock_client_state.hpp"
+
+#include <memory>
+
+namespace wsrep
+{
+ class mock_high_priority_service : public wsrep::high_priority_service
+ {
+ public:
+ mock_high_priority_service(
+ wsrep::server_state& server_state,
+ wsrep::mock_client_state* client_state,
+ bool replaying)
+ : wsrep::high_priority_service(server_state)
+ , do_2pc_()
+ , fail_next_applying_()
+ , fail_next_toi_()
+ , client_state_(client_state)
+ , replaying_(replaying)
+ , nbo_cs_()
+ { }
+
+ ~mock_high_priority_service() WSREP_OVERRIDE
+ { }
+ int start_transaction(const wsrep::ws_handle&, const wsrep::ws_meta&)
+ WSREP_OVERRIDE;
+
+ int next_fragment(const wsrep::ws_meta&) WSREP_OVERRIDE;
+
+ const wsrep::transaction& transaction() const WSREP_OVERRIDE
+ { return client_state_->transaction(); }
+ int adopt_transaction(const wsrep::transaction&) WSREP_OVERRIDE;
+ int apply_write_set(const wsrep::ws_meta&,
+ const wsrep::const_buffer&,
+ wsrep::mutable_buffer&) WSREP_OVERRIDE;
+ int append_fragment_and_commit(
+ const wsrep::ws_handle&,
+ const wsrep::ws_meta&,
+ const wsrep::const_buffer&,
+ const wsrep::xid&) WSREP_OVERRIDE
+ { return 0; }
+ int remove_fragments(const wsrep::ws_meta&) WSREP_OVERRIDE
+ { return 0; }
+ int commit(const wsrep::ws_handle&, const wsrep::ws_meta&)
+ WSREP_OVERRIDE;
+ int rollback(const wsrep::ws_handle&, const wsrep::ws_meta&) WSREP_OVERRIDE;
+ int apply_toi(const wsrep::ws_meta&,
+ const wsrep::const_buffer&,
+ wsrep::mutable_buffer&) WSREP_OVERRIDE;
+ int apply_nbo_begin(const wsrep::ws_meta&,
+ const wsrep::const_buffer&,
+ wsrep::mutable_buffer&) WSREP_OVERRIDE;
+ void adopt_apply_error(wsrep::mutable_buffer& err) WSREP_OVERRIDE;
+ void after_apply() WSREP_OVERRIDE;
+ void store_globals() WSREP_OVERRIDE { }
+ void reset_globals() WSREP_OVERRIDE { }
+ void switch_execution_context(wsrep::high_priority_service&)
+ WSREP_OVERRIDE { }
+ int log_dummy_write_set(const wsrep::ws_handle&,
+ const wsrep::ws_meta&,
+ wsrep::mutable_buffer&) WSREP_OVERRIDE;
+ bool is_replaying() const WSREP_OVERRIDE { return replaying_; }
+ void debug_crash(const char*) WSREP_OVERRIDE { /* Not in unit tests*/}
+
+ wsrep::client_state& client_state()
+ {
+ return *client_state_;
+ }
+ bool do_2pc_;
+ bool fail_next_applying_;
+ bool fail_next_toi_;
+
+ wsrep::mock_client* nbo_cs() const { return nbo_cs_.get(); }
+
+ private:
+ mock_high_priority_service(const mock_high_priority_service&);
+ mock_high_priority_service& operator=(const mock_high_priority_service&);
+ wsrep::mock_client_state* client_state_;
+ bool replaying_;
+
+ /* Client state associated to NBO processing. This should be
+ * stored elsewhere (like mock_server_state), but is kept
+ * here for convenience. */
+ std::unique_ptr<wsrep::mock_client> nbo_cs_;
+ };
+}
+
+#endif // WSREP_MOCK_HIGH_PRIORITY_SERVICE_HPP
diff --git a/wsrep-lib/test/mock_provider.hpp b/wsrep-lib/test/mock_provider.hpp
new file mode 100644
index 00000000..bcfd2e45
--- /dev/null
+++ b/wsrep-lib/test/mock_provider.hpp
@@ -0,0 +1,356 @@
+/*
+ * Copyright (C) 2018-2019 Codership Oy <info@codership.com>
+ *
+ * This file is part of wsrep-lib.
+ *
+ * Wsrep-lib is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * Wsrep-lib is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with wsrep-lib. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#ifndef WSREP_MOCK_PROVIDER_HPP
+#define WSREP_MOCK_PROVIDER_HPP
+
+#include "wsrep/provider.hpp"
+#include "wsrep/logger.hpp"
+#include "wsrep/buffer.hpp"
+#include "wsrep/high_priority_service.hpp"
+
+#include <cstring>
+#include <map>
+#include <iostream> // todo: proper logging
+
+#include <boost/test/unit_test.hpp>
+
+namespace wsrep
+{
+ class mock_provider : public wsrep::provider
+ {
+ public:
+ typedef std::map<wsrep::transaction_id, wsrep::seqno> bf_abort_map;
+
+ mock_provider(wsrep::server_state& server_state)
+ : provider(server_state)
+ , certify_result_()
+ , commit_order_enter_result_()
+ , commit_order_leave_result_()
+ , release_result_()
+ , replay_result_()
+ , group_id_("1")
+ , server_id_("1")
+ , group_seqno_(0)
+ , bf_abort_map_()
+ , start_fragments_()
+ , fragments_()
+ , commit_fragments_()
+ , rollback_fragments_()
+ , toi_write_sets_()
+ , toi_start_transaction_()
+ , toi_commit_()
+ { }
+
+ enum wsrep::provider::status
+ connect(const std::string&, const std::string&, const std::string&,
+ bool) WSREP_OVERRIDE
+ { return wsrep::provider::success; }
+ int disconnect() WSREP_OVERRIDE { return 0; }
+ int capabilities() const WSREP_OVERRIDE { return 0; }
+ int desync() WSREP_OVERRIDE { return 0; }
+ int resync() WSREP_OVERRIDE { return 0; }
+ wsrep::seqno pause() WSREP_OVERRIDE { return wsrep::seqno(0); }
+ int resume() WSREP_OVERRIDE { return 0; }
+ enum wsrep::provider::status run_applier(wsrep::high_priority_service*)
+ WSREP_OVERRIDE
+ {
+ return wsrep::provider::success;
+ }
+ // Provider implemenatation interface
+ int start_transaction(wsrep::ws_handle&) WSREP_OVERRIDE { return 0; }
+ enum wsrep::provider::status
+ certify(wsrep::client_id client_id,
+ wsrep::ws_handle& ws_handle,
+ int flags,
+ wsrep::ws_meta& ws_meta)
+ WSREP_OVERRIDE
+ {
+ ws_handle = wsrep::ws_handle(ws_handle.transaction_id(), (void*)1);
+ wsrep::log_debug() << "provider certify: "
+ << "client: " << client_id.get()
+ << " flags: " << std::hex << flags
+ << std::dec
+ << " certify_status: " << certify_result_;
+ if (certify_result_)
+ {
+ return certify_result_;
+ }
+
+ ++fragments_;
+ if (starts_transaction(flags))
+ {
+ ++start_fragments_;
+ }
+ if (commits_transaction(flags))
+ {
+ ++commit_fragments_;
+ }
+ if (rolls_back_transaction(flags))
+ {
+ ++rollback_fragments_;
+ }
+
+ wsrep::stid stid(server_id_,
+ ws_handle.transaction_id(),
+ client_id);
+ bf_abort_map::iterator it(bf_abort_map_.find(
+ ws_handle.transaction_id()));
+ if (it == bf_abort_map_.end())
+ {
+ ++group_seqno_;
+ wsrep::gtid gtid(group_id_, wsrep::seqno(group_seqno_));
+ ws_meta = wsrep::ws_meta(gtid, stid,
+ wsrep::seqno(group_seqno_ - 1),
+ flags);
+ return wsrep::provider::success;
+ }
+ else
+ {
+ enum wsrep::provider::status ret;
+ if (it->second.is_undefined())
+ {
+ ws_meta = wsrep::ws_meta(wsrep::gtid(), wsrep::stid(),
+ wsrep::seqno::undefined(), 0);
+ ret = wsrep::provider::error_certification_failed;
+ }
+ else
+ {
+ ++group_seqno_;
+ wsrep::gtid gtid(group_id_, wsrep::seqno(group_seqno_));
+ ws_meta = wsrep::ws_meta(gtid, stid,
+ wsrep::seqno(group_seqno_ - 1),
+ flags);
+ ret = wsrep::provider::error_bf_abort;
+ }
+ bf_abort_map_.erase(it);
+ return ret;
+ }
+ }
+
+ enum wsrep::provider::status
+ assign_read_view(wsrep::ws_handle&, const wsrep::gtid*)
+ WSREP_OVERRIDE
+ { return wsrep::provider::success; }
+ int append_key(wsrep::ws_handle&, const wsrep::key&)
+ WSREP_OVERRIDE
+ { return 0; }
+ enum wsrep::provider::status
+ append_data(wsrep::ws_handle&, const wsrep::const_buffer&)
+ WSREP_OVERRIDE
+ { return wsrep::provider::success; }
+ enum wsrep::provider::status rollback(const wsrep::transaction_id)
+ WSREP_OVERRIDE
+ {
+ ++fragments_;
+ ++rollback_fragments_;
+ return wsrep::provider::success;
+ }
+ enum wsrep::provider::status
+ commit_order_enter(const wsrep::ws_handle& ws_handle,
+ const wsrep::ws_meta& ws_meta)
+ WSREP_OVERRIDE
+ {
+ BOOST_REQUIRE(ws_handle.opaque());
+ BOOST_REQUIRE(ws_meta.seqno().is_undefined() == false);
+ return commit_order_enter_result_;
+ }
+
+ int commit_order_leave(const wsrep::ws_handle& ws_handle,
+ const wsrep::ws_meta& ws_meta,
+ const wsrep::mutable_buffer& err)
+ WSREP_OVERRIDE
+ {
+ BOOST_REQUIRE(ws_handle.opaque());
+ BOOST_REQUIRE(ws_meta.seqno().is_undefined() == false);
+ return err.size() > 0 ?
+ wsrep::provider::error_fatal :
+ commit_order_leave_result_;
+ }
+
+ int release(wsrep::ws_handle& )
+ WSREP_OVERRIDE
+ {
+ // BOOST_REQUIRE(ws_handle.opaque());
+ return release_result_;
+ }
+
+ enum wsrep::provider::status replay(
+ const wsrep::ws_handle& ws_handle,
+ wsrep::high_priority_service* hps)
+ WSREP_OVERRIDE
+ {
+ wsrep::mock_high_priority_service& high_priority_service(
+ *static_cast<wsrep::mock_high_priority_service*>(hps));
+ wsrep::mock_client_state& cc(
+ static_cast<wsrep::mock_client_state&>(
+ high_priority_service.client_state()));
+ const wsrep::transaction& tc(cc.transaction());
+ wsrep::ws_meta ws_meta;
+ if (replay_result_ == wsrep::provider::success)
+ {
+ // If the ws_meta was not assigned yet, the certify
+ // returned early due to BF abort.
+ if (tc.ws_meta().seqno().is_undefined())
+ {
+ ++group_seqno_;
+ ws_meta = wsrep::ws_meta(
+ wsrep::gtid(group_id_, wsrep::seqno(group_seqno_)),
+ wsrep::stid(server_id_, tc.id(), cc.id()),
+ wsrep::seqno(group_seqno_ - 1),
+ wsrep::provider::flag::start_transaction |
+ wsrep::provider::flag::commit);
+ }
+ else
+ {
+ ws_meta = tc.ws_meta();
+ }
+ }
+ else
+ {
+ return replay_result_;
+ }
+
+ if (high_priority_service.apply(ws_handle, ws_meta,
+ wsrep::const_buffer()))
+ {
+ return wsrep::provider::error_fatal;
+ }
+ return wsrep::provider::success;
+ }
+
+ enum wsrep::provider::status enter_toi(wsrep::client_id client_id,
+ const wsrep::key_array&,
+ const wsrep::const_buffer&,
+ wsrep::ws_meta& toi_meta,
+ int flags)
+ WSREP_OVERRIDE
+ {
+ ++group_seqno_;
+ wsrep::gtid gtid(group_id_, wsrep::seqno(group_seqno_));
+ wsrep::stid stid(server_id_,
+ wsrep::transaction_id::undefined(),
+ client_id);
+ toi_meta = wsrep::ws_meta(gtid, stid,
+ wsrep::seqno(group_seqno_ - 1),
+ flags);
+ ++toi_write_sets_;
+ if (flags & wsrep::provider::flag::start_transaction)
+ ++toi_start_transaction_;
+ if (flags & wsrep::provider::flag::commit)
+ ++toi_commit_;
+ return certify_result_;
+ }
+
+ enum wsrep::provider::status leave_toi(wsrep::client_id,
+ const wsrep::mutable_buffer&)
+ WSREP_OVERRIDE
+ { return wsrep::provider::success; }
+
+ std::pair<wsrep::gtid, enum wsrep::provider::status>
+ causal_read(int) const WSREP_OVERRIDE
+ {
+ return std::make_pair(wsrep::gtid::undefined(),
+ wsrep::provider::error_not_implemented);
+ }
+ enum wsrep::provider::status wait_for_gtid(const wsrep::gtid&,
+ int) const WSREP_OVERRIDE
+ { return wsrep::provider::success; }
+ wsrep::gtid last_committed_gtid() const WSREP_OVERRIDE
+ { return wsrep::gtid(); }
+ enum wsrep::provider::status sst_sent(const wsrep::gtid&, int)
+ WSREP_OVERRIDE
+ { return wsrep::provider::success; }
+ enum wsrep::provider::status sst_received(const wsrep::gtid&, int)
+ WSREP_OVERRIDE
+ { return wsrep::provider::success; }
+
+ enum wsrep::provider::status enc_set_key(const wsrep::const_buffer&)
+ WSREP_OVERRIDE
+ { return wsrep::provider::success; }
+
+ std::vector<status_variable> status() const WSREP_OVERRIDE
+ {
+ return std::vector<status_variable>();
+ }
+ void reset_status() WSREP_OVERRIDE { }
+ std::string options() const WSREP_OVERRIDE { return ""; }
+ enum wsrep::provider::status options(const std::string&)
+ WSREP_OVERRIDE
+ { return wsrep::provider::success; }
+ std::string name() const WSREP_OVERRIDE { return "mock"; }
+ std::string version() const WSREP_OVERRIDE { return "0.0"; }
+ std::string vendor() const WSREP_OVERRIDE { return "mock"; }
+ void* native() const WSREP_OVERRIDE { return 0; }
+
+ //
+ // Methods to modify mock state
+ //
+ /** Inject BF abort event into the provider.
+ *
+ * @param bf_seqno Aborter sequence number
+ * @param trx_id Trx id to be aborted
+ * @param[out] victim_seqno
+ */
+ enum wsrep::provider::status
+ bf_abort(wsrep::seqno bf_seqno,
+ wsrep::transaction_id trx_id,
+ wsrep::seqno& victim_seqno)
+ WSREP_OVERRIDE
+ {
+ bf_abort_map_.insert(std::make_pair(trx_id, bf_seqno));
+ if (bf_seqno.is_undefined() == false)
+ {
+ group_seqno_ = bf_seqno.get();
+ }
+ victim_seqno = wsrep::seqno::undefined();
+ return wsrep::provider::success;
+ }
+
+ // Parameters to control return value from the call
+ enum wsrep::provider::status certify_result_;
+ enum wsrep::provider::status commit_order_enter_result_;
+ enum wsrep::provider::status commit_order_leave_result_;
+ enum wsrep::provider::status release_result_;
+ enum wsrep::provider::status replay_result_;
+
+ size_t start_fragments() const { return start_fragments_; }
+ size_t fragments() const { return fragments_; }
+ size_t commit_fragments() const { return commit_fragments_; }
+ size_t rollback_fragments() const { return rollback_fragments_; }
+ size_t toi_write_sets() const { return toi_write_sets_; }
+ size_t toi_start_transaction() const { return toi_start_transaction_; }
+ size_t toi_commit() const { return toi_commit_; }
+ private:
+ wsrep::id group_id_;
+ wsrep::id server_id_;
+ long long group_seqno_;
+ bf_abort_map bf_abort_map_;
+ size_t start_fragments_;
+ size_t fragments_;
+ size_t commit_fragments_;
+ size_t rollback_fragments_;
+ size_t toi_write_sets_;
+ size_t toi_start_transaction_;
+ size_t toi_commit_;
+ };
+}
+
+
+#endif // WSREP_MOCK_PROVIDER_HPP
diff --git a/wsrep-lib/test/mock_server_state.hpp b/wsrep-lib/test/mock_server_state.hpp
new file mode 100644
index 00000000..093a620a
--- /dev/null
+++ b/wsrep-lib/test/mock_server_state.hpp
@@ -0,0 +1,315 @@
+/*
+ * Copyright (C) 2018-2013 Codership Oy <info@codership.com>
+ *
+ * This file is part of wsrep-lib.
+ *
+ * Wsrep-lib is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * Wsrep-lib is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with wsrep-lib. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#ifndef WSREP_MOCK_SERVER_STATE_HPP
+#define WSREP_MOCK_SERVER_STATE_HPP
+
+#include "wsrep/server_state.hpp"
+#include "wsrep/server_service.hpp"
+#include "mock_client_state.hpp"
+#include "mock_high_priority_service.hpp"
+#include "mock_storage_service.hpp"
+#include "mock_provider.hpp"
+
+#include "wsrep/compiler.hpp"
+
+namespace wsrep
+{
+ class mock_server_service : public wsrep::server_service
+ {
+ public:
+ mock_server_service(wsrep::server_state* server_state)
+ : sync_point_enabled_()
+ , sync_point_action_()
+ , sst_before_init_()
+ , server_state_(server_state)
+ , last_client_id_(0)
+ , last_transaction_id_(0)
+ , logged_view_()
+ , position_()
+ { }
+ mock_server_service(const mock_server_service&) = delete;
+ mock_server_service& operator=(const mock_server_service&) = delete;
+
+ wsrep::storage_service* storage_service(wsrep::client_service&)
+ WSREP_OVERRIDE
+ {
+ return new wsrep::mock_storage_service(*server_state_,
+ wsrep::client_id(++last_client_id_));
+ }
+
+ wsrep::storage_service* storage_service(wsrep::high_priority_service&)
+ WSREP_OVERRIDE
+ {
+ return new wsrep::mock_storage_service(*server_state_,
+ wsrep::client_id(++last_client_id_));
+ }
+
+ void release_storage_service(wsrep::storage_service* storage_service)
+ WSREP_OVERRIDE
+ {
+ delete storage_service;
+ }
+
+ wsrep::high_priority_service* streaming_applier_service(
+ wsrep::client_service&)
+ WSREP_OVERRIDE
+ {
+ wsrep::mock_client* cs(new wsrep::mock_client(
+ *server_state_,
+ wsrep::client_id(++last_client_id_),
+ wsrep::client_state::m_high_priority));
+ wsrep::mock_high_priority_service* ret(
+ new wsrep::mock_high_priority_service(*server_state_,
+ cs, false));
+ cs->open(cs->id());
+ cs->before_command();
+ return ret;
+ }
+
+ wsrep::high_priority_service* streaming_applier_service(
+ wsrep::high_priority_service&) WSREP_OVERRIDE
+ {
+ wsrep::mock_client* cs(new wsrep::mock_client(
+ *server_state_,
+ wsrep::client_id(++last_client_id_),
+ wsrep::client_state::m_high_priority));
+ wsrep::mock_high_priority_service* ret(
+ new wsrep::mock_high_priority_service(*server_state_,
+ cs, false));
+ cs->open(cs->id());
+ cs->before_command();
+ return ret;
+ }
+
+ void release_high_priority_service(
+ wsrep::high_priority_service *high_priority_service)
+ WSREP_OVERRIDE
+ {
+ mock_high_priority_service* mhps(
+ static_cast<mock_high_priority_service*>(high_priority_service));
+ wsrep::mock_client* cs(&static_cast<wsrep::mock_client&>(
+ mhps->client_state()));
+ cs->after_command_before_result();
+ cs->after_command_after_result();
+ cs->close();
+ cs->cleanup();
+ delete cs;
+ delete mhps;
+ }
+ void bootstrap() WSREP_OVERRIDE { }
+ void log_message(enum wsrep::log::level level, const char* message)
+ WSREP_OVERRIDE
+ {
+ wsrep::log(level, server_state_->name().c_str()) << message;
+ }
+ void log_dummy_write_set(wsrep::client_state&,
+ const wsrep::ws_meta&)
+ WSREP_OVERRIDE
+ {
+ }
+ void log_view(wsrep::high_priority_service*, const wsrep::view& view)
+ WSREP_OVERRIDE
+ {
+ logged_view_ = view;
+ }
+
+ void recover_streaming_appliers(wsrep::client_service&)
+ WSREP_OVERRIDE
+ { }
+
+ void recover_streaming_appliers(wsrep::high_priority_service&)
+ WSREP_OVERRIDE
+ { }
+
+ wsrep::view get_view(wsrep::client_service&, const wsrep::id& own_id)
+ WSREP_OVERRIDE
+ {
+ int const my_idx(logged_view_.member_index(own_id));
+ wsrep::view my_view(
+ logged_view_.state_id(),
+ logged_view_.view_seqno(),
+ logged_view_.status(),
+ logged_view_.capabilities(),
+ my_idx,
+ logged_view_.protocol_version(),
+ logged_view_.members()
+ );
+ return my_view;
+ }
+
+ wsrep::gtid get_position(wsrep::client_service&) WSREP_OVERRIDE
+ {
+ return position_;
+ }
+
+ void set_position(wsrep::client_service&,
+ const wsrep::gtid& gtid) WSREP_OVERRIDE
+ {
+ position_ = gtid;
+ }
+
+ void log_state_change(enum wsrep::server_state::state,
+ enum wsrep::server_state::state)
+ WSREP_OVERRIDE
+ { }
+ bool sst_before_init() const WSREP_OVERRIDE
+ { return sst_before_init_; }
+ std::string sst_request() WSREP_OVERRIDE { return ""; }
+
+ // Action to take when start_sst() method is called.
+ // This can be overriden by test case to inject custom
+ // behavior.
+ std::function<int()> start_sst_action{[](){ return 0; }};
+ int start_sst(const std::string&, const wsrep::gtid&,
+ bool) WSREP_OVERRIDE
+ {
+ return start_sst_action();
+ }
+
+ void
+ background_rollback(wsrep::unique_lock<wsrep::mutex>& lock,
+ wsrep::client_state& client_state) WSREP_OVERRIDE
+ {
+ lock.unlock();
+ client_state.before_rollback();
+ client_state.after_rollback();
+ lock.lock();
+ }
+
+ int wait_committing_transactions(int) WSREP_OVERRIDE { return 0; }
+
+ wsrep::transaction_id next_transaction_id()
+ {
+ return wsrep::transaction_id(++last_transaction_id_);
+ }
+
+ void debug_sync(const char* sync_point) WSREP_OVERRIDE
+ {
+ if (sync_point_enabled_ == sync_point)
+ {
+ switch (sync_point_action_)
+ {
+ case spa_none:
+ break;
+ case spa_initialize:
+ server_state_->initialized();
+ break;
+ case spa_initialize_error:
+ throw wsrep::runtime_error("Inject initialization error");
+ break;
+ }
+ }
+ }
+
+ std::string sync_point_enabled_;
+ enum sync_point_action
+ {
+ spa_none,
+ spa_initialize,
+ spa_initialize_error
+
+ } sync_point_action_;
+ bool sst_before_init_;
+
+ void logged_view(const wsrep::view& view)
+ {
+ logged_view_ = view;
+ }
+ void position(const wsrep::gtid& position)
+ {
+ position_ = position;
+ }
+ private:
+ wsrep::server_state* server_state_;
+ unsigned long long last_client_id_;
+ unsigned long long last_transaction_id_;
+ wsrep::view logged_view_;
+ wsrep::gtid position_;
+ };
+
+
+ class mock_server_state : public wsrep::server_state
+ {
+ public:
+ mock_server_state(const std::string& name,
+ enum wsrep::server_state::rollback_mode rollback_mode,
+ wsrep::server_service& server_service)
+ : wsrep::server_state(mutex_, cond_, server_service, NULL,
+ name, "", "", "./",
+ wsrep::gtid::undefined(),
+ 1,
+ rollback_mode)
+ , mutex_()
+ , cond_()
+ , provider_(*this)
+ { }
+
+ wsrep::mock_provider& provider() const WSREP_OVERRIDE
+ { return provider_; }
+
+ // mock connected state for tests without overriding the connect()
+ // method.
+ int mock_connect(const std::string& own_id,
+ const std::string& cluster_name,
+ const std::string& cluster_address,
+ const std::string& state_donor,
+ bool bootstrap)
+ {
+ int const ret(server_state::connect(cluster_name,
+ cluster_address,
+ state_donor,
+ bootstrap));
+ if (0 == ret)
+ {
+ wsrep::id cluster_id("1");
+ wsrep::gtid state_id(cluster_id, wsrep::seqno(0));
+ std::vector<wsrep::view::member> members;
+ members.push_back(wsrep::view::member(wsrep::id(own_id),
+ "name", ""));
+ wsrep::view bootstrap_view(state_id,
+ wsrep::seqno(1),
+ wsrep::view::primary,
+ 0,
+ 0,
+ 1,
+ members);
+ server_state::on_connect(bootstrap_view);
+ }
+ else
+ {
+ assert(0);
+ }
+
+ return ret;
+ }
+
+ int mock_connect()
+ {
+ return mock_connect(name(), "cluster", "local", "0", false);
+ }
+
+ private:
+ wsrep::default_mutex mutex_;
+ wsrep::default_condition_variable cond_;
+ mutable wsrep::mock_provider provider_;
+ };
+}
+
+#endif // WSREP_MOCK_SERVER_STATE_HPP
diff --git a/wsrep-lib/test/mock_storage_service.cpp b/wsrep-lib/test/mock_storage_service.cpp
new file mode 100644
index 00000000..db513bc4
--- /dev/null
+++ b/wsrep-lib/test/mock_storage_service.cpp
@@ -0,0 +1,94 @@
+/*
+ * Copyright (C) 2018-2019 Codership Oy <info@codership.com>
+ *
+ * This file is part of wsrep-lib.
+ *
+ * Wsrep-lib is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * Wsrep-lib is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with wsrep-lib. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include "mock_storage_service.hpp"
+#include "mock_server_state.hpp"
+
+#include "wsrep/client_state.hpp"
+
+wsrep::mock_storage_service::mock_storage_service(
+ wsrep::server_state& server_state,
+ wsrep::client_id client_id)
+ : client_service_(&client_state_)
+ , client_state_(server_state, client_service_, client_id,
+ wsrep::client_state::m_high_priority)
+{
+ client_state_.open(client_id);
+ client_state_.before_command();
+}
+
+
+wsrep::mock_storage_service::~mock_storage_service()
+{
+ client_state_.after_command_before_result();
+ client_state_.after_command_after_result();
+ client_state_.close();
+ client_state_.cleanup();
+}
+
+int wsrep::mock_storage_service::start_transaction(
+ const wsrep::ws_handle& ws_handle)
+{
+ return client_state_.start_transaction(ws_handle.transaction_id());
+}
+
+void wsrep::mock_storage_service::adopt_transaction(
+ const wsrep::transaction& transaction)
+{
+ client_state_.adopt_transaction(transaction);
+}
+
+int wsrep::mock_storage_service::commit(const wsrep::ws_handle& ws_handle,
+ const wsrep::ws_meta& ws_meta)
+{
+ // the logic here matches mariadb's wsrep_storage_service::commit
+ bool ret = 0;
+ const bool is_ordered = !ws_meta.seqno().is_undefined();
+ if (is_ordered)
+ {
+ ret = ret || client_state_.prepare_for_ordering(ws_handle, ws_meta, true);
+ ret = ret || client_state_.before_commit();
+ ret = ret || client_state_.ordered_commit();
+ ret = ret || client_state_.after_commit();
+ }
+
+ if (!is_ordered)
+ {
+ client_state_.before_rollback();
+ client_state_.after_rollback();
+ }
+ else if (ret)
+ {
+ client_state_.prepare_for_ordering(wsrep::ws_handle(), wsrep::ws_meta(), false);
+ }
+
+ client_state_.after_applying();
+ return ret;
+}
+
+int wsrep::mock_storage_service::rollback(const wsrep::ws_handle& ws_handle,
+ const wsrep::ws_meta& ws_meta)
+{
+ int ret(client_state_.prepare_for_ordering(
+ ws_handle, ws_meta, false) ||
+ client_state_.before_rollback() ||
+ client_state_.after_rollback());
+ client_state_.after_applying();
+ return ret;
+}
diff --git a/wsrep-lib/test/mock_storage_service.hpp b/wsrep-lib/test/mock_storage_service.hpp
new file mode 100644
index 00000000..18d2b98d
--- /dev/null
+++ b/wsrep-lib/test/mock_storage_service.hpp
@@ -0,0 +1,63 @@
+/*
+ * Copyright (C) 2018 Codership Oy <info@codership.com>
+ *
+ * This file is part of wsrep-lib.
+ *
+ * Wsrep-lib is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * Wsrep-lib is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with wsrep-lib. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#ifndef WSREP_MOCK_STORAGE_SERVICE_HPP
+#define WSREP_MOCK_STORAGE_SERVICE_HPP
+
+#include "wsrep/storage_service.hpp"
+#include "mock_client_state.hpp"
+
+namespace wsrep
+{
+class mock_server_state;
+ class mock_storage_service : public wsrep::storage_service
+ {
+ public:
+ mock_storage_service(wsrep::server_state&, wsrep::client_id);
+ ~mock_storage_service() WSREP_OVERRIDE;
+
+ int start_transaction(const wsrep::ws_handle&) WSREP_OVERRIDE;
+
+ void adopt_transaction(const wsrep::transaction&) WSREP_OVERRIDE;
+
+ int append_fragment(const wsrep::id&,
+ wsrep::transaction_id,
+ int,
+ const wsrep::const_buffer&,
+ const wsrep::xid&) WSREP_OVERRIDE
+ { return 0; }
+
+ int update_fragment_meta(const wsrep::ws_meta&) WSREP_OVERRIDE
+ { return 0; }
+ int remove_fragments() WSREP_OVERRIDE { return 0; }
+ int commit(const wsrep::ws_handle&, const wsrep::ws_meta&)
+ WSREP_OVERRIDE;
+
+ int rollback(const wsrep::ws_handle&, const wsrep::ws_meta&)
+ WSREP_OVERRIDE;
+
+ void store_globals() WSREP_OVERRIDE { }
+ void reset_globals() WSREP_OVERRIDE { }
+ private:
+ wsrep::mock_client_service client_service_;
+ wsrep::mock_client_state client_state_;
+ };
+}
+
+#endif // WSREP_MOCK_STORAGE_SERVICE_HPP
diff --git a/wsrep-lib/test/nbo_test.cpp b/wsrep-lib/test/nbo_test.cpp
new file mode 100644
index 00000000..238a4da5
--- /dev/null
+++ b/wsrep-lib/test/nbo_test.cpp
@@ -0,0 +1,171 @@
+/*
+ * Copyright (C) 2019 Codership Oy <info@codership.com>
+ *
+ * This file is part of wsrep-lib.
+ *
+ * Wsrep-lib is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * Wsrep-lib is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with wsrep-lib. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include "wsrep/client_state.hpp"
+
+#include "client_state_fixture.hpp"
+
+#include <boost/test/unit_test.hpp>
+
+BOOST_FIXTURE_TEST_CASE(test_local_nbo,
+ replicating_client_fixture_sync_rm)
+{
+ // NBO is executed in two consecutive TOI operations
+ BOOST_REQUIRE(cc.mode() == wsrep::client_state::m_local);
+ // First phase certifies the write set and enters TOI
+ wsrep::key key(wsrep::key::exclusive);
+ key.append_key_part("k1", 2);
+ key.append_key_part("k2", 2);
+ wsrep::key_array keys{key};
+ std::string data("data");
+ BOOST_REQUIRE(cc.begin_nbo_phase_one(
+ keys,
+ wsrep::const_buffer(data.data(),
+ data.size())) == 0);
+ BOOST_REQUIRE(cc.mode() == wsrep::client_state::m_nbo);
+ BOOST_REQUIRE(cc.in_toi());
+ BOOST_REQUIRE(cc.toi_mode() == wsrep::client_state::m_local);
+ // After required resoureces have been grabbed, NBO leave should
+ // end TOI but leave the client state in m_nbo.
+ const wsrep::mutable_buffer err;
+ BOOST_REQUIRE(cc.end_nbo_phase_one(err) == 0);
+ BOOST_REQUIRE(cc.mode() == wsrep::client_state::m_nbo);
+ BOOST_REQUIRE(cc.in_toi() == false);
+ BOOST_REQUIRE(cc.toi_mode() == wsrep::client_state::m_undefined);
+ // Second phase replicates the NBO end event and grabs TOI
+ // again for finalizing the NBO.
+ BOOST_REQUIRE(cc.begin_nbo_phase_two(keys) == 0);
+ BOOST_REQUIRE(cc.mode() == wsrep::client_state::m_nbo);
+ BOOST_REQUIRE(cc.in_toi());
+ BOOST_REQUIRE(cc.toi_mode() == wsrep::client_state::m_local);
+ // End of NBO phase will leave TOI and put the client state back to
+ // m_local
+ BOOST_REQUIRE(cc.end_nbo_phase_two(err) == 0);
+ BOOST_REQUIRE(cc.mode() == wsrep::client_state::m_local);
+ BOOST_REQUIRE(cc.in_toi() == false);
+ BOOST_REQUIRE(cc.toi_mode() == wsrep::client_state::m_undefined);
+
+ // There must have been two toi write sets, one with
+ // start transaction flag, another with commit flag.
+ BOOST_REQUIRE(sc.provider().toi_write_sets() == 2);
+ BOOST_REQUIRE(sc.provider().toi_start_transaction() == 1);
+ BOOST_REQUIRE(sc.provider().toi_commit() == 1);
+}
+
+BOOST_FIXTURE_TEST_CASE(test_local_nbo_cert_failure,
+ replicating_client_fixture_sync_rm)
+{
+ // NBO is executed in two consecutive TOI operations
+ BOOST_REQUIRE(cc.mode() == wsrep::client_state::m_local);
+ // First phase certifies the write set and enters TOI
+ wsrep::key key(wsrep::key::exclusive);
+ key.append_key_part("k1", 2);
+ key.append_key_part("k2", 2);
+ wsrep::key_array keys{key};
+ std::string data("data");
+ sc.provider().certify_result_ = wsrep::provider::error_certification_failed;
+ BOOST_REQUIRE(cc.begin_nbo_phase_one(
+ keys,
+ wsrep::const_buffer(data.data(),
+ data.size())) == 1);
+ BOOST_REQUIRE(cc.current_error() == wsrep::e_deadlock_error);
+ BOOST_REQUIRE(cc.current_error_status() ==
+ wsrep::provider::error_certification_failed);
+ BOOST_REQUIRE(cc.mode() == wsrep::client_state::m_local);
+ BOOST_REQUIRE(cc.in_toi() == false);
+ BOOST_REQUIRE(cc.toi_mode() == wsrep::client_state::m_undefined);
+}
+
+// This test case operates through server_state object in order to
+// verify that the high priority service is called with appropriate
+// arguments.
+BOOST_FIXTURE_TEST_CASE(test_applying_nbo,
+ applying_client_fixture)
+{
+
+ wsrep::mock_high_priority_service hps(sc, &cc, false);
+ wsrep::ws_handle ws_handle(wsrep::transaction_id::undefined(), (void*)(1));
+ const int nbo_begin_flags(wsrep::provider::flag::start_transaction |
+ wsrep::provider::flag::isolation);
+ wsrep::ws_meta ws_meta(wsrep::gtid(wsrep::id("cluster1"),
+ wsrep::seqno(1)),
+ wsrep::stid(wsrep::id("s1"),
+ wsrep::transaction_id::undefined(),
+ wsrep::client_id(1)),
+ wsrep::seqno(0),
+ nbo_begin_flags);
+ std::string nbo_begin("nbo_begin");
+ BOOST_REQUIRE(sc.on_apply(hps, ws_handle, ws_meta,
+ wsrep::const_buffer(nbo_begin.data(),
+ nbo_begin.size())) == 0);
+ wsrep::mock_client* nbo_cs(hps.nbo_cs());
+ BOOST_REQUIRE(nbo_cs);
+ BOOST_REQUIRE(nbo_cs->toi_mode() == wsrep::client_state::m_undefined);
+ BOOST_REQUIRE(nbo_cs->mode() == wsrep::client_state::m_nbo);
+
+ // After this point the control is on local process and applier
+ // has released toi critical section.
+ wsrep::key key(wsrep::key::exclusive);
+ key.append_key_part("k1", 2);
+ key.append_key_part("k2", 2);
+ wsrep::key_array keys{key};
+ // Starting phase two should put nbo_cs in toi mode.
+ BOOST_REQUIRE(nbo_cs->begin_nbo_phase_two(keys) == 0);
+ BOOST_REQUIRE(nbo_cs->mode() == wsrep::client_state::m_nbo);
+ BOOST_REQUIRE(nbo_cs->in_toi());
+ BOOST_REQUIRE(nbo_cs->toi_mode() == wsrep::client_state::m_local);
+ // Ending phase two should make nbo_cs leave TOI mode and
+ // return to m_local mode.
+ const wsrep::mutable_buffer err;
+ BOOST_REQUIRE(nbo_cs->end_nbo_phase_two(err) == 0);
+ BOOST_REQUIRE(nbo_cs->mode() == wsrep::client_state::m_local);
+ BOOST_REQUIRE(nbo_cs->in_toi() == false);
+ BOOST_REQUIRE(nbo_cs->toi_mode() == wsrep::client_state::m_undefined);
+
+ // There must have been one toi write set with commit flag.
+ BOOST_REQUIRE(sc.provider().toi_write_sets() == 1);
+ BOOST_REQUIRE(sc.provider().toi_start_transaction() == 0);
+ BOOST_REQUIRE(sc.provider().toi_commit() == 1);
+}
+
+// This test case operates through server_state object in order to
+// verify that the high priority service is called with appropriate
+// arguments. The test checks that error is returned in the case if
+// launching asynchronous process for NBO fails.
+BOOST_FIXTURE_TEST_CASE(test_applying_nbo_fail,
+ applying_client_fixture)
+{
+
+ wsrep::mock_high_priority_service hps(sc, &cc, false);
+ wsrep::ws_handle ws_handle(wsrep::transaction_id::undefined(), (void*)(1));
+ const int nbo_begin_flags(wsrep::provider::flag::start_transaction |
+ wsrep::provider::flag::isolation);
+ wsrep::ws_meta ws_meta(wsrep::gtid(wsrep::id("cluster1"),
+ wsrep::seqno(1)),
+ wsrep::stid(wsrep::id("s1"),
+ wsrep::transaction_id::undefined(),
+ wsrep::client_id(1)),
+ wsrep::seqno(0),
+ nbo_begin_flags);
+ std::string nbo_begin("nbo_begin");
+ hps.fail_next_toi_ = true;
+ BOOST_REQUIRE(sc.on_apply(hps, ws_handle, ws_meta,
+ wsrep::const_buffer(nbo_begin.data(),
+ nbo_begin.size())) == 1);
+}
diff --git a/wsrep-lib/test/reporter_test.cpp b/wsrep-lib/test/reporter_test.cpp
new file mode 100644
index 00000000..9ee381e1
--- /dev/null
+++ b/wsrep-lib/test/reporter_test.cpp
@@ -0,0 +1,655 @@
+/*
+ * Copyright (C) 2021 Codership Oy <info@codership.com>
+ *
+ * This file is part of wsrep-lib.
+ *
+ * Wsrep-lib is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * Wsrep-lib is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with wsrep-lib. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include "wsrep/reporter.hpp"
+
+#include <boost/test/unit_test.hpp>
+
+#include <boost/json/src.hpp>
+
+#include <fstream>
+#include <deque>
+#include <vector>
+#include <unistd.h> // unlink() for cleanup
+
+namespace json = boost::json;
+
+//////// HELPERS ///////
+
+static inline double
+timestamp()
+{
+ struct timespec time;
+ clock_gettime(CLOCK_REALTIME, &time);
+ return (double(time.tv_sec) + double(time.tv_nsec)*1.0e-9);
+}
+
+static std::string make_progress_string(int const from, int const to,
+ int const total,int const done,
+ int const indefinite)
+{
+ std::ostringstream os;
+
+ os << "{ \"from\": " << from << ", "
+ << "\"to\": " << to << ", "
+ << "\"total\": " << total << ", "
+ << "\"done\": " << done << ", "
+ << "\"indefinite\": " << indefinite << " }";
+
+ return os.str();
+}
+
+
+static json::value
+read_file(const char* const filename)
+{
+ std::ifstream input(filename, std::ios::binary);
+ std::vector<char> buffer(std::istreambuf_iterator<char>(input), {});
+ json::stream_parser parser;
+ json::error_code err;
+
+ parser.write(buffer.data(), buffer.size(), err);
+ if (err)
+ {
+ assert(0);
+ return nullptr;
+ }
+
+ parser.finish(err);
+ if (err)
+ {
+ assert(0);
+ return nullptr;
+ }
+
+ return parser.release();
+}
+
+struct logs
+{
+ std::deque<double> tstamp_;
+ std::deque<std::string> msg_;
+};
+
+struct progress
+{
+ int from_;
+ int to_;
+ int total_;
+ int done_;
+ int indefinite_;
+
+ bool indefinite() const { return total_ == indefinite_; }
+ bool steady() const { return total_ == 0; }
+ progress(int const from, int const to, int const total, int const done,
+ int const indefinite)
+ : from_(from)
+ , to_(to)
+ , total_(total)
+ , done_(done)
+ , indefinite_(indefinite)
+ {}
+};
+
+static bool
+operator==(const progress& left, const progress& right)
+{
+ if (left.indefinite() && right.indefinite()) return true;
+ if (left.steady() && right.steady()) return true;
+
+ return (left.from_ == right.from_ &&
+ left.to_ == right.to_ &&
+ left.total_ == right.total_ &&
+ left.done_ == right.done_ &&
+ left.indefinite_ == right.indefinite_);
+}
+
+static bool
+operator!=(const progress& left, const progress& right)
+{
+ return !(left == right);
+}
+
+static std::ostream&
+operator<<(std::ostream& os, const progress& p)
+{
+ os << make_progress_string(p.from_, p.to_, p.total_, p.done_,p.indefinite_);
+ return os;
+}
+
+struct result
+{
+ logs errors_;
+ logs warnings_;
+ struct
+ {
+ std::string state_;
+ std::string comment_;
+ progress progress_;
+ } status_;
+};
+
+static void
+parse_result(const json::value& value, struct result& res,
+ const std::string& path = "")
+{
+ //std::cout << "Parsing " << path << ": " << value << ": " << value.kind() << std::endl;
+ switch (value.kind())
+ {
+ case json::kind::object:
+ {
+ auto const obj(value.get_object());
+ if (!obj.empty())
+ {
+ for (auto it = obj.begin(); it != obj.end(); ++it)
+ {
+ std::string const key(it->key().data(), it->key().length());
+ parse_result(it->value(), res, path + "." + key);
+ }
+ }
+ return;
+ }
+ case json::kind::array:
+ {
+ auto const arr(value.get_array());
+ if (!arr.empty())
+ {
+ for (auto it = arr.begin(); it != arr.end(); ++it)
+ {
+ parse_result(*it, res, path + ".[]");
+ }
+ }
+ return;
+ }
+ case json::kind::string:
+ {
+ auto const val(value.get_string().c_str());
+ if (path == ".errors.[].msg")
+ {
+ res.errors_.msg_.push_back(val);
+ }
+ else if (path == ".warnings.[].msg")
+ {
+ res.warnings_.msg_.push_back(val);
+ }
+ else if (path == ".status.state")
+ {
+ res.status_.state_ = val;
+ }
+ else if (path == ".status.comment")
+ {
+ res.status_.comment_ = val;
+ }
+ return;
+ }
+ case json::kind::uint64:
+ WSREP_FALLTHROUGH;
+ case json::kind::int64:
+ if (path == ".status.progress.from")
+ {
+ res.status_.progress_.from_ = int(value.get_int64());
+ }
+ else if (path == ".status.progress.to")
+ {
+ res.status_.progress_.to_ = int(value.get_int64());
+ }
+ else if (path == ".status.progress.total")
+ {
+ res.status_.progress_.total_ = int(value.get_int64());
+ }
+ else if (path == ".status.progress.done")
+ {
+ res.status_.progress_.done_ = int(value.get_int64());
+ }
+ else if (path == ".status.progress.indefinite")
+ {
+ res.status_.progress_.indefinite_ = int(value.get_int64());
+ }
+ return;
+ case json::kind::double_:
+ if (path == ".errors.[].timestamp")
+ {
+ res.errors_.tstamp_.push_back(value.get_double());
+ }
+ else if (path == ".warnings.[].timestamp")
+ {
+ res.warnings_.tstamp_.push_back(value.get_double());
+ }
+
+ return;
+ case json::kind::bool_:
+ return;
+ case json::kind::null:
+ return;
+ }
+
+ assert(0);
+}
+
+static bool
+equal(const std::string& left, const std::string& right)
+{
+ return left == right;
+}
+
+static bool
+equal(double const left, double const right)
+{
+ return ::fabs(left - right) < 0.0001; // we are looking for ms precision
+}
+
+template <typename T>
+static bool
+operator!=(const std::deque<T>& left, const std::deque<T>& right)
+{
+ if (left.size() != right.size()) return true;
+
+ for (size_t i(0); i < left.size(); ++i)
+ if (!equal(left[i], right[i])) return true;
+
+ return false;
+}
+
+static bool
+operator!=(const logs& left, const logs& right)
+{
+ if (left.tstamp_ != right.tstamp_) return true;
+ return (left.msg_ != right.msg_);
+}
+
+static bool
+operator==(const result& left, const result& right)
+{
+ if (left.errors_ != right.errors_) return false;
+ if (left.warnings_ != right.warnings_) return false;
+
+ if (left.status_.state_ != right.status_.state_) return false;
+ if (left.status_.comment_ != right.status_.comment_) return false;
+ if (left.status_.progress_ != right.status_.progress_) return false;
+
+ return true;
+}
+
+template <typename T>
+static void
+print_deque(std::ostream& os,const std::deque<T> left,const std::deque<T> right)
+{
+ auto const max(std::max(left.size(), right.size()));
+ for (size_t i(0); i < max; ++i)
+ {
+ os << "|\t'";
+
+ if (i < left.size())
+ os << left[i] << "'";
+ else
+ os << "'\t";
+
+ if (i < right.size())
+ os << "\t'" << right[i] << "'";
+ else
+ os << "\t''";
+
+ if (!equal(left[i], right[i])) os << "\t!!!";
+
+ os << "\n";
+ }
+}
+
+static void
+print_logs(std::ostream& os, const logs& left, const logs& right)
+{
+ os << "|\t" << left.msg_.size() << "\t" << right.msg_.size() << "\n";
+ print_deque(os, left.tstamp_, right.tstamp_);
+ print_deque(os, left.msg_, right.msg_);
+}
+
+// print two results against each other
+template <typename Iteration>
+static std::string
+print(const result& left, const result& right, Iteration it)
+{
+ std::ostringstream os;
+
+ os << std::showpoint << std::setprecision(18);
+
+ os << "Iteration " << it << "\nerrors:\n";
+ print_logs(os, left.errors_, right.errors_);
+ os << "warnings:\n";
+ print_logs(os, left.warnings_, right.warnings_);
+ os << "state:\n";
+ os << "\t" << left.status_.state_ << "\t" << right.status_.state_
+ << "\n";
+ os << "\t" << left.status_.comment_ << "\t" << right.status_.comment_
+ << "\n";
+ os << "\t" << left.status_.progress_ << "\t" << right.status_.progress_
+ << "\n";
+
+ return os.str();
+}
+
+#define VERIFY_RESULT(left, right, it) \
+ BOOST_CHECK_MESSAGE(left == right, print(left, right, it));
+
+static const char*
+const REPORT = "report.json";
+
+static progress
+const indefinite(-1, -1, -1, -1, -1);
+
+static progress
+const steady(-1, -1, 0, 0, -1);
+
+static struct logs
+const LOGS_INIT = { std::deque<double>(), std::deque<std::string>() };
+static struct result
+const RES_INIT = { LOGS_INIT, LOGS_INIT,
+ { "DISCONNECTED", "Disconnected", indefinite } };
+
+template <typename Iteration>
+static void
+test_log(const char* const fname,
+ wsrep::reporter& rep,
+ result& check,
+ wsrep::reporter::log_level const lvl,
+ double const tstamp,
+ const std::string& msg,
+ Iteration const iteration)
+{
+ // this is implementaiton detail, if it changes in the code, it needs
+ // to be changed here
+ size_t const MAX_ERROR(4);
+
+ logs& log(lvl == wsrep::reporter::error ? check.errors_ : check.warnings_);
+ log.tstamp_.push_back(tstamp);
+ if (log.tstamp_.size() > MAX_ERROR) log.tstamp_.pop_front();
+ log.msg_.push_back(msg);
+ if (log.msg_.size() > MAX_ERROR) log.msg_.pop_front();
+
+ rep.report_log_msg(lvl, msg, tstamp);
+
+ auto value = read_file(fname);
+ auto res = RES_INIT;
+ parse_result(value, res);
+ VERIFY_RESULT(res, check, iteration);
+}
+
+static size_t const MAX_MSG = 4;
+
+struct reporter_fixture
+{
+ wsrep::default_mutex mutex{};
+ wsrep::reporter rep{mutex, REPORT, MAX_MSG};
+};
+
+BOOST_FIXTURE_TEST_CASE(log_msg_test, reporter_fixture)
+{
+ auto value = read_file(REPORT);
+ BOOST_REQUIRE(value != nullptr);
+
+ struct result res(RES_INIT), check(RES_INIT);
+ parse_result(value, res);
+ VERIFY_RESULT(res, check, -1);
+
+ struct entry
+ {
+ double tstamp_;
+ std::string msg_;
+ };
+ std::vector<entry> msgs =
+ {
+ { 0.1, "a" },
+ { 0.2, "bb" },
+ { 0.3, "ccc" },
+ { 0.4, "dddd" },
+ { 0.5, "eeeee" },
+ { 0.6, "ffffff" }
+ };
+ for (size_t i(0); i < msgs.size(); ++i)
+ {
+ test_log(REPORT, rep, check,
+ wsrep::reporter::error, msgs[i].tstamp_, msgs[i].msg_, i);
+ test_log(REPORT, rep, check,
+ wsrep::reporter::warning, msgs[i].tstamp_, msgs[i].msg_, i);
+ }
+
+ // test indefinite timestmap
+ std::string const msg("err");
+ rep.report_log_msg(wsrep::reporter::error, msg);
+ value = read_file(REPORT);
+ res = RES_INIT;
+ parse_result(value, res);
+ BOOST_REQUIRE(res.errors_.tstamp_.back() > 0);
+ BOOST_REQUIRE(res.errors_.msg_.back() == msg);
+
+ ::unlink(REPORT);
+}
+
+BOOST_FIXTURE_TEST_CASE(state_test, reporter_fixture)
+{
+ using wsrep::server_state;
+
+ double const err_tstamp(timestamp());
+ std::string const err_msg("Error!");
+
+ struct test
+ {
+ struct
+ {
+ enum wsrep::server_state::state state;
+ float progress;
+ } input;
+ struct result output;
+ };
+
+ logs const ERRS_INIT = { {err_tstamp}, {err_msg} };
+
+ std::vector<test> tests =
+ {
+ {{ server_state::s_disconnected, 0 },
+ { ERRS_INIT, LOGS_INIT,
+ { "DISCONNECTED", "Disconnected", indefinite }}},
+ {{ server_state::s_initializing, 0 },
+ { ERRS_INIT, LOGS_INIT,
+ { "DISCONNECTED", "Initializing", indefinite }}},
+ {{ server_state::s_initialized, 0 },
+ { ERRS_INIT, LOGS_INIT,
+ { "DISCONNECTED", "Connecting", indefinite }}},
+ {{ server_state::s_connected, 0 },
+ { ERRS_INIT, LOGS_INIT,
+ { "CONNECTED", "Waiting", indefinite }}},
+ {{ server_state::s_joiner, 0 },
+ { ERRS_INIT, LOGS_INIT,
+ { "JOINING", "Receiving state", indefinite }}},
+ {{ server_state::s_disconnecting, 0 },
+ { ERRS_INIT, LOGS_INIT,
+ { "DISCONNECTING", "Disconnecting", indefinite }}},
+ {{ server_state::s_disconnected, 0 },
+ { ERRS_INIT, LOGS_INIT,
+ { "DISCONNECTED", "Disconnected", indefinite }}},
+ {{ server_state::s_connected, 0 },
+ { ERRS_INIT, LOGS_INIT,
+ { "CONNECTED", "Waiting", indefinite }}},
+ {{ server_state::s_joiner, 0 },
+ { ERRS_INIT, LOGS_INIT,
+ { "JOINING", "Receiving SST", indefinite }}},
+ {{ server_state::s_initializing, 0 },
+ { ERRS_INIT, LOGS_INIT,
+ { "JOINING", "Initializing", indefinite }}},
+ {{ server_state::s_initialized, 0 },
+ { ERRS_INIT, LOGS_INIT,
+ { "JOINING", "Receiving IST", indefinite }}},
+ {{ server_state::s_joined, 0 },
+ { ERRS_INIT, LOGS_INIT,
+ { "JOINED", "Syncing", indefinite }}},
+ {{ server_state::s_synced, 0 },
+ { ERRS_INIT, LOGS_INIT,
+ { "SYNCED", "Operational", steady }}},
+ {{ server_state::s_donor, 0 },
+ { ERRS_INIT, LOGS_INIT,
+ { "DONOR", "Donating SST", indefinite }}},
+ {{ server_state::s_joined, 0 },
+ { ERRS_INIT, LOGS_INIT,
+ { "JOINED", "Syncing", indefinite }}},
+ {{ server_state::s_synced, 0 },
+ { ERRS_INIT, LOGS_INIT,
+ { "SYNCED", "Operational", steady }}},
+ {{ server_state::s_disconnecting, 0 },
+ { ERRS_INIT, LOGS_INIT,
+ { "DISCONNECTING", "Disconnecting", indefinite }}},
+ };
+
+ rep.report_log_msg(wsrep::reporter::error, err_msg, err_tstamp);
+
+ for (auto i(tests.begin()); i != tests.end(); ++i)
+ {
+ rep.report_state(i->input.state);
+ auto value = read_file(REPORT);
+ result res(RES_INIT);
+ parse_result(value, res);
+ auto check(i->output);
+ VERIFY_RESULT(res, check, i - tests.begin());
+ }
+
+ ::unlink(REPORT);
+}
+
+BOOST_FIXTURE_TEST_CASE(progress_test, reporter_fixture)
+{
+ using wsrep::server_state;
+
+ wsrep::default_mutex m;
+ wsrep::reporter rep(m, REPORT, MAX_MSG);
+ double const warn_tstamp(timestamp());
+ std::string const warn_msg("Warn!");
+
+ static progress const progress5_0(-1, -1, 5, 0, -1);
+ static progress const progress5_2(-1, -1, 5, 2, -1);
+ static progress const progress5_5(-1, -1, 5, 5, -1);
+
+ struct test
+ {
+ struct
+ {
+ enum wsrep::server_state::state state;
+ int total;
+ int done;
+ } input;
+ struct result output;
+ };
+
+ logs const WARN_INIT = { {warn_tstamp}, {warn_msg} };
+
+ std::vector<test> tests =
+ {
+ {{ server_state::s_initialized, -1, -1 },
+ { LOGS_INIT, WARN_INIT,
+ { "DISCONNECTED", "Connecting", indefinite }}},
+ {{ server_state::s_connected, -1, -1 },
+ { LOGS_INIT, WARN_INIT,
+ { "CONNECTED", "Waiting", indefinite }}},
+ {{ server_state::s_joiner, 5, 0 },
+ { LOGS_INIT, WARN_INIT,
+ { "JOINING", "Receiving state", progress5_0 }}},
+ {{ server_state::s_joiner, 5, 2 },
+ { LOGS_INIT, WARN_INIT,
+ { "JOINING", "Receiving state", progress5_2 }}},
+ {{ server_state::s_disconnected, -1, -1 },
+ { LOGS_INIT, WARN_INIT,
+ { "DISCONNECTED", "Disconnected", indefinite }}},
+ {{ server_state::s_connected, -1, -1 },
+ { LOGS_INIT, WARN_INIT,
+ { "CONNECTED", "Waiting", indefinite }}},
+ {{ server_state::s_joiner, 5, 0 },
+ { LOGS_INIT, WARN_INIT,
+ { "JOINING", "Receiving SST", progress5_0 }}},
+ {{ server_state::s_joiner, 5, 2 },
+ { LOGS_INIT, WARN_INIT,
+ { "JOINING", "Receiving SST", progress5_2 }}},
+ {{ server_state::s_joiner, 5, 5 },
+ { LOGS_INIT, WARN_INIT,
+ { "JOINING", "Receiving SST", progress5_5 }}},
+ {{ server_state::s_initializing, -1, -1 },
+ { LOGS_INIT, WARN_INIT,
+ { "JOINING", "Initializing", indefinite }}},
+ {{ server_state::s_initializing, 5, 2 },
+ { LOGS_INIT, WARN_INIT,
+ { "JOINING", "Initializing", progress5_2 }}},
+ {{ server_state::s_initialized, 5, 0 },
+ { LOGS_INIT, WARN_INIT,
+ { "JOINING", "Receiving IST", progress5_0 }}},
+ {{ server_state::s_initialized, 5, 5 },
+ { LOGS_INIT, WARN_INIT,
+ { "JOINING", "Receiving IST", progress5_5 }}},
+ {{ server_state::s_joined, -1, -1 },
+ { LOGS_INIT, WARN_INIT,
+ { "JOINED", "Syncing", indefinite }}},
+ {{ server_state::s_joined, 5, 2 },
+ { LOGS_INIT, WARN_INIT,
+ { "JOINED", "Syncing", progress5_2 }}},
+ {{ server_state::s_synced, -1, -1 },
+ { LOGS_INIT, WARN_INIT,
+ { "SYNCED", "Operational", steady }}},
+ {{ server_state::s_donor, -1, -1 },
+ { LOGS_INIT, WARN_INIT,
+ { "DONOR", "Donating SST", indefinite }}},
+ {{ server_state::s_donor, 5, 0 },
+ { LOGS_INIT, WARN_INIT,
+ { "DONOR", "Donating SST", progress5_0 }}},
+ {{ server_state::s_joined, -1, -1 },
+ { LOGS_INIT, WARN_INIT,
+ { "JOINED", "Syncing", indefinite }}},
+ {{ server_state::s_synced, -1, -1 },
+ { LOGS_INIT, WARN_INIT,
+ { "SYNCED", "Operational", steady }}},
+ };
+
+ rep.report_log_msg(wsrep::reporter::warning, warn_msg, warn_tstamp);
+
+ for (auto i(tests.begin()); i != tests.end(); ++i)
+ {
+ rep.report_state(i->input.state);
+ if (i->input.total >= 0)
+ rep.report_progress(make_progress_string(-1, -1,
+ i->input.total, i->input.done,
+ -1));
+ auto value = read_file(REPORT);
+ result res(RES_INIT);
+ parse_result(value, res);
+ auto check(i->output);
+ VERIFY_RESULT(res, check, i - tests.begin());
+ }
+
+ ::unlink(REPORT);
+}
+
+BOOST_FIXTURE_TEST_CASE(event_test, reporter_fixture)
+{
+ rep.report_event("{\"msg\": \"message\"}");
+ auto value = read_file(REPORT);
+ BOOST_REQUIRE(value.at("events").is_array());
+ auto event_array = value.at("events").as_array();
+ BOOST_REQUIRE(event_array.size() == 1);
+ auto event = event_array[0];
+ BOOST_REQUIRE(event.is_object());
+ BOOST_REQUIRE(event.at("timestamp").is_double());
+ BOOST_REQUIRE(event.at("event").is_object());
+ BOOST_REQUIRE(event.at("event").at("msg").is_string());
+ BOOST_REQUIRE(event.at("event").at("msg").as_string() == "message");
+ ::unlink(REPORT);
+}
diff --git a/wsrep-lib/test/rsu_test.cpp b/wsrep-lib/test/rsu_test.cpp
new file mode 100644
index 00000000..b032ef8c
--- /dev/null
+++ b/wsrep-lib/test/rsu_test.cpp
@@ -0,0 +1,36 @@
+/*
+ * Copyright (C) 2021 Codership Oy <info@codership.com>
+ *
+ * This file is part of wsrep-lib.
+ *
+ * Wsrep-lib is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * Wsrep-lib is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with wsrep-lib. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include "wsrep/client_state.hpp"
+
+#include "client_state_fixture.hpp"
+
+#include <boost/test/unit_test.hpp>
+
+BOOST_FIXTURE_TEST_CASE(test_rsu,
+ replicating_client_fixture_sync_rm)
+{
+ BOOST_REQUIRE(cc.begin_rsu(1) == 0);
+ BOOST_REQUIRE(cc.mode() == wsrep::client_state::m_rsu);
+ BOOST_REQUIRE(cc.toi_mode() == wsrep::client_state::m_local);
+
+ BOOST_REQUIRE(cc.end_rsu() == 0);
+ BOOST_REQUIRE(cc.mode() == wsrep::client_state::m_local);
+ BOOST_REQUIRE(cc.toi_mode() == wsrep::client_state::m_undefined);
+}
diff --git a/wsrep-lib/test/server_context_test.cpp b/wsrep-lib/test/server_context_test.cpp
new file mode 100644
index 00000000..42b3055d
--- /dev/null
+++ b/wsrep-lib/test/server_context_test.cpp
@@ -0,0 +1,960 @@
+/*
+ * Copyright (C) 2018-2023 Codership Oy <info@codership.com>
+ *
+ * This file is part of wsrep-lib.
+ *
+ * Wsrep-lib is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * Wsrep-lib is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with wsrep-lib. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include "mock_server_state.hpp"
+
+#include <boost/test/unit_test.hpp>
+
+namespace
+{
+ struct server_fixture_base
+ {
+ server_fixture_base()
+ : server_service(&ss)
+ , ss("s1",
+ wsrep::server_state::rm_sync, server_service)
+ , cc(ss,
+ wsrep::client_id(1),
+ wsrep::client_state::m_high_priority)
+ , hps(ss, &cc, false)
+ , ws_handle(wsrep::transaction_id(1), (void*)1)
+ , ws_meta(wsrep::gtid(wsrep::id("1"), wsrep::seqno(1)),
+ wsrep::stid(wsrep::id("1"), wsrep::transaction_id(1),
+ wsrep::client_id(1)),
+ wsrep::seqno(0),
+ wsrep::provider::flag::start_transaction |
+ wsrep::provider::flag::commit)
+ , cluster_id("1")
+ , bootstrap_view()
+ , second_view()
+ , third_view()
+ {
+ wsrep::gtid state_id(cluster_id, wsrep::seqno(0));
+ std::vector<wsrep::view::member> members;
+ members.push_back(wsrep::view::member(
+ wsrep::id("s1"), "s1", ""));
+ bootstrap_view = wsrep::view(state_id,
+ wsrep::seqno(1),
+ wsrep::view::primary,
+ 0, // capabilities
+ 0, // own index
+ 1, // protocol version
+ members);
+
+ members.push_back(wsrep::view::member(
+ wsrep::id("s2"), "s2", ""));
+ second_view = wsrep::view(wsrep::gtid(cluster_id, wsrep::seqno(1)),
+ wsrep::seqno(2),
+ wsrep::view::primary,
+ 0, // capabilities
+ 1, // own index
+ 1, // protocol version
+ members);
+
+ members.push_back(wsrep::view::member(
+ wsrep::id("s3"), "s3", ""));
+
+ third_view = wsrep::view(wsrep::gtid(cluster_id, wsrep::seqno(2)),
+ wsrep::seqno(3),
+ wsrep::view::primary,
+ 0, // capabilities
+ 1, // own index
+ 1, // protocol version
+ members);
+
+ cc.open(cc.id());
+ BOOST_REQUIRE(cc.before_command() == 0);
+ }
+ wsrep::mock_server_service server_service;
+ wsrep::mock_server_state ss;
+ wsrep::mock_client cc;
+ wsrep::mock_high_priority_service hps;
+ wsrep::ws_handle ws_handle;
+ wsrep::ws_meta ws_meta;
+ wsrep::id cluster_id;
+ wsrep::view bootstrap_view;
+ wsrep::view second_view;
+ wsrep::view third_view;
+
+ void connect_in_view(const wsrep::view& view)
+ {
+ BOOST_REQUIRE(ss.connect("cluster", "local", "0", false) == 0);
+ ss.on_connect(view);
+ BOOST_REQUIRE(ss.state() == wsrep::server_state::s_connected);
+ }
+
+ void prepare_for_sst()
+ {
+ ss.prepare_for_sst();
+ BOOST_REQUIRE(ss.state() == wsrep::server_state::s_joiner);
+ }
+
+ void non_prim()
+ {
+ BOOST_REQUIRE(ss.state() != wsrep::server_state::s_disconnected);
+ std::vector<wsrep::view::member> members;
+ members.push_back(wsrep::view::member(
+ ss.id(), "s1", ""));
+
+ wsrep::view view(wsrep::gtid(), // state_id
+ wsrep::seqno::undefined(), // view seqno
+ wsrep::view::non_primary, // status
+ 0, // capabilities
+ 0, // own_index
+ 0, // protocol ver
+ members // members
+ );
+ ss.on_view(view, &hps);
+ }
+
+ void final_view()
+ {
+ BOOST_REQUIRE(ss.state() != wsrep::server_state::s_disconnected);
+ wsrep::view view(wsrep::gtid(), // state_id
+ wsrep::seqno::undefined(), // view seqno
+ wsrep::view::disconnected, // status
+ 0, // capabilities
+ -1, // own_index
+ 0, // protocol ver
+ std::vector<wsrep::view::member>() // members
+ );
+ ss.on_view(view, &hps);
+ }
+
+ void disconnect()
+ {
+ BOOST_REQUIRE(ss.state() != wsrep::server_state::s_disconnecting);
+ ss.disconnect();
+ BOOST_REQUIRE(ss.state() == wsrep::server_state::s_disconnecting);
+ final_view();
+ BOOST_REQUIRE(ss.state() == wsrep::server_state::s_disconnected);
+ }
+
+ };
+
+ struct applying_server_fixture : server_fixture_base
+ {
+ applying_server_fixture()
+ : server_fixture_base()
+ {
+ ss.mock_connect();
+ }
+ };
+
+ struct sst_first_server_fixture : server_fixture_base
+ {
+ sst_first_server_fixture()
+ : server_fixture_base()
+ {
+ server_service.sst_before_init_ = true;
+ }
+
+ void sst_received_action()
+ {
+ server_service.sync_point_enabled_ = "on_view_wait_initialized";
+ server_service.sync_point_action_ = server_service.spa_initialize;
+ }
+
+ void initialization_failure_action()
+ {
+ server_service.sync_point_enabled_ = "on_view_wait_initialized";
+ server_service.sync_point_action_ =
+ server_service.spa_initialize_error;
+ }
+
+ void clear_sync_point_action()
+ {
+ server_service.sync_point_enabled_ = "";
+ server_service.sync_point_action_ = server_service.spa_none;
+ }
+
+ // Helper method to bootstrap the server with bootstrap view
+ void bootstrap()
+ {
+ connect_in_view(bootstrap_view);
+
+ sst_received_action();
+ ss.on_view(bootstrap_view, &hps);
+ clear_sync_point_action();
+ BOOST_REQUIRE(ss.state() == wsrep::server_state::s_joined);
+ ss.on_sync();
+ BOOST_REQUIRE(ss.state() == wsrep::server_state::s_synced);
+ }
+
+ };
+
+ struct init_first_server_fixture : server_fixture_base
+ {
+ init_first_server_fixture()
+ : server_fixture_base()
+ {
+ server_service.sst_before_init_ = false;
+ }
+
+ // Helper method to bootstrap the server with bootstrap view
+ void bootstrap()
+ {
+ ss.initialized();
+ BOOST_REQUIRE(ss.state() == wsrep::server_state::s_initialized);
+ BOOST_REQUIRE(ss.connect("cluster", "local", "0", false) == 0);
+ ss.on_connect(bootstrap_view);
+ BOOST_REQUIRE(ss.state() == wsrep::server_state::s_connected);
+ ss.on_view(bootstrap_view, &hps);
+ BOOST_REQUIRE(ss.state() == wsrep::server_state::s_joined);
+ ss.on_sync();
+ BOOST_REQUIRE(ss.state() == wsrep::server_state::s_synced);
+ }
+ };
+
+ // Helper to pass to BOOST_REQUIRE_EXCEPTION. Always returns true.
+ bool exception_check(const wsrep::runtime_error&) { return true; }
+}
+
+// Test on_apply() method for 1pc
+BOOST_FIXTURE_TEST_CASE(server_state_applying_1pc,
+ applying_server_fixture)
+{
+ char buf[1] = { 1 };
+ BOOST_REQUIRE(ss.on_apply(hps, ws_handle, ws_meta,
+ wsrep::const_buffer(buf, 1)) == 0);
+ const wsrep::transaction& txc(cc.transaction());
+ // ::abort();
+ BOOST_REQUIRE_MESSAGE(
+ txc.state() == wsrep::transaction::s_committed,
+ "Transaction state " << txc.state() << " not committed");
+}
+
+// Test on_apply() method for 2pc
+BOOST_FIXTURE_TEST_CASE(server_state_applying_2pc,
+ applying_server_fixture)
+{
+ hps.do_2pc_ = true;
+ char buf[1] = { 1 };
+ BOOST_REQUIRE(ss.on_apply(hps, ws_handle, ws_meta,
+ wsrep::const_buffer(buf, 1)) == 0);
+ const wsrep::transaction& txc(cc.transaction());
+ BOOST_REQUIRE(txc.state() == wsrep::transaction::s_committed);
+}
+
+// Test on_apply() method for 1pc transaction which
+// fails applying and rolls back
+BOOST_FIXTURE_TEST_CASE(server_state_applying_1pc_rollback,
+ applying_server_fixture)
+{
+ /* make sure default success result is flipped to error_fatal */
+ ss.provider().commit_order_leave_result_ = wsrep::provider::success;
+ hps.fail_next_applying_ = true;
+ char buf[1] = { 1 };
+ BOOST_REQUIRE(ss.on_apply(hps, ws_handle, ws_meta,
+ wsrep::const_buffer(buf, 1)) == 1);
+ const wsrep::transaction& txc(cc.transaction());
+ BOOST_REQUIRE(txc.state() == wsrep::transaction::s_aborted);
+}
+
+// Test on_apply() method for 2pc transaction which
+// fails applying and rolls back
+BOOST_FIXTURE_TEST_CASE(server_state_applying_2pc_rollback,
+ applying_server_fixture)
+{
+ /* make sure default success result is flipped to error_fatal */
+ ss.provider().commit_order_leave_result_ = wsrep::provider::success;
+ hps.do_2pc_ = true;
+ hps.fail_next_applying_ = true;
+ char buf[1] = { 1 };
+ BOOST_REQUIRE(ss.on_apply(hps, ws_handle, ws_meta,
+ wsrep::const_buffer(buf, 1)) == 1);
+ const wsrep::transaction& txc(cc.transaction());
+ BOOST_REQUIRE(txc.state() == wsrep::transaction::s_aborted);
+}
+
+BOOST_FIXTURE_TEST_CASE(server_state_streaming, applying_server_fixture)
+{
+ ws_meta = wsrep::ws_meta(wsrep::gtid(wsrep::id("1"), wsrep::seqno(1)),
+ wsrep::stid(wsrep::id("1"),
+ wsrep::transaction_id(1),
+ wsrep::client_id(1)),
+ wsrep::seqno(0),
+ wsrep::provider::flag::start_transaction);
+ BOOST_REQUIRE(ss.on_apply(hps, ws_handle, ws_meta,
+ wsrep::const_buffer("1", 1)) == 0);
+ BOOST_REQUIRE(ss.find_streaming_applier(
+ ws_meta.server_id(), ws_meta.transaction_id()));
+ ws_meta = wsrep::ws_meta(wsrep::gtid(wsrep::id("1"), wsrep::seqno(2)),
+ wsrep::stid(wsrep::id("1"),
+ wsrep::transaction_id(1),
+ wsrep::client_id(1)),
+ wsrep::seqno(1),
+ 0);
+ BOOST_REQUIRE(ss.on_apply(hps, ws_handle, ws_meta,
+ wsrep::const_buffer("1", 1)) == 0);
+ ws_meta = wsrep::ws_meta(wsrep::gtid(wsrep::id("1"), wsrep::seqno(2)),
+ wsrep::stid(wsrep::id("1"),
+ wsrep::transaction_id(1),
+ wsrep::client_id(1)),
+ wsrep::seqno(1),
+ wsrep::provider::flag::commit);
+ BOOST_REQUIRE(ss.on_apply(hps, ws_handle, ws_meta,
+ wsrep::const_buffer("1", 1)) == 0);
+ BOOST_REQUIRE(ss.find_streaming_applier(
+ ws_meta.server_id(), ws_meta.transaction_id()) == 0);
+}
+
+
+BOOST_AUTO_TEST_CASE(server_state_state_strings)
+{
+ BOOST_REQUIRE(wsrep::to_string(
+ wsrep::server_state::s_disconnected) == "disconnected");
+ BOOST_REQUIRE(wsrep::to_string(
+ wsrep::server_state::s_initializing) == "initializing");
+ BOOST_REQUIRE(wsrep::to_string(
+ wsrep::server_state::s_initialized) == "initialized");
+ BOOST_REQUIRE(wsrep::to_string(
+ wsrep::server_state::s_connected) == "connected");
+ BOOST_REQUIRE(wsrep::to_string(
+ wsrep::server_state::s_joiner) == "joiner");
+ BOOST_REQUIRE(wsrep::to_string(
+ wsrep::server_state::s_joined) == "joined");
+ BOOST_REQUIRE(wsrep::to_string(
+ wsrep::server_state::s_donor) == "donor");
+ BOOST_REQUIRE(wsrep::to_string(
+ wsrep::server_state::s_synced) == "synced");
+ BOOST_REQUIRE(wsrep::to_string(
+ wsrep::server_state::s_disconnecting) == "disconnecting");
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// Test cases for SST first //
+///////////////////////////////////////////////////////////////////////////////
+
+BOOST_FIXTURE_TEST_CASE(server_state_sst_first_boostrap,
+ sst_first_server_fixture)
+{
+ bootstrap();
+ BOOST_REQUIRE(ss.state() == wsrep::server_state::s_synced);
+}
+
+
+BOOST_FIXTURE_TEST_CASE(server_state_sst_first_join_with_sst,
+ sst_first_server_fixture)
+{
+ connect_in_view(second_view);
+ prepare_for_sst();
+ sst_received_action();
+ // Mock server service get_view() gets view from logged_view_.
+ // Get_view() is called from sst_received(). This emulates the
+ // case where SST contains the view in which SST happens.
+ server_service.logged_view(second_view);
+ server_service.position(wsrep::gtid(cluster_id, wsrep::seqno(2)));
+ BOOST_REQUIRE(ss.sst_received(cc, 0) == 0);
+ clear_sync_point_action();
+ BOOST_REQUIRE(ss.state() == wsrep::server_state::s_joined);
+ ss.on_sync();
+ BOOST_REQUIRE(ss.state() == wsrep::server_state::s_synced);
+}
+
+BOOST_FIXTURE_TEST_CASE(server_state_sst_first_join_with_ist,
+ sst_first_server_fixture)
+{
+ connect_in_view(second_view);
+ // Mock server service get_view() gets view from logged_view_.
+ // Get_view() is called from sst_received(). This emulates the
+ // case where the view is stored in stable storage.
+ server_service.logged_view(second_view);
+ sst_received_action();
+ ss.on_view(second_view, &hps);
+ clear_sync_point_action();
+ BOOST_REQUIRE(ss.state() == wsrep::server_state::s_joined);
+ ss.on_view(third_view, &hps);
+ BOOST_REQUIRE(ss.state() == wsrep::server_state::s_joined);
+ ss.on_sync();
+ BOOST_REQUIRE(ss.state() == wsrep::server_state::s_synced);
+}
+
+
+// Cycle from synced state to disconnected and back to synced. Server
+// storage engines remain initialized.
+BOOST_FIXTURE_TEST_CASE(
+ server_state_sst_first_synced_disconnected_synced_no_sst,
+ sst_first_server_fixture)
+{
+ bootstrap();
+ ss.disconnect();
+ BOOST_REQUIRE(ss.state() == wsrep::server_state::s_disconnecting);
+ final_view();
+ BOOST_REQUIRE(ss.state() == wsrep::server_state::s_disconnected);
+
+ // Connect back as a sole member in the cluster
+ BOOST_REQUIRE(ss.connect("cluster", "local", "0", false) == 0);
+ // @todo: s_connecting state would be good to have
+ BOOST_REQUIRE(ss.state() == wsrep::server_state::s_disconnected);
+ // Server state must keep the initialized state
+ BOOST_REQUIRE(ss.is_initialized() == true);
+ std::vector<wsrep::view::member> members;
+ members.push_back(wsrep::view::member(wsrep::id("s1"), "name", ""));
+ wsrep::view view(wsrep::gtid(cluster_id, wsrep::seqno(1)),
+ wsrep::seqno(2),
+ wsrep::view::primary,
+ 0, // capabilities
+ 0, // own index
+ 1, // protocol version
+ members);
+ ss.on_connect(view);
+ BOOST_REQUIRE(ss.state() == wsrep::server_state::s_connected);
+ // As storage engines have been initialized, there should not be
+ // any reason to wait for initialization. State should jump directly
+ // to s_joined after handling the view.
+ ss.on_view(view, &hps);
+ BOOST_REQUIRE(ss.state() == wsrep::server_state::s_joined);
+ ss.on_sync();
+ BOOST_REQUIRE(ss.state() == wsrep::server_state::s_synced);
+}
+
+//
+// Error after connecting to cluster. This scenario may happen if SST
+// request preparation fails.
+//
+BOOST_FIXTURE_TEST_CASE(
+ server_state_sst_first_error_on_connect,
+ sst_first_server_fixture)
+{
+ connect_in_view(second_view);
+ BOOST_REQUIRE(ss.state() == wsrep::server_state::s_connected);
+ disconnect();
+}
+
+// Error during SST.
+BOOST_FIXTURE_TEST_CASE(
+ server_state_sst_first_error_on_joiner,
+ sst_first_server_fixture)
+{
+ connect_in_view(second_view);
+ ss.prepare_for_sst();
+ BOOST_REQUIRE(ss.state() == wsrep::server_state::s_joiner);
+ server_service.position(wsrep::gtid::undefined());
+ BOOST_REQUIRE(ss.sst_received(cc, 1) == 0);
+ disconnect();
+}
+
+BOOST_FIXTURE_TEST_CASE(
+ server_state_sst_first_error_on_initializing,
+ sst_first_server_fixture)
+{
+ connect_in_view(second_view);
+ ss.prepare_for_sst();
+ BOOST_REQUIRE(ss.state() == wsrep::server_state::s_joiner);
+ initialization_failure_action();
+ server_service.position(wsrep::gtid(second_view.state_id()));
+ BOOST_REQUIRE(ss.sst_received(cc, 0) != 0);
+ BOOST_REQUIRE(ss.state() == wsrep::server_state::s_initializing);
+ BOOST_REQUIRE_EXCEPTION(ss.on_view(second_view, &hps),
+ wsrep::runtime_error, exception_check);
+ BOOST_REQUIRE(ss.state() == wsrep::server_state::s_initializing);
+ disconnect();
+}
+
+// Error or shutdown happens during catchup phase after receiving
+// SST successfully.
+BOOST_FIXTURE_TEST_CASE(
+ server_state_sst_first_error_on_joined,
+ sst_first_server_fixture)
+{
+ connect_in_view(second_view);
+ ss.prepare_for_sst();
+ BOOST_REQUIRE(ss.state() == wsrep::server_state::s_joiner);
+ sst_received_action();
+ // Mock server service get_view() gets view from logged_view_.
+ // Get_view() is called from sst_received(). This emulates the
+ // case where SST contains the view in which SST happens.
+ server_service.logged_view(second_view);
+ server_service.position(wsrep::gtid(cluster_id, wsrep::seqno(2)));
+ BOOST_REQUIRE(ss.sst_received(cc, 0) == 0);
+ clear_sync_point_action();
+ BOOST_REQUIRE(ss.state() == wsrep::server_state::s_joined);
+ disconnect();
+ BOOST_REQUIRE(ss.state() == wsrep::server_state::s_disconnected);
+}
+
+// Error or shutdown happens when donating a snapshot.
+BOOST_FIXTURE_TEST_CASE(
+ server_state_sst_first_error_on_donor,
+ sst_first_server_fixture)
+{
+ bootstrap();
+ ss.start_sst("", wsrep::gtid(cluster_id, wsrep::seqno(2)), false);
+ BOOST_REQUIRE(ss.state() == wsrep::server_state::s_donor);
+ disconnect();
+ BOOST_REQUIRE(ss.state() == wsrep::server_state::s_disconnected);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// Test cases for init first //
+///////////////////////////////////////////////////////////////////////////////
+
+BOOST_FIXTURE_TEST_CASE(server_state_init_first_boostrap,
+ init_first_server_fixture)
+{
+ bootstrap();
+ BOOST_REQUIRE(ss.state() == wsrep::server_state::s_synced);
+}
+
+BOOST_FIXTURE_TEST_CASE(server_state_init_first_join_with_sst,
+ init_first_server_fixture)
+{
+ ss.initialized();
+ BOOST_REQUIRE(ss.state() == wsrep::server_state::s_initialized);
+ connect_in_view(second_view);
+ BOOST_REQUIRE(ss.state() == wsrep::server_state::s_connected);
+ prepare_for_sst();
+ BOOST_REQUIRE(ss.state() == wsrep::server_state::s_joiner);
+ server_service.logged_view(second_view);
+ server_service.position(wsrep::gtid(cluster_id, wsrep::seqno(2)));
+ BOOST_REQUIRE(ss.sst_received(cc, 0) == 0);
+ BOOST_REQUIRE(ss.state() == wsrep::server_state::s_joined);
+ ss.on_sync();
+ BOOST_REQUIRE(ss.state() == wsrep::server_state::s_synced);
+}
+
+BOOST_FIXTURE_TEST_CASE(server_state_init_first_join_with_ist,
+ init_first_server_fixture)
+{
+ ss.initialized();
+ BOOST_REQUIRE(ss.state() == wsrep::server_state::s_initialized);
+ connect_in_view(second_view);
+ BOOST_REQUIRE(ss.state() == wsrep::server_state::s_connected);
+ server_service.logged_view(second_view);
+ ss.on_view(second_view, &hps);
+ BOOST_REQUIRE(ss.state() == wsrep::server_state::s_joined);
+ ss.on_view(third_view, &hps);
+ BOOST_REQUIRE(ss.state() == wsrep::server_state::s_joined);
+ ss.on_sync();
+ BOOST_REQUIRE(ss.state() == wsrep::server_state::s_synced);
+}
+
+
+// Cycle from synced state to disconnected and back to synced. Server
+// storage engines remain initialized.
+BOOST_FIXTURE_TEST_CASE(
+ server_state_init_first_synced_disconnected_synced_no_sst,
+ init_first_server_fixture)
+{
+ bootstrap();
+ ss.disconnect();
+ BOOST_REQUIRE(ss.state() == wsrep::server_state::s_disconnecting);
+ final_view();
+ BOOST_REQUIRE(ss.state() == wsrep::server_state::s_disconnected);
+
+ // Connect back as a sole member in the cluster
+ BOOST_REQUIRE(ss.connect("cluster", "local", "0", false) == 0);
+ // @todo: s_connecting state would be good to have
+ BOOST_REQUIRE(ss.state() == wsrep::server_state::s_disconnected);
+ // Server state must keep the initialized state
+ BOOST_REQUIRE(ss.is_initialized() == true);
+ std::vector<wsrep::view::member> members;
+ members.push_back(wsrep::view::member(wsrep::id("s1"), "name", ""));
+ wsrep::view view(wsrep::gtid(cluster_id, wsrep::seqno(1)),
+ wsrep::seqno(2),
+ wsrep::view::primary,
+ 0, // capabilities
+ 0, // own index
+ 1, // protocol version
+ members);
+ ss.on_connect(view);
+ BOOST_REQUIRE(ss.state() == wsrep::server_state::s_connected);
+ // As storage engines have been initialized, there should not be
+ // any reason to wait for initialization. State should jump directly
+ // to s_joined after handling the view.
+ ss.on_view(view, &hps);
+ BOOST_REQUIRE(ss.state() == wsrep::server_state::s_joined);
+ ss.on_sync();
+ BOOST_REQUIRE(ss.state() == wsrep::server_state::s_synced);
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// Donor state transitions //
+/////////////////////////////////////////////////////////////////////////////
+
+BOOST_FIXTURE_TEST_CASE(
+ server_state_sst_first_donate_success,
+ sst_first_server_fixture)
+{
+ bootstrap();
+ BOOST_REQUIRE(ss.state() == wsrep::server_state::s_synced);
+ ss.start_sst("", wsrep::gtid(cluster_id, wsrep::seqno(2)), false);
+ BOOST_REQUIRE(ss.state() == wsrep::server_state::s_donor);
+ ss.sst_sent(wsrep::gtid(cluster_id, wsrep::seqno(2)), 0);
+ BOOST_REQUIRE(ss.state() == wsrep::server_state::s_joined);
+ ss.on_sync();
+ BOOST_REQUIRE(ss.state() == wsrep::server_state::s_synced);
+}
+
+BOOST_FIXTURE_TEST_CASE(
+ server_state_sst_first_donate_error,
+ sst_first_server_fixture)
+{
+ bootstrap();
+ BOOST_REQUIRE(ss.state() == wsrep::server_state::s_synced);
+ ss.start_sst("", wsrep::gtid(cluster_id, wsrep::seqno(2)), false);
+ BOOST_REQUIRE(ss.state() == wsrep::server_state::s_donor);
+ ss.sst_sent(wsrep::gtid(cluster_id, wsrep::seqno(2)), 1);
+ BOOST_REQUIRE(ss.state() == wsrep::server_state::s_joined);
+ ss.on_sync();
+ BOOST_REQUIRE(ss.state() == wsrep::server_state::s_synced);
+}
+
+BOOST_FIXTURE_TEST_CASE(
+ server_state_sst_first_donor_start_sst_error_in_non_prim,
+ sst_first_server_fixture)
+{
+ bootstrap();
+ BOOST_REQUIRE(ss.state() == wsrep::server_state::s_synced);
+ server_service.start_sst_action = [&]() {
+ non_prim();
+ return 1;
+ };
+ ss.start_sst("", wsrep::gtid(cluster_id, wsrep::seqno(2)), false);
+ BOOST_REQUIRE(ss.state() == wsrep::server_state::s_connected);
+}
+
+BOOST_FIXTURE_TEST_CASE(
+ server_state_sst_first_donor_sst_sent_in_non_prim,
+ sst_first_server_fixture)
+{
+ bootstrap();
+ BOOST_REQUIRE(ss.state() == wsrep::server_state::s_synced);
+ ss.start_sst("", wsrep::gtid(cluster_id, wsrep::seqno(2)), false);
+ BOOST_REQUIRE(ss.state() == wsrep::server_state::s_donor);
+ non_prim();
+ BOOST_REQUIRE(ss.state() == wsrep::server_state::s_connected);
+ ss.sst_sent(wsrep::gtid(cluster_id, wsrep::seqno(2)), 0);
+ // Must stay in connected state
+ BOOST_REQUIRE(ss.state() == wsrep::server_state::s_connected);
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// Pause/Resume and Desync/Resync //
+/////////////////////////////////////////////////////////////////////////////
+
+BOOST_FIXTURE_TEST_CASE(
+ server_state_sst_first_desync_and_pause_resync_and_resume,
+ sst_first_server_fixture)
+{
+ bootstrap();
+ ss.desync_and_pause();
+ // @todo: Should we have here different state than synced
+ BOOST_REQUIRE(ss.state() == wsrep::server_state::s_synced);
+ ss.resume_and_resync();
+ BOOST_REQUIRE(ss.state() == wsrep::server_state::s_synced);
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// Disconnect //
+/////////////////////////////////////////////////////////////////////////////
+
+BOOST_FIXTURE_TEST_CASE(
+ server_state_disconnect,
+ sst_first_server_fixture)
+{
+ bootstrap();
+ ss.disconnect();
+ BOOST_REQUIRE(ss.state() == wsrep::server_state::s_disconnecting);
+ final_view();
+ BOOST_REQUIRE(ss.state() == wsrep::server_state::s_disconnected);
+}
+
+// This test case verifies that the disconnect can be initiated
+// concurrently by several callers. This may happen in failure situations
+// where provider shutdown causes cascading failures and the failing operations
+// try to disconnect the provider.
+BOOST_FIXTURE_TEST_CASE(
+ server_state_disconnect_twice,
+ sst_first_server_fixture)
+{
+ bootstrap();
+ ss.disconnect();
+ BOOST_REQUIRE(ss.state() == wsrep::server_state::s_disconnecting);
+ ss.disconnect();
+ BOOST_REQUIRE(ss.state() == wsrep::server_state::s_disconnecting);
+ final_view();
+ BOOST_REQUIRE(ss.state() == wsrep::server_state::s_disconnected);
+ ss.disconnect();
+ BOOST_REQUIRE(ss.state() == wsrep::server_state::s_disconnected);
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// Orphaned SR //
+/////////////////////////////////////////////////////////////////////////////
+
+// Test the behavior of server_state::close_orphaned_sr_transactions().
+// In this test we check the scenario where we initially have 3 nodes in
+// the cluster (s1, s2, s3), and this server_state delivers one streaming
+// fragment from s2 and s3 each, followed by view changes:
+//
+// view 1: primary (s1, s2, s3)
+// view 2: primary (s1, s2)
+// view 3: non-primary (s1)
+// view 4: non-primary (s1, s3)
+// view 5: primary (s1, s2, s3)
+//
+// We expect that on view 2, transaction originated from s3 is considered
+// orphaned, so it should be rolled back.
+// Transaction from s2 should never be considered orphaned in this scenario,
+// we expect it to survive until the end of the test. That's because
+// transactions are rolled back in primary views only, and because s2
+// is member of all primary views in this scenario.
+BOOST_FIXTURE_TEST_CASE(server_state_close_orphaned_transactions,
+ sst_first_server_fixture)
+{
+ connect_in_view(third_view);
+ server_service.logged_view(third_view);
+ sst_received_action();
+ ss.on_view(third_view, &hps);
+
+ // initially we have members (s1, s2, s3)
+ std::vector<wsrep::view::member> members(ss.current_view().members());
+
+ // apply a fragment coming from s2
+ wsrep::ws_meta meta_s2(wsrep::gtid(wsrep::id("s2"), wsrep::seqno(1)),
+ wsrep::stid(wsrep::id("s2"),
+ wsrep::transaction_id(1),
+ wsrep::client_id(1)),
+ wsrep::seqno(1),
+ wsrep::provider::flag::start_transaction);
+
+ BOOST_REQUIRE(ss.on_apply(hps, ws_handle, meta_s2,
+ wsrep::const_buffer("1", 1)) == 0);
+ BOOST_REQUIRE(ss.find_streaming_applier(
+ meta_s2.server_id(), meta_s2.transaction_id()));
+
+ // apply a fragment coming from s3
+ wsrep::ws_meta meta_s3(wsrep::gtid(wsrep::id("s3"), wsrep::seqno(2)),
+ wsrep::stid(wsrep::id("s3"),
+ wsrep::transaction_id(1),
+ wsrep::client_id(1)),
+ wsrep::seqno(2),
+ wsrep::provider::flag::start_transaction);
+
+ BOOST_REQUIRE(ss.on_apply(hps, ws_handle, meta_s3,
+ wsrep::const_buffer("1", 1)) == 0);
+ BOOST_REQUIRE(ss.find_streaming_applier(
+ meta_s3.server_id(), meta_s3.transaction_id()));
+
+ // s3 drops out of the cluster, deliver primary view (s1, s2)
+ wsrep::view::member s3(members.back());
+ members.pop_back();
+ ss.on_view(wsrep::view(ss.current_view().state_id(),
+ ss.current_view().view_seqno() + 1,
+ wsrep::view::primary,
+ 0, // capabilities
+ 0, // own index
+ 1, // protocol version
+ members), &hps);
+
+ // transaction from s2 is still present
+ BOOST_REQUIRE(ss.find_streaming_applier(
+ meta_s2.server_id(), meta_s2.transaction_id()));
+ // transaction from s3 is gone
+ BOOST_REQUIRE(not ss.find_streaming_applier(
+ meta_s3.server_id(), meta_s3.transaction_id()));
+
+ // s2 drops out of the cluster, deliver non-primary view (s1)
+ wsrep::view::member s2(members.back());
+ members.pop_back();
+ ss.on_view(wsrep::view(ss.current_view().state_id(),
+ ss.current_view().view_seqno(),
+ wsrep::view::non_primary,
+ 0, // capabilities
+ 0, // own index
+ 1, // protocol version
+ members), &hps);
+
+ // no streaming appliers are closed on non-primary view,
+ // so transaction from s2 is still present
+ BOOST_REQUIRE(ss.find_streaming_applier(
+ meta_s2.server_id(), meta_s2.transaction_id()));
+
+ // s3 comes back, deliver non-primary view (s1, s3)
+ members.push_back(s3);
+ ss.on_view(wsrep::view(ss.current_view().state_id(),
+ ss.current_view().view_seqno() + 1,
+ wsrep::view::non_primary,
+ 0, // capabilities
+ 0, // own index
+ 1, // protocol version
+ members), &hps);
+
+ // transaction s2 is still present after non-primary view
+ BOOST_REQUIRE(ss.find_streaming_applier(
+ meta_s2.server_id(), meta_s2.transaction_id()));
+
+ // s2 comes back, deliver primary-view (s1, s2, s3)
+ members.push_back(s2);
+ ss.on_view(wsrep::view(ss.current_view().state_id(),
+ ss.current_view().view_seqno() + 1,
+ wsrep::view::primary,
+ 0, // capabilities
+ 0, // own index
+ 1, // protocol version
+ members), &hps);
+
+ // finally, transaction from s2 is still present (part of primary view)
+ // and transaction from s3 is gone
+ BOOST_REQUIRE(ss.find_streaming_applier(
+ meta_s2.server_id(), meta_s2.transaction_id()));
+ BOOST_REQUIRE(not ss.find_streaming_applier(
+ meta_s3.server_id(), meta_s3.transaction_id()));
+
+ // cleanup
+ wsrep::ws_meta meta_commit_s2(wsrep::gtid(wsrep::id("s2"), wsrep::seqno(3)),
+ wsrep::stid(wsrep::id("s2"),
+ wsrep::transaction_id(1),
+ wsrep::client_id(1)),
+ wsrep::seqno(3),
+ wsrep::provider::flag::commit);
+
+ BOOST_REQUIRE(ss.on_apply(hps, ws_handle, meta_commit_s2,
+ wsrep::const_buffer("1", 1)) == 0);
+
+ BOOST_REQUIRE(not ss.find_streaming_applier(
+ meta_commit_s2.server_id(), meta_commit_s2.transaction_id()));
+}
+
+
+// Test the case where two consecutive primary views with the
+// same members are delivered (provider may do so).
+// Expect SR transactions to be rolled back on equal consecutive views
+BOOST_FIXTURE_TEST_CASE(server_state_equal_consecutive_views,
+ sst_first_server_fixture)
+{
+ connect_in_view(third_view);
+ server_service.logged_view(third_view);
+ sst_received_action();
+ ss.on_view(third_view, &hps);
+
+ // apply a fragment coming from s2
+ wsrep::ws_meta meta_s2(wsrep::gtid(wsrep::id("s2"), wsrep::seqno(1)),
+ wsrep::stid(wsrep::id("s2"),
+ wsrep::transaction_id(1),
+ wsrep::client_id(1)),
+ wsrep::seqno(1),
+ wsrep::provider::flag::start_transaction);
+
+ BOOST_REQUIRE(ss.on_apply(hps, ws_handle, meta_s2,
+ wsrep::const_buffer("1", 1)) == 0);
+ BOOST_REQUIRE(ss.find_streaming_applier(
+ meta_s2.server_id(), meta_s2.transaction_id()));
+
+ // apply a fragment coming from s3
+ wsrep::ws_meta meta_s3(wsrep::gtid(wsrep::id("s3"), wsrep::seqno(2)),
+ wsrep::stid(wsrep::id("s3"),
+ wsrep::transaction_id(1),
+ wsrep::client_id(1)),
+ wsrep::seqno(2),
+ wsrep::provider::flag::start_transaction);
+
+ BOOST_REQUIRE(ss.on_apply(hps, ws_handle, meta_s3,
+ wsrep::const_buffer("1", 1)) == 0);
+ BOOST_REQUIRE(ss.find_streaming_applier(
+ meta_s3.server_id(), meta_s3.transaction_id()));
+
+ // deliver primary view with the same members (s1, s2, s3)
+ ss.on_view(wsrep::view(ss.current_view().state_id(),
+ ss.current_view().view_seqno() + 1,
+ wsrep::view::primary,
+ 0, // capabilities
+ 0, // own index
+ 1, // protocol version
+ ss.current_view().members()), &hps);
+
+ // transaction from s2 and s3 are gone
+ BOOST_REQUIRE(not ss.find_streaming_applier(
+ meta_s2.server_id(), meta_s2.transaction_id()));
+ BOOST_REQUIRE(not ss.find_streaming_applier(
+ meta_s3.server_id(), meta_s3.transaction_id()));
+}
+
+// Verify that prepared XA transactions are not rolled back
+// by close_orphaned_transactions()
+BOOST_FIXTURE_TEST_CASE(server_state_xa_not_orphaned,
+ sst_first_server_fixture)
+{
+ connect_in_view(third_view);
+ server_service.logged_view(third_view);
+ sst_received_action();
+ ss.on_view(third_view, &hps);
+
+ // initially we have members (s1, s2, s3)
+ std::vector<wsrep::view::member> members(ss.current_view().members());
+
+
+ wsrep::ws_meta meta_s3(wsrep::gtid(wsrep::id("s3"), wsrep::seqno(1)),
+ wsrep::stid(wsrep::id("s3"),
+ wsrep::transaction_id(1),
+ wsrep::client_id(1)),
+ wsrep::seqno(1),
+ wsrep::provider::flag::start_transaction |
+ wsrep::provider::flag::prepare);
+
+ BOOST_REQUIRE(ss.on_apply(hps, ws_handle, meta_s3,
+ wsrep::const_buffer("1", 1)) == 0);
+ BOOST_REQUIRE(ss.find_streaming_applier(
+ meta_s3.server_id(), meta_s3.transaction_id()));
+
+
+ // s3 drops out of the cluster, deliver primary view (s1, s2)
+ wsrep::view::member s3(members.back());
+ members.pop_back();
+ ss.on_view(wsrep::view(ss.current_view().state_id(),
+ ss.current_view().view_seqno() + 1,
+ wsrep::view::primary,
+ 0, // capabilities
+ 0, // own index
+ 1, // protocol version
+ members), &hps);
+
+ // transaction from s3 is still present
+ BOOST_REQUIRE(ss.find_streaming_applier(
+ meta_s3.server_id(), meta_s3.transaction_id()));
+
+ // s3 comes back, deliver primary view (s1, s2, s3)
+ members.push_back(s3);
+ ss.on_view(wsrep::view(ss.current_view().state_id(),
+ ss.current_view().view_seqno() + 1,
+ wsrep::view::primary,
+ 0, // capabilities
+ 0, // own index
+ 1, // protocol version
+ members), &hps);
+
+ // transaction from s3 is still present
+ BOOST_REQUIRE(ss.find_streaming_applier(
+ meta_s3.server_id(), meta_s3.transaction_id()));
+
+ // cleanup
+ wsrep::ws_meta meta_commit_s3(wsrep::gtid(wsrep::id("s3"), wsrep::seqno(3)),
+ wsrep::stid(wsrep::id("s3"),
+ wsrep::transaction_id(1),
+ wsrep::client_id(1)),
+ wsrep::seqno(3),
+ wsrep::provider::flag::commit);
+
+ BOOST_REQUIRE(ss.on_apply(hps, ws_handle, meta_commit_s3,
+ wsrep::const_buffer("1", 1)) == 0);
+ BOOST_REQUIRE(not ss.find_streaming_applier(
+ meta_commit_s3.server_id(), meta_commit_s3.transaction_id()));
+}
diff --git a/wsrep-lib/test/test_utils.cpp b/wsrep-lib/test/test_utils.cpp
new file mode 100644
index 00000000..02e88cf0
--- /dev/null
+++ b/wsrep-lib/test/test_utils.cpp
@@ -0,0 +1,75 @@
+/*
+ * Copyright (C) 2018 Codership Oy <info@codership.com>
+ *
+ * This file is part of wsrep-lib.
+ *
+ * Wsrep-lib is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * Wsrep-lib is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with wsrep-lib. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include "test_utils.hpp"
+#include "wsrep/client_state.hpp"
+#include "mock_server_state.hpp"
+
+
+// Simple BF abort method to BF abort unordered transasctions
+void wsrep_test::bf_abort_unordered(wsrep::client_state& cc)
+{
+ assert(cc.transaction().ordered() == false);
+ cc.bf_abort(wsrep::seqno(1));
+}
+
+void wsrep_test::bf_abort_ordered(wsrep::client_state& cc)
+{
+ assert(cc.transaction().ordered());
+ cc.bf_abort(wsrep::seqno(0));
+}
+
+void wsrep_test::bf_abort_in_total_order(wsrep::client_state& cc)
+{
+ cc.total_order_bf_abort(wsrep::seqno(0));
+}
+// BF abort method to abort transactions via provider
+void wsrep_test::bf_abort_provider(wsrep::mock_server_state& sc,
+ const wsrep::transaction& tc,
+ wsrep::seqno bf_seqno)
+{
+ wsrep::seqno victim_seqno;
+ sc.provider().bf_abort(bf_seqno, tc.id(), victim_seqno);
+ (void)victim_seqno;
+}
+
+void wsrep_test::terminate_streaming_applier(
+ wsrep::mock_server_state& sc,
+ const wsrep::id& server_id,
+ wsrep::transaction_id transaction_id)
+{
+ // Note that all other arguments than server_id and
+ // transaction_id are chosen arbitrarily and it is hoped
+ // that the mock implementation does not freak out about it.
+ wsrep::mock_client mc(sc, wsrep::client_id(10),
+ wsrep::client_state::m_high_priority);
+ mc.open(wsrep::client_id(10));
+ mc.before_command();
+ wsrep::mock_high_priority_service hps(sc, &mc, false);
+ wsrep::ws_handle ws_handle(transaction_id, (void*)(1));
+ wsrep::ws_meta ws_meta(wsrep::gtid(wsrep::id("cluster1"),
+ wsrep::seqno(100)),
+ wsrep::stid(server_id,
+ transaction_id,
+ wsrep::client_id(1)),
+ wsrep::seqno(0),
+ wsrep::provider::flag::rollback);
+ wsrep::const_buffer data(0, 0);
+ sc.on_apply(hps, ws_handle, ws_meta, data);
+}
diff --git a/wsrep-lib/test/test_utils.hpp b/wsrep-lib/test/test_utils.hpp
new file mode 100644
index 00000000..7e4c896d
--- /dev/null
+++ b/wsrep-lib/test/test_utils.hpp
@@ -0,0 +1,55 @@
+/*
+ * Copyright (C) 2018 Codership Oy <info@codership.com>
+ *
+ * This file is part of wsrep-lib.
+ *
+ * Wsrep-lib is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * Wsrep-lib is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with wsrep-lib. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+// Forward declarations
+namespace wsrep
+{
+ class client_state;
+ class mock_server_state;
+}
+
+#include "wsrep/transaction.hpp"
+#include "wsrep/provider.hpp"
+
+//
+// Utility functions
+//
+namespace wsrep_test
+{
+
+ // Simple BF abort method to BF abort unordered transasctions
+ void bf_abort_unordered(wsrep::client_state& cc);
+
+ // Simple BF abort method to BF abort unordered transasctions
+ void bf_abort_ordered(wsrep::client_state& cc);
+
+ // BF abort method to abort transactions via provider
+ void bf_abort_provider(wsrep::mock_server_state& sc,
+ const wsrep::transaction& tc,
+ wsrep::seqno bf_seqno);
+
+ // BF abort in total order
+ void bf_abort_in_total_order(wsrep::client_state&);
+
+ // Terminate streaming applier by applying rollback fragment.
+ void terminate_streaming_applier(
+ wsrep::mock_server_state& sc,
+ const wsrep::id& server_id,
+ wsrep::transaction_id transaction_id);
+}
diff --git a/wsrep-lib/test/toi_test.cpp b/wsrep-lib/test/toi_test.cpp
new file mode 100644
index 00000000..e6370170
--- /dev/null
+++ b/wsrep-lib/test/toi_test.cpp
@@ -0,0 +1,66 @@
+/*
+ * Copyright (C) 2019 Codership Oy <info@codership.com>
+ *
+ * This file is part of wsrep-lib.
+ *
+ * Wsrep-lib is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * Wsrep-lib is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with wsrep-lib. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include "wsrep/client_state.hpp"
+
+#include "client_state_fixture.hpp"
+
+#include <boost/test/unit_test.hpp>
+
+BOOST_FIXTURE_TEST_CASE(test_toi_mode,
+ replicating_client_fixture_sync_rm)
+{
+ BOOST_REQUIRE(cc.mode() == wsrep::client_state::m_local);
+ BOOST_REQUIRE(cc.toi_mode() == wsrep::client_state::m_undefined);
+ wsrep::key key(wsrep::key::exclusive);
+ key.append_key_part("k1", 2);
+ key.append_key_part("k2", 2);
+ wsrep::key_array keys{key};
+ wsrep::const_buffer buf("toi", 3);
+ BOOST_REQUIRE(cc.enter_toi_local(keys, buf) == 0);
+ BOOST_REQUIRE(cc.mode() == wsrep::client_state::m_toi);
+ BOOST_REQUIRE(cc.in_toi());
+ BOOST_REQUIRE(cc.toi_mode() == wsrep::client_state::m_local);
+ wsrep::mutable_buffer err;
+ BOOST_REQUIRE(cc.leave_toi_local(err) == 0);
+ BOOST_REQUIRE(cc.mode() == wsrep::client_state::m_local);
+ BOOST_REQUIRE(cc.toi_mode() == wsrep::client_state::m_undefined);
+ BOOST_REQUIRE(sc.provider().toi_write_sets() == 1);
+ BOOST_REQUIRE(sc.provider().toi_start_transaction() == 1);
+ BOOST_REQUIRE(sc.provider().toi_commit() == 1);
+}
+
+BOOST_FIXTURE_TEST_CASE(test_toi_applying,
+ applying_client_fixture)
+{
+ BOOST_REQUIRE(cc.toi_mode() == wsrep::client_state::m_undefined);
+ wsrep::ws_meta ws_meta(wsrep::gtid(wsrep::id("1"), wsrep::seqno(2)),
+ wsrep::stid(sc.id(),
+ wsrep::transaction_id::undefined(),
+ cc.id()),
+ wsrep::seqno(1),
+ wsrep::provider::flag::start_transaction |
+ wsrep::provider::flag::commit);
+ cc.enter_toi_mode(ws_meta);
+ BOOST_REQUIRE(cc.in_toi());
+ BOOST_REQUIRE(cc.toi_mode() == wsrep::client_state::m_high_priority);
+ cc.leave_toi_mode();
+ BOOST_REQUIRE(cc.toi_mode() == wsrep::client_state::m_undefined);
+ cc.after_applying();
+}
diff --git a/wsrep-lib/test/transaction_test.cpp b/wsrep-lib/test/transaction_test.cpp
new file mode 100644
index 00000000..3efd038d
--- /dev/null
+++ b/wsrep-lib/test/transaction_test.cpp
@@ -0,0 +1,1763 @@
+/*
+ * Copyright (C) 2018-2019 Codership Oy <info@codership.com>
+ *
+ * This file is part of wsrep-lib.
+ *
+ * Wsrep-lib is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * Wsrep-lib is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with wsrep-lib. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include "wsrep/transaction.hpp"
+#include "wsrep/provider.hpp"
+
+#include "test_utils.hpp"
+#include "client_state_fixture.hpp"
+
+#include <boost/mpl/vector.hpp>
+
+namespace
+{
+ typedef
+ boost::mpl::vector<replicating_client_fixture_sync_rm,
+ replicating_client_fixture_async_rm>
+ replicating_fixtures;
+}
+
+BOOST_FIXTURE_TEST_CASE(transaction_append_key_data,
+ replicating_client_fixture_sync_rm)
+{
+ cc.start_transaction(wsrep::transaction_id(1));
+ BOOST_REQUIRE(tc.active());
+ BOOST_REQUIRE(tc.is_empty());
+ int vals[3] = {1, 2, 3};
+ wsrep::key key(wsrep::key::exclusive);
+ for (int i(0); i < 3; ++i)
+ {
+ key.append_key_part(&vals[i], sizeof(vals[i]));
+ }
+ BOOST_REQUIRE(cc.append_key(key) == 0);
+ BOOST_REQUIRE(tc.is_empty() == false);
+ wsrep::const_buffer data(&vals[2], sizeof(vals[2]));
+ BOOST_REQUIRE(cc.append_data(data) == 0);
+ BOOST_REQUIRE(cc.before_commit() == 0);
+ BOOST_REQUIRE(cc.ordered_commit() == 0);
+ BOOST_REQUIRE(cc.after_commit() == 0);
+ cc.after_statement();
+}
+//
+// Test a succesful 1PC transaction lifecycle
+//
+BOOST_FIXTURE_TEST_CASE_TEMPLATE(transaction_1pc, T,
+ replicating_fixtures, T)
+{
+ wsrep::mock_client& cc(T::cc);
+ const wsrep::transaction& tc(T::tc);
+ // Start a new transaction with ID 1
+ cc.start_transaction(wsrep::transaction_id(1));
+ BOOST_REQUIRE(tc.active());
+ BOOST_REQUIRE(tc.id() == wsrep::transaction_id(1));
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_executing);
+
+ // Establish default read view
+ BOOST_REQUIRE(0 == cc.assign_read_view(NULL));
+
+ // Verify that the commit can be successfully executed in separate command
+ BOOST_REQUIRE(cc.after_statement() == 0);
+ cc.after_command_before_result();
+ cc.after_command_after_result();
+ BOOST_REQUIRE(cc.current_error() == wsrep::e_success);
+ BOOST_REQUIRE(cc.before_command() == 0);
+ BOOST_REQUIRE(cc.before_statement() == 0);
+ // Run before commit
+ BOOST_REQUIRE(cc.before_commit() == 0);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_committing);
+
+ // Run ordered commit
+ BOOST_REQUIRE(cc.ordered_commit() == 0);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_ordered_commit);
+
+ // Run after commit
+ BOOST_REQUIRE(cc.after_commit() == 0);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_committed);
+
+ // Cleanup after statement
+ cc.after_statement();
+ BOOST_REQUIRE(tc.active() == false);
+ BOOST_REQUIRE(tc.ordered() == false);
+ BOOST_REQUIRE(tc.certified() == false);
+ BOOST_REQUIRE(cc.current_error() == wsrep::e_success);
+}
+
+
+//
+// Test a voluntary rollback
+//
+BOOST_FIXTURE_TEST_CASE_TEMPLATE(transaction_rollback, T,
+ replicating_fixtures, T)
+{
+ wsrep::mock_client& cc(T::cc);
+ const wsrep::transaction& tc(T::tc);
+
+ // Start a new transaction with ID 1
+ cc.start_transaction(wsrep::transaction_id(1));
+ BOOST_REQUIRE(tc.active());
+ BOOST_REQUIRE(tc.id() == wsrep::transaction_id(1));
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_executing);
+
+ // Run before commit
+ BOOST_REQUIRE(cc.before_rollback() == 0);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_aborting);
+
+ // Run after commit
+ BOOST_REQUIRE(cc.after_rollback() == 0);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_aborted);
+
+ // Cleanup after statement
+ cc.after_statement();
+ BOOST_REQUIRE(tc.active() == false);
+ BOOST_REQUIRE(tc.ordered() == false);
+ BOOST_REQUIRE(tc.certified() == false);
+ BOOST_REQUIRE(cc.current_error() == wsrep::e_success);
+}
+
+//
+// Test a 1PC transaction which gets BF aborted before before_commit
+//
+BOOST_FIXTURE_TEST_CASE_TEMPLATE(
+ transaction_1pc_bf_before_before_commit, T,
+ replicating_fixtures, T)
+{
+ wsrep::mock_client& cc(T::cc);
+ const wsrep::transaction& tc(T::tc);
+
+ // Start a new transaction with ID 1
+ cc.start_transaction(wsrep::transaction_id(1));
+ BOOST_REQUIRE(tc.active());
+ BOOST_REQUIRE(tc.id() == wsrep::transaction_id(1));
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_executing);
+
+ wsrep_test::bf_abort_unordered(cc);
+
+ // Run before commit
+ BOOST_REQUIRE(cc.before_commit());
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_must_abort);
+ BOOST_REQUIRE(tc.certified() == false);
+ BOOST_REQUIRE(tc.ordered() == false);
+
+ // Rollback sequence
+ BOOST_REQUIRE(cc.before_rollback() == 0);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_aborting);
+ BOOST_REQUIRE(cc.after_rollback() == 0);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_aborted);
+
+ // Cleanup after statement
+ cc.after_statement();
+ BOOST_REQUIRE(tc.active() == false);
+ BOOST_REQUIRE(tc.ordered() == false);
+ BOOST_REQUIRE(tc.certified() == false);
+ BOOST_REQUIRE(cc.current_error());
+}
+
+
+
+//
+// Test a 1PC transaction which gets BF aborted during before_commit via
+// provider before the write set was ordered and certified.
+//
+BOOST_FIXTURE_TEST_CASE_TEMPLATE(
+ transaction_1pc_bf_during_before_commit_uncertified, T,
+ replicating_fixtures, T)
+{
+ wsrep::mock_server_state& sc(T::sc);
+ wsrep::mock_client& cc(T::cc);
+ const wsrep::transaction& tc(T::tc);
+
+ // Start a new transaction with ID 1
+ cc.start_transaction(wsrep::transaction_id(1));
+ BOOST_REQUIRE(tc.active());
+ BOOST_REQUIRE(tc.id() == wsrep::transaction_id(1));
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_executing);
+
+ wsrep_test::bf_abort_provider(sc, tc, wsrep::seqno::undefined());
+
+ // Run before commit
+ BOOST_REQUIRE(cc.before_commit());
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_cert_failed);
+ BOOST_REQUIRE(tc.certified() == false);
+ BOOST_REQUIRE(tc.ordered() == false);
+
+ // Rollback sequence
+ BOOST_REQUIRE(cc.before_rollback() == 0);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_aborting);
+ BOOST_REQUIRE(cc.after_rollback() == 0);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_aborted);
+
+ // Cleanup after statement
+ cc.after_statement();
+ BOOST_REQUIRE(tc.active() == false);
+ BOOST_REQUIRE(tc.ordered() == false);
+ BOOST_REQUIRE(tc.certified() == false);
+ BOOST_REQUIRE(cc.current_error());
+}
+
+//
+// Test a 1PC transaction which gets BF aborted during before_commit
+// when waiting for replayers
+//
+BOOST_FIXTURE_TEST_CASE_TEMPLATE(
+ transaction_1pc_bf_during_commit_wait_for_replayers, T,
+ replicating_fixtures, T)
+{
+ wsrep::mock_client& cc(T::cc);
+ const wsrep::transaction& tc(T::tc);
+
+ // Start a new transaction with ID 1
+ cc.start_transaction(wsrep::transaction_id(1));
+ BOOST_REQUIRE(tc.active());
+ BOOST_REQUIRE(tc.id() == wsrep::transaction_id(1));
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_executing);
+
+ cc.bf_abort_during_wait_ = true;
+
+ // Run before commit
+ BOOST_REQUIRE(cc.before_commit());
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_must_abort);
+ BOOST_REQUIRE(tc.certified() == false);
+ BOOST_REQUIRE(tc.ordered() == false);
+
+ // Rollback sequence
+ BOOST_REQUIRE(cc.before_rollback() == 0);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_aborting);
+ BOOST_REQUIRE(cc.after_rollback() == 0);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_aborted);
+
+ // Cleanup after statement
+ cc.after_statement();
+ BOOST_REQUIRE(tc.active() == false);
+ BOOST_REQUIRE(tc.ordered() == false);
+ BOOST_REQUIRE(tc.certified() == false);
+ BOOST_REQUIRE(cc.current_error());
+}
+
+BOOST_FIXTURE_TEST_CASE_TEMPLATE(
+ transaction_1pc_bf_during_commit_order_enter, T,
+ replicating_fixtures, T)
+{
+ wsrep::mock_client& cc(T::cc);
+ const wsrep::transaction& tc(T::tc);
+ auto& sc(T::sc);
+
+ // Start a new transaction with ID 1
+ cc.start_transaction(wsrep::transaction_id(1));
+ BOOST_REQUIRE(tc.active());
+ BOOST_REQUIRE(tc.id() == wsrep::transaction_id(1));
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_executing);
+
+ sc.provider().commit_order_enter_result_ = wsrep::provider::error_bf_abort;
+
+ // Run before commit
+ BOOST_REQUIRE(cc.before_commit());
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_must_replay);
+ BOOST_REQUIRE(cc.will_replay_called() == true);
+ BOOST_REQUIRE(tc.certified() == true);
+ BOOST_REQUIRE(tc.ordered() == true);
+
+ sc.provider().commit_order_enter_result_ = wsrep::provider::success;
+
+ // Rollback sequence
+ BOOST_REQUIRE(cc.before_rollback() == 0);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_must_replay);
+ BOOST_REQUIRE(cc.after_rollback() == 0);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_must_replay);
+
+ // Replay from after_statement()
+ cc.after_statement();
+ BOOST_REQUIRE(cc.replays() > 0);
+ BOOST_REQUIRE(tc.active() == false);
+ BOOST_REQUIRE(tc.ordered() == false);
+ BOOST_REQUIRE(tc.certified() == false);
+ BOOST_REQUIRE(not cc.current_error());
+}
+
+BOOST_FIXTURE_TEST_CASE(
+ transaction_1pc_bf_after_before_commit,
+ replicating_client_fixture_async_rm)
+{
+ // Start a new transaction with ID 1
+ cc.start_transaction(wsrep::transaction_id(1));
+ BOOST_REQUIRE(tc.active());
+ BOOST_REQUIRE(tc.id() == wsrep::transaction_id(1));
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_executing);
+
+ // Run before commit
+ BOOST_REQUIRE(cc.before_commit() == 0);
+ BOOST_REQUIRE_EQUAL(tc.state(), wsrep::transaction::s_committing);
+ BOOST_REQUIRE(tc.certified() == true);
+ BOOST_REQUIRE(tc.ordered() == true);
+
+ wsrep_test::bf_abort_ordered(cc);
+ BOOST_REQUIRE_EQUAL(tc.state(), wsrep::transaction::s_committing);
+
+ // Clean up
+ cc.ordered_commit();
+ cc.after_commit();
+ cc.after_statement();
+}
+
+
+//
+// Test a 1PC transaction for which prepare data fails
+//
+BOOST_FIXTURE_TEST_CASE_TEMPLATE(
+ transaction_1pc_error_during_prepare_data, T,
+ replicating_fixtures, T)
+{
+ wsrep::mock_client& cc(T::cc);
+ const wsrep::transaction& tc(T::tc);
+
+ // Start a new transaction with ID 1
+ cc.start_transaction(wsrep::transaction_id(1));
+ BOOST_REQUIRE(tc.active());
+ BOOST_REQUIRE(tc.id() == wsrep::transaction_id(1));
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_executing);
+
+ cc.error_during_prepare_data_ = true;
+
+ // Run before commit
+ BOOST_REQUIRE(cc.before_commit());
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_must_abort);
+ BOOST_REQUIRE(cc.current_error() == wsrep::e_size_exceeded_error);
+ BOOST_REQUIRE(tc.certified() == false);
+ BOOST_REQUIRE(tc.ordered() == false);
+
+ // Rollback sequence
+ BOOST_REQUIRE(cc.before_rollback() == 0);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_aborting);
+ BOOST_REQUIRE(cc.after_rollback() == 0);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_aborted);
+
+ // Cleanup after statement
+ cc.after_statement();
+ BOOST_REQUIRE(tc.active() == false);
+ BOOST_REQUIRE(tc.ordered() == false);
+ BOOST_REQUIRE(tc.certified() == false);
+ BOOST_REQUIRE(cc.current_error());
+}
+
+//
+// Test a 1PC transaction which gets killed by DBMS before certification
+//
+BOOST_FIXTURE_TEST_CASE_TEMPLATE(
+ transaction_1pc_killed_before_certify, T,
+ replicating_fixtures, T)
+{
+ wsrep::mock_client& cc(T::cc);
+ const wsrep::transaction& tc(T::tc);
+
+ // Start a new transaction with ID 1
+ cc.start_transaction(wsrep::transaction_id(1));
+ BOOST_REQUIRE(tc.active());
+ BOOST_REQUIRE(tc.id() == wsrep::transaction_id(1));
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_executing);
+
+ cc.killed_before_certify_ = true;
+
+ // Run before commit
+ BOOST_REQUIRE(cc.before_commit());
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_must_abort);
+ BOOST_REQUIRE(cc.current_error() == wsrep::e_interrupted_error);
+ BOOST_REQUIRE(tc.certified() == false);
+ BOOST_REQUIRE(tc.ordered() == false);
+
+ // Rollback sequence
+ BOOST_REQUIRE(cc.before_rollback() == 0);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_aborting);
+ BOOST_REQUIRE(cc.after_rollback() == 0);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_aborted);
+
+ // Cleanup after statement
+ cc.after_statement();
+ BOOST_REQUIRE(tc.active() == false);
+ BOOST_REQUIRE(tc.ordered() == false);
+ BOOST_REQUIRE(tc.certified() == false);
+ BOOST_REQUIRE(cc.current_error());
+}
+
+//
+// Test a transaction which gets BF aborted inside provider before
+// certification result is known. Replaying will be successful
+//
+BOOST_FIXTURE_TEST_CASE(
+ transaction_bf_before_cert_result_replay_success,
+ replicating_client_fixture_sync_rm)
+{
+ BOOST_REQUIRE(cc.start_transaction(wsrep::transaction_id(1)) == 0);
+ sc.provider().certify_result_ = wsrep::provider::error_bf_abort;
+ sc.provider().replay_result_ = wsrep::provider::success;
+
+ BOOST_REQUIRE(cc.before_commit());
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_must_replay);
+ BOOST_REQUIRE(cc.will_replay_called() == true);
+ BOOST_REQUIRE(cc.after_statement() == 0);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_committed);
+ BOOST_REQUIRE(cc.current_error() == wsrep::e_success);
+}
+
+//
+// Test a transaction which gets BF aborted inside provider before
+// certification result is known. Replaying will fail because of
+// certification failure.
+//
+BOOST_FIXTURE_TEST_CASE(
+ transaction_bf_before_cert_result_replay_cert_fail,
+ replicating_client_fixture_sync_rm)
+{
+ BOOST_REQUIRE(cc.start_transaction(wsrep::transaction_id(1)) == 0);
+ sc.provider().certify_result_ = wsrep::provider::error_bf_abort;
+ sc.provider().replay_result_ = wsrep::provider::error_certification_failed;
+
+ BOOST_REQUIRE(cc.before_commit());
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_must_replay);
+ BOOST_REQUIRE(cc.will_replay_called() == true);
+ BOOST_REQUIRE(cc.after_statement() );
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_aborted);
+ BOOST_REQUIRE(cc.current_error() == wsrep::e_deadlock_error);
+ BOOST_REQUIRE(tc.active() == false);
+}
+
+//
+// Test a 1PC transaction which gets BF aborted during before_commit via
+// provider after the write set was ordered and certified. This must
+// result replaying of transaction.
+//
+BOOST_FIXTURE_TEST_CASE_TEMPLATE(
+ transaction_1pc_bf_during_before_commit_certified, T,
+ replicating_fixtures, T)
+{
+ wsrep::mock_server_state& sc(T::sc);
+ wsrep::mock_client& cc(T::cc);
+ const wsrep::transaction& tc(T::tc);
+
+ // Start a new transaction with ID 1
+ cc.start_transaction(wsrep::transaction_id(1));
+ BOOST_REQUIRE(tc.active());
+ BOOST_REQUIRE(tc.id() == wsrep::transaction_id(1));
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_executing);
+
+ wsrep_test::bf_abort_provider(sc, tc, wsrep::seqno(1));
+
+ // Run before commit
+ BOOST_REQUIRE(cc.before_commit());
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_must_replay);
+ BOOST_REQUIRE(cc.will_replay_called() == true);
+ BOOST_REQUIRE(tc.certified() == false);
+ BOOST_REQUIRE(tc.ordered() == true);
+
+ // Rollback sequence
+ BOOST_REQUIRE(cc.before_rollback() == 0);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_must_replay);
+ BOOST_REQUIRE(cc.after_rollback() == 0);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_must_replay);
+
+ // Cleanup after statement
+ cc.after_statement();
+ BOOST_REQUIRE(tc.active() == false);
+ BOOST_REQUIRE(tc.ordered() == false);
+ BOOST_REQUIRE(tc.certified() == false);
+ BOOST_REQUIRE(cc.current_error() == wsrep::e_success);
+ BOOST_REQUIRE(cc.replays() == 1);
+}
+
+//
+// Test a 1PC transaction which gets BF aborted simultaneously with
+// certification failure. BF abort should not succeed as the
+// transaction is going to roll back anyway. Certification failure
+// should not generate seqno for write set meta.
+//
+BOOST_FIXTURE_TEST_CASE_TEMPLATE(
+ transaction_1pc_bf_before_unordered_cert_failure, T,
+ replicating_fixtures, T)
+{
+ wsrep::mock_server_state& sc(T::sc);
+ wsrep::mock_client& cc(T::cc);
+ const wsrep::transaction& tc(T::tc);
+
+ cc.start_transaction(wsrep::transaction_id(1));
+ BOOST_REQUIRE(tc.active());
+ BOOST_REQUIRE(tc.id() == wsrep::transaction_id(1));
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_executing);
+ cc.sync_point_enabled_ = "wsrep_before_certification";
+ cc.sync_point_action_ = wsrep::mock_client_service::spa_bf_abort_unordered;
+ sc.provider().certify_result_ = wsrep::provider::error_certification_failed;
+ BOOST_REQUIRE(cc.before_commit());
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_cert_failed);
+ BOOST_REQUIRE(tc.certified() == false);
+ BOOST_REQUIRE(tc.ordered() == false);
+ BOOST_REQUIRE(cc.before_rollback() == 0);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_aborting);
+ BOOST_REQUIRE(cc.after_rollback() == 0);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_aborted);
+ BOOST_REQUIRE(cc.after_statement() );
+ BOOST_REQUIRE(tc.active() == false);
+ BOOST_REQUIRE(tc.ordered() == false);
+ BOOST_REQUIRE(tc.certified() == false);
+ BOOST_REQUIRE(cc.current_error() == wsrep::e_deadlock_error);
+}
+
+//
+// Test a 1PC transaction which gets "warning error" from certify call
+//
+BOOST_FIXTURE_TEST_CASE_TEMPLATE(
+ transaction_1pc_warning_error_from_certify, T,
+ replicating_fixtures, T)
+{
+ wsrep::mock_server_state& sc(T::sc);
+ wsrep::mock_client& cc(T::cc);
+ const wsrep::transaction& tc(T::tc);
+
+ // Start a new transaction with ID 1
+ cc.start_transaction(wsrep::transaction_id(1));
+ BOOST_REQUIRE(tc.active());
+ BOOST_REQUIRE(tc.id() == wsrep::transaction_id(1));
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_executing);
+
+ sc.provider().certify_result_ = wsrep::provider::error_warning;
+
+ // Run before commit
+ BOOST_REQUIRE(cc.before_commit());
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_must_abort);
+ BOOST_REQUIRE(tc.certified() == false);
+ BOOST_REQUIRE(tc.ordered() == false);
+
+ sc.provider().certify_result_ = wsrep::provider::success;
+
+ // Rollback sequence
+ BOOST_REQUIRE(cc.before_rollback() == 0);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_aborting);
+ BOOST_REQUIRE(cc.after_rollback() == 0);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_aborted);
+
+ // Cleanup after statement
+ cc.after_statement();
+ BOOST_REQUIRE(tc.active() == false);
+ BOOST_REQUIRE(tc.ordered() == false);
+ BOOST_REQUIRE(tc.certified() == false);
+ BOOST_REQUIRE(cc.current_error() == wsrep::e_error_during_commit);
+}
+
+//
+// Test a 1PC transaction which gets transaction missing from certify call
+//
+BOOST_FIXTURE_TEST_CASE_TEMPLATE(
+ transaction_1pc_transaction_missing_from_certify, T,
+ replicating_fixtures, T)
+{
+ wsrep::mock_server_state& sc(T::sc);
+ wsrep::mock_client& cc(T::cc);
+ const wsrep::transaction& tc(T::tc);
+
+ // Start a new transaction with ID 1
+ cc.start_transaction(wsrep::transaction_id(1));
+ BOOST_REQUIRE(tc.active());
+ BOOST_REQUIRE(tc.id() == wsrep::transaction_id(1));
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_executing);
+
+ sc.provider().certify_result_ = wsrep::provider::error_transaction_missing;
+
+ // Run before commit
+ BOOST_REQUIRE(cc.before_commit());
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_must_abort);
+ BOOST_REQUIRE(tc.certified() == false);
+ BOOST_REQUIRE(tc.ordered() == false);
+
+ sc.provider().certify_result_ = wsrep::provider::success;
+
+ // Rollback sequence
+ BOOST_REQUIRE(cc.before_rollback() == 0);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_aborting);
+ BOOST_REQUIRE(cc.after_rollback() == 0);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_aborted);
+
+ // Cleanup after statement
+ cc.after_statement();
+ BOOST_REQUIRE(tc.active() == false);
+ BOOST_REQUIRE(tc.ordered() == false);
+ BOOST_REQUIRE(tc.certified() == false);
+ BOOST_REQUIRE(cc.current_error() == wsrep::e_error_during_commit);
+}
+
+//
+// Test a 1PC transaction which gets size exceeded error from certify call
+//
+BOOST_FIXTURE_TEST_CASE_TEMPLATE(
+ transaction_1pc_size_exceeded_from_certify, T,
+ replicating_fixtures, T)
+{
+ wsrep::mock_server_state& sc(T::sc);
+ wsrep::mock_client& cc(T::cc);
+ const wsrep::transaction& tc(T::tc);
+
+ // Start a new transaction with ID 1
+ cc.start_transaction(wsrep::transaction_id(1));
+ BOOST_REQUIRE(tc.active());
+ BOOST_REQUIRE(tc.id() == wsrep::transaction_id(1));
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_executing);
+
+ sc.provider().certify_result_ = wsrep::provider::error_size_exceeded;
+
+ // Run before commit
+ BOOST_REQUIRE(cc.before_commit());
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_must_abort);
+ BOOST_REQUIRE(tc.certified() == false);
+ BOOST_REQUIRE(tc.ordered() == false);
+
+ sc.provider().certify_result_ = wsrep::provider::success;
+
+ // Rollback sequence
+ BOOST_REQUIRE(cc.before_rollback() == 0);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_aborting);
+ BOOST_REQUIRE(cc.after_rollback() == 0);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_aborted);
+
+ // Cleanup after statement
+ cc.after_statement();
+ BOOST_REQUIRE(tc.active() == false);
+ BOOST_REQUIRE(tc.ordered() == false);
+ BOOST_REQUIRE(tc.certified() == false);
+ BOOST_REQUIRE(cc.current_error() == wsrep::e_error_during_commit);
+}
+
+//
+// Test a 1PC transaction which gets connection failed error from certify call
+//
+BOOST_FIXTURE_TEST_CASE_TEMPLATE(
+ transaction_1pc_connection_failed_from_certify, T,
+ replicating_fixtures, T)
+{
+ wsrep::mock_server_state& sc(T::sc);
+ wsrep::mock_client& cc(T::cc);
+ const wsrep::transaction& tc(T::tc);
+
+ // Start a new transaction with ID 1
+ cc.start_transaction(wsrep::transaction_id(1));
+ BOOST_REQUIRE(tc.active());
+ BOOST_REQUIRE(tc.id() == wsrep::transaction_id(1));
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_executing);
+
+ sc.provider().certify_result_ = wsrep::provider::error_connection_failed;
+
+ // Run before commit
+ BOOST_REQUIRE(cc.before_commit());
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_must_abort);
+ BOOST_REQUIRE(tc.certified() == false);
+ BOOST_REQUIRE(tc.ordered() == false);
+
+ sc.provider().certify_result_ = wsrep::provider::success;
+
+ // Rollback sequence
+ BOOST_REQUIRE(cc.before_rollback() == 0);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_aborting);
+ BOOST_REQUIRE(cc.after_rollback() == 0);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_aborted);
+
+ // Cleanup after statement
+ cc.after_statement();
+ BOOST_REQUIRE(tc.active() == false);
+ BOOST_REQUIRE(tc.ordered() == false);
+ BOOST_REQUIRE(tc.certified() == false);
+ BOOST_REQUIRE(cc.current_error() == wsrep::e_error_during_commit);
+}
+
+//
+// Test a 1PC transaction which gets not allowed error from certify call
+//
+BOOST_FIXTURE_TEST_CASE_TEMPLATE(
+ transaction_1pc_no_allowed_from_certify, T,
+ replicating_fixtures, T)
+{
+ wsrep::mock_server_state& sc(T::sc);
+ wsrep::mock_client& cc(T::cc);
+ const wsrep::transaction& tc(T::tc);
+
+ // Start a new transaction with ID 1
+ cc.start_transaction(wsrep::transaction_id(1));
+ BOOST_REQUIRE(tc.active());
+ BOOST_REQUIRE(tc.id() == wsrep::transaction_id(1));
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_executing);
+
+ sc.provider().certify_result_ = wsrep::provider::error_not_allowed;
+
+ // Run before commit
+ BOOST_REQUIRE(cc.before_commit());
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_must_abort);
+ BOOST_REQUIRE(tc.certified() == false);
+ BOOST_REQUIRE(tc.ordered() == false);
+
+ sc.provider().certify_result_ = wsrep::provider::success;
+
+ // Rollback sequence
+ BOOST_REQUIRE(cc.before_rollback() == 0);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_aborting);
+ BOOST_REQUIRE(cc.after_rollback() == 0);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_aborted);
+
+ // Cleanup after statement
+ cc.after_statement();
+ BOOST_REQUIRE(tc.active() == false);
+ BOOST_REQUIRE(tc.ordered() == false);
+ BOOST_REQUIRE(tc.certified() == false);
+ BOOST_REQUIRE(cc.current_error() == wsrep::e_error_during_commit);
+}
+
+//
+// Test a 1PC transaction which gets fatal error from certify call
+//
+BOOST_FIXTURE_TEST_CASE_TEMPLATE(
+ transaction_1pc_fatal_from_certify, T,
+ replicating_fixtures, T)
+{
+ wsrep::mock_server_state& sc(T::sc);
+ wsrep::mock_client& cc(T::cc);
+ const wsrep::transaction& tc(T::tc);
+
+ // Start a new transaction with ID 1
+ cc.start_transaction(wsrep::transaction_id(1));
+ BOOST_REQUIRE(tc.active());
+ BOOST_REQUIRE(tc.id() == wsrep::transaction_id(1));
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_executing);
+
+ sc.provider().certify_result_ = wsrep::provider::error_fatal;
+
+ // Run before commit
+ BOOST_REQUIRE(cc.before_commit());
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_must_abort);
+ BOOST_REQUIRE(tc.certified() == false);
+ BOOST_REQUIRE(tc.ordered() == false);
+
+ sc.provider().certify_result_ = wsrep::provider::success;
+
+ // Rollback sequence
+ BOOST_REQUIRE(cc.before_rollback() == 0);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_aborting);
+ BOOST_REQUIRE(cc.after_rollback() == 0);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_aborted);
+
+ // Cleanup after statement
+ cc.after_statement();
+ BOOST_REQUIRE(tc.active() == false);
+ BOOST_REQUIRE(tc.ordered() == false);
+ BOOST_REQUIRE(tc.certified() == false);
+ BOOST_REQUIRE(cc.current_error() == wsrep::e_error_during_commit);
+ BOOST_REQUIRE(cc.aborts() == 1);
+}
+
+//
+// Test a 1PC transaction which gets unknown from certify call
+//
+BOOST_FIXTURE_TEST_CASE_TEMPLATE(
+ transaction_1pc_unknown_from_certify, T,
+ replicating_fixtures, T)
+{
+ wsrep::mock_server_state& sc(T::sc);
+ wsrep::mock_client& cc(T::cc);
+ const wsrep::transaction& tc(T::tc);
+
+ // Start a new transaction with ID 1
+ cc.start_transaction(wsrep::transaction_id(1));
+ BOOST_REQUIRE(tc.active());
+ BOOST_REQUIRE(tc.id() == wsrep::transaction_id(1));
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_executing);
+
+ sc.provider().certify_result_ = wsrep::provider::error_unknown;
+
+ // Run before commit
+ BOOST_REQUIRE(cc.before_commit());
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_must_abort);
+ BOOST_REQUIRE(tc.certified() == false);
+ BOOST_REQUIRE(tc.ordered() == false);
+
+ sc.provider().certify_result_ = wsrep::provider::success;
+
+ // Rollback sequence
+ BOOST_REQUIRE(cc.before_rollback() == 0);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_aborting);
+ BOOST_REQUIRE(cc.after_rollback() == 0);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_aborted);
+
+ // Cleanup after statement
+ cc.after_statement();
+ BOOST_REQUIRE(tc.active() == false);
+ BOOST_REQUIRE(tc.ordered() == false);
+ BOOST_REQUIRE(tc.certified() == false);
+ BOOST_REQUIRE(cc.current_error() == wsrep::e_error_during_commit);
+}
+
+//
+// Test a 1PC transaction which gets BF aborted before grabbing lock
+// after certify call
+//
+BOOST_FIXTURE_TEST_CASE_TEMPLATE(
+ transaction_1pc_bf_abort_before_certify_regain_lock, T,
+ replicating_fixtures, T)
+{
+ wsrep::mock_client& cc(T::cc);
+ const wsrep::transaction& tc(T::tc);
+
+ // Start a new transaction with ID 1
+ cc.start_transaction(wsrep::transaction_id(1));
+ BOOST_REQUIRE(tc.active());
+ BOOST_REQUIRE(tc.id() == wsrep::transaction_id(1));
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_executing);
+
+ cc.sync_point_enabled_ = "wsrep_after_certification";
+ cc.sync_point_action_ = wsrep::mock_client_service::spa_bf_abort_ordered;
+ // Run before commit
+ BOOST_REQUIRE(cc.before_commit());
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_must_replay);
+ BOOST_REQUIRE(cc.will_replay_called() == true);
+ BOOST_REQUIRE(tc.certified() == true);
+ BOOST_REQUIRE(tc.ordered() == true);
+
+ // Rollback sequence
+ BOOST_REQUIRE(cc.before_rollback() == 0);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_must_replay);
+ BOOST_REQUIRE(cc.after_rollback() == 0);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_must_replay);
+
+ // Cleanup after statement
+ cc.after_statement();
+ BOOST_REQUIRE(cc.replays() == 1);
+ BOOST_REQUIRE(tc.active() == false);
+ BOOST_REQUIRE(tc.ordered() == false);
+ BOOST_REQUIRE(tc.certified() == false);
+ BOOST_REQUIRE(cc.current_error() == wsrep::e_success);
+}
+
+//
+// Test a transaction which gets BF aborted before before_statement.
+//
+BOOST_FIXTURE_TEST_CASE_TEMPLATE(
+ transaction_1pc_bf_before_before_statement, T,
+ replicating_fixtures, T)
+{
+ wsrep::client_state& cc(T::cc);
+ const wsrep::transaction& tc(T::tc);
+
+ // Start a new transaction with ID 1
+ cc.start_transaction(wsrep::transaction_id(1));
+ BOOST_REQUIRE(tc.active());
+ BOOST_REQUIRE(tc.id() == wsrep::transaction_id(1));
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_executing);
+ cc.after_statement();
+ cc.after_command_before_result();
+ cc.after_command_after_result();
+ BOOST_REQUIRE(cc.before_command() == 0);
+ BOOST_REQUIRE(tc.active());
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_executing);
+ wsrep_test::bf_abort_unordered(cc);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_must_abort);
+ BOOST_REQUIRE(cc.before_statement() == 1);
+ BOOST_REQUIRE(tc.active());
+ cc.after_command_before_result();
+ BOOST_REQUIRE(cc.current_error() == wsrep::e_deadlock_error);
+ cc.after_command_after_result();
+ BOOST_REQUIRE(tc.active() == false);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_aborted);
+}
+
+//
+// Test a transaction which gets BF aborted before after_statement.
+//
+BOOST_FIXTURE_TEST_CASE_TEMPLATE(
+ transaction_1pc_bf_before_after_statement, T,
+ replicating_fixtures, T)
+{
+ wsrep::client_state& cc(T::cc);
+ const wsrep::transaction& tc(T::tc);
+
+ // Start a new transaction with ID 1
+ cc.start_transaction(wsrep::transaction_id(1));
+ BOOST_REQUIRE(tc.active());
+ BOOST_REQUIRE(tc.id() == wsrep::transaction_id(1));
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_executing);
+
+ wsrep_test::bf_abort_unordered(cc);
+
+ cc.after_statement();
+ BOOST_REQUIRE(tc.active() == false);
+ BOOST_REQUIRE(tc.ordered() == false);
+ BOOST_REQUIRE(tc.certified() == false);
+ BOOST_REQUIRE(cc.current_error());
+}
+
+BOOST_FIXTURE_TEST_CASE_TEMPLATE(
+ transaction_1pc_bf_abort_after_after_statement, T,
+ replicating_fixtures, T)
+{
+ wsrep::client_state& cc(T::cc);
+ const wsrep::transaction& tc(T::tc);
+
+ cc.start_transaction(wsrep::transaction_id(1));
+ BOOST_REQUIRE(tc.active());
+ cc.after_statement();
+ BOOST_REQUIRE(cc.state() == wsrep::client_state::s_exec);
+ wsrep_test::bf_abort_unordered(cc);
+ BOOST_REQUIRE(cc.current_error() == wsrep::e_success);
+ BOOST_REQUIRE(tc.active());
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_must_abort);
+ cc.after_command_before_result();
+ BOOST_REQUIRE(cc.current_error() == wsrep::e_deadlock_error);
+ BOOST_REQUIRE(tc.active() == false);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_aborted);
+ cc.after_command_after_result();
+ BOOST_REQUIRE(cc.current_error() == wsrep::e_success);
+ BOOST_REQUIRE(tc.active() == false);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_aborted);
+}
+
+BOOST_FIXTURE_TEST_CASE(
+ transaction_1pc_autocommit_retry_bf_aborted,
+ replicating_client_fixture_autocommit)
+{
+
+ cc.start_transaction(wsrep::transaction_id(1));
+ BOOST_REQUIRE(tc.active());
+ wsrep_test::bf_abort_unordered(cc);
+ BOOST_REQUIRE(cc.before_commit());
+ BOOST_REQUIRE(cc.current_error() == wsrep::e_deadlock_error);
+ BOOST_REQUIRE(cc.before_rollback() == 0);
+ BOOST_REQUIRE(cc.after_rollback() == 0);
+ BOOST_REQUIRE(cc.after_statement());
+ BOOST_REQUIRE(tc.active() == false);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_aborted);
+ BOOST_REQUIRE(cc.state() == wsrep::client_state::s_exec);
+}
+
+BOOST_FIXTURE_TEST_CASE_TEMPLATE(
+ transaction_1pc_bf_abort_after_after_command_before_result, T,
+ replicating_fixtures, T)
+{
+ wsrep::client_state& cc(T::cc);
+ const wsrep::transaction& tc(T::tc);
+
+ cc.start_transaction(wsrep::transaction_id(1));
+ BOOST_REQUIRE(tc.active());
+ cc.after_statement();
+ BOOST_REQUIRE(cc.state() == wsrep::client_state::s_exec);
+ cc.after_command_before_result();
+ BOOST_REQUIRE(cc.state() == wsrep::client_state::s_result);
+ BOOST_REQUIRE(cc.current_error() == wsrep::e_success);
+ wsrep_test::bf_abort_unordered(cc);
+ // The result is being sent to client. We need to mark transaction
+ // as must_abort but not override error yet as this might cause
+ // a race condition resulting incorrect result returned to the DBMS client.
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_must_abort);
+ BOOST_REQUIRE(cc.current_error() == wsrep::e_success);
+ // After the result has been sent to the DBMS client, the after result
+ // processing should roll back the transaction and set the error.
+ cc.after_command_after_result();
+ BOOST_REQUIRE(cc.state() == wsrep::client_state::s_idle);
+ BOOST_REQUIRE(cc.current_error() == wsrep::e_deadlock_error);
+ BOOST_REQUIRE(tc.active() == true);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_aborted);
+ cc.sync_rollback_complete();
+ BOOST_REQUIRE(cc.before_command() == 1);
+ BOOST_REQUIRE(tc.active() == false);
+ BOOST_REQUIRE(cc.current_error() == wsrep::e_deadlock_error);
+ cc.after_command_before_result();
+ BOOST_REQUIRE(cc.current_error() == wsrep::e_deadlock_error);
+ cc.after_command_after_result();
+ BOOST_REQUIRE(cc.current_error() == wsrep::e_success);
+}
+
+BOOST_FIXTURE_TEST_CASE(
+ transaction_1pc_bf_abort_after_after_command_after_result_sync_rm,
+ replicating_client_fixture_sync_rm)
+{
+ cc.start_transaction(wsrep::transaction_id(1));
+ BOOST_REQUIRE(tc.active());
+ cc.after_statement();
+ BOOST_REQUIRE(cc.state() == wsrep::client_state::s_exec);
+ cc.after_command_before_result();
+ BOOST_REQUIRE(cc.state() == wsrep::client_state::s_result);
+ cc.after_command_after_result();
+ BOOST_REQUIRE(cc.state() == wsrep::client_state::s_idle);
+ wsrep_test::bf_abort_unordered(cc);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_aborted);
+ BOOST_REQUIRE(tc.active());
+ cc.sync_rollback_complete();
+ BOOST_REQUIRE(cc.before_command() == 1);
+ BOOST_REQUIRE(tc.active() == false);
+ BOOST_REQUIRE(cc.current_error() == wsrep::e_deadlock_error);
+ cc.after_command_before_result();
+ BOOST_REQUIRE(cc.current_error() == wsrep::e_deadlock_error);
+ cc.after_command_after_result();
+ BOOST_REQUIRE(cc.current_error() == wsrep::e_success);
+ BOOST_REQUIRE(tc.active() == false);
+}
+
+// Check the case where client program calls wait_rollback_complete() to
+// gain control before before_command().
+BOOST_FIXTURE_TEST_CASE(
+ transaction_1pc_bf_abort_after_after_command_after_result_sync_rm_wait_rollback,
+ replicating_client_fixture_sync_rm)
+{
+ cc.start_transaction(wsrep::transaction_id(1));
+ BOOST_REQUIRE(tc.active());
+ cc.after_statement();
+ BOOST_REQUIRE(cc.state() == wsrep::client_state::s_exec);
+ cc.after_command_before_result();
+ BOOST_REQUIRE(cc.state() == wsrep::client_state::s_result);
+ cc.after_command_after_result();
+ BOOST_REQUIRE(cc.state() == wsrep::client_state::s_idle);
+ wsrep_test::bf_abort_unordered(cc);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_aborted);
+ BOOST_REQUIRE(tc.active());
+ cc.sync_rollback_complete();
+ BOOST_REQUIRE(cc.state() == wsrep::client_state::s_idle);
+ cc.wait_rollback_complete_and_acquire_ownership();
+ BOOST_REQUIRE(cc.state() == wsrep::client_state::s_exec);
+ // Idempotent
+ cc.wait_rollback_complete_and_acquire_ownership();
+ BOOST_REQUIRE(cc.state() == wsrep::client_state::s_exec);
+ BOOST_REQUIRE(cc.before_command() == 1);
+ BOOST_REQUIRE(tc.active() == false);
+ BOOST_REQUIRE(cc.current_error() == wsrep::e_deadlock_error);
+ cc.after_command_before_result();
+ BOOST_REQUIRE(cc.current_error() == wsrep::e_deadlock_error);
+ cc.after_command_after_result();
+ BOOST_REQUIRE(cc.current_error() == wsrep::e_success);
+ BOOST_REQUIRE(tc.active() == false);
+}
+
+// Check the case where BF abort happens between client calls to
+// wait_rollback_complete_and_acquire_ownership()
+// and before before_command().
+BOOST_FIXTURE_TEST_CASE(
+ transaction_1pc_bf_abort_after_acquire_before_before_command_sync_rm,
+ replicating_client_fixture_sync_rm)
+{
+ cc.start_transaction(wsrep::transaction_id(1));
+ BOOST_REQUIRE(tc.active());
+ cc.after_statement();
+ BOOST_REQUIRE(cc.state() == wsrep::client_state::s_exec);
+ cc.after_command_before_result();
+ BOOST_REQUIRE(cc.state() == wsrep::client_state::s_result);
+ cc.after_command_after_result();
+ BOOST_REQUIRE(cc.state() == wsrep::client_state::s_idle);
+ cc.wait_rollback_complete_and_acquire_ownership();
+ BOOST_REQUIRE(cc.state() == wsrep::client_state::s_exec);
+ // As the control is now on client, the BF abort must just change
+ // the state to s_must_abort.
+ wsrep_test::bf_abort_unordered(cc);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_must_abort);
+ BOOST_REQUIRE(tc.active());
+ BOOST_REQUIRE(cc.before_command() == 1);
+ BOOST_REQUIRE(tc.active() == false);
+ BOOST_REQUIRE(cc.current_error() == wsrep::e_deadlock_error);
+ cc.after_command_before_result();
+ BOOST_REQUIRE(cc.current_error() == wsrep::e_deadlock_error);
+ cc.after_command_after_result();
+ BOOST_REQUIRE(cc.current_error() == wsrep::e_success);
+ BOOST_REQUIRE(tc.active() == false);
+}
+
+BOOST_FIXTURE_TEST_CASE(
+ transaction_1pc_bf_abort_after_after_command_after_result_async_rm,
+ replicating_client_fixture_async_rm)
+{
+ cc.start_transaction(wsrep::transaction_id(1));
+ BOOST_REQUIRE(tc.active());
+ cc.after_statement();
+ BOOST_REQUIRE(cc.state() == wsrep::client_state::s_exec);
+ cc.after_command_before_result();
+ BOOST_REQUIRE(cc.state() == wsrep::client_state::s_result);
+ cc.after_command_after_result();
+ BOOST_REQUIRE(cc.state() == wsrep::client_state::s_idle);
+ wsrep_test::bf_abort_unordered(cc);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_must_abort);
+ BOOST_REQUIRE(tc.active());
+ BOOST_REQUIRE(cc.before_command() == 1);
+ BOOST_REQUIRE(tc.active() == false);
+ BOOST_REQUIRE(cc.current_error() == wsrep::e_deadlock_error);
+ cc.after_command_before_result();
+ BOOST_REQUIRE(cc.current_error() == wsrep::e_deadlock_error);
+ cc.after_command_after_result();
+ BOOST_REQUIRE(cc.current_error() == wsrep::e_success);
+ BOOST_REQUIRE(tc.active() == false);
+}
+
+//
+// Test before_command() with keep_command_error param
+// Failure free case is not affected by keep_command_error
+//
+BOOST_FIXTURE_TEST_CASE_TEMPLATE(transaction_keep_error, T,
+ replicating_fixtures, T)
+{
+ wsrep::mock_client& cc(T::cc);
+ const wsrep::transaction& tc(T::tc);
+
+ cc.start_transaction(wsrep::transaction_id(1));
+ BOOST_REQUIRE(tc.active());
+ cc.after_statement();
+ cc.after_command_before_result();
+ cc.after_command_after_result();
+
+ bool keep_command_error(true);
+ BOOST_REQUIRE(cc.before_command(keep_command_error) == 0);
+ BOOST_REQUIRE(tc.active());
+ cc.after_command_before_result();
+ cc.after_command_after_result();
+
+ keep_command_error = false;
+ BOOST_REQUIRE(cc.before_command(keep_command_error) == 0);
+ BOOST_REQUIRE(cc.before_statement() == 0);
+ BOOST_REQUIRE(cc.before_commit() == 0);
+ BOOST_REQUIRE(cc.ordered_commit() == 0);
+ BOOST_REQUIRE(cc.after_commit() == 0);
+ cc.after_statement();
+ BOOST_REQUIRE(cc.current_error() == wsrep::e_success);
+}
+
+//
+// Test before_command() with keep_command_error param
+// BF abort while idle
+//
+BOOST_FIXTURE_TEST_CASE(transaction_keep_error_bf_idle_sync_rm,
+ replicating_client_fixture_sync_rm)
+{
+ cc.start_transaction(wsrep::transaction_id(1));
+ cc.after_statement();
+ cc.after_command_before_result();
+ cc.after_command_after_result();
+
+ BOOST_REQUIRE(cc.state() == wsrep::client_state::s_idle);
+ wsrep_test::bf_abort_unordered(cc);
+ cc.sync_rollback_complete();
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_aborted);
+
+ bool keep_command_error(true);
+ BOOST_REQUIRE(cc.before_command(keep_command_error) == 0);
+ BOOST_REQUIRE(tc.active());
+ BOOST_REQUIRE(cc.current_error() == wsrep::e_deadlock_error);
+ cc.after_command_before_result();
+ cc.after_command_after_result();
+ BOOST_REQUIRE(cc.current_error() == wsrep::e_deadlock_error);
+
+ keep_command_error = false;
+ BOOST_REQUIRE(cc.before_command(keep_command_error) == 1);
+ BOOST_REQUIRE(cc.current_error() == wsrep::e_deadlock_error);
+ cc.after_command_before_result();
+ cc.after_command_after_result();
+ BOOST_REQUIRE(cc.current_error() == wsrep::e_success);
+}
+
+//
+// Test before_command() with keep_command_error param
+// BF abort after ownership is acquired and before before_command()
+//
+BOOST_FIXTURE_TEST_CASE_TEMPLATE(transaction_keep_error_bf_after_ownership, T,
+ replicating_fixtures, T)
+{
+ wsrep::mock_client& cc(T::cc);
+ const wsrep::transaction& tc(T::tc);
+
+ cc.start_transaction(wsrep::transaction_id(1));
+ cc.after_statement();
+ cc.after_command_before_result();
+ cc.after_command_after_result();
+
+ cc.wait_rollback_complete_and_acquire_ownership();
+ wsrep_test::bf_abort_unordered(cc);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_must_abort);
+
+ bool keep_command_error(true);
+ BOOST_REQUIRE(cc.before_command(keep_command_error) == 0);
+ BOOST_REQUIRE(tc.active());
+ BOOST_REQUIRE(cc.current_error() == wsrep::e_deadlock_error);
+ cc.after_command_before_result();
+ cc.after_command_after_result();
+ BOOST_REQUIRE(cc.current_error() == wsrep::e_deadlock_error);
+
+ keep_command_error = false;
+ BOOST_REQUIRE(cc.before_command(keep_command_error) == 1);
+ BOOST_REQUIRE(cc.current_error() == wsrep::e_deadlock_error);
+ cc.after_command_before_result();
+ cc.after_command_after_result();
+ BOOST_REQUIRE(cc.current_error() == wsrep::e_success);
+}
+
+//
+// Test before_command() with keep_command_error param
+// BF abort right after before_command()
+//
+BOOST_FIXTURE_TEST_CASE_TEMPLATE(transaction_keep_error_bf_after_before_command, T,
+ replicating_fixtures, T)
+{
+ wsrep::mock_client& cc(T::cc);
+ const wsrep::transaction& tc(T::tc);
+
+ cc.start_transaction(wsrep::transaction_id(1));
+ cc.after_statement();
+ cc.after_command_before_result();
+ cc.after_command_after_result();
+
+ bool keep_command_error(true);
+ BOOST_REQUIRE(cc.before_command(keep_command_error) == 0);
+ BOOST_REQUIRE(tc.active());
+
+ wsrep_test::bf_abort_unordered(cc);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_must_abort);
+ cc.after_command_before_result();
+ cc.after_command_after_result();
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_aborted);
+ BOOST_REQUIRE(cc.current_error() == wsrep::e_deadlock_error);
+
+ keep_command_error = false;
+ BOOST_REQUIRE(cc.before_command(keep_command_error) == 1);
+ BOOST_REQUIRE(cc.current_error() == wsrep::e_deadlock_error);
+ cc.after_command_before_result();
+ cc.after_command_after_result();
+ BOOST_REQUIRE(cc.current_error() == wsrep::e_success);
+}
+
+//
+// Test before_command() with keep_command_error param
+// BF abort right after after_command_before_result()
+//
+BOOST_FIXTURE_TEST_CASE_TEMPLATE(transaction_keep_error_bf_after_after_command_before_result, T,
+ replicating_fixtures, T)
+{
+ wsrep::mock_client& cc(T::cc);
+ const wsrep::transaction& tc(T::tc);
+
+ cc.start_transaction(wsrep::transaction_id(1));
+ cc.after_statement();
+ cc.after_command_before_result();
+ cc.after_command_after_result();
+
+ bool keep_command_error(true);
+ BOOST_REQUIRE(cc.before_command(keep_command_error) == 0);
+ BOOST_REQUIRE(tc.active());
+
+ cc.after_command_before_result();
+
+ wsrep_test::bf_abort_unordered(cc);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_must_abort);
+
+ cc.after_command_after_result();
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_aborted);
+ BOOST_REQUIRE(cc.current_error() == wsrep::e_deadlock_error);
+
+ keep_command_error = false;
+ BOOST_REQUIRE(cc.before_command(keep_command_error) == 1);
+ BOOST_REQUIRE(cc.current_error() == wsrep::e_deadlock_error);
+ cc.after_command_before_result();
+ cc.after_command_after_result();
+ BOOST_REQUIRE(cc.current_error() == wsrep::e_success);
+}
+
+BOOST_FIXTURE_TEST_CASE(transaction_1pc_applying,
+ applying_client_fixture)
+{
+ start_transaction(wsrep::transaction_id(1),
+ wsrep::seqno(1));
+ BOOST_REQUIRE(cc.before_commit() == 0);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_committing);
+ BOOST_REQUIRE(cc.ordered_commit() == 0);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_ordered_commit);
+ BOOST_REQUIRE(cc.after_commit() == 0);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_committed);
+ cc.after_applying();
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_committed);
+ BOOST_REQUIRE(tc.active() == false);
+ BOOST_REQUIRE(cc.current_error() == wsrep::e_success);
+}
+
+
+BOOST_FIXTURE_TEST_CASE(transaction_applying_rollback,
+ applying_client_fixture)
+{
+ BOOST_REQUIRE(cc.before_rollback() == 0);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_aborting);
+ BOOST_REQUIRE(cc.after_rollback() == 0);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_aborted);
+ cc.after_applying();
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_aborted);
+ BOOST_REQUIRE(tc.active() == false);
+ BOOST_REQUIRE(cc.current_error() == wsrep::e_success);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// STREAMING REPLICATION //
+///////////////////////////////////////////////////////////////////////////////
+
+//
+// Test 1PC with row streaming with one row
+//
+BOOST_FIXTURE_TEST_CASE(transaction_row_streaming_1pc_commit,
+ streaming_client_fixture_row)
+{
+ BOOST_REQUIRE(cc.start_transaction(wsrep::transaction_id(1)) == 0);
+ BOOST_REQUIRE(cc.after_row() == 0);
+ BOOST_REQUIRE(tc.streaming_context().fragments_certified() == 1);
+ BOOST_REQUIRE(cc.before_commit() == 0);
+ BOOST_REQUIRE(cc.ordered_commit() == 0);
+ BOOST_REQUIRE(cc.after_commit() == 0);
+ BOOST_REQUIRE(cc.after_statement() == 0);
+ BOOST_REQUIRE(sc.provider().fragments() == 2);
+ BOOST_REQUIRE(sc.provider().start_fragments() == 1);
+ BOOST_REQUIRE(sc.provider().commit_fragments() == 1);
+}
+
+//
+// Test 1PC with row streaming with one row
+//
+BOOST_FIXTURE_TEST_CASE(transaction_row_batch_streaming_1pc_commit,
+ streaming_client_fixture_row)
+{
+ BOOST_REQUIRE(cc.enable_streaming(
+ wsrep::streaming_context::row, 2) == 0);
+ BOOST_REQUIRE(cc.start_transaction(wsrep::transaction_id(1)) == 0);
+ BOOST_REQUIRE(cc.after_row() == 0);
+ BOOST_REQUIRE(tc.streaming_context().fragments_certified() == 0);
+ BOOST_REQUIRE(cc.after_row() == 0);
+ BOOST_REQUIRE(tc.streaming_context().fragments_certified() == 1);
+ BOOST_REQUIRE(cc.before_commit() == 0);
+ BOOST_REQUIRE(cc.ordered_commit() == 0);
+ BOOST_REQUIRE(cc.after_commit() == 0);
+ BOOST_REQUIRE(cc.after_statement() == 0);
+ BOOST_REQUIRE(sc.provider().fragments() == 2);
+ BOOST_REQUIRE(sc.provider().start_fragments() == 1);
+ BOOST_REQUIRE(sc.provider().commit_fragments() == 1);
+}
+
+//
+// Test 1PC row streaming with two separate statements
+//
+BOOST_FIXTURE_TEST_CASE(
+ transaction_row_streaming_1pc_commit_two_statements,
+ streaming_client_fixture_row)
+{
+ BOOST_REQUIRE(cc.start_transaction(wsrep::transaction_id(1)) == 0);
+ BOOST_REQUIRE(cc.after_row() == 0);
+ BOOST_REQUIRE(tc.streaming_context().fragments_certified() == 1);
+ BOOST_REQUIRE(cc.after_statement() == 0);
+ BOOST_REQUIRE(cc.before_statement() == 0);
+ BOOST_REQUIRE(cc.after_row() == 0);
+ BOOST_REQUIRE(tc.streaming_context().fragments_certified() == 2);
+ BOOST_REQUIRE(cc.before_commit() == 0);
+ BOOST_REQUIRE(cc.ordered_commit() == 0);
+ BOOST_REQUIRE(cc.after_commit() == 0);
+ BOOST_REQUIRE(cc.after_statement() == 0);
+ BOOST_REQUIRE(sc.provider().fragments() == 3);
+ BOOST_REQUIRE(sc.provider().start_fragments() == 1);
+ BOOST_REQUIRE(sc.provider().commit_fragments() == 1);
+}
+
+//
+// Fragments are removed in before_prepare in running transaction context.
+// In 1pc the before_prepare() is called from before_commit().
+// However, the BF abort may arrive during this removal and the
+// client_service::remove_fragments() may roll back the transaction
+// internally. This will cause the transaction to leave before_prepare()
+// in aborted state.
+//
+BOOST_FIXTURE_TEST_CASE(transaction_streaming_1pc_bf_abort_during_fragment_removal,
+ streaming_client_fixture_row)
+{
+ BOOST_REQUIRE(cc.start_transaction(wsrep::transaction_id(1)) == 0);
+ BOOST_REQUIRE(cc.after_row() == 0);
+ BOOST_REQUIRE(tc.streaming_context().fragments_certified() == 1);
+ cc.bf_abort_during_fragment_removal_ = true;
+ BOOST_REQUIRE(cc.before_commit());
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_aborted);
+ BOOST_REQUIRE(cc.after_statement());
+ BOOST_REQUIRE(tc.active() == false);
+ wsrep_test::terminate_streaming_applier(sc, sc.id(),
+ wsrep::transaction_id(1));
+}
+
+//
+// Test streaming rollback
+//
+BOOST_FIXTURE_TEST_CASE(transaction_row_streaming_rollback,
+ streaming_client_fixture_row)
+{
+ BOOST_REQUIRE(cc.start_transaction(wsrep::transaction_id(1)) == 0);
+ BOOST_REQUIRE(cc.after_row() == 0);
+ BOOST_REQUIRE(tc.streaming_context().fragments_certified() == 1);
+ BOOST_REQUIRE(cc.before_rollback() == 0);
+ BOOST_REQUIRE(cc.after_rollback() == 0);
+ BOOST_REQUIRE(cc.after_statement() == 0);
+ BOOST_REQUIRE(sc.provider().fragments() == 2);
+ BOOST_REQUIRE(sc.provider().start_fragments() == 1);
+ BOOST_REQUIRE(sc.provider().rollback_fragments() == 1);
+
+ wsrep::high_priority_service* hps(
+ sc.find_streaming_applier(
+ sc.id(), wsrep::transaction_id(1)));
+ BOOST_REQUIRE(hps);
+ hps->rollback(wsrep::ws_handle(), wsrep::ws_meta());
+ hps->after_apply();
+ sc.stop_streaming_applier(sc.id(), wsrep::transaction_id(1));
+ server_service.release_high_priority_service(hps);
+}
+
+//
+// Test streaming BF abort in executing state.
+//
+BOOST_FIXTURE_TEST_CASE(transaction_row_streaming_bf_abort_executing,
+ streaming_client_fixture_row)
+{
+ BOOST_REQUIRE(cc.start_transaction(wsrep::transaction_id(1)) == 0);
+ BOOST_REQUIRE(cc.after_row() == 0);
+ BOOST_REQUIRE(tc.streaming_context().fragments_certified() == 1);
+ wsrep_test::bf_abort_unordered(cc);
+ BOOST_REQUIRE(tc.streaming_context().rolled_back());
+ BOOST_REQUIRE(cc.before_rollback() == 0);
+ BOOST_REQUIRE(cc.after_rollback() == 0);
+ BOOST_REQUIRE(cc.after_statement());
+ wsrep_test::terminate_streaming_applier(sc, sc.id(),
+ wsrep::transaction_id(1));
+
+}
+
+BOOST_FIXTURE_TEST_CASE(
+ transaction_row_streaming_total_order_bf_abort_executing,
+ streaming_client_fixture_row)
+{
+ BOOST_REQUIRE(cc.start_transaction(wsrep::transaction_id(1)) == 0);
+ BOOST_REQUIRE(cc.after_row() == 0);
+ BOOST_REQUIRE(tc.streaming_context().fragments_certified() == 1);
+ wsrep_test::bf_abort_in_total_order(cc);
+ BOOST_REQUIRE(tc.bf_aborted_in_total_order());
+ // TO BF abort must not replicate rollback fragment,
+ // rollback must complete before TO is allowed to
+ // continue.
+ BOOST_REQUIRE(sc.provider().rollback_fragments() == 0);
+ BOOST_REQUIRE(tc.streaming_context().rolled_back());
+ BOOST_REQUIRE(cc.before_rollback() == 0);
+ BOOST_REQUIRE(cc.after_rollback() == 0);
+ BOOST_REQUIRE(cc.after_statement());
+ wsrep_test::terminate_streaming_applier(sc, sc.id(),
+ wsrep::transaction_id(1));
+}
+
+//
+// Test streaming certification failure during fragment replication
+//
+BOOST_FIXTURE_TEST_CASE(transaction_row_streaming_cert_fail_non_commit,
+ streaming_client_fixture_row)
+{
+ BOOST_REQUIRE(cc.start_transaction(wsrep::transaction_id(1)) == 0);
+ BOOST_REQUIRE(cc.after_row() == 0);
+ BOOST_REQUIRE(tc.streaming_context().fragments_certified() == 1);
+ sc.provider().certify_result_ = wsrep::provider::error_certification_failed;
+ BOOST_REQUIRE(cc.after_row() == 1);
+ sc.provider().certify_result_ = wsrep::provider::success;
+ BOOST_REQUIRE(cc.before_rollback() == 0);
+ BOOST_REQUIRE(cc.after_rollback() == 0);
+ BOOST_REQUIRE(cc.after_statement() == 1);
+ BOOST_REQUIRE(sc.provider().fragments() == 2);
+ BOOST_REQUIRE(sc.provider().start_fragments() == 1);
+ BOOST_REQUIRE(sc.provider().rollback_fragments() == 1);
+
+ wsrep::high_priority_service* hps(
+ sc.find_streaming_applier(
+ sc.id(), wsrep::transaction_id(1)));
+ BOOST_REQUIRE(hps);
+ hps->rollback(wsrep::ws_handle(), wsrep::ws_meta());
+ hps->after_apply();
+ sc.stop_streaming_applier(sc.id(), wsrep::transaction_id(1));
+ server_service.release_high_priority_service(hps);
+}
+
+//
+// Test streaming certification failure during commit
+//
+BOOST_FIXTURE_TEST_CASE(transaction_row_streaming_cert_fail_commit,
+ streaming_client_fixture_row)
+{
+ BOOST_REQUIRE(cc.start_transaction(wsrep::transaction_id(1)) == 0);
+ BOOST_REQUIRE(cc.after_row() == 0);
+ BOOST_REQUIRE(tc.streaming_context().fragments_certified() == 1);
+ sc.provider().certify_result_ = wsrep::provider::error_certification_failed;
+ BOOST_REQUIRE(cc.before_commit() == 1);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_cert_failed);
+ sc.provider().certify_result_ = wsrep::provider::success;
+ BOOST_REQUIRE(cc.before_rollback() == 0);
+ BOOST_REQUIRE(cc.after_rollback() == 0);
+ BOOST_REQUIRE(cc.after_statement() );
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_aborted);
+ BOOST_REQUIRE(sc.provider().fragments() == 2);
+ BOOST_REQUIRE(sc.provider().start_fragments() == 1);
+ BOOST_REQUIRE(sc.provider().rollback_fragments() == 1);
+
+ wsrep::high_priority_service* hps(
+ sc.find_streaming_applier(
+ sc.id(), wsrep::transaction_id(1)));
+ BOOST_REQUIRE(hps);
+ hps->rollback(wsrep::ws_handle(), wsrep::ws_meta());
+ hps->after_apply();
+ sc.stop_streaming_applier(sc.id(), wsrep::transaction_id(1));
+ server_service.release_high_priority_service(hps);
+}
+
+//
+// Test streaming BF abort after succesful certification
+//
+BOOST_FIXTURE_TEST_CASE(
+ transaction_row_streaming_bf_abort_during_commit_order_enter,
+ streaming_client_fixture_row)
+{
+ BOOST_REQUIRE(cc.start_transaction(wsrep::transaction_id(1)) == 0);
+ BOOST_REQUIRE(cc.after_row() == 0);
+ BOOST_REQUIRE(tc.streaming_context().fragments_certified() == 1);
+ sc.provider().commit_order_enter_result_ = wsrep::provider::error_bf_abort;
+ BOOST_REQUIRE(cc.before_commit());
+ BOOST_REQUIRE_EQUAL(tc.state(), wsrep::transaction::s_must_replay);
+ sc.provider().commit_order_enter_result_ = wsrep::provider::success;
+ BOOST_REQUIRE(cc.before_rollback() == 0);
+ BOOST_REQUIRE(cc.after_rollback() == 0);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_must_replay);
+ BOOST_REQUIRE(cc.will_replay_called() == true);
+ BOOST_REQUIRE(cc.after_statement() == 0);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_committed);
+ BOOST_REQUIRE(sc.provider().fragments() == 2);
+ BOOST_REQUIRE(sc.provider().start_fragments() == 1);
+ BOOST_REQUIRE(sc.provider().commit_fragments() == 1);
+}
+
+//
+// Test a streaming transaction which gets BF aborted inside provider before
+// certification result is known. Replaying will be successful
+//
+BOOST_FIXTURE_TEST_CASE(
+ transaction_row_streaming_bf_before_cert_result_replay_success,
+ streaming_client_fixture_row)
+{
+ BOOST_REQUIRE(cc.start_transaction(wsrep::transaction_id(1)) == 0);
+ BOOST_REQUIRE(cc.after_row() == 0);
+ BOOST_REQUIRE(tc.streaming_context().fragments_certified() == 1);
+
+ sc.provider().certify_result_ = wsrep::provider::error_bf_abort;
+ sc.provider().replay_result_ = wsrep::provider::success;
+
+ BOOST_REQUIRE(cc.before_commit());
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_must_replay);
+ BOOST_REQUIRE(cc.will_replay_called() == true);
+ BOOST_REQUIRE(cc.after_statement() == 0);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_committed);
+ BOOST_REQUIRE(cc.current_error() == wsrep::e_success);
+}
+
+//
+// Test a streaming transaction which gets BF aborted inside provider before
+// certification result is known. Replaying will fail because of
+// certification failure.
+//
+BOOST_FIXTURE_TEST_CASE(
+ transaction_row_streaming_bf_before_cert_result_replay_cert_fail,
+ streaming_client_fixture_row)
+{
+ BOOST_REQUIRE(cc.start_transaction(wsrep::transaction_id(1)) == 0);
+ BOOST_REQUIRE(cc.after_row() == 0);
+ BOOST_REQUIRE(tc.streaming_context().fragments_certified() == 1);
+
+ sc.provider().certify_result_ = wsrep::provider::error_bf_abort;
+ sc.provider().replay_result_ = wsrep::provider::error_certification_failed;
+
+ BOOST_REQUIRE(cc.before_commit());
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_must_replay);
+ BOOST_REQUIRE(cc.will_replay_called() == true);
+ BOOST_REQUIRE(cc.after_statement() );
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_aborted);
+ BOOST_REQUIRE(cc.current_error() == wsrep::e_deadlock_error);
+ BOOST_REQUIRE(tc.active() == false);
+}
+
+
+BOOST_FIXTURE_TEST_CASE(transaction_byte_streaming_1pc_commit,
+ streaming_client_fixture_byte)
+{
+ BOOST_REQUIRE(cc.start_transaction(wsrep::transaction_id(1)) == 0);
+ cc.bytes_generated_ = 1;
+ BOOST_REQUIRE(cc.after_row() == 0);
+ BOOST_REQUIRE(tc.streaming_context().fragments_certified() == 1);
+ BOOST_REQUIRE(cc.before_commit() == 0);
+ BOOST_REQUIRE(cc.ordered_commit() == 0);
+ BOOST_REQUIRE(cc.after_commit() == 0);
+ BOOST_REQUIRE(cc.after_statement() == 0);
+ BOOST_REQUIRE(sc.provider().fragments() == 2);
+ BOOST_REQUIRE(sc.provider().start_fragments() == 1);
+ BOOST_REQUIRE(sc.provider().commit_fragments() == 1);
+}
+
+BOOST_FIXTURE_TEST_CASE(transaction_byte_batch_streaming_1pc_commit,
+ streaming_client_fixture_byte)
+{
+ BOOST_REQUIRE(
+ cc.enable_streaming(
+ wsrep::streaming_context::bytes, 2) == 0);
+ BOOST_REQUIRE(cc.start_transaction(wsrep::transaction_id(1)) == 0);
+ BOOST_REQUIRE(cc.after_row() == 0);
+ BOOST_REQUIRE(tc.streaming_context().fragments_certified() == 0);
+ BOOST_REQUIRE(cc.after_row() == 0);
+ BOOST_REQUIRE(tc.streaming_context().fragments_certified() == 1);
+ BOOST_REQUIRE(cc.before_commit() == 0);
+ BOOST_REQUIRE(cc.ordered_commit() == 0);
+ BOOST_REQUIRE(cc.after_commit() == 0);
+ BOOST_REQUIRE(cc.after_statement() == 0);
+ BOOST_REQUIRE(sc.provider().fragments() == 2);
+ BOOST_REQUIRE(sc.provider().start_fragments() == 1);
+ BOOST_REQUIRE(sc.provider().commit_fragments() == 1);
+}
+
+
+BOOST_FIXTURE_TEST_CASE(transaction_statement_streaming_statement_with_no_effect,
+ streaming_client_fixture_statement)
+{
+ BOOST_REQUIRE(cc.start_transaction(wsrep::transaction_id(1)) == 0);
+ BOOST_REQUIRE(tc.streaming_context().fragments_certified() == 0);
+ BOOST_REQUIRE(cc.before_statement() == 0);
+ BOOST_REQUIRE(cc.after_statement() == 0);
+ BOOST_REQUIRE(tc.streaming_context().fragments_certified() == 0);
+ BOOST_REQUIRE(cc.after_row() == 0);
+ BOOST_REQUIRE(cc.before_statement() == 0);
+ BOOST_REQUIRE(cc.after_statement() == 0);
+ BOOST_REQUIRE(tc.streaming_context().fragments_certified() == 1);
+ BOOST_REQUIRE(cc.before_statement() == 0);
+ BOOST_REQUIRE(cc.before_commit() == 0);
+ BOOST_REQUIRE(cc.ordered_commit() == 0);
+ BOOST_REQUIRE(cc.after_commit() == 0);
+ BOOST_REQUIRE(cc.after_statement() == 0);
+ BOOST_REQUIRE(sc.provider().fragments() == 2);
+ BOOST_REQUIRE(sc.provider().start_fragments() == 1);
+ BOOST_REQUIRE(sc.provider().commit_fragments() == 1);
+}
+
+BOOST_FIXTURE_TEST_CASE(transaction_statement_streaming_1pc_commit,
+ streaming_client_fixture_statement)
+{
+ BOOST_REQUIRE(cc.start_transaction(wsrep::transaction_id(1)) == 0);
+ BOOST_REQUIRE(cc.after_row() == 0);
+ BOOST_REQUIRE(tc.streaming_context().fragments_certified() == 0);
+ BOOST_REQUIRE(cc.after_statement() == 0);
+ BOOST_REQUIRE(tc.streaming_context().fragments_certified() == 1);
+ BOOST_REQUIRE(cc.before_statement() == 0);
+ BOOST_REQUIRE(cc.before_commit() == 0);
+ BOOST_REQUIRE(cc.ordered_commit() == 0);
+ BOOST_REQUIRE(cc.after_commit() == 0);
+ BOOST_REQUIRE(cc.after_statement() == 0);
+ BOOST_REQUIRE(sc.provider().fragments() == 2);
+ BOOST_REQUIRE(sc.provider().start_fragments() == 1);
+ BOOST_REQUIRE(sc.provider().commit_fragments() == 1);
+}
+
+BOOST_FIXTURE_TEST_CASE(transaction_statement_batch_streaming_1pc_commit,
+ streaming_client_fixture_statement)
+{
+ BOOST_REQUIRE(
+ cc.enable_streaming(
+ wsrep::streaming_context::statement, 2) == 0);
+ BOOST_REQUIRE(cc.start_transaction(wsrep::transaction_id(1)) == 0);
+ BOOST_REQUIRE(cc.after_row() == 0);
+ BOOST_REQUIRE(tc.streaming_context().fragments_certified() == 0);
+ BOOST_REQUIRE(cc.after_statement() == 0);
+ BOOST_REQUIRE(tc.streaming_context().fragments_certified() == 0);
+ BOOST_REQUIRE(cc.before_statement() == 0);
+ BOOST_REQUIRE(cc.after_row() == 0);
+ BOOST_REQUIRE(tc.streaming_context().fragments_certified() == 0);
+ BOOST_REQUIRE(cc.after_statement() == 0);
+ BOOST_REQUIRE(tc.streaming_context().fragments_certified() == 1);
+ BOOST_REQUIRE(cc.before_statement() == 0);
+ BOOST_REQUIRE(cc.before_commit() == 0);
+ BOOST_REQUIRE(cc.ordered_commit() == 0);
+ BOOST_REQUIRE(cc.after_commit() == 0);
+ BOOST_REQUIRE(cc.after_statement() == 0);
+ BOOST_REQUIRE(sc.provider().fragments() == 2);
+ BOOST_REQUIRE(sc.provider().start_fragments() == 1);
+ BOOST_REQUIRE(sc.provider().commit_fragments() == 1);
+}
+
+BOOST_FIXTURE_TEST_CASE(transaction_statement_streaming_cert_fail,
+ streaming_client_fixture_statement)
+{
+ BOOST_REQUIRE(cc.start_transaction(wsrep::transaction_id(1)) == 0);
+ BOOST_REQUIRE(cc.after_row() == 0);
+ BOOST_REQUIRE(tc.streaming_context().fragments_certified() == 0);
+ sc.provider().certify_result_ = wsrep::provider::error_certification_failed;
+ BOOST_REQUIRE(cc.after_statement());
+ BOOST_REQUIRE(cc.current_error() == wsrep::e_deadlock_error);
+ // Note: Due to possible limitation in wsrep-API error codes
+ // or a bug in current Galera provider, rollback fragment may be
+ // replicated even in case of certification failure.
+ // If the limitation is lifted later on or the provider is fixed,
+ // the above check should be change for fragments == 0,
+ // rollback_fragments == 0.
+ BOOST_REQUIRE(sc.provider().fragments() == 1);
+ BOOST_REQUIRE(sc.provider().start_fragments() == 0);
+ BOOST_REQUIRE(sc.provider().rollback_fragments() == 1);
+
+ wsrep::high_priority_service* hps(
+ sc.find_streaming_applier(
+ sc.id(), wsrep::transaction_id(1)));
+ BOOST_REQUIRE(hps);
+ hps->rollback(wsrep::ws_handle(), wsrep::ws_meta());
+ hps->after_apply();
+ sc.stop_streaming_applier(sc.id(), wsrep::transaction_id(1));
+ server_service.release_high_priority_service(hps);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// misc //
+///////////////////////////////////////////////////////////////////////////////
+
+BOOST_AUTO_TEST_CASE(transaction_state_strings)
+{
+ BOOST_REQUIRE(wsrep::to_string(
+ wsrep::transaction::s_executing) == "executing");
+ BOOST_REQUIRE(wsrep::to_string(
+ wsrep::transaction::s_preparing) == "preparing");
+ BOOST_REQUIRE(
+ wsrep::to_string(
+ wsrep::transaction::s_certifying) == "certifying");
+ BOOST_REQUIRE(
+ wsrep::to_string(
+ wsrep::transaction::s_committing) == "committing");
+ BOOST_REQUIRE(
+ wsrep::to_string(
+ wsrep::transaction::s_ordered_commit) == "ordered_commit");
+ BOOST_REQUIRE(
+ wsrep::to_string(
+ wsrep::transaction::s_committed) == "committed");
+ BOOST_REQUIRE(
+ wsrep::to_string(
+ wsrep::transaction::s_cert_failed) == "cert_failed");
+ BOOST_REQUIRE(
+ wsrep::to_string(
+ wsrep::transaction::s_must_abort) == "must_abort");
+ BOOST_REQUIRE(
+ wsrep::to_string(
+ wsrep::transaction::s_aborting) == "aborting");
+ BOOST_REQUIRE(
+ wsrep::to_string(
+ wsrep::transaction::s_aborted) == "aborted");
+ BOOST_REQUIRE(
+ wsrep::to_string(
+ wsrep::transaction::s_must_replay) == "must_replay");
+ BOOST_REQUIRE(
+ wsrep::to_string(
+ wsrep::transaction::s_replaying) == "replaying");
+}
diff --git a/wsrep-lib/test/transaction_test_2pc.cpp b/wsrep-lib/test/transaction_test_2pc.cpp
new file mode 100644
index 00000000..8f95828d
--- /dev/null
+++ b/wsrep-lib/test/transaction_test_2pc.cpp
@@ -0,0 +1,290 @@
+/*
+ * Copyright (C) 2018-2019 Codership Oy <info@codership.com>
+ *
+ * This file is part of wsrep-lib.
+ *
+ * Wsrep-lib is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * Wsrep-lib is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with wsrep-lib. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include "client_state_fixture.hpp"
+
+//
+// Test a succesful 2PC transaction lifecycle
+//
+BOOST_FIXTURE_TEST_CASE(transaction_2pc,
+ replicating_client_fixture_2pc)
+{
+ cc.start_transaction(wsrep::transaction_id(1));
+ BOOST_REQUIRE(tc.active());
+ BOOST_REQUIRE(tc.id() == wsrep::transaction_id(1));
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_executing);
+ BOOST_REQUIRE(cc.before_prepare() == 0);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_preparing);
+ BOOST_REQUIRE(tc.ordered());
+ BOOST_REQUIRE(tc.certified());
+ BOOST_REQUIRE(tc.ws_meta().gtid().is_undefined() == false);
+ BOOST_REQUIRE(cc.after_prepare() == 0);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_committing);
+ BOOST_REQUIRE(cc.before_commit() == 0);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_committing);
+ BOOST_REQUIRE(cc.ordered_commit() == 0);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_ordered_commit);
+ BOOST_REQUIRE(cc.after_commit() == 0);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_committed);
+ BOOST_REQUIRE(cc.after_statement() == 0);
+ BOOST_REQUIRE(tc.active() == false);
+ BOOST_REQUIRE(tc.ordered() == false);
+ BOOST_REQUIRE(tc.certified() == false);
+ BOOST_REQUIRE(cc.current_error() == wsrep::e_success);
+}
+
+//
+// Test a 2PC transaction which gets BF aborted before before_prepare
+//
+BOOST_FIXTURE_TEST_CASE(
+ transaction_2pc_bf_before_before_prepare,
+ replicating_client_fixture_2pc)
+{
+ cc.start_transaction(wsrep::transaction_id(1));
+ BOOST_REQUIRE(tc.active());
+ BOOST_REQUIRE(tc.id() == wsrep::transaction_id(1));
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_executing);
+ wsrep_test::bf_abort_unordered(cc);
+ BOOST_REQUIRE(cc.before_prepare());
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_must_abort);
+ BOOST_REQUIRE(tc.certified() == false);
+ BOOST_REQUIRE(tc.ordered() == false);
+ BOOST_REQUIRE(cc.before_rollback() == 0);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_aborting);
+ BOOST_REQUIRE(cc.after_rollback() == 0);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_aborted);
+ BOOST_REQUIRE(cc.after_statement() );
+ BOOST_REQUIRE(tc.active() == false);
+ BOOST_REQUIRE(tc.ordered() == false);
+ BOOST_REQUIRE(tc.certified() == false);
+ BOOST_REQUIRE(cc.current_error());
+}
+
+//
+// Test a 2PC transaction which gets BF aborted before before_prepare
+//
+BOOST_FIXTURE_TEST_CASE(
+ transaction_2pc_bf_before_after_prepare,
+ replicating_client_fixture_2pc)
+{
+ cc.start_transaction(wsrep::transaction_id(1));
+ BOOST_REQUIRE(tc.active());
+ BOOST_REQUIRE(tc.id() == wsrep::transaction_id(1));
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_executing);
+ BOOST_REQUIRE(cc.before_prepare() == 0);
+ BOOST_REQUIRE(tc.certified() == true);
+ BOOST_REQUIRE(tc.ordered() == true);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_preparing);
+ wsrep_test::bf_abort_ordered(cc);
+ BOOST_REQUIRE(cc.after_prepare());
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_must_replay);
+ BOOST_REQUIRE(cc.will_replay_called() == true);
+ BOOST_REQUIRE(cc.before_rollback() == 0);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_must_replay);
+ BOOST_REQUIRE(cc.after_rollback() == 0);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_must_replay);
+ BOOST_REQUIRE(cc.after_statement() == 0);
+ BOOST_REQUIRE(tc.active() == false);
+ BOOST_REQUIRE(tc.ordered() == false);
+ BOOST_REQUIRE(tc.certified() == false);
+ BOOST_REQUIRE(cc.current_error() == wsrep::e_success);
+}
+
+//
+// Test a 2PC transaction which gets BF aborted after_prepare() and
+// the rollback takes place before entering before_commit().
+//
+BOOST_FIXTURE_TEST_CASE(
+ transaction_2pc_bf_after_after_prepare,
+ replicating_client_fixture_2pc)
+{
+ cc.start_transaction(wsrep::transaction_id(1));
+ BOOST_REQUIRE(tc.active());
+ BOOST_REQUIRE(tc.id() == wsrep::transaction_id(1));
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_executing);
+ BOOST_REQUIRE(cc.before_prepare() == 0);
+ BOOST_REQUIRE(cc.after_prepare() == 0);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_committing);
+ wsrep_test::bf_abort_ordered(cc);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_must_abort);
+ BOOST_REQUIRE(cc.before_rollback() == 0);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_must_replay);
+ BOOST_REQUIRE(cc.will_replay_called() == true);
+ BOOST_REQUIRE(cc.after_rollback() == 0);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_must_replay);
+ BOOST_REQUIRE(cc.after_statement() == 0);
+ BOOST_REQUIRE(tc.active() == false);
+ BOOST_REQUIRE(tc.ordered() == false);
+ BOOST_REQUIRE(tc.certified() == false);
+ BOOST_REQUIRE(cc.current_error() == wsrep::e_success);
+}
+
+//
+// Test a 2PC transaction which gets BF aborted between after_prepare()
+// and before_commit()
+//
+BOOST_FIXTURE_TEST_CASE(
+ transaction_2pc_bf_before_before_commit,
+ replicating_client_fixture_2pc)
+{
+ cc.start_transaction(wsrep::transaction_id(1));
+ BOOST_REQUIRE(tc.active());
+ BOOST_REQUIRE(tc.id() == wsrep::transaction_id(1));
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_executing);
+ BOOST_REQUIRE(cc.before_prepare() == 0);
+ BOOST_REQUIRE(cc.after_prepare() == 0);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_committing);
+ wsrep_test::bf_abort_ordered(cc);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_must_abort);
+ BOOST_REQUIRE(cc.before_commit());
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_must_replay);
+ BOOST_REQUIRE(cc.will_replay_called() == true);
+ BOOST_REQUIRE(tc.certified() == true);
+ BOOST_REQUIRE(tc.ordered() == true);
+ BOOST_REQUIRE(cc.before_rollback() == 0);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_must_replay);
+ BOOST_REQUIRE(cc.after_rollback() == 0);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_must_replay);
+ BOOST_REQUIRE(cc.after_statement() == 0);
+ BOOST_REQUIRE(tc.active() == false);
+ BOOST_REQUIRE(tc.ordered() == false);
+ BOOST_REQUIRE(tc.certified() == false);
+ BOOST_REQUIRE(cc.current_error() == wsrep::e_success);
+}
+
+
+//
+// Test a 2PC transaction which gets BF aborted when trying to grab
+// commit order.
+//
+BOOST_FIXTURE_TEST_CASE(
+ transaction_2pc_bf_during_commit_order_enter,
+ replicating_client_fixture_2pc)
+{
+ cc.start_transaction(wsrep::transaction_id(1));
+ BOOST_REQUIRE(tc.active());
+ BOOST_REQUIRE(tc.id() == wsrep::transaction_id(1));
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_executing);
+ BOOST_REQUIRE(cc.before_prepare() == 0);
+ BOOST_REQUIRE(cc.after_prepare() == 0);
+ sc.provider().commit_order_enter_result_ = wsrep::provider::error_bf_abort;
+ BOOST_REQUIRE(cc.before_commit());
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_must_replay);
+ BOOST_REQUIRE(cc.will_replay_called() == true);
+ BOOST_REQUIRE(tc.certified() == true);
+ BOOST_REQUIRE(tc.ordered() == true);
+ sc.provider().commit_order_enter_result_ = wsrep::provider::success;
+ BOOST_REQUIRE(cc.before_rollback() == 0);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_must_replay);
+ BOOST_REQUIRE(cc.after_rollback() == 0);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_must_replay);
+ BOOST_REQUIRE(cc.after_statement() == 0);
+ BOOST_REQUIRE(tc.active() == false);
+ BOOST_REQUIRE(tc.ordered() == false);
+ BOOST_REQUIRE(tc.certified() == false);
+ BOOST_REQUIRE(cc.current_error() == wsrep::e_success);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// STREAMING REPLICATION //
+///////////////////////////////////////////////////////////////////////////////
+
+
+BOOST_FIXTURE_TEST_CASE(transaction_streaming_2pc_commit,
+ streaming_client_fixture_row)
+{
+ BOOST_REQUIRE(cc.start_transaction(wsrep::transaction_id(1)) == 0);
+ BOOST_REQUIRE(cc.after_row() == 0);
+ BOOST_REQUIRE(tc.streaming_context().fragments_certified() == 1);
+ BOOST_REQUIRE(cc.before_prepare() == 0);
+ BOOST_REQUIRE(cc.after_prepare() == 0);
+ BOOST_REQUIRE(cc.before_commit() == 0);
+ BOOST_REQUIRE(cc.ordered_commit() == 0);
+ BOOST_REQUIRE(cc.after_commit() == 0);
+ BOOST_REQUIRE(cc.after_statement() == 0);
+ BOOST_REQUIRE(sc.provider().fragments() == 2);
+ BOOST_REQUIRE(sc.provider().start_fragments() == 1);
+ BOOST_REQUIRE(sc.provider().commit_fragments() == 1);
+}
+
+BOOST_FIXTURE_TEST_CASE(transaction_streaming_2pc_commit_two_statements,
+ streaming_client_fixture_row)
+{
+ BOOST_REQUIRE(cc.start_transaction(wsrep::transaction_id(1)) == 0);
+ BOOST_REQUIRE(cc.after_row() == 0);
+ BOOST_REQUIRE(tc.streaming_context().fragments_certified() == 1);
+ BOOST_REQUIRE(cc.after_statement() == 0);
+ BOOST_REQUIRE(cc.before_statement() == 0);
+ BOOST_REQUIRE(cc.after_row() == 0);
+ BOOST_REQUIRE(tc.streaming_context().fragments_certified() == 2);
+ BOOST_REQUIRE(cc.before_prepare() == 0);
+ BOOST_REQUIRE(cc.after_prepare() == 0);
+ BOOST_REQUIRE(cc.before_commit() == 0);
+ BOOST_REQUIRE(cc.ordered_commit() == 0);
+ BOOST_REQUIRE(cc.after_commit() == 0);
+ BOOST_REQUIRE(cc.after_statement() == 0);
+ BOOST_REQUIRE(sc.provider().fragments() == 3);
+ BOOST_REQUIRE(sc.provider().start_fragments() == 1);
+ BOOST_REQUIRE(sc.provider().commit_fragments() == 1);
+}
+
+//
+// Fragments are removed in before_prepare in running transaction context.
+// However, the BF abort may arrive during this removal and the
+// client_service::remove_fragments() may roll back the transaction
+// internally. This will cause the transaction to leave before_prepare()
+// in aborted state.
+//
+BOOST_FIXTURE_TEST_CASE(transaction_streaming_2pc_bf_abort_during_fragment_removal,
+ streaming_client_fixture_row)
+{
+ BOOST_REQUIRE(cc.start_transaction(wsrep::transaction_id(1)) == 0);
+ BOOST_REQUIRE(cc.after_row() == 0);
+ BOOST_REQUIRE(tc.streaming_context().fragments_certified() == 1);
+ cc.bf_abort_during_fragment_removal_ = true;
+ BOOST_REQUIRE(cc.before_prepare());
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_aborted);
+ BOOST_REQUIRE(cc.after_statement());
+ BOOST_REQUIRE(tc.active() == false);
+ wsrep_test::terminate_streaming_applier(sc, sc.id(),
+ wsrep::transaction_id(1));
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// APPLYING //
+///////////////////////////////////////////////////////////////////////////////
+
+BOOST_FIXTURE_TEST_CASE(transaction_2pc_applying,
+ applying_client_fixture_2pc)
+{
+ BOOST_REQUIRE(cc.before_prepare() == 0);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_preparing);
+ BOOST_REQUIRE(cc.after_prepare() == 0);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_committing);
+ BOOST_REQUIRE(cc.before_commit() == 0);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_committing);
+ BOOST_REQUIRE(cc.ordered_commit() == 0);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_ordered_commit);
+ BOOST_REQUIRE(cc.after_commit() == 0);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_committed);
+ cc.after_applying();
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_committed);
+ BOOST_REQUIRE(tc.active() == false);
+ BOOST_REQUIRE(cc.current_error() == wsrep::e_success);
+}
diff --git a/wsrep-lib/test/transaction_test_xa.cpp b/wsrep-lib/test/transaction_test_xa.cpp
new file mode 100644
index 00000000..d9fbad27
--- /dev/null
+++ b/wsrep-lib/test/transaction_test_xa.cpp
@@ -0,0 +1,296 @@
+#include "client_state_fixture.hpp"
+#include <iostream>
+
+//
+// Test a successful XA transaction lifecycle
+//
+BOOST_FIXTURE_TEST_CASE(transaction_xa,
+ replicating_client_fixture_sync_rm)
+{
+ wsrep::xid xid(1, 9, 0, "test xid");
+
+ BOOST_REQUIRE(cc.start_transaction(wsrep::transaction_id(1)) == 0);
+ cc.assign_xid(xid);
+
+ BOOST_REQUIRE(tc.active());
+ BOOST_REQUIRE(tc.id() == wsrep::transaction_id(1));
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_executing);
+
+ BOOST_REQUIRE(cc.before_prepare() == 0);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_preparing);
+ BOOST_REQUIRE(tc.ordered() == false);
+ // certified() only after the last fragment
+ BOOST_REQUIRE(tc.certified() == false);
+ BOOST_REQUIRE(cc.after_prepare() == 0);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_prepared);
+ BOOST_REQUIRE(tc.streaming_context().fragments_certified() == 1);
+ // XA START + PREPARE fragment
+ BOOST_REQUIRE(sc.provider().start_fragments() == 1);
+ BOOST_REQUIRE(sc.provider().fragments() == 1);
+
+ BOOST_REQUIRE(cc.before_commit() == 0);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_committing);
+ BOOST_REQUIRE(cc.ordered_commit() == 0);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_ordered_commit);
+ BOOST_REQUIRE(tc.ordered());
+ BOOST_REQUIRE(tc.certified());
+ BOOST_REQUIRE(cc.after_commit() == 0);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_committed);
+ // XA PREPARE and XA COMMIT fragments
+ BOOST_REQUIRE(sc.provider().fragments() == 2);
+ BOOST_REQUIRE(sc.provider().commit_fragments() == 1);
+
+ BOOST_REQUIRE(cc.after_statement() == 0);
+ BOOST_REQUIRE(tc.active() == false);
+ BOOST_REQUIRE(tc.ordered() == false);
+ BOOST_REQUIRE(tc.certified() == false);
+ BOOST_REQUIRE(cc.current_error() == wsrep::e_success);
+}
+
+
+//
+// Test detaching of XA transactions
+//
+BOOST_FIXTURE_TEST_CASE(transaction_xa_detach_commit_by_xid,
+ replicating_two_clients_fixture_sync_rm)
+{
+ wsrep::xid xid(1, 1, 1, "id");
+
+ cc1.start_transaction(wsrep::transaction_id(1));
+ cc1.assign_xid(xid);
+ cc1.before_prepare();
+ cc1.after_prepare();
+ BOOST_REQUIRE(sc.provider().fragments() == 1);
+ BOOST_REQUIRE(tc.streaming_context().fragments_certified() == 1);
+
+ cc1.xa_detach();
+
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_aborted);
+ BOOST_REQUIRE(cc1.after_statement() == 0);
+
+ cc2.start_transaction(wsrep::transaction_id(2));
+ cc2.assign_xid(xid);
+ BOOST_REQUIRE(cc2.client_state::commit_by_xid(xid) == 0);
+ BOOST_REQUIRE(cc2.after_statement() == 0);
+ BOOST_REQUIRE(sc.provider().commit_fragments() == 1);
+
+ // xa_detach() creates a streaming applier, clean it up
+ wsrep::mock_high_priority_service* hps(
+ static_cast<wsrep::mock_high_priority_service*>(
+ sc.find_streaming_applier(xid)));
+ BOOST_REQUIRE(hps);
+ hps->rollback(wsrep::ws_handle(), wsrep::ws_meta());
+ hps->after_apply();
+ sc.stop_streaming_applier(sc.id(), wsrep::transaction_id(1));
+ server_service.release_high_priority_service(hps);
+}
+
+BOOST_FIXTURE_TEST_CASE(transaction_xa_detach_rollback_by_xid,
+ replicating_two_clients_fixture_sync_rm)
+{
+ wsrep::xid xid(1, 1, 1, "id");
+
+ cc1.start_transaction(wsrep::transaction_id(1));
+ cc1.assign_xid(xid);
+ cc1.before_prepare();
+ cc1.after_prepare();
+ BOOST_REQUIRE(sc.provider().fragments() == 1);
+ BOOST_REQUIRE(tc.streaming_context().fragments_certified() == 1);
+
+ cc1.xa_detach();
+
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_aborted);
+ BOOST_REQUIRE(cc1.after_statement() == 0);
+
+ cc2.start_transaction(wsrep::transaction_id(2));
+ cc2.assign_xid(xid);
+ BOOST_REQUIRE(cc2.rollback_by_xid(xid) == 0);
+ BOOST_REQUIRE(cc2.after_statement() == 0);
+ BOOST_REQUIRE(sc.provider().rollback_fragments() == 1);
+
+ // xa_detach() creates a streaming applier, clean it up
+ wsrep::mock_high_priority_service* hps(
+ static_cast<wsrep::mock_high_priority_service*>(
+ sc.find_streaming_applier(xid)));
+ BOOST_REQUIRE(hps);
+ hps->rollback(wsrep::ws_handle(), wsrep::ws_meta());
+ hps->after_apply();
+ sc.stop_streaming_applier(sc.id(), wsrep::transaction_id(1));
+ server_service.release_high_priority_service(hps);
+}
+
+
+//
+// Test XA replay
+//
+BOOST_FIXTURE_TEST_CASE(transaction_xa_replay,
+ replicating_client_fixture_sync_rm)
+{
+ wsrep::xid xid(1, 1, 1, "id");
+
+ cc.start_transaction(wsrep::transaction_id(1));
+ cc.assign_xid(xid);
+ cc.before_prepare();
+ cc.after_prepare();
+ cc.after_command_before_result();
+ cc.after_command_after_result();
+ BOOST_REQUIRE(cc.state() == wsrep::client_state::s_idle);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_prepared);
+ wsrep_test::bf_abort_unordered(cc);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_must_replay);
+
+ // this is normally done by rollbacker
+ cc.xa_replay();
+ cc.sync_rollback_complete();
+
+ BOOST_REQUIRE(cc.unordered_replays() == 1);
+
+ // xa_replay() creates a streaming applier, clean it up
+ wsrep::mock_high_priority_service* hps(
+ static_cast<wsrep::mock_high_priority_service*>(
+ sc.find_streaming_applier(sc.id(), wsrep::transaction_id(1))));
+ BOOST_REQUIRE(hps);
+ hps->rollback(wsrep::ws_handle(), wsrep::ws_meta());
+ hps->after_apply();
+ sc.stop_streaming_applier(sc.id(), wsrep::transaction_id(1));
+ server_service.release_high_priority_service(hps);
+}
+
+BOOST_FIXTURE_TEST_CASE(transaction_xa_replay_after_command_before_result,
+ replicating_client_fixture_sync_rm)
+{
+ wsrep::xid xid(1, 1, 1, "id");
+
+ cc.start_transaction(wsrep::transaction_id(1));
+ cc.assign_xid(xid);
+ cc.before_prepare();
+ cc.after_prepare();
+ BOOST_REQUIRE(cc.state() == wsrep::client_state::s_exec);
+ wsrep_test::bf_abort_unordered(cc);
+ cc.after_command_before_result();
+ cc.after_command_after_result();
+
+ BOOST_REQUIRE(cc.unordered_replays() == 1);
+
+ // xa_replay() creates a streaming applier, clean it up
+ wsrep::mock_high_priority_service* hps(
+ static_cast<wsrep::mock_high_priority_service*>(
+ sc.find_streaming_applier(sc.id(), wsrep::transaction_id(1))));
+ BOOST_REQUIRE(hps);
+ hps->rollback(wsrep::ws_handle(), wsrep::ws_meta());
+ hps->after_apply();
+ sc.stop_streaming_applier(sc.id(), wsrep::transaction_id(1));
+ server_service.release_high_priority_service(hps);
+}
+
+BOOST_FIXTURE_TEST_CASE(transaction_xa_replay_after_command_after_result,
+ replicating_client_fixture_sync_rm)
+{
+ wsrep::xid xid(1, 1, 1, "id");
+
+ cc.start_transaction(wsrep::transaction_id(1));
+ cc.assign_xid(xid);
+ cc.before_prepare();
+ cc.after_prepare();
+ cc.after_command_before_result();
+ BOOST_REQUIRE(cc.state() == wsrep::client_state::s_result);
+ wsrep_test::bf_abort_unordered(cc);
+
+ cc.after_command_after_result();
+
+ BOOST_REQUIRE(cc.unordered_replays() == 1);
+
+ // xa_replay() creates a a streaming applier, clean it up
+ wsrep::mock_high_priority_service* hps(
+ static_cast<wsrep::mock_high_priority_service*>(
+ sc.find_streaming_applier(sc.id(), wsrep::transaction_id(1))));
+ BOOST_REQUIRE(hps);
+ hps->rollback(wsrep::ws_handle(), wsrep::ws_meta());
+ hps->after_apply();
+ sc.stop_streaming_applier(sc.id(), wsrep::transaction_id(1));
+ server_service.release_high_priority_service(hps);
+}
+
+//
+// Test a successful XA transaction lifecycle (applying side)
+//
+BOOST_FIXTURE_TEST_CASE(transaction_xa_applying,
+ applying_client_fixture)
+{
+ wsrep::xid xid(1, 9, 0, "test xid");
+
+ start_transaction(wsrep::transaction_id(1), wsrep::seqno(1));
+ cc.assign_xid(xid);
+
+ BOOST_REQUIRE(cc.before_prepare() == 0);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_preparing);
+ BOOST_REQUIRE(tc.ordered());
+ BOOST_REQUIRE(tc.certified());
+ BOOST_REQUIRE(tc.ws_meta().gtid().is_undefined() == false);
+ BOOST_REQUIRE(cc.after_prepare() == 0);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_prepared);
+
+ BOOST_REQUIRE(cc.before_commit() == 0);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_committing);
+ BOOST_REQUIRE(cc.ordered_commit() == 0);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_ordered_commit);
+ BOOST_REQUIRE(cc.after_commit() == 0);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_committed);
+ cc.after_applying();
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_committed);
+ BOOST_REQUIRE(tc.active() == false);
+ BOOST_REQUIRE(cc.current_error() == wsrep::e_success);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// STREAMING REPLICATION //
+///////////////////////////////////////////////////////////////////////////////
+
+//
+// Test a successful XA transaction lifecycle
+//
+BOOST_FIXTURE_TEST_CASE(transaction_xa_sr,
+ streaming_client_fixture_byte)
+{
+ wsrep::xid xid(1, 9, 0, "test xid");
+
+ BOOST_REQUIRE(cc.start_transaction(wsrep::transaction_id(1)) == 0);
+ cc.assign_xid(xid);
+
+ cc.bytes_generated_ = 1;
+ BOOST_REQUIRE(cc.after_row() == 0);
+ BOOST_REQUIRE(tc.streaming_context().fragments_certified() == 1);
+ // XA START fragment with data
+ BOOST_REQUIRE(sc.provider().fragments() == 1);
+ BOOST_REQUIRE(sc.provider().start_fragments() == 1);
+
+ BOOST_REQUIRE(tc.active());
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_executing);
+
+ BOOST_REQUIRE(cc.before_prepare() == 0);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_preparing);
+ BOOST_REQUIRE(tc.ordered() == false);
+ BOOST_REQUIRE(tc.certified() == false);
+ BOOST_REQUIRE(cc.after_prepare() == 0);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_prepared);
+ // XA PREPARE fragment
+ BOOST_REQUIRE(sc.provider().fragments() == 2);
+
+ BOOST_REQUIRE(cc.before_commit() == 0);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_committing);
+ BOOST_REQUIRE(cc.ordered_commit() == 0);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_ordered_commit);
+ BOOST_REQUIRE(tc.ordered());
+ BOOST_REQUIRE(tc.certified());
+ BOOST_REQUIRE(cc.after_commit() == 0);
+ BOOST_REQUIRE(tc.state() == wsrep::transaction::s_committed);
+ BOOST_REQUIRE(cc.after_statement() == 0);
+ BOOST_REQUIRE(tc.active() == false);
+ BOOST_REQUIRE(tc.ordered() == false);
+ BOOST_REQUIRE(tc.certified() == false);
+ BOOST_REQUIRE(cc.current_error() == wsrep::e_success);
+ // XA START fragment (with data), XA PREPARE fragment and XA COMMIT fragment
+ BOOST_REQUIRE(sc.provider().fragments() == 3);
+ BOOST_REQUIRE(sc.provider().start_fragments() == 1);
+ BOOST_REQUIRE(sc.provider().commit_fragments() == 1);
+}
diff --git a/wsrep-lib/test/view_test.cpp b/wsrep-lib/test/view_test.cpp
new file mode 100644
index 00000000..1cab1e7c
--- /dev/null
+++ b/wsrep-lib/test/view_test.cpp
@@ -0,0 +1,105 @@
+/*
+ * Copyright (C) 2018 Codership Oy <info@codership.com>
+ *
+ * This file is part of wsrep-lib.
+ *
+ * Wsrep-lib is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * Wsrep-lib is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with wsrep-lib. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include "wsrep/view.hpp"
+#include <boost/test/unit_test.hpp>
+
+BOOST_AUTO_TEST_CASE(view_test_member_index)
+{
+ std::vector<wsrep::view::member> members;
+ members.push_back(wsrep::view::member(wsrep::id("1"), "", ""));
+ members.push_back(wsrep::view::member(wsrep::id("2"), "", ""));
+ members.push_back(wsrep::view::member(wsrep::id("3"), "", ""));
+
+ wsrep::view view(wsrep::gtid(wsrep::id("cluster"), wsrep::seqno(1)),
+ wsrep::seqno(1),
+ wsrep::view::primary,
+ 0,
+ 1,
+ 0,
+ members);
+ BOOST_REQUIRE(view.member_index(wsrep::id("1")) == 0);
+ BOOST_REQUIRE(view.member_index(wsrep::id("2")) == 1);
+ BOOST_REQUIRE(view.member_index(wsrep::id("3")) == 2);
+ BOOST_REQUIRE(view.member_index(wsrep::id("4")) == -1);
+}
+
+BOOST_AUTO_TEST_CASE(view_test_equal_membership)
+{
+ std::vector<wsrep::view::member> m1;
+ m1.push_back(wsrep::view::member(wsrep::id("1"), "", ""));
+ m1.push_back(wsrep::view::member(wsrep::id("2"), "", ""));
+ m1.push_back(wsrep::view::member(wsrep::id("3"), "", ""));
+
+ std::vector<wsrep::view::member> m2;
+ m2.push_back(wsrep::view::member(wsrep::id("2"), "", ""));
+ m2.push_back(wsrep::view::member(wsrep::id("3"), "", ""));
+ m2.push_back(wsrep::view::member(wsrep::id("1"), "", ""));
+
+ std::vector<wsrep::view::member> m3;
+ m3.push_back(wsrep::view::member(wsrep::id("1"), "", ""));
+ m3.push_back(wsrep::view::member(wsrep::id("2"), "", ""));
+ m3.push_back(wsrep::view::member(wsrep::id("3"), "", ""));
+ m3.push_back(wsrep::view::member(wsrep::id("4"), "", ""));
+
+ wsrep::view v1(wsrep::gtid(wsrep::id("cluster"), wsrep::seqno(1)),
+ wsrep::seqno(1),
+ wsrep::view::primary,
+ 0,
+ 1,
+ 0,
+ m1);
+
+ wsrep::view v2(wsrep::gtid(wsrep::id("cluster"), wsrep::seqno(1)),
+ wsrep::seqno(1),
+ wsrep::view::primary,
+ 0,
+ 1,
+ 0,
+ m2);
+
+ wsrep::view v3(wsrep::gtid(wsrep::id("cluster"), wsrep::seqno(1)),
+ wsrep::seqno(1),
+ wsrep::view::primary,
+ 0,
+ 1,
+ 0,
+ m3);
+
+ BOOST_REQUIRE(v1.equal_membership(v2));
+ BOOST_REQUIRE(v2.equal_membership(v1));
+ BOOST_REQUIRE(!v1.equal_membership(v3));
+ BOOST_REQUIRE(!v3.equal_membership(v1));
+}
+
+BOOST_AUTO_TEST_CASE(view_test_is_member)
+{
+ wsrep::view view(wsrep::gtid(wsrep::id("cluster"), wsrep::seqno(1)),
+ wsrep::seqno(1),
+ wsrep::view::primary,
+ 0,
+ 1,
+ 0,
+ { wsrep::view::member(wsrep::id("1"), "", ""),
+ wsrep::view::member(wsrep::id("2"), "", "") });
+
+ BOOST_REQUIRE(view.is_member(wsrep::id("2")));
+ BOOST_REQUIRE(view.is_member(wsrep::id("1")));
+ BOOST_REQUIRE(not view.is_member(wsrep::id("0")));
+}
diff --git a/wsrep-lib/test/wsrep-lib_test.cpp b/wsrep-lib/test/wsrep-lib_test.cpp
new file mode 100644
index 00000000..4eedaa30
--- /dev/null
+++ b/wsrep-lib/test/wsrep-lib_test.cpp
@@ -0,0 +1,119 @@
+/*
+ * Copyright (C) 2018-2019 Codership Oy <info@codership.com>
+ *
+ * This file is part of wsrep-lib.
+ *
+ * Wsrep-lib is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * Wsrep-lib is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with wsrep-lib. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+/** @file wsrep-lib_test.cpp
+ *
+ * Run wsrep-lib unit tests.
+ *
+ * Commandline arguments:
+ *
+ * --wsrep-log-file=<file> Write log from wsrep-lib logging facility
+ * into <file>. If <file> is left empty, the
+ * log is written into stdout.
+ * --wsrep-debug-level=<int> Set debug level
+ * See wsrep::log::debug_level for valid values
+ */
+
+#include "wsrep/logger.hpp"
+#include <fstream>
+
+#define BOOST_TEST_ALTERNATIVE_INIT_API
+#include <boost/test/included/unit_test.hpp>
+
+// Log file to write messages logged via wsrep-lib logging facility.
+static std::string log_file_name("wsrep-lib_test.log");
+static std::ofstream log_file;
+// Debug log level for wsrep-lib logging
+static std::string debug_log_level;
+
+
+static void log_fn(wsrep::log::level level,
+ const char* pfx,
+ const char* msg)
+{
+ log_file << wsrep::log::to_c_string(level) << " " << pfx << msg << std::endl;
+}
+
+static bool parse_arg(const std::string& arg)
+{
+ const std::string delim("=");
+ auto delim_pos(arg.find(delim));
+ const auto parm(arg.substr(0, delim_pos));
+ std::string val;
+ if (delim_pos != std::string::npos)
+ {
+ val = arg.substr(delim_pos + 1);
+ }
+
+ if (parm == "--wsrep-log-file")
+ {
+ log_file_name = val;
+ }
+ else if (parm == "--wsrep-debug-level")
+ {
+ debug_log_level = val;
+ }
+ else
+ {
+ std::cerr << "Error: Unknown argument " << arg << std::endl;
+ return false;
+ }
+ return true;
+}
+
+static bool setup_env(int argc, char* argv[])
+{
+ for (int i(1); i < argc; ++i)
+ {
+ if (parse_arg(argv[i]) == false)
+ {
+ return false;
+ }
+ }
+
+ if (log_file_name.size())
+ {
+ log_file.open(log_file_name);
+ if (!log_file)
+ {
+ int err(errno);
+ std::cerr << "Failed to open '" << log_file_name
+ << "': '" << ::strerror(err) << "'" << std::endl;
+ return false;
+ }
+ std::cout << "Writing wsrep-lib log into '" << log_file_name << "'"
+ << std::endl;
+ wsrep::log::logger_fn(log_fn);
+ }
+
+ if (debug_log_level.size())
+ {
+ int level = std::stoi(debug_log_level);
+ std::cout << "Setting debug level '" << level << "'" << std::endl;
+ wsrep::log::debug_log_level(level);
+ }
+
+ return true;
+}
+
+bool init_unit_test()
+{
+ return setup_env(boost::unit_test::framework::master_test_suite().argc,
+ boost::unit_test::framework::master_test_suite().argv);
+}
diff --git a/wsrep-lib/test/xid_test.cpp b/wsrep-lib/test/xid_test.cpp
new file mode 100644
index 00000000..ce2ffab4
--- /dev/null
+++ b/wsrep-lib/test/xid_test.cpp
@@ -0,0 +1,90 @@
+/*
+ * Copyright (C) 2020 Codership Oy <info@codership.com>
+ *
+ * This file is part of wsrep-lib.
+ *
+ * Wsrep-lib is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * Wsrep-lib is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with wsrep-lib. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include "wsrep/xid.hpp"
+#include <boost/test/unit_test.hpp>
+
+BOOST_AUTO_TEST_CASE(xid_test_is_null)
+{
+ wsrep::xid null_xid;
+ BOOST_REQUIRE(null_xid.is_null());
+ wsrep::xid test_xid(1,0,0,nullptr);
+ BOOST_REQUIRE(!test_xid.is_null());
+}
+
+BOOST_AUTO_TEST_CASE(xid_test_equal)
+{
+ wsrep::xid a(1,1,1,"ab");
+ wsrep::xid b(1,1,1,"ab");
+ BOOST_REQUIRE(a == b);
+}
+
+BOOST_AUTO_TEST_CASE(xid_test_null_equal)
+{
+ wsrep::xid a;
+ wsrep::xid b;
+ BOOST_REQUIRE(a == b);
+ BOOST_REQUIRE(a.is_null());
+}
+
+BOOST_AUTO_TEST_CASE(xid_test_not_equal)
+{
+ wsrep::xid a(1,1,0,"a");
+ wsrep::xid b(1,0,1,"a");
+ wsrep::xid c(-1,1,0,"a");
+ wsrep::xid d(1,1,0,"b");
+ BOOST_REQUIRE(!(a == b));
+ BOOST_REQUIRE(!(a == c));
+ BOOST_REQUIRE(!(a == d));
+}
+
+BOOST_AUTO_TEST_CASE(xid_clear)
+{
+ wsrep::xid null_xid;
+ wsrep::xid to_clear(1, 1, 0, "a");
+ to_clear.clear();
+ BOOST_REQUIRE(to_clear.is_null());
+ BOOST_REQUIRE(null_xid == to_clear);
+}
+
+BOOST_AUTO_TEST_CASE(xid_to_string)
+{
+ wsrep::xid null_xid;
+ std::stringstream null_xid_str;
+ null_xid_str << null_xid;
+ BOOST_REQUIRE(null_xid_str.str() == "");
+
+ wsrep::xid test_xid(1,4,0,"test");
+ std::string xid_str(to_string(test_xid));
+ BOOST_REQUIRE(xid_str == "test");
+}
+
+static bool exception_check(const wsrep::runtime_error&)
+{
+ return true;
+}
+
+BOOST_AUTO_TEST_CASE(xid_too_big)
+{
+ std::string s(65,'a');
+ BOOST_REQUIRE_EXCEPTION(wsrep::xid a(1, 65, 0, s.c_str()),
+ wsrep::runtime_error, exception_check);
+ BOOST_REQUIRE_EXCEPTION(wsrep::xid b(1, 0, 65, s.c_str()),
+ wsrep::runtime_error, exception_check);
+}