From 9bc1623dd3b23c0b77ea080ded4d9345ec6eb7f3 Mon Sep 17 00:00:00 2001 From: Leonard Viktor Pooch Date: Mon, 6 Dec 2021 14:02:32 +0100 Subject: [PATCH] in progress --- .../inc/com/centreon/broker/broker_impl.hh | 16 +-- .../com/centreon/broker/mysql_connection.hh | 16 ++- .../inc/com/centreon/broker/stats/center.hh | 3 +- centreon-broker/core/src/broker.proto | 11 +- centreon-broker/core/src/broker_impl.cc | 40 ++++--- centreon-broker/core/src/mysql_connection.cc | 91 ++++++++-------- centreon-broker/core/src/mysql_manager.cc | 12 ++- centreon-broker/core/src/stats/center.cc | 37 ++++--- centreon-broker/core/test/rpc/brokerrpc.cc | 102 +++++++++++------- centreon-broker/core/test/rpc/client.cc | 43 ++++++-- .../broker-database/sqlUptime.robot | 18 ++++ 11 files changed, 252 insertions(+), 137 deletions(-) create mode 100644 centreon-tests/broker-database/sqlUptime.robot diff --git a/centreon-broker/core/inc/com/centreon/broker/broker_impl.hh b/centreon-broker/core/inc/com/centreon/broker/broker_impl.hh index 8cd74a556aa..fdff4f5517e 100644 --- a/centreon-broker/core/inc/com/centreon/broker/broker_impl.hh +++ b/centreon-broker/core/inc/com/centreon/broker/broker_impl.hh @@ -35,14 +35,18 @@ class broker_impl final : public Broker::Service { GenericString* response) override; grpc::Status GetSqlConnectionStats(grpc::ServerContext* context, - const GenericInt* request, - SqlConnectionStats* response) override; + const GenericInt* request, + SqlConnectionStats* response) override; + grpc::Status GetAllSqlConnectionsStats( + grpc::ServerContext* context, + const ::google::protobuf::Empty* /*request*/, + AllSqlConnectionsStats* response) override; grpc::Status GetConflictManagerStats(grpc::ServerContext* context, - const ::google::protobuf::Empty* request, - ConflictManagerStats* response) override; + const ::google::protobuf::Empty* request, + ConflictManagerStats* response) override; grpc::Status GetSqlConnectionSize(grpc::ServerContext* context, - const ::google::protobuf::Empty* request, - GenericSize* response) override; + const ::google::protobuf::Empty* request, + GenericSize* response) override; grpc::Status GetNumModules(grpc::ServerContext* context, const ::google::protobuf::Empty* /*request*/, GenericSize* response) override; diff --git a/centreon-broker/core/inc/com/centreon/broker/mysql_connection.hh b/centreon-broker/core/inc/com/centreon/broker/mysql_connection.hh index 5251410b9b8..465e0eb2342 100644 --- a/centreon-broker/core/inc/com/centreon/broker/mysql_connection.hh +++ b/centreon-broker/core/inc/com/centreon/broker/mysql_connection.hh @@ -75,9 +75,6 @@ class mysql_connection { std::atomic_int _tasks_count; bool _need_commit; - bool _isConnected; - std::chrono::time_point _startPoint; - std::unordered_map _stmt; std::unordered_map _stmt_query; @@ -95,6 +92,14 @@ class mysql_connection { int _port; std::atomic _state; + // Intermediate variables used to fill _stats + // _isConnected indicate the state of the connection + // => false : not connected + // => true : connected + // _switchPoint holds the timestamp of the last time _isConnected switched + bool _is_connected; + std::time_t _switch_point; + SqlConnectionStats* _stats; std::time_t _clk; uint32_t _qps; @@ -129,7 +134,7 @@ class mysql_connection { void _prepare_connection(); void _clear_connection(); - void updateStats(void) noexcept; + void update_stats(void) noexcept; public: /**************************************************************************/ @@ -174,6 +179,9 @@ class mysql_connection { void clear_error(); std::string get_error_message(); + bool is_connected(void) const noexcept; + std::time_t get_switch_point(void) const noexcept; + /** * @brief Create an error on the connection. All error created as this, is a * fatal error that will throw an exception later. diff --git a/centreon-broker/core/inc/com/centreon/broker/stats/center.hh b/centreon-broker/core/inc/com/centreon/broker/stats/center.hh index cadbdbff56f..fb8a0b9f111 100644 --- a/centreon-broker/core/inc/com/centreon/broker/stats/center.hh +++ b/centreon-broker/core/inc/com/centreon/broker/stats/center.hh @@ -76,7 +76,8 @@ class center { SqlConnectionStats* register_mysql_connection(); ConflictManagerStats* register_conflict_manager(); bool unregister_mysql_connection(SqlConnectionStats* connection); - void get_sql_connection_stats(uint32_t index, SqlConnectionStats* response); + bool get_sql_connection_stats(uint32_t index, SqlConnectionStats* response); + void get_all_sql_connections_stats(AllSqlConnectionsStats *response); void get_conflict_manager_stats(ConflictManagerStats* response); // bool unregister_endpoint(const std::string& name); // bool unregister_feeder(EndpointStats* ep_stats, const std::string& name); diff --git a/centreon-broker/core/src/broker.proto b/centreon-broker/core/src/broker.proto index cf7ff96e74b..81533b74470 100644 --- a/centreon-broker/core/src/broker.proto +++ b/centreon-broker/core/src/broker.proto @@ -1,7 +1,6 @@ syntax = "proto3"; import "google/protobuf/empty.proto"; -import "google/protobuf/duration.proto"; package com.centreon.broker; @@ -11,6 +10,7 @@ service Broker { // stats rpc GetGenericStats(google.protobuf.Empty) returns (GenericString) {} rpc GetSqlConnectionStats(GenericInt) returns (SqlConnectionStats) {} + rpc GetAllSqlConnectionsStats(google.protobuf.Empty) returns (AllSqlConnectionsStats) {} rpc GetSqlConnectionSize(google.protobuf.Empty) returns (GenericSize) {} rpc GetConflictManagerStats(google.protobuf.Empty) returns (ConflictManagerStats) {} @@ -77,7 +77,14 @@ message EngineStats { message SqlConnectionStats { int32 waiting_tasks = 1; bool is_connected = 2; - google.protobuf.Duration uptime = 3; + oneof since { + uint64 up_since = 3; + uint64 down_since = 4; + } +} + +message AllSqlConnectionsStats { + repeated SqlConnectionStats connections = 1; } message ConflictManagerStats { diff --git a/centreon-broker/core/src/broker_impl.cc b/centreon-broker/core/src/broker_impl.cc index 84c32a27744..90d466de489 100644 --- a/centreon-broker/core/src/broker_impl.cc +++ b/centreon-broker/core/src/broker_impl.cc @@ -190,29 +190,39 @@ grpc::Status broker_impl::GetGenericStats( } grpc::Status broker_impl::GetSqlConnectionStats(grpc::ServerContext* context - __attribute__((unused)), - const GenericInt* request, - SqlConnectionStats* response) { + __attribute__((unused)), + const GenericInt* request, + SqlConnectionStats* response) { uint32_t index = request->value(); - stats::center::instance().get_sql_connection_stats(index, response); - return grpc::Status::OK; + auto status = + stats::center::instance().get_sql_connection_stats(index, response); + return status ? grpc::Status::OK + : grpc::Status( + grpc::StatusCode::NOT_FOUND, + std::string("no sql connection stats found for index: " + + std::to_string(index))); } +grpc::Status broker_impl::GetAllSqlConnectionsStats( + grpc::ServerContext* context __attribute__((unused)), + const ::google::protobuf::Empty* request __attribute__((unused)), + AllSqlConnectionsStats* response) { + stats::center::instance().get_all_sql_connections_stats(response); + return grpc::Status::OK; +} -grpc::Status broker_impl::GetConflictManagerStats(grpc::ServerContext* context - __attribute__((unused)), - const ::google::protobuf::Empty* request - __attribute__((unused)), - ConflictManagerStats* response) { +grpc::Status broker_impl::GetConflictManagerStats( + grpc::ServerContext* context __attribute__((unused)), + const ::google::protobuf::Empty* request __attribute__((unused)), + ConflictManagerStats* response) { stats::center::instance().get_conflict_manager_stats(response); return grpc::Status::OK; } -grpc::Status broker_impl::GetSqlConnectionSize(grpc::ServerContext* context - __attribute__((unused)), - const ::google::protobuf::Empty* request - __attribute__((unused)), - GenericSize* response) { +grpc::Status broker_impl::GetSqlConnectionSize( + grpc::ServerContext* context __attribute__((unused)), + const ::google::protobuf::Empty* request __attribute__((unused)), + GenericSize* response) { stats::center::instance().get_sql_connection_size(response); return grpc::Status::OK; } diff --git a/centreon-broker/core/src/mysql_connection.cc b/centreon-broker/core/src/mysql_connection.cc index 332cfe5e17c..a4c838bd7ce 100644 --- a/centreon-broker/core/src/mysql_connection.cc +++ b/centreon-broker/core/src/mysql_connection.cc @@ -19,8 +19,6 @@ #include -#include - #include "com/centreon/broker/config/applier/init.hh" #include "com/centreon/broker/log_v2.hh" #include "com/centreon/broker/mysql_manager.hh" @@ -98,25 +96,23 @@ void mysql_connection::_clear_connection() { } _stmt.clear(); mysql_close(_conn); + _is_connected = false; + _switch_point = std::time(nullptr); + update_stats(); } /** * @brief Fill statistics if it happened more than 1 second ago */ -void mysql_connection::updateStats(void) noexcept { +void mysql_connection::update_stats(void) noexcept { auto now(std::time(nullptr)); if ((now - _clk) > 1000) { _clk = now; - std::chrono::time_point nowPoint( - std::chrono::steady_clock::now()); - stats::center::instance().execute([this, nowPoint] { - auto duration = std::chrono::duration_cast( - nowPoint - _startPoint) - .count(); + stats::center::instance().execute([this]() { _stats->set_waiting_tasks(_tasks_count); - _stats->set_is_connected(_isConnected); - *_stats->mutable_uptime() = - google::protobuf::util::TimeUtil::MillisecondsToDuration(duration); + _stats->set_is_connected(_is_connected); + _is_connected ? _stats->set_up_since(_switch_point) : + _stats->set_down_since(_switch_point); }); } } @@ -135,6 +131,9 @@ bool mysql_connection::_try_to_reconnect() { _conn = mysql_init(nullptr); if (!_conn) { log_v2::sql()->error("mysql_connection: reconnection failed."); + _is_connected = false; + _switch_point = std::time(nullptr); + update_stats(); return false; } @@ -147,6 +146,9 @@ bool mysql_connection::_try_to_reconnect() { CLIENT_FOUND_ROWS)) { log_v2::sql()->error( "mysql_connection: The mysql/mariadb database seems not started."); + _is_connected = false; + _switch_point = std::time(nullptr); + update_stats(); return false; } @@ -526,6 +528,16 @@ std::string mysql_connection::get_error_message() { return _error.get_message(); } +bool mysql_connection::is_connected(void) const noexcept +{ + return _is_connected; +} + +std::time_t mysql_connection::get_switch_point(void) const noexcept +{ + return _switch_point; +} + /** * @brief Disable the connection's error. Therefore, the connection is no more * in error. @@ -623,23 +635,11 @@ void mysql_connection::_run() { std::list> tasks_list; if (!_tasks_list.empty()) { std::swap(_tasks_list, tasks_list); - // - updateStats(); - /* - stats::center::instance().update(&SqlConnectionStats::set_waiting_tasks, - _stats, - static_cast(_tasks_count)); - */ + update_stats(); assert(_tasks_list.empty()); } else { _tasks_count = 0; - // - updateStats(); - /* - stats::center::instance().update(&SqlConnectionStats::set_waiting_tasks, - _stats, - static_cast(_tasks_count)); - */ + update_stats(); _tasks_condition.wait( lock, [this] { return _finish_asked || !_tasks_list.empty(); }); if (_tasks_list.empty()) { @@ -652,10 +652,18 @@ void mysql_connection::_run() { log_v2::sql()->trace("SQL: performing mysql_ping."); if (mysql_ping(_conn)) { - if (!_try_to_reconnect()) + if (!_try_to_reconnect()) { log_v2::sql()->error("SQL: Reconnection failed."); - } else + _is_connected = false; + _switch_point = std::time(nullptr); + } + } else { log_v2::sql()->trace("SQL: connection always alive"); + _is_connected = true; + _switch_point = std::time(nullptr); + } + + update_stats(); time_t start = time(nullptr); for (auto& task : tasks_list) { @@ -669,13 +677,7 @@ void mysql_connection::_run() { if (time(nullptr) - start != 0) { start = time(nullptr); - // - updateStats(); - /* - stats::center::instance().update( - &SqlConnectionStats::set_waiting_tasks, _stats, - static_cast(_tasks_count)); - */ + update_stats(); } } @@ -696,8 +698,6 @@ mysql_connection::mysql_connection(database_config const& db_cfg) _finish_asked(false), _tasks_count(0), _need_commit(false), - _isConnected(false), - _startPoint{std::chrono::steady_clock::now()}, _host(db_cfg.get_host()), _socket(db_cfg.get_socket()), _user(db_cfg.get_user()), @@ -705,6 +705,8 @@ mysql_connection::mysql_connection(database_config const& db_cfg) _name(db_cfg.get_name()), _port(db_cfg.get_port()), _state(not_started), + _is_connected(false), + _switch_point{std::time(nullptr)}, _stats{stats::center::instance().register_mysql_connection()}, _clk{std::time(nullptr)}, _qps(db_cfg.get_queries_per_transaction()) { @@ -714,17 +716,17 @@ mysql_connection::mysql_connection(database_config const& db_cfg) _start_condition.wait(lck, [this] { return _state != not_started; }); if (_state == finished) { _thread->join(); + _switch_point = std::time(nullptr); + _is_connected = false; log_v2::sql()->error("mysql_connection: error while starting connection"); + update_stats(); throw msg_fmt("mysql_connection: error while starting connection"); } pthread_setname_np(_thread->native_handle(), "mysql_connect"); + _switch_point = std::time(nullptr); + _is_connected = true; log_v2::sql()->info("mysql_connection: connection started"); - - updateStats(); - // stats::center::instance().update(&SqlConnectionStats::set_waiting_tasks, - // _stats, 0); - // stats::center::instance().update(&SqlConnectionStats::set_uptime, _stats, - // 0); + update_stats(); } /** @@ -735,6 +737,8 @@ mysql_connection::~mysql_connection() { log_v2::sql()->info("mysql_connection: finished"); finish(); _thread->join(); + stats::center::instance().unregister_mysql_connection(_stats); + update_stats(); } void mysql_connection::_push(std::unique_ptr&& q) { @@ -745,6 +749,7 @@ void mysql_connection::_push(std::unique_ptr&& q) { _tasks_list.push_back(std::move(q)); ++_tasks_count; _tasks_condition.notify_all(); + update_stats(); } /** diff --git a/centreon-broker/core/src/mysql_manager.cc b/centreon-broker/core/src/mysql_manager.cc index 9af4109409a..7190e48fa45 100644 --- a/centreon-broker/core/src/mysql_manager.cc +++ b/centreon-broker/core/src/mysql_manager.cc @@ -178,5 +178,15 @@ std::map mysql_manager::get_stats() { key.replace(key_len, std::string::npos, std::to_string(i)); retval.insert(std::make_pair(key, std::to_string(_stats_counts[i]))); } + retval.insert(std::make_pair("size", std::to_string(_connection.size()))); + for (std::vector>::iterator conn = _connection.begin(); + conn != _connection.end(); ++conn) { + std::string conn_name = "connection_" + std::to_string(std::distance(_connection.begin(), conn)); + std::stringstream ss; + ss << "connected: " << std::boolalpha << (*conn)->is_connected(); + ss << ", since: " << std::to_string((*conn)->get_switch_point()); + ss << ", tasks: " << std::to_string((*conn)->get_tasks_count()); + retval.insert(std::make_pair(conn_name, ss.str())); + } return retval; -} +} \ No newline at end of file diff --git a/centreon-broker/core/src/stats/center.cc b/centreon-broker/core/src/stats/center.cc index 4841a3d4809..9a3f31a5802 100644 --- a/centreon-broker/core/src/stats/center.cc +++ b/centreon-broker/core/src/stats/center.cc @@ -56,6 +56,10 @@ center::center() : _strand(pool::instance().io_context()) { ASIO_VERSION % 100); _stats.set_pid(getpid()); + // + assert(_stats.connections().size() == 0); + // + /* Bringing modules statistics */ if (config::applier::state::loaded()) { config::applier::modules& mod_applier( @@ -137,7 +141,6 @@ bool center::unregister_mysql_connection(SqlConnectionStats* connection) { return retval.get(); } - /** * @brief When a feeder needs to write statistics, it primarily has to * call this function to be registered in the statistic center and to get @@ -320,24 +323,30 @@ std::string center::to_string() { // done.get(); //} -void center::get_sql_connection_stats(uint32_t index, SqlConnectionStats* response) { +bool center::get_sql_connection_stats(uint32_t index, SqlConnectionStats* response) { std::promise p; std::future done = p.get_future(); _strand.post([&s = this->_stats, &p, &index, response] { - uint32_t i = 0; - for (auto it = s.connections().begin(), - end = s.connections().end(); - it != end; ++it, ++i) { - if (index == i) { - *response = (*it); - } + if (index > static_cast(s.connections().size() - 1)) { + log_v2::sql()->info("mysql_connection: index out of range in get sql connection stats"); + p.set_value(false); } - - if (i > index) { - log_v2::sql()->info("mysql_connection: index out of range in get sql " - "connection stats"); + else { + *response = s.connections().at(index); + p.set_value(true); } - p.set_value(true); + }); + + // We wait for the response. + return done.get(); +} + +void center::get_all_sql_connections_stats(AllSqlConnectionsStats *response) { + std::promise p; + std::future done = p.get_future(); + _strand.post([&s = this->_stats, &p, response] { + response->mutable_connections()->Assign(s.connections().begin(), s.connections().end()); + p.set_value(true); }); // We wait for the response. diff --git a/centreon-broker/core/test/rpc/brokerrpc.cc b/centreon-broker/core/test/rpc/brokerrpc.cc index fbca784fd6b..3f5da1cb8d2 100644 --- a/centreon-broker/core/test/rpc/brokerrpc.cc +++ b/centreon-broker/core/test/rpc/brokerrpc.cc @@ -89,46 +89,30 @@ TEST_F(BrokerRpc, GetSqlConnectionStatsValue) { brokerrpc brpc("0.0.0.0", 40000, "test"); SqlConnectionStats* _stats; std::vector vectests = { - "waiting_tasks: 3, is_connected: false, uptime: 2567\n", - "waiting_tasks: 10, is_connected: true, uptime: 1234\n", - "waiting_tasks: 0, is_connected: false, uptime: 115\n", - "waiting_tasks: 15, is_connected: true, uptime: 356\n"}; + "waiting_tasks: 3, is_connected: false, down_since: 2567\n", + "waiting_tasks: 10, is_connected: true, up_since: 1234\n", + "waiting_tasks: 0, is_connected: false, down_since: 115\n", + "waiting_tasks: 15, is_connected: true, up_since: 356\n"}; _stats = stats::center::instance().register_mysql_connection(); - stats::center::instance().update(&SqlConnectionStats::set_waiting_tasks, - _stats, 3); - stats::center::instance().update(&SqlConnectionStats::set_is_connected, - _stats, false); - stats::center::instance().update( - _stats->mutable_uptime(), - google::protobuf::util::TimeUtil::MillisecondsToDuration(2567)); + stats::center::instance().update(&SqlConnectionStats::set_waiting_tasks, _stats, 3); + stats::center::instance().update(&SqlConnectionStats::set_is_connected, _stats, false); + stats::center::instance().update(&SqlConnectionStats::set_down_since, _stats, 2567lu); _stats = stats::center::instance().register_mysql_connection(); - stats::center::instance().update(&SqlConnectionStats::set_waiting_tasks, - _stats, 10); - stats::center::instance().update(&SqlConnectionStats::set_is_connected, - _stats, true); - stats::center::instance().update( - _stats->mutable_uptime(), - google::protobuf::util::TimeUtil::MillisecondsToDuration(1234)); + stats::center::instance().update(&SqlConnectionStats::set_waiting_tasks, _stats, 10); + stats::center::instance().update(&SqlConnectionStats::set_is_connected, _stats, true); + stats::center::instance().update(&SqlConnectionStats::set_up_since, _stats, 1234lu); _stats = stats::center::instance().register_mysql_connection(); - stats::center::instance().update(&SqlConnectionStats::set_waiting_tasks, - _stats, 0); - stats::center::instance().update(&SqlConnectionStats::set_is_connected, - _stats, false); - stats::center::instance().update( - _stats->mutable_uptime(), - google::protobuf::util::TimeUtil::MillisecondsToDuration(115)); + stats::center::instance().update(&SqlConnectionStats::set_waiting_tasks, _stats, 0); + stats::center::instance().update(&SqlConnectionStats::set_is_connected, _stats, false); + stats::center::instance().update(&SqlConnectionStats::set_down_since, _stats, 115lu); _stats = stats::center::instance().register_mysql_connection(); - stats::center::instance().update(&SqlConnectionStats::set_waiting_tasks, - _stats, 15); - stats::center::instance().update(&SqlConnectionStats::set_is_connected, - _stats, true); - stats::center::instance().update( - _stats->mutable_uptime(), - google::protobuf::util::TimeUtil::MillisecondsToDuration(356)); + stats::center::instance().update(&SqlConnectionStats::set_waiting_tasks, _stats, 15); + stats::center::instance().update(&SqlConnectionStats::set_is_connected, _stats, true); + stats::center::instance().update(&SqlConnectionStats::set_up_since, _stats, 356lu); auto output = execute("GetSqlConnectionStatsValue 4"); @@ -139,17 +123,57 @@ TEST_F(BrokerRpc, GetSqlConnectionStatsValue) { brpc.shutdown(); } +TEST_F(BrokerRpc, GetAllSqlConnectionsStatsValues) { + brokerrpc brpc("0.0.0.0", 40000, "test"); + SqlConnectionStats* _stats; + + std::vector vectests = { + "waiting_tasks: 3, is_connected: false, down_since: 2567\n", + "waiting_tasks: 10, is_connected: true, up_since: 1234\n", + "waiting_tasks: 0, is_connected: false, down_since: 115\n", + "waiting_tasks: 15, is_connected: true, up_since: 356\n"}; + + _stats = stats::center::instance().register_mysql_connection(); + stats::center::instance().update(&SqlConnectionStats::set_waiting_tasks, _stats, 3); + stats::center::instance().update(&SqlConnectionStats::set_is_connected, _stats, false); + stats::center::instance().update(&SqlConnectionStats::set_down_since, _stats, 2567lu); + + _stats = stats::center::instance().register_mysql_connection(); + stats::center::instance().update(&SqlConnectionStats::set_waiting_tasks, _stats, 10); + stats::center::instance().update(&SqlConnectionStats::set_is_connected, _stats, true); + stats::center::instance().update(&SqlConnectionStats::set_up_since, _stats, 1234lu); + + _stats = stats::center::instance().register_mysql_connection(); + stats::center::instance().update(&SqlConnectionStats::set_waiting_tasks, _stats, 0); + stats::center::instance().update(&SqlConnectionStats::set_is_connected, _stats, false); + stats::center::instance().update(&SqlConnectionStats::set_down_since, _stats, 115lu); + + _stats = stats::center::instance().register_mysql_connection(); + stats::center::instance().update(&SqlConnectionStats::set_waiting_tasks, _stats, 15); + stats::center::instance().update(&SqlConnectionStats::set_is_connected, _stats, true); + stats::center::instance().update(&SqlConnectionStats::set_up_since, _stats, 356lu); + + auto size = execute("GetSqlConnectionSize"); + ASSERT_EQ(size.front(), "connection array size: 4\n"); + + auto output = execute("GetAllSqlConnectionsStatsValues"); + std::vector results(output.size()); + std::copy(output.begin(), output.end(), results.begin()); + + ASSERT_EQ(vectests, results); + + brpc.shutdown(); +} + TEST_F(BrokerRpc, GetSqlConnectionSize) { brokerrpc brpc("0.0.0.0", 40000, "test"); SqlConnectionStats* _stats; _stats = stats::center::instance().register_mysql_connection(); - stats::center::instance().update(&SqlConnectionStats::set_waiting_tasks, - _stats, 3); + stats::center::instance().update(&SqlConnectionStats::set_waiting_tasks, _stats, 3); _stats = stats::center::instance().register_mysql_connection(); - stats::center::instance().update(&SqlConnectionStats::set_waiting_tasks, - _stats, 5); + stats::center::instance().update(&SqlConnectionStats::set_waiting_tasks, _stats, 5); auto output = execute("GetSqlConnectionSize"); ASSERT_EQ(output.front(), "connection array size: 2\n"); @@ -162,10 +186,8 @@ TEST_F(BrokerRpc, GetConflictManagerStats) { ConflictManagerStats* _stats; _stats = stats::center::instance().register_conflict_manager(); - stats::center::instance().update(&ConflictManagerStats::set_events_handled, - _stats, 3); - stats::center::instance().update(&ConflictManagerStats::set_loop_timeout, - _stats, 30u); + stats::center::instance().update(&ConflictManagerStats::set_events_handled, _stats, 3); + stats::center::instance().update(&ConflictManagerStats::set_loop_timeout, _stats, 30u); auto output = execute("GetConflictManagerStats"); diff --git a/centreon-broker/core/test/rpc/client.cc b/centreon-broker/core/test/rpc/client.cc index b2b6e7a3d90..25b408c29c8 100644 --- a/centreon-broker/core/test/rpc/client.cc +++ b/centreon-broker/core/test/rpc/client.cc @@ -59,10 +59,23 @@ class BrokerRPCClient { return true; } + bool GetAllSqlConnectionsStats(AllSqlConnectionsStats* response) { + const ::google::protobuf::Empty e; + grpc::ClientContext context; + grpc::Status status = _stub->GetAllSqlConnectionsStats(&context, e, response); + + if (!status.ok()) { + std::cout << "GetAllSqlConnectionsStats rpc failed." << std::endl; + return false; + } + return true; + } + bool GetSqlConnectionSize(GenericSize* response) { const ::google::protobuf::Empty e; grpc::ClientContext context; grpc::Status status = _stub->GetSqlConnectionSize(&context, e, response); + if (!status.ok()) { std::cout << "GetSqlConnectionStats rpc failed." << std::endl; return false; @@ -93,33 +106,41 @@ int main(int argc, char** argv) { exit(1); } - if (strcmp(argv[1], "GetVersion") == 0) { + if (argc == 2 && strcmp(argv[1], "GetVersion") == 0) { Version version; status = client.GetVersion(&version) ? 0 : 1; std::cout << "GetVersion: " << version.DebugString(); } - if (strcmp(argv[1], "GetSqlConnectionStatsValue") == 0) { + if (argc == 3 && strcmp(argv[1], "GetSqlConnectionStatsValue") == 0) { uint32_t sz = atoi(argv[2]); SqlConnectionStats response; for (uint32_t i = 0; i < sz; ++i) { - status = client.GetSqlConnectionStats(&response, i) ? 0 : 1; - std::cout << "waiting_tasks: " << response.waiting_tasks() - << ", is_connected: " << std::boolalpha - << response.is_connected() << ", uptime: " - << google::protobuf::util::TimeUtil::DurationToMilliseconds( - response.uptime()) - << std::endl; + status += client.GetSqlConnectionStats(&response, i) ? 0 : 1; + std::cout << "waiting_tasks: " << response.waiting_tasks() << ", is_connected: " + << std::boolalpha << response.is_connected() + << (response.is_connected() ? (", up_since: " + std::to_string(response.up_since())) : + (", down_since: " + std::to_string(response.down_since()))) << std::endl; } } - if (strcmp(argv[1], "GetSqlConnectionSize") == 0) { + if (argc == 2 && strcmp(argv[1], "GetAllSqlConnectionsStatsValues") == 0) { + AllSqlConnectionsStats response; + status = client.GetAllSqlConnectionsStats(&response); + for (auto res : response.connections()) + std::cout << "waiting_tasks: " << res.waiting_tasks() << ", is_connected: " + << std::boolalpha << res.is_connected() + << (res.is_connected() ? (", up_since: " + std::to_string(res.up_since())) : + (", down_since: " + std::to_string(res.down_since()))) << std::endl; + } + + if (argc == 2 && strcmp(argv[1], "GetSqlConnectionSize") == 0) { GenericSize response; status = client.GetSqlConnectionSize(&response) ? 0 : 1; std::cout << "connection array size: " << response.size() << std::endl; } - if (strcmp(argv[1], "GetConflictManagerStats") == 0) { + if (argc == 2 && strcmp(argv[1], "GetConflictManagerStats") == 0) { ConflictManagerStats response; status = client.GetConflictManagerStats(&response) ? 0 : 1; std::cout << "events_handled: " << response.events_handled() << std::endl; diff --git a/centreon-tests/broker-database/sqlUptime.robot b/centreon-tests/broker-database/sqlUptime.robot new file mode 100644 index 00000000000..92a97f6d874 --- /dev/null +++ b/centreon-tests/broker-database/sqlUptime.robot @@ -0,0 +1,18 @@ +*** Settings *** +Resource ../resources/resources.robot +Suite Setup Clean Before Suite +Suite Teardown Clean After Suite +Test Setup Stop Processes + +Documentation Centreon Broker database stats +Library Process +Library DateTime +Library OperatingSystem +Library ../resources/BrokerDatabase.py +Library ../resources/Common.py +Library ../resources/Broker.py +Library ../resources/Engine.py + +*** Test Cases *** + +*** Keywords *** \ No newline at end of file