diff options
Diffstat (limited to 'mod/mod-builds.cxx')
| -rw-r--r-- | mod/mod-builds.cxx | 218 |
1 files changed, 218 insertions, 0 deletions
diff --git a/mod/mod-builds.cxx b/mod/mod-builds.cxx new file mode 100644 index 0000000..6ffb517 --- /dev/null +++ b/mod/mod-builds.cxx @@ -0,0 +1,218 @@ +// file : mod/mod-builds.cxx -*- C++ -*- +// copyright : Copyright (c) 2014-2017 Code Synthesis Ltd +// license : MIT; see accompanying LICENSE file + +#include <mod/mod-builds.hxx> + +#include <libstudxml/serializer.hxx> + +#include <odb/database.hxx> +#include <odb/transaction.hxx> + +#include <web/xhtml.hxx> +#include <web/module.hxx> + +#include <libbrep/build.hxx> +#include <libbrep/build-odb.hxx> +#include <libbrep/package.hxx> +#include <libbrep/package-odb.hxx> + +#include <mod/page.hxx> +#include <mod/options.hxx> +#include <mod/build-config.hxx> // *_url() + +using namespace std; +using namespace butl; +using namespace bbot; +using namespace odb::core; +using namespace brep::cli; + +// While currently the user-defined copy constructor is not required (we don't +// need to deep copy nullptr's), it is a good idea to keep the placeholder +// ready for less trivial cases. +// +brep::builds:: +builds (const builds& r) + : database_module (r), + options_ (r.initialized_ ? r.options_ : nullptr) +{ +} + +void brep::builds:: +init (scanner& s) +{ + MODULE_DIAG; + + options_ = make_shared<options::builds> ( + s, unknown_mode::fail, unknown_mode::fail); + + database_module::init (*options_, options_->package_db_retry ()); + + if (options_->build_config_specified ()) + database_module::init (static_cast<options::build> (*options_), + static_cast<options::build_db> (*options_), + options_->build_db_retry ()); + + if (options_->root ().empty ()) + options_->root (dir_path ("/")); +} + +template <typename T, typename C> +static inline query<T> +build_query (const C& configs) +{ + using query = query<T>; + + return query::id.configuration.in_range (configs.begin (), configs.end ()) && + (query::state == "testing" || query::state == "tested"); +} + +bool brep::builds:: +handle (request& rq, response& rs) +{ + using namespace web::xhtml; + + MODULE_DIAG; + + if (build_db_ == nullptr) + throw invalid_request (501, "not implemented"); + + const size_t page_configs (options_->build_configurations ()); + const string& host (options_->host ()); + const dir_path& root (options_->root ()); + + params::builds params; + + try + { + name_value_scanner s (rq.parameters ()); + params = params::builds ( + s, unknown_mode::fail, unknown_mode::fail); + } + catch (const cli::exception& e) + { + throw invalid_request (400, e.what ()); + } + + size_t page (params.page ()); + const char* title ("Builds"); + + xml::serializer s (rs.content (), title); + + s << HTML + << HEAD + << TITLE << title << ~TITLE + << CSS_LINKS (path ("builds.css"), root) + << ~HEAD + << BODY + << DIV_HEADER (root, options_->logo (), options_->menu ()) + << DIV(ID="content"); + + transaction t (build_db_->begin ()); + + // Having packages and packages configurations builds in different databases, + // we unable to filter out builds for non-existent packages at the query + // level. Doing that in the C++ code would complicate it significantly. So + // we will print all the builds, relying on the sorting algorithm, that will + // likely to place expired ones at the end of the query result. + // + auto count ( + build_db_->query_value<build_count> ( + build_query<build_count> (*build_conf_names_))); + + s << DIV_COUNTER (count, "Build", "Builds"); + + // Enclose the subsequent tables to be able to use nth-child CSS selector. + // + s << DIV; + for (auto& b: build_db_->query<build> ( + build_query<build> (*build_conf_names_) + + "ORDER BY" + query<build>::timestamp + "DESC" + + "OFFSET" + to_string (page * page_configs) + + "LIMIT" + to_string (page_configs))) + { + assert (b.machine); + + auto i (build_conf_map_->find (b.configuration.c_str ())); + assert (i != build_conf_map_->end ()); + const build_config& c (*i->second); + + s << TABLE(CLASS="proplist build") + << TBODY + << TR_NAME (b.package_name, string (), root) + << TR_VERSION (b.package_name, b.package_version, root) + << TR_VALUE ("config", b.configuration) + << TR_VALUE ("toolchain", + b.toolchain_name + '-' + + b.toolchain_version.string ()) + << TR_VALUE ("machine", *b.machine) + << TR_VALUE ("target", c.target ? c.target->string () : "default") + << TR(CLASS="result") + << TH << "result" << ~TH + << TD + << SPAN(CLASS="value"); + + if (b.state == build_state::testing) + s << "building"; + else + { + assert (b.state == build_state::tested); + + build_db_->load (b, b.results_section); + + // If no results available, then print the overall build status. + // Otherwise print unsuccessful operations statuses with the links to the + // respective logs, followed with a link to the operations combined log. + // Print the forced package rebuild link afterwards. + // + if (b.results.empty ()) + { + assert (b.status); + s << SPAN_BUILD_RESULT_STATUS (*b.status); + } + else + { + for (const auto& r: b.results) + { + if (r.status != result_status::success) + s << SPAN_BUILD_RESULT_STATUS (r.status) << '(' + << A + << HREF + << build_log_url (host, root, b, &r.operation) + << ~HREF + << r.operation + << ~A + << ')' << ' '; + } + + s << A + << HREF << build_log_url (host, root, b) << ~HREF + << "all" + << ~A; + } + + s << ' ' + << A + << HREF << force_rebuild_url (host, root, b) << ~HREF + << "rebuild" + << ~A; + } + + s << ~SPAN + << ~TD + << ~TR + << ~TBODY + << ~TABLE; + } + s << ~DIV; + + t.commit (); + + s << DIV_PAGER (page, count, page_configs, options_->build_pages (), + root.string () + "?builds") + << ~DIV + << ~BODY + << ~HTML; + + return true; +} |