{

LOG_TRACE(log, "HTTP Request for {}. {}", name, request.toStringForLogging());

for (auto & handler_factory : child_factories)

{

if (auto handler = handler_factory->createRequestHandler(request))

return handler;

}

if (request.getMethod() == Poco::Net::HTTPRequest::HTTP_GET || request.getMethod() == Poco::Net::HTTPRequest::HTTP_HEAD

|| request.getMethod() == Poco::Net::HTTPRequest::HTTP_POST)

{

return std::make_unique<KeeperNotFoundHandler>(hints.getHints(request.getURI()));

}

return nullptr;

KeeperHTTPRequestHandlerFactory & factory, std::shared_ptr<KeeperDispatcher> keeper_dispatcher)

{

auto dashboard_ui_creator = []() -> std::unique_ptr<KeeperDashboardWebUIRequestHandler>

{ return std::make_unique<KeeperDashboardWebUIRequestHandler>(); };

auto dashboard_path_filter = [](const String & path)

{

return [path](const auto & request)

{

const auto & uri = request.getURI();

return uri == path

|| (uri.size() > path.size() && uri.starts_with(path) && uri[path.size()] == '?');

};

};

auto dashboard_handler = std::make_shared<HandlingRuleHTTPHandlerFactory<KeeperDashboardWebUIRequestHandler>>(dashboard_ui_creator);

dashboard_handler->addFilter(dashboard_path_filter("/dashboard"));

dashboard_handler->allowGetAndHeadRequest();

factory.addPathToHints("/dashboard");

factory.addHandler(dashboard_handler);

auto dashboard_content_creator = [keeper_dispatcher]() -> std::unique_ptr<KeeperDashboardContentRequestHandler>

{ return std::make_unique<KeeperDashboardContentRequestHandler>(keeper_dispatcher); };

auto dashboard_content_handler

= std::make_shared<HandlingRuleHTTPHandlerFactory<KeeperDashboardContentRequestHandler>>(dashboard_content_creator);

dashboard_content_handler->addFilter(dashboard_path_filter("/dashboard/content"));

dashboard_content_handler->allowGetAndHeadRequest();

factory.addHandler(dashboard_content_handler);

KeeperHTTPRequestHandlerFactory & factory,

std::shared_ptr<KeeperDispatcher> keeper_dispatcher,

const Poco::Util::AbstractConfiguration & config)

{

auto creator = [keeper_dispatcher]() -> std::unique_ptr<KeeperHTTPReadinessHandler>

{ return std::make_unique<KeeperHTTPReadinessHandler>(keeper_dispatcher); };

auto readiness_handler = std::make_shared<HandlingRuleHTTPHandlerFactory<KeeperHTTPReadinessHandler>>(std::move(creator));

readiness_handler->attachStrictPath(config.getString("keeper_server.http_control.readiness.endpoint", "/ready"));

readiness_handler->allowGetAndHeadRequest();

factory.addPathToHints("/ready");

factory.addHandler(readiness_handler);

KeeperHTTPRequestHandlerFactory & factory,

std::shared_ptr<KeeperDispatcher> keeper_dispatcher,

std::shared_ptr<KeeperHTTPClient> keeper_client)

