62e06d4b70
Summary: Once a leader loses it's leadership, in order to handle hanging transactions, we reset the storage and the transaction engine. This requires to re-apply all the commited entries from the log. Once we add snapshot (log compaction) we would need to do that also. One thing to have in mind is the `election_timeout_min` parameter. If it's set too low it could trigger leader re-election too often. Reviewers: ipaljak Reviewed By: ipaljak Subscribers: pullbot Differential Revision: https://phabricator.memgraph.io/D1822
127 lines
4.0 KiB
C++
127 lines
4.0 KiB
C++
#include <atomic>
|
|
#include <chrono>
|
|
#include <experimental/optional>
|
|
#include <fstream>
|
|
#include <thread>
|
|
|
|
#include <fmt/format.h>
|
|
#include <gflags/gflags.h>
|
|
|
|
#include "communication/bolt/client.hpp"
|
|
#include "io/network/endpoint.hpp"
|
|
#include "io/network/utils.hpp"
|
|
#include "utils/flag_validation.hpp"
|
|
#include "utils/thread.hpp"
|
|
#include "utils/timer.hpp"
|
|
|
|
using namespace std::literals::chrono_literals;
|
|
|
|
DEFINE_string(address, "127.0.0.1", "Server address");
|
|
DEFINE_int32(port, 7687, "Server port");
|
|
DEFINE_int32(cluster_size, 3, "Size of the raft cluster.");
|
|
DEFINE_string(username, "", "Username for the database");
|
|
DEFINE_string(password, "", "Password for the database");
|
|
DEFINE_bool(use_ssl, false, "Set to true to connect with SSL to the server.");
|
|
DEFINE_double(duration, 10.0,
|
|
"How long should the client perform writes (seconds)");
|
|
DEFINE_string(output_file, "", "Output file where the results should be.");
|
|
|
|
std::experimental::optional<io::network::Endpoint> GetLeaderEndpoint() {
|
|
for (int retry = 0; retry < 10; ++retry) {
|
|
for (int i = 0; i < FLAGS_cluster_size; ++i) {
|
|
try {
|
|
communication::ClientContext context(FLAGS_use_ssl);
|
|
communication::bolt::Client client(&context);
|
|
|
|
uint16_t port = FLAGS_port + i;
|
|
io::network::Endpoint endpoint{FLAGS_address, port};
|
|
|
|
client.Connect(endpoint, FLAGS_username, FLAGS_password);
|
|
client.Execute("MATCH (n) RETURN n", {});
|
|
client.Close();
|
|
|
|
// If we succeeded with the above query, we found the current leader.
|
|
return std::experimental::make_optional(endpoint);
|
|
|
|
} catch (const communication::bolt::ClientQueryException &) {
|
|
// This one is not the leader, continue.
|
|
continue;
|
|
} catch (const communication::bolt::ClientFatalException &) {
|
|
// This one seems to be down, continue.
|
|
continue;
|
|
}
|
|
}
|
|
LOG(INFO) << "Couldn't find Raft cluster leader, retrying...";
|
|
std::this_thread::sleep_for(1s);
|
|
}
|
|
|
|
return std::experimental::nullopt;
|
|
}
|
|
|
|
int main(int argc, char **argv) {
|
|
gflags::ParseCommandLineFlags(&argc, &argv, true);
|
|
google::SetUsageMessage("Memgraph HA benchmark client");
|
|
google::InitGoogleLogging(argv[0]);
|
|
|
|
std::atomic<int64_t> query_counter{0};
|
|
|
|
auto leader_endpoint = GetLeaderEndpoint();
|
|
if (!leader_endpoint) {
|
|
LOG(ERROR) << "Couldn't find Raft cluster leader!";
|
|
return 1;
|
|
}
|
|
|
|
const int num_threads = std::thread::hardware_concurrency();
|
|
std::vector<std::thread> threads;
|
|
std::vector<double> thread_duration;
|
|
threads.reserve(num_threads);
|
|
thread_duration.resize(num_threads);
|
|
|
|
for (int i = 0; i < num_threads; ++i) {
|
|
threads.emplace_back([i, endpoint = *leader_endpoint, &query_counter,
|
|
&local_duration = thread_duration[i]]() {
|
|
utils::ThreadSetName(fmt::format("BenchWriter{}", i));
|
|
communication::ClientContext context(FLAGS_use_ssl);
|
|
communication::bolt::Client client(&context);
|
|
client.Connect(endpoint, FLAGS_username, FLAGS_password);
|
|
|
|
utils::Timer t;
|
|
while (true) {
|
|
local_duration = t.Elapsed().count();
|
|
if (local_duration >= FLAGS_duration) break;
|
|
|
|
try {
|
|
client.Execute("CREATE (:Node)", {});
|
|
query_counter.fetch_add(1);
|
|
} catch (const communication::bolt::ClientQueryException &e) {
|
|
LOG(WARNING) << e.what();
|
|
break;
|
|
} catch (const communication::bolt::ClientFatalException &e) {
|
|
LOG(WARNING) << e.what();
|
|
break;
|
|
}
|
|
}
|
|
|
|
client.Close();
|
|
});
|
|
}
|
|
|
|
for (auto &t : threads) {
|
|
if (t.joinable()) t.join();
|
|
}
|
|
|
|
double duration = 0;
|
|
for (auto &d : thread_duration) duration += d;
|
|
duration /= num_threads;
|
|
|
|
double write_per_second = query_counter / duration;
|
|
|
|
std::ofstream output(FLAGS_output_file);
|
|
output << "duration " << duration << std::endl;
|
|
output << "executed_writes " << query_counter << std::endl;
|
|
output << "write_per_second " << write_per_second << std::endl;
|
|
output.close();
|
|
|
|
return 0;
|
|
}
|