be/src/http/web_page_handler.cpp - doris - Git at Google

 // Licensed to the Apache Software Foundation (ASF) under one
 // or more contributor license agreements.  See the NOTICE file
 // distributed with this work for additional information
 // regarding copyright ownership.  The ASF licenses this file
 // to you under the Apache License, Version 2.0 (the
 // "License"); you may not use this file except in compliance
 // with the License.  You may obtain a copy of the License at
 //
 //   http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing,
 // software distributed under the License is distributed on an
 // "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 // KIND, either express or implied.  See the License for the
 // specific language governing permissions and limitations
 // under the License.

 #include "http/web_page_handler.h"

 #include <stdlib.h>

 #include <functional>
 #include <memory>

 #include "absl/strings/substitute.h"
 #include "common/logging.h"
 #include "common/status.h"
 #include "http/ev_http_server.h"
 #include "http/http_channel.h"
 #include "http/http_headers.h"
 #include "http/http_method.h"
 #include "http/http_request.h"
 #include "http/http_status.h"
 #include "http/utils.h"
 #include "io/fs/local_file_system.h"
 #include "util/cpu_info.h"
 #include "util/debug_util.h"
 #include "util/disk_info.h"
 #include "util/easy_json.h"
 #include "util/mem_info.h"
 #include "util/mustache/mustache.h"

 namespace doris {

 static std::string s_html_content_type = "text/html";

 WebPageHandler::WebPageHandler(EvHttpServer* server, ExecEnv* exec_env)
         : HttpHandlerWithAuth(exec_env), _http_server(server) {
     _www_path = std::string(getenv("DORIS_HOME")) + "/www/";

     // Make WebPageHandler to be static file handler, static files, e.g. css, png, will be handled by WebPageHandler.
     _http_server->register_static_file_handler(this);

     TemplatePageHandlerCallback root_callback =
             std::bind<void>(std::mem_fn(&WebPageHandler::root_handler), this, std::placeholders::_1,
                             std::placeholders::_2);
     register_template_page("/", "Home", root_callback, false /* is_on_nav_bar */);
 }

 WebPageHandler::~WebPageHandler() {
     for (auto& handler : _page_map) {
         delete handler.second;
     }
 }

 void WebPageHandler::register_template_page(const std::string& path, const std::string& alias,
                                             const TemplatePageHandlerCallback& callback,
                                             bool is_on_nav_bar) {
     // Relative path which will be used to find .mustache file in _www_path
     std::string render_path = (path == "/") ? "/home" : path;
     auto wrapped_cb = [callback, render_path, this](const ArgumentMap& args,
                                                     std::stringstream* output) {
         EasyJson ej;
         callback(args, &ej);
         render(render_path, ej, true /* is_styled */, output);
     };
     register_page(path, alias, wrapped_cb, is_on_nav_bar);
 }

 void WebPageHandler::register_page(const std::string& path, const std::string& alias,
                                    const PageHandlerCallback& callback, bool is_on_nav_bar) {
     std::unique_lock lock(_map_lock);
     CHECK(_page_map.find(path) == _page_map.end());
     // first time, register this to web server
     _http_server->register_handler(HttpMethod::GET, path, this);
     _page_map[path] = new PathHandler(true /* is_styled */, is_on_nav_bar, alias, callback);
 }

 void WebPageHandler::handle(HttpRequest* req) {
     VLOG_TRACE << req->debug_string();
     PathHandler* handler = nullptr;
     {
         std::unique_lock lock(_map_lock);
         auto iter = _page_map.find(req->raw_path());
         if (iter != _page_map.end()) {
             handler = iter->second;
         }
     }

     if (handler == nullptr) {
         // Try to handle static file request
         do_file_response(_www_path + req->raw_path(), req);
         // Has replied in do_file_response, so we return here.
         return;
     }

     const auto& params = *req->params();

     // Should we render with css styles?
     bool use_style = (params.find("raw") == params.end());

     std::stringstream content;
     handler->callback()(params, &content);

     std::string output;
     if (use_style) {
         std::stringstream oss;
         render_main_template(content.str(), &oss);
         output = oss.str();
     } else {
         output = content.str();
     }

     req->add_output_header(HttpHeaders::CONTENT_TYPE, s_html_content_type.c_str());
     HttpChannel::send_reply(req, HttpStatus::OK, output);
 }

 static const std::string kMainTemplate = R"(
 <!DOCTYPE html>
 <html>
   <head>
     <title>Doris</title>
     <meta charset='utf-8'/>
     <link href='/Bootstrap-3.3.7/css/bootstrap.min.css' rel='stylesheet' media='screen' />
     <link href='/Bootstrap-3.3.7/css/bootstrap-table.min.css' rel='stylesheet' media='screen' />
     <script src='/jQuery-3.6.0/jquery-3.6.0.min.js'></script>
     <script src='/Bootstrap-3.3.7/js/bootstrap.min.js' defer></script>
     <script src='/Bootstrap-3.3.7/js/bootstrap-table.min.js' defer></script>
     <script src='/doris.js' defer></script>
     <link href='/doris.css' rel='stylesheet' />
   </head>
   <body>
     <nav class="navbar navbar-default">
       <div class="container-fluid">
         <div class="navbar-header">
           <a class="navbar-brand" style="padding-top: 5px;" href="/">
             <img src="/logo.png" width='40' height='40' alt="Doris" />
           </a>
         </div>
         <div id="navbar" class="navbar-collapse collapse">
           <ul class="nav navbar-nav">
            {{#path_handlers}}
             <li><a class="nav-link"href="{{path}}">{{alias}}</a></li>
            {{/path_handlers}}
           </ul>
         </div><!--/.nav-collapse -->
       </div><!--/.container-fluid -->
     </nav>
       {{^static_pages_available}}
       <div style="color: red">
         <strong>Static pages not available. Make sure ${DORIS_HOME}/www/ exists and contains web static files.</strong>
       </div>
       {{/static_pages_available}}
       {{{content}}}
     </div>
     {{#footer_html}}
     <footer class="footer"><div class="container text-muted">
       {{{.}}}
     </div></footer>
     {{/footer_html}}
   </body>
 </html>
 )";

 std::string WebPageHandler::mustache_partial_tag(const std::string& path) const {
     return absl::Substitute("{{> $0.mustache}}", path);
 }

 bool WebPageHandler::static_pages_available() const {
     bool is_dir = false;
     return io::global_local_filesystem()->is_directory(_www_path, &is_dir).ok() && is_dir;
 }

 bool WebPageHandler::mustache_template_available(const std::string& path) const {
     if (!static_pages_available()) {
         return false;
     }
     bool exists;
     return io::global_local_filesystem()
                    ->exists(absl::Substitute("$0/$1.mustache", _www_path, path), &exists)
                    .ok() &&
            exists;
 }

 void WebPageHandler::render_main_template(const std::string& content, std::stringstream* output) {
     static const std::string& footer =
             std::string("<pre>") + get_version_string(true) + std::string("</pre>");

     EasyJson ej;
     ej["static_pages_available"] = static_pages_available();
     ej["content"] = content;
     ej["footer_html"] = footer;
     EasyJson path_handlers = ej.Set("path_handlers", EasyJson::kArray);
     for (const auto& handler : _page_map) {
         if (handler.second->is_on_nav_bar()) {
             EasyJson path_handler = path_handlers.PushBack(EasyJson::kObject);
             path_handler["path"] = handler.first;
             path_handler["alias"] = handler.second->alias();
         }
     }
     mustache::RenderTemplate(kMainTemplate, _www_path, ej.value(), output);
 }

 void WebPageHandler::render(const std::string& path, const EasyJson& ej, bool use_style,
                             std::stringstream* output) {
     if (mustache_template_available(path)) {
         mustache::RenderTemplate(mustache_partial_tag(path), _www_path, ej.value(), output);
     } else if (use_style) {
         (*output) << "<pre>" << ej.ToString() << "</pre>";
     } else {
         (*output) << ej.ToString();
     }
 }

 void WebPageHandler::root_handler(const ArgumentMap& args, EasyJson* output) {
     (*output)["version"] = get_version_string(false);
     (*output)["cpuinfo"] = CpuInfo::debug_string();
     (*output)["meminfo"] = MemInfo::debug_string();
     (*output)["diskinfo"] = DiskInfo::debug_string();
 }

 } // namespace doris
	// Licensed to the Apache Software Foundation (ASF) under one
	// or more contributor license agreements. See the NOTICE file
	// distributed with this work for additional information
	// regarding copyright ownership. The ASF licenses this file
	// to you under the Apache License, Version 2.0 (the
	// "License"); you may not use this file except in compliance
	// with the License. You may obtain a copy of the License at
	//
	// http://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing,
	// software distributed under the License is distributed on an
	// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
	// KIND, either express or implied. See the License for the
	// specific language governing permissions and limitations
	// under the License.

	#include "http/web_page_handler.h"

	#include <stdlib.h>

	#include <functional>
	#include <memory>

	#include "absl/strings/substitute.h"
	#include "common/logging.h"
	#include "common/status.h"
	#include "http/ev_http_server.h"
	#include "http/http_channel.h"
	#include "http/http_headers.h"
	#include "http/http_method.h"
	#include "http/http_request.h"
	#include "http/http_status.h"
	#include "http/utils.h"
	#include "io/fs/local_file_system.h"
	#include "util/cpu_info.h"
	#include "util/debug_util.h"
	#include "util/disk_info.h"
	#include "util/easy_json.h"
	#include "util/mem_info.h"
	#include "util/mustache/mustache.h"

	namespace doris {

	static std::string s_html_content_type = "text/html";

	WebPageHandler::WebPageHandler(EvHttpServer* server, ExecEnv* exec_env)
	: HttpHandlerWithAuth(exec_env), _http_server(server) {
	_www_path = std::string(getenv("DORIS_HOME")) + "/www/";

	// Make WebPageHandler to be static file handler, static files, e.g. css, png, will be handled by WebPageHandler.
	_http_server->register_static_file_handler(this);

	TemplatePageHandlerCallback root_callback =
	std::bind<void>(std::mem_fn(&WebPageHandler::root_handler), this, std::placeholders::_1,
	std::placeholders::_2);
	register_template_page("/", "Home", root_callback, false /* is_on_nav_bar */);
	}

	WebPageHandler::~WebPageHandler() {
	for (auto& handler : _page_map) {
	delete handler.second;
	}
	}

	void WebPageHandler::register_template_page(const std::string& path, const std::string& alias,
	const TemplatePageHandlerCallback& callback,
	bool is_on_nav_bar) {
	// Relative path which will be used to find .mustache file in _www_path
	std::string render_path = (path == "/") ? "/home" : path;
	auto wrapped_cb = [callback, render_path, this](const ArgumentMap& args,
	std::stringstream* output) {
	EasyJson ej;
	callback(args, &ej);
	render(render_path, ej, true /* is_styled */, output);
	};
	register_page(path, alias, wrapped_cb, is_on_nav_bar);
	}

	void WebPageHandler::register_page(const std::string& path, const std::string& alias,
	const PageHandlerCallback& callback, bool is_on_nav_bar) {
	std::unique_lock lock(_map_lock);
	CHECK(_page_map.find(path) == _page_map.end());
	// first time, register this to web server
	_http_server->register_handler(HttpMethod::GET, path, this);
	_page_map[path] = new PathHandler(true /* is_styled */, is_on_nav_bar, alias, callback);
	}

	void WebPageHandler::handle(HttpRequest* req) {
	VLOG_TRACE << req->debug_string();
	PathHandler* handler = nullptr;
	{
	std::unique_lock lock(_map_lock);
	auto iter = _page_map.find(req->raw_path());
	if (iter != _page_map.end()) {
	handler = iter->second;
	}
	}

	if (handler == nullptr) {
	// Try to handle static file request
	do_file_response(_www_path + req->raw_path(), req);
	// Has replied in do_file_response, so we return here.
	return;
	}

	const auto& params = *req->params();

	// Should we render with css styles?
	bool use_style = (params.find("raw") == params.end());

	std::stringstream content;
	handler->callback()(params, &content);

	std::string output;
	if (use_style) {
	std::stringstream oss;
	render_main_template(content.str(), &oss);
	output = oss.str();
	} else {
	output = content.str();
	}

	req->add_output_header(HttpHeaders::CONTENT_TYPE, s_html_content_type.c_str());
	HttpChannel::send_reply(req, HttpStatus::OK, output);
	}

	static const std::string kMainTemplate = R"(
	<!DOCTYPE html>
	<html>
	<head>
	<title>Doris</title>
	<meta charset='utf-8'/>
	<link href='/Bootstrap-3.3.7/css/bootstrap.min.css' rel='stylesheet' media='screen' />
	<link href='/Bootstrap-3.3.7/css/bootstrap-table.min.css' rel='stylesheet' media='screen' />
	<script src='/jQuery-3.6.0/jquery-3.6.0.min.js'></script>
	<script src='/Bootstrap-3.3.7/js/bootstrap.min.js' defer></script>
	<script src='/Bootstrap-3.3.7/js/bootstrap-table.min.js' defer></script>
	<script src='/doris.js' defer></script>
	<link href='/doris.css' rel='stylesheet' />
	</head>
	<body>
	<nav class="navbar navbar-default">
	<div class="container-fluid">
	<div class="navbar-header">
	<a class="navbar-brand" style="padding-top: 5px;" href="/">
	<img src="/logo.png" width='40' height='40' alt="Doris" />
	</a>
	</div>
	<div id="navbar" class="navbar-collapse collapse">
	<ul class="nav navbar-nav">
	{{#path_handlers}}
	<li><a class="nav-link"href="{{path}}">{{alias}}</a></li>
	{{/path_handlers}}
	</ul>
	</div><!--/.nav-collapse -->
	</div><!--/.container-fluid -->
	</nav>
	{{^static_pages_available}}
	<div style="color: red">
	<strong>Static pages not available. Make sure ${DORIS_HOME}/www/ exists and contains web static files.</strong>
	</div>
	{{/static_pages_available}}
	{{{content}}}
	</div>
	{{#footer_html}}
	<footer class="footer"><div class="container text-muted">
	{{{.}}}
	</div></footer>
	{{/footer_html}}
	</body>
	</html>
	)";

	std::string WebPageHandler::mustache_partial_tag(const std::string& path) const {
	return absl::Substitute("{{> $0.mustache}}", path);
	}

	bool WebPageHandler::static_pages_available() const {
	bool is_dir = false;
	return io::global_local_filesystem()->is_directory(_www_path, &is_dir).ok() && is_dir;
	}

	bool WebPageHandler::mustache_template_available(const std::string& path) const {
	if (!static_pages_available()) {
	return false;
	}
	bool exists;
	return io::global_local_filesystem()
	->exists(absl::Substitute("$0/$1.mustache", _www_path, path), &exists)
	.ok() &&
	exists;
	}

	void WebPageHandler::render_main_template(const std::string& content, std::stringstream* output) {
	static const std::string& footer =
	std::string("<pre>") + get_version_string(true) + std::string("</pre>");

	EasyJson ej;
	ej["static_pages_available"] = static_pages_available();
	ej["content"] = content;
	ej["footer_html"] = footer;
	EasyJson path_handlers = ej.Set("path_handlers", EasyJson::kArray);
	for (const auto& handler : _page_map) {
	if (handler.second->is_on_nav_bar()) {
	EasyJson path_handler = path_handlers.PushBack(EasyJson::kObject);
	path_handler["path"] = handler.first;
	path_handler["alias"] = handler.second->alias();
	}
	}
	mustache::RenderTemplate(kMainTemplate, _www_path, ej.value(), output);
	}

	void WebPageHandler::render(const std::string& path, const EasyJson& ej, bool use_style,
	std::stringstream* output) {
	if (mustache_template_available(path)) {
	mustache::RenderTemplate(mustache_partial_tag(path), _www_path, ej.value(), output);
	} else if (use_style) {
	(*output) << "<pre>" << ej.ToString() << "</pre>";
	} else {
	(*output) << ej.ToString();
	}
	}

	void WebPageHandler::root_handler(const ArgumentMap& args, EasyJson* output) {
	(*output)["version"] = get_version_string(false);
	(*output)["cpuinfo"] = CpuInfo::debug_string();
	(*output)["meminfo"] = MemInfo::debug_string();
	(*output)["diskinfo"] = DiskInfo::debug_string();
	}

	} // namespace doris