{

auto creator = [keeper_dispatcher, keeper_client]() -> std::unique_ptr<KeeperHTTPCommandsHandler>

{ return std::make_unique<KeeperHTTPCommandsHandler>(keeper_dispatcher, keeper_client); };

auto commands_handler = std::make_shared<HandlingRuleHTTPHandlerFactory<KeeperHTTPCommandsHandler>>(std::move(creator));

commands_handler->attachNonStrictPath("/api/v1/commands");

commands_handler->allowRESTMethods();

factory.addPathToHints("/api/v1/commands");

factory.addHandler(commands_handler);

{

auto handler = std::make_shared<HandlingRuleHTTPHandlerFactory<H>>(

[] { return std::make_unique<H>(); });

handler->addFilter([path](const auto & request)

{

const auto & uri = request.getURI();

return uri == path

|| (uri.size() > path.size() && uri.starts_with(path) && uri[path.size()] == '?');

});

handler->allowGetAndHeadRequest();

factory.addHandler(handler);

{

addStrictHandler<KeeperJemallocWebUIHandler>(factory, "/jemalloc");

factory.addPathToHints("/jemalloc");

addStrictHandler<KeeperJemallocRedirectHandler>(factory, "/jemalloc/");

#if USE_JEMALLOC

addStrictHandler<KeeperJemallocProfileHandler>(factory, "/jemalloc/profile");

addStrictHandler<KeeperJemallocStatsHandler>(factory, "/jemalloc/stats");

addStrictHandler<KeeperJemallocStatusHandler>(factory, "/jemalloc/status");

#else

addStrictHandler<KeeperJemallocNotAvailableHandler>(factory, "/jemalloc/profile");

addStrictHandler<KeeperJemallocNotAvailableHandler>(factory, "/jemalloc/stats");

addStrictHandler<KeeperJemallocNotAvailableHandler>(factory, "/jemalloc/status");

#endif

KeeperHTTPRequestHandlerFactory & factory,

std::shared_ptr<KeeperDispatcher> keeper_dispatcher,

std::shared_ptr<KeeperHTTPClient> keeper_client)

{

auto creator = [keeper_client, keeper_context = keeper_dispatcher->getKeeperContext()]() -> std::unique_ptr<KeeperHTTPStorageHandler>

{ return std::make_unique<KeeperHTTPStorageHandler>(keeper_client, keeper_context); };

auto storage_handler = std::make_shared<HandlingRuleHTTPHandlerFactory<KeeperHTTPStorageHandler>>(std::move(creator));

storage_handler->attachNonStrictPath("/api/v1/storage");

storage_handler->allowRESTMethods();

factory.addPathToHints("/api/v1/storage");

factory.addHandler(storage_handler);

const IServer & server,

std::shared_ptr<KeeperDispatcher> keeper_dispatcher)

{

auto session_timeout = Poco::Timespan(

server.config().getUInt("keeper_server.http_control.storage.session_timeout_ms", Coordination::DEFAULT_SESSION_TIMEOUT_MS)

* Poco::Timespan::MILLISECONDS);

/// Client is created lazily on first use to avoid blocking server startup

/// with synchronous Keeper session creation, which requires Raft consensus

/// and can time out if the leader is not yet fully available.

auto client_factory = [keeper_dispatcher, session_timeout]() -> std::shared_ptr<zkutil::ZooKeeper>

{

return zkutil::ZooKeeper::createFromImpl(

[keeper_dispatcher, session_timeout]()

{

return std::make_unique<Coordination::KeeperOverDispatcher>(keeper_dispatcher, session_timeout);

});

};

return std::make_shared<KeeperHTTPClient>(std::move(client_factory));

KeeperHTTPRequestHandlerFactory & factory,

const IServer & server,

std::shared_ptr<KeeperDispatcher> keeper_dispatcher,

const Poco::Util::AbstractConfiguration & config)

{

auto keeper_client = createKeeperClient(server, keeper_dispatcher);

addReadinessHandlerToFactory(factory, keeper_dispatcher, config);

addDashboardHandlersToFactory(factory, keeper_dispatcher);

addCommandsHandlersToFactory(factory, keeper_dispatcher, keeper_client);

addStorageHandlersToFactory(factory, keeper_dispatcher, keeper_client);

addJemallocHandlersToFactory(factory);

const IServer & server,

std::shared_ptr<KeeperDispatcher> keeper_dispatcher,

const Poco::Util::AbstractConfiguration & config,

const std::string & name,

const String & prefix)

{

auto main_handler_factory = std::make_shared<KeeperHTTPRequestHandlerFactory>(name);

auto keeper_client = createKeeperClient(server, keeper_dispatcher);

Poco::Util::AbstractConfiguration::Keys keys;

config.keys(prefix, keys);

for (const auto & key : keys)

{

if (key == "defaults")

{

addDefaultHandlersToFactory(*main_handler_factory, server, keeper_dispatcher, config);

}

else if (startsWith(key, "rule"))

{

const auto & handler_type = config.getString(prefix + "." + key + ".handler.type", "");

if (handler_type.empty())

throw Exception(

ErrorCodes::INVALID_CONFIG_PARAMETER,

"Handler type in config is not specified here: "

"{}.{}.handler.type",

prefix,

key);

if (handler_type == "ready")

addReadinessHandlerToFactory(*main_handler_factory, keeper_dispatcher, config);

else if (handler_type == "dashboard")

addDashboardHandlersToFactory(*main_handler_factory, keeper_dispatcher);

else if (handler_type == "commands")

addCommandsHandlersToFactory(*main_handler_factory, keeper_dispatcher, keeper_client);

else if (handler_type == "storage")

addStorageHandlersToFactory(*main_handler_factory, keeper_dispatcher, keeper_client);

else if (handler_type == "jemalloc")

addJemallocHandlersToFactory(*main_handler_factory);

else

throw Exception(

ErrorCodes::INVALID_CONFIG_PARAMETER,

"Unknown handler type '{}' in config here: {}.{}.handler.type",

handler_type,

prefix,

key);

}

else

throw Exception(

ErrorCodes::UNKNOWN_ELEMENT_IN_CONFIG,

"Unknown element in config: "

"{}.{}, must be 'rule' or 'defaults'",

prefix,

key);

}

return main_handler_factory;

HTTPServerRequest & /*request*/, HTTPServerResponse & response, const ProfileEvents::Event & /*write_event*/)

{

try

{

auto is_leader = keeper_dispatcher->isLeader();

auto is_follower = keeper_dispatcher->isFollower() && keeper_dispatcher->hasLeader();

auto is_observer = keeper_dispatcher->isObserver() && keeper_dispatcher->hasLeader();

auto data = keeper_dispatcher->getKeeper4LWInfo();

auto status = is_leader || is_follower || is_observer;

Poco::JSON::Object json;

Poco::JSON::Object details;

details.set("role", data.getRole());

details.set("hasLeader", keeper_dispatcher->hasLeader());

json.set("details", details);

json.set("status", status ? "ok" : "fail");

std::ostringstream oss; // STYLE_CHECK_ALLOW_STD_STRING_STREAM

oss.exceptions(std::ios::failbit);

Poco::JSON::Stringifier::stringify(json, oss);

if (!status)

response.setStatusAndReason(Poco::Net::HTTPResponse::HTTP_SERVICE_UNAVAILABLE);

*response.send() << oss.str();

}

catch (...)

{

tryLogCurrentException(log);

try

{

response.setStatusAndReason(Poco::Net::HTTPResponse::HTTP_INTERNAL_SERVER_ERROR);

if (!response.sent())

{

/// We have not sent anything yet and we don't even know if we need to compress response.

*response.send() << getCurrentExceptionMessage(false) << '\n';

}

}

catch (...)

{

LOG_ERROR(log, "Cannot send exception to client");

}

}

std::shared_ptr<KeeperDispatcher> keeper_dispatcher_,

std::shared_ptr<KeeperHTTPClient> keeper_client_)

: log(getLogger("KeeperHTTPCommandsHandler"))

, keeper_dispatcher(std::move(keeper_dispatcher_))

, keeper_client(std::move(keeper_client_))

{

HTTPServerRequest & request, HTTPServerResponse & response, const ProfileEvents::Event & /*write_event*/)

try

{

std::vector<std::string> uri_segments;

Poco::URI uri;

try

{

uri = Poco::URI(request.getURI());

uri.getPathSegments(uri_segments);

}

catch (const std::exception &)

{

response.setStatusAndReason(Poco::Net::HTTPResponse::HTTP_BAD_REQUEST, "Could not parse request path.");

*response.send() << "Could not parse request path.\n";

return;

}

String command;

String cwd = "/";

const auto params = uri.getQueryParameters();

for (const auto & [key, value]: params)

{

if (key == "command")

command = value;

else if (key == "cwd")

cwd = value;

}

if (command.empty())

{

response.setStatusAndReason(Poco::Net::HTTPResponse::HTTP_BAD_REQUEST, "Invalid command");

*response.send() << "Invalid command\n";

return;

}

setResponseDefaultHeaders(response);

Poco::JSON::Object response_json;

response.setContentType("application/json");

if (FourLetterCommandFactory::instance().isKnown(DB::IFourLetterCommand::toCode(command)))

{

auto command_ptr = FourLetterCommandFactory::instance().get(DB::IFourLetterCommand::toCode(command));

LOG_DEBUG(log, "Received four letter command {}", command_ptr->name());

try

{

String res = command_ptr->run();

response_json.set("result", res);

response.setStatus(Poco::Net::HTTPResponse::HTTP_OK);

}

catch (...)

{

tryLogCurrentException(log, "Error when executing four letter command " + command_ptr->name());

response_json.set("message", "Internal server error.");

response.setStatusAndReason(Poco::Net::HTTPResponse::HTTP_INTERNAL_SERVER_ERROR);

}

}

else

{

std::ostringstream stream; // STYLE_CHECK_ALLOW_STD_STRING_STREAM

KeeperClientBase client(stream, stream);

client.zookeeper = keeper_client->get();

client.cwd = cwd;

client.ask_confirmation = false; // Confirmations are not supported in UI

client.processQueryText(command);

response_json.set("result", stream.str());

}

std::ostringstream oss; // STYLE_CHECK_ALLOW_STD_STRING_STREAM

oss.exceptions(std::ios::failbit);

Poco::JSON::Stringifier::stringify(response_json, oss);

*response.send() << oss.str();

}

catch (...)

{

tryLogCurrentException(log);

try

{

response.setStatusAndReason(Poco::Net::HTTPResponse::HTTP_INTERNAL_SERVER_ERROR);

if (!response.sent())

{

/// We have not sent anything yet and we don't even know if we need to compress response.

*response.send() << getCurrentExceptionMessage(false) << '\n';

}

}

catch (...)

{

LOG_ERROR(log, "Cannot send exception to client");

}

const IServer & server,

const Poco::Util::AbstractConfiguration & config,

std::shared_ptr<KeeperDispatcher> keeper_dispatcher,

const std::string & name)

{

if (config.has("keeper_server.http_control.handlers"))

return createHandlersFactoryFromConfig(server, keeper_dispatcher, config, name, "keeper_server.http_control.handlers");

auto factory = std::make_shared<KeeperHTTPRequestHandlerFactory>(name);

addDefaultHandlersToFactory(*factory, server, keeper_dispatcher, config);

return factory;