--- /dev/null
+#include <ostream>
+#include <cstdlib>
+#include <fstream>
+#include <string>
+#include <iostream>
+#include <boost/property_tree/ptree.hpp>
+#include <boost/property_tree/json_parser.hpp>
+#include <chrono>
+#include <arpa/inet.h>
+#include <sdl/asyncstorage.hpp>
+#include <boost/asio.hpp>
+#include <thread>
+#include "private/cli/commandmap.hpp"
+#include "private/configurationpaths.hpp"
+#include "private/createlogger.hpp"
+#include "private/engineimpl.hpp"
+#include "private/databaseconfigurationimpl.hpp"
+#include "private/configurationreader.hpp"
+#include "private/redis/databaseinfo.hpp"
+#include "private/asyncstorageimpl.hpp"
+#include "private/redis/asyncredisstorage.hpp"
+
+using namespace shareddatalayer;
+using namespace shareddatalayer::cli;
+using namespace shareddatalayer::redis;
+
+namespace
+{
+ void handler(std::shared_ptr<shareddatalayer::AsyncStorage> sdl, boost::asio::posix::stream_descriptor& sd)
+ {
+ sdl->handleEvents();
+ sd.async_read_some(boost::asio::null_buffers(), std::bind(handler, sdl, std::ref(sd)));
+ }
+
+ std::shared_ptr<AsyncStorage> createStorage(const std::string& nsStr, std::ostream& out)
+ {
+ try
+ {
+ std::shared_ptr<AsyncStorage> sdl(AsyncStorage::create());
+ boost::asio::io_service ios;
+ boost::asio::posix::stream_descriptor sd(ios);
+ sd.assign(sdl->fd());
+ sd.async_read_some(boost::asio::null_buffers(), std::bind(handler, sdl, std::ref(sd)));
+ sdl->waitReadyAsync(nsStr, [&ios](const std::error_code& error)
+ {
+ if (error)
+ std::cerr << "SDL waitReadyAsync failed. Error:\n" << error.message() << std::endl;
+ ios.stop();
+ });
+ ios.run();
+ sd.release();
+ out << "Storage to namespace " << nsStr << " created." << std::endl;
+ return sdl;
+ }
+ catch (const shareddatalayer::Exception& error)
+ {
+ out << "Storage create failed: " << error.what() << std::endl;
+ }
+ return nullptr;
+ }
+
+ std::string getHosts(const DatabaseConfiguration::Addresses& databaseAddresses)
+ {
+ std::string hosts("");
+ for (auto i(databaseAddresses.begin()); i != databaseAddresses.end(); ++i)
+ hosts = hosts + i->getHost() + " ";
+ return hosts;
+ }
+
+ std::string getPorts(const DatabaseConfiguration::Addresses& databaseAddresses)
+ {
+ std::string ports("");
+ for (auto i(databaseAddresses.begin()); i != databaseAddresses.end(); ++i)
+ ports = ports + std::to_string(ntohs(i->getPort())) + " ";
+ return ports;
+ }
+
+ void PrintStaticConfiguration(std::ostream& out)
+ {
+ auto engine(std::make_shared<EngineImpl>());
+ DatabaseConfigurationImpl databaseConfigurationImpl;
+ ConfigurationReader configurationReader(createLogger(SDL_LOG_PREFIX));
+ configurationReader.readDatabaseConfiguration(databaseConfigurationImpl);
+ auto staticAddresses(databaseConfigurationImpl.getServerAddresses());
+ auto defaultAddresses(databaseConfigurationImpl.getDefaultServerAddresses());
+ auto staticDbType(databaseConfigurationImpl.getDbType());
+ if (!staticAddresses.empty())
+ {
+ out << "\nStatic Server Addresses:" << std::endl;
+ out << "Static Host: " << getHosts(staticAddresses) << std::endl;
+ out << "Static Port: " << getPorts(staticAddresses) << std::endl;
+ if (staticDbType == DatabaseConfiguration::DbType::REDIS_CLUSTER)
+ out << "Static DB type: redis-cluster" << std::endl;
+ else if (staticDbType == DatabaseConfiguration::DbType::REDIS_STANDALONE)
+ out << "Static DB type: redis-standalone" << std::endl;
+ else
+ out << "Static DB type not defined" << std::endl;
+ }
+ if (!defaultAddresses.empty() && staticAddresses.empty())
+ {
+ out << "\nDefault Server Addresses:" << std::endl;
+ out << "Default Host: " << getHosts(defaultAddresses) << std::endl;
+ out << "Default Port: " << getPorts(defaultAddresses) << std::endl;
+ }
+ const auto var(DB_HOST_ENV_VAR_NAME);
+ const auto conf(getenv(var));
+ if (conf != nullptr)
+ out << var << ": " << conf << std::endl;
+ }
+
+ void PrintDatabaseInfo(const DatabaseInfo& databaseInfo, std::ostream& out)
+ {
+ out << "Used database configuration (databaseInfo):" << std::endl;
+ out << "Host: " << getHosts(databaseInfo.hosts) << std::endl;
+ out << "Port: " << getPorts(databaseInfo.hosts) << std::endl;
+ switch (databaseInfo.type)
+ {
+ case DatabaseInfo::Type::SINGLE:
+ out << "Database type: SINGLE" << std::endl;
+ break;
+ case DatabaseInfo::Type::REDUNDANT:
+ out << "Database type: REDUNDANT" << std::endl;
+ break;
+ case DatabaseInfo::Type::CLUSTER:
+ out << "Database type: CLUSTER" << std::endl;
+ break;
+ }
+ switch (databaseInfo.discovery)
+ {
+ case DatabaseInfo::Discovery::HIREDIS:
+ out << "Discovery type:: HIREDIS" << std::endl;
+ PrintStaticConfiguration(out);
+ break;
+ }
+ }
+
+ [[noreturn]] void timeoutThread(const int& timeout)
+ {
+ std::this_thread::sleep_for(std::chrono::seconds(timeout));
+ std::cerr << "Storage create timeout, aborting after " << timeout << " seconds"<< std::endl;
+ PrintStaticConfiguration(std::cerr);
+ std::exit(EXIT_FAILURE);
+ }
+
+ void setTimeout(const int& timeout)
+ {
+ if (timeout)
+ {
+ std::thread t(timeoutThread, timeout);
+ t.detach();
+ }
+ }
+
+ int TestConnectivityCommand(std::ostream& out,
+ const boost::program_options::variables_map& map)
+ {
+ const auto ns(map["ns"].as<std::string>());
+ const auto timeout(map["timeout"].as<int>());
+ setTimeout(timeout);
+ auto sdl(createStorage(ns, out));
+ if (sdl != nullptr)
+ {
+ auto asyncStorageImpl(std::dynamic_pointer_cast<AsyncStorageImpl>(sdl));
+ if (asyncStorageImpl != nullptr)
+ {
+ AsyncStorage& operationalHandler(asyncStorageImpl->getOperationHandler(ns));
+ AsyncRedisStorage* redisStorage = dynamic_cast<AsyncRedisStorage*>(&operationalHandler);
+ if (redisStorage != nullptr)
+ {
+ auto databaseinfo (redisStorage->getDatabaseInfo());
+ PrintDatabaseInfo(databaseinfo, out);
+ }
+ else
+ {
+ // @TODO Improve output for the case if dummy backend is used.
+ out << "Cannot get AsyncRedisStorage." << std::endl;
+ return EXIT_FAILURE;
+ }
+ }
+ else
+ {
+ out << "Cannot get AsyncStorageImpl." << std::endl;
+ return EXIT_FAILURE;
+ }
+ }
+ return EXIT_SUCCESS;
+ }
+}
+
+AUTO_REGISTER_COMMAND(std::bind(TestConnectivityCommand, std::placeholders::_1, std::placeholders::_3),
+ "test-connectivity",
+ "Test SDL backend connectivity",
+ "Check that SDL database backend is available and show discovered redis host address and port",
+ CommandMap::Category::UTIL, 30020,
+ ("ns", boost::program_options::value<std::string>()->default_value("sdltoolns"), "Used namespace")
+ ("timeout", boost::program_options::value<int>()->default_value(0), "Timeout (in seconds), Default is no timeout"));
Code Review / ric-plt / sdl.git / blobdiff