diff options
| -rw-r--r-- | brep/database.cxx | 58 | ||||
| -rw-r--r-- | brep/mod-package-details | 8 | ||||
| -rw-r--r-- | brep/mod-package-details.cxx | 23 | ||||
| -rw-r--r-- | brep/mod-package-search | 8 | ||||
| -rw-r--r-- | brep/mod-package-search.cxx | 23 | ||||
| -rw-r--r-- | brep/mod-package-version-details | 8 | ||||
| -rw-r--r-- | brep/mod-package-version-details.cxx | 21 | ||||
| -rw-r--r-- | brep/mod-repository-details | 8 | ||||
| -rw-r--r-- | brep/mod-repository-details.cxx | 21 | ||||
| -rw-r--r-- | brep/mod-repository-root | 6 | ||||
| -rw-r--r-- | brep/mod-repository-root.cxx | 33 | ||||
| -rw-r--r-- | brep/module | 2 | ||||
| -rw-r--r-- | brep/module.cxx | 12 | ||||
| -rw-r--r-- | web/apache/service | 189 | ||||
| -rw-r--r-- | web/apache/service.cxx | 167 | ||||
| -rw-r--r-- | web/apache/service.txx | 156 | ||||
| -rw-r--r-- | web/module | 12 |
17 files changed, 606 insertions, 149 deletions
diff --git a/brep/database.cxx b/brep/database.cxx index 9177b55..17605c5 100644 --- a/brep/database.cxx +++ b/brep/database.cxx @@ -4,40 +4,50 @@ #include <brep/database> +#include <map> + #include <odb/pgsql/database.hxx> namespace brep { + namespace options + { + bool + operator< (const db& x, const db& y) + { + int r; + if ((r = x.db_user ().compare (y.db_user ())) != 0 || + (r = x.db_password ().compare (y.db_password ())) != 0 || + (r = x.db_name ().compare (y.db_name ())) != 0 || + (r = x.db_host ().compare (y.db_host ()))) + return r < 0; + + return x.db_port () < y.db_port (); + } + } + shared_ptr<odb::database> shared_database (const options::db& o) { using odb::pgsql::database; - static weak_ptr<database> db; - // In C++11, function-static variable initialization is guaranteed to be - // thread-safe, thought this doesn't seem to be enough in our case - // (because we are re-initializing the weak pointer). - // - if (shared_ptr<database> d = db.lock ()) - { - if (o.db_user () != d->user () || - o.db_password () != d->password () || - o.db_name () != d->db () || - o.db_host () != d->host () || - o.db_port () != d->port ()) - throw runtime_error ("shared database options mismatch"); - - return d; - } - else + static std::map<options::db, weak_ptr<database>> databases; + + auto i (databases.find (o)); + if (i != databases.end ()) { - d = make_shared<database> (o.db_user (), - o.db_password (), - o.db_name (), - o.db_host (), - o.db_port ()); - db = d; - return d; + if (shared_ptr<database> d = i->second.lock ()) + return d; } + + shared_ptr<database> d ( + make_shared<database> (o.db_user (), + o.db_password (), + o.db_name (), + o.db_host (), + o.db_port ())); + + databases[o] = d; + return d; } } diff --git a/brep/mod-package-details b/brep/mod-package-details index a99d271..0a86fc2 100644 --- a/brep/mod-package-details +++ b/brep/mod-package-details @@ -18,6 +18,14 @@ namespace brep class package_details: public module { public: + package_details () = default; + + // Create a shallow copy (handling instance) if initialized and a deep + // copy (context exemplar) otherwise. + // + explicit + package_details (const package_details&); + virtual bool handle (request&, response&); diff --git a/brep/mod-package-details.cxx b/brep/mod-package-details.cxx index fa07dd1..a5c2e3e 100644 --- a/brep/mod-package-details.cxx +++ b/brep/mod-package-details.cxx @@ -24,6 +24,18 @@ 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::package_details:: +package_details (const package_details& r) + : module (r), + options_ (r.initialized_ ? r.options_ : nullptr), + db_ (r.initialized_ ? r.db_ : nullptr) +{ +} + void brep::package_details:: init (scanner& s) { @@ -61,13 +73,8 @@ handle (request& rq, response& rs) MODULE_DIAG; - // The module options object is not changed after being created once per - // server process. - // - static const size_t res_page (options_->search_results ()); - static const dir_path& root (options_->root ()); - static const fragment& logo (options_->logo ()); - static const vector<page_menu>& menu (options_->menu ()); + const size_t res_page (options_->search_results ()); + const dir_path& root (options_->root ()); const string& name (*rq.path ().rbegin ()); const string ename (mime_url_encode (name)); @@ -130,7 +137,7 @@ handle (request& rq, response& rs) << SCRIPT << " " << ~SCRIPT << ~HEAD << BODY - << DIV_HEADER (root, logo, menu) + << DIV_HEADER (root, options_->logo (), options_->menu ()) << DIV(ID="content"); if (full) diff --git a/brep/mod-package-search b/brep/mod-package-search index 7db976b..1730be4 100644 --- a/brep/mod-package-search +++ b/brep/mod-package-search @@ -18,6 +18,14 @@ namespace brep class package_search: public module { public: + package_search () = default; + + // Create a shallow copy (handling instance) if initialized and a deep + // copy (context exemplar) otherwise. + // + explicit + package_search (const package_search&); + virtual bool handle (request&, response&); diff --git a/brep/mod-package-search.cxx b/brep/mod-package-search.cxx index 7505e02..77a06b6 100644 --- a/brep/mod-package-search.cxx +++ b/brep/mod-package-search.cxx @@ -27,6 +27,18 @@ 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::package_search:: +package_search (const package_search& r) + : module (r), + options_ (r.initialized_ ? r.options_ : nullptr), + db_ (r.initialized_ ? r.db_ : nullptr) +{ +} + void brep::package_search:: init (scanner& s) { @@ -74,13 +86,8 @@ handle (request& rq, response& rs) MODULE_DIAG; - // The module options object is not changed after being created once per - // server process. - // - static const size_t res_page (options_->search_results ()); - static const dir_path& root (options_->root ()); - static const fragment& logo (options_->logo ()); - static const vector<page_menu>& menu (options_->menu ()); + const size_t res_page (options_->search_results ()); + const dir_path& root (options_->root ()); params::package_search params; @@ -124,7 +131,7 @@ handle (request& rq, response& rs) << SCRIPT << " " << ~SCRIPT << ~HEAD << BODY - << DIV_HEADER (root, logo, menu) + << DIV_HEADER (root, options_->logo (), options_->menu ()) << DIV(ID="content"); session sn; diff --git a/brep/mod-package-version-details b/brep/mod-package-version-details index d102fdf..cfbcf94 100644 --- a/brep/mod-package-version-details +++ b/brep/mod-package-version-details @@ -18,6 +18,14 @@ namespace brep class package_version_details: public module { public: + package_version_details () = default; + + // Create a shallow copy (handling instance) if initialized and a deep + // copy (context exemplar) otherwise. + // + explicit + package_version_details (const package_version_details&); + virtual bool handle (request&, response&); diff --git a/brep/mod-package-version-details.cxx b/brep/mod-package-version-details.cxx index c9055a5..cbf9c86 100644 --- a/brep/mod-package-version-details.cxx +++ b/brep/mod-package-version-details.cxx @@ -25,6 +25,18 @@ using namespace std; 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::package_version_details:: +package_version_details (const package_version_details& r) + : module (r), + options_ (r.initialized_ ? r.options_ : nullptr), + db_ (r.initialized_ ? r.db_ : nullptr) +{ +} + void brep::package_version_details:: init (scanner& s) { @@ -48,12 +60,7 @@ handle (request& rq, response& rs) MODULE_DIAG; - // The module options object is not changed after being created once per - // server process. - // - static const dir_path& root (options_->root ()); - static const fragment& logo (options_->logo ()); - static const vector<page_menu>& menu (options_->menu ()); + const dir_path& root (options_->root ()); auto i (rq.path ().rbegin ()); version ver; @@ -107,7 +114,7 @@ handle (request& rq, response& rs) << CSS_LINKS (path ("package-version-details.css"), root) << ~HEAD << BODY - << DIV_HEADER (root, logo, menu) + << DIV_HEADER (root, options_->logo (), options_->menu ()) << DIV(ID="content"); if (full) diff --git a/brep/mod-repository-details b/brep/mod-repository-details index 5f1e93f..411d9e6 100644 --- a/brep/mod-repository-details +++ b/brep/mod-repository-details @@ -18,6 +18,14 @@ namespace brep class repository_details: public module { public: + repository_details () = default; + + // Create a shallow copy (handling instance) if initialized and a deep + // copy (context exemplar) otherwise. + // + explicit + repository_details (const repository_details&); + virtual bool handle (request&, response&); diff --git a/brep/mod-repository-details.cxx b/brep/mod-repository-details.cxx index 0a88a16..f040be6 100644 --- a/brep/mod-repository-details.cxx +++ b/brep/mod-repository-details.cxx @@ -31,6 +31,18 @@ using namespace std; 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::repository_details:: +repository_details (const repository_details& r) + : module (r), + options_ (r.initialized_ ? r.options_ : nullptr), + db_ (r.initialized_ ? r.db_ : nullptr) +{ +} + void brep::repository_details:: init (scanner& s) { @@ -54,12 +66,7 @@ handle (request& rq, response& rs) MODULE_DIAG; - // The module options object is not changed after being created once per - // server process. - // - static const dir_path& root (options_->root ()); - static const fragment& logo (options_->logo ()); - static const vector<page_menu>& menu (options_->menu ()); + const dir_path& root (options_->root ()); // Make sure no parameters passed. // @@ -82,7 +89,7 @@ handle (request& rq, response& rs) << CSS_LINKS (path ("repository-details.css"), root) << ~HEAD << BODY - << DIV_HEADER (root, logo, menu) + << DIV_HEADER (root, options_->logo (), options_->menu ()) << DIV(ID="content"); transaction t (db_->begin ()); diff --git a/brep/mod-repository-root b/brep/mod-repository-root index 254dfa3..f2c2ba0 100644 --- a/brep/mod-repository-root +++ b/brep/mod-repository-root @@ -23,6 +23,12 @@ namespace brep public: repository_root (); + // Create a shallow copy (handling instance) if initialized and a deep + // copy (context exemplar) otherwise. + // + explicit + repository_root (const repository_root&); + private: virtual bool handle (request&, response&); diff --git a/brep/mod-repository-root.cxx b/brep/mod-repository-root.cxx index 61aa71b..7c27a60 100644 --- a/brep/mod-repository-root.cxx +++ b/brep/mod-repository-root.cxx @@ -58,6 +58,37 @@ namespace brep { } + repository_root:: + repository_root (const repository_root& r) + : module (r), + // + // Deep/shallow-copy sub-modules depending on whether this is an + // exemplar/handler. + // + package_search_ ( + r.initialized_ + ? r.package_search_ + : make_shared<package_search> (*r.package_search_)), + package_details_ ( + r.initialized_ + ? r.package_details_ + : make_shared<package_details> (*r.package_details_)), + package_version_details_ ( + r.initialized_ + ? r.package_version_details_ + : make_shared<package_version_details> ( + *r.package_version_details_)), + repository_details_ ( + r.initialized_ + ? r.repository_details_ + : make_shared<repository_details> (*r.repository_details_)), + options_ ( + r.initialized_ + ? r.options_ + : nullptr) + { + } + // Return amalgamation of repository_root and all its sub-modules option // descriptions. // @@ -112,7 +143,7 @@ namespace brep { MODULE_DIAG; - static const dir_path& root (options_->root ()); + const dir_path& root (options_->root ()); const path& rpath (rq.path ()); if (!rpath.sub (root)) diff --git a/brep/module b/brep/module index 4ea5164..52106cd 100644 --- a/brep/module +++ b/brep/module @@ -88,7 +88,7 @@ namespace brep // Set to true when the module is successfully initialized. // - bool loaded_ {false}; + bool initialized_ {false}; // Implementation details. // diff --git a/brep/module.cxx b/brep/module.cxx index e8a824d..1257d82 100644 --- a/brep/module.cxx +++ b/brep/module.cxx @@ -30,7 +30,7 @@ namespace brep try { - if (!loaded_) + if (!initialized_) { MODULE_DIAG; fail << "not initialized, presumably due to misconfiguration"; @@ -187,7 +187,7 @@ namespace brep void module:: init (const name_values& options, log& log) { - assert (!loaded_); + assert (!initialized_); log_ = &log; @@ -207,7 +207,7 @@ namespace brep options::module o (s, cli::unknown_mode::fail, cli::unknown_mode::fail); verb_ = o.verbosity (); - loaded_ = true; + initialized_ = true; } catch (const server_error& e) { @@ -236,7 +236,11 @@ namespace brep // Custom copy constructor is required to initialize log_writer_ properly. // module:: - module (const module& m): module () {verb_ = m.verb_; loaded_ = m.loaded_;} + module (const module& m): module () + { + verb_ = m.verb_; + initialized_ = m.initialized_; + } // For function func declared like this: // using B = std::string (*)(int); diff --git a/web/apache/service b/web/apache/service index 75c096c..4c0d395 100644 --- a/web/apache/service +++ b/web/apache/service @@ -8,6 +8,8 @@ #include <httpd.h> #include <http_config.h> // module, ap_hook_*() +#include <map> +#include <memory> // unique_ptr #include <string> #include <cassert> @@ -19,6 +21,22 @@ namespace web { namespace apache { + // Apache has 3 configuration scopes: main server, virtual server, and + // directory (location). It provides configuration scope-aware modules + // with the ability to build a hierarchy of configuration contexts. Later, + // when processing a request, Apache passes the appropriate directory + // configuration context to the request handler. + // + // This Apache service implementation first makes a copy of the provided + // (in the constructor below) module exemplar for each directory context. + // It then initializes each of these "context exemplars" with the (merged) + // set of configuration options. Finally, when handling a request, it + // copies the corresponding "context exemplar" to create the "handling + // instance". Note that the "context exemplars" are create before the + // provided exemplar is initialized. As a result, it is possible to detect + // if the module's copy constructor is used to create a "context exemplar" + // or a "handling instance". + // class service: ::module { public: @@ -41,6 +59,41 @@ namespace web { init_directives (); + // Set configuration context management hooks. + // + // The overall process of building the configuration hierarchy for a + // module is as follows: + // + // 1. Apache creates directory and server configuration contexts for + // scopes containing module-defined directives by calling the + // create_{server,dir}_context() callback functions. For directives + // at the server scope the special directory context is created as + // well. + // + // 2. Apache calls parse_option() function for each module-defined + // directive. The function parses the directives and places the + // resulting options into the corresponding configuration context. + // It also establishes the directory-server contexts relations. + // + // 3. Apache calls merge_server_context() function for each virtual + // server. The function complements virtual server context options + // with the ones from the main server. + // + // 4. Apache calls config_finalizer() which complements the directory + // contexts options with the ones from the enclosing servers. + // + // 5. Apache calls worker_initializer() which creates module exemplar + // for each directory configuration context. + // + // References: + // http://www.apachetutor.org/dev/config + // http://httpd.apache.org/docs/2.4/developer/modguide.html + // http://wiki.apache.org/httpd/ModuleLife + // + create_server_config = &create_server_context; + create_dir_config = &create_dir_context; + merge_server_config = &merge_server_context<M>; + // instance<M> () is invented to delegate processing from apache // request handler C function to the service non static member // function. This appoach resticts number of service objects per @@ -56,6 +109,7 @@ namespace web delete [] cmds; } + private: template <typename M> static service*& instance () noexcept @@ -88,16 +142,7 @@ namespace web config_finalizer (apr_pool_t*, apr_pool_t*, apr_pool_t*, server_rec* s) noexcept { - auto srv (instance<M> ()); - bool& parsed (srv->options_parsed_); - - if (!parsed) - { - log l (s, srv); - srv->exemplar_.version (l); - parsed = true; - } - + instance<M> ()->finalize_config (s); return OK; } @@ -107,44 +152,140 @@ namespace web { auto srv (instance<M> ()); log l (s, srv); - srv->init_worker (l); + srv->template init_worker<M> (l); } template <typename M> static int - request_handler (request_rec* r) noexcept + request_handler (request_rec* r) noexcept; + + private: + // Our representation of the Apache configuration context. + // + // The lifetime of this object is under the control of the Apache API, + // which treats it as a raw sequence of bytes. In order not to tinker + // with the C-style structures and APR memory pools, we will keep it a + // (C++11) POD type with just the members required to maintain the + // context hierarchy. + // + // We will then use the pointers to these context objects as keys in + // maps to (1) the corresponding application-level option lists during + // the configuration cycle and to (2) the corresponding module exemplar + // during the HTTP request handling phase. We will also use the same + // type for both directory and server configuration contexts. + // + struct context { - auto srv (instance<M> ()); - if (!r->handler || srv->name_ != r->handler) return DECLINED; + // Outer (server) configuration context for the directory + // configuration context, NULL otherwise. + // + context* server; - request req (r); - log l (r->server, srv); - return srv->template handle<M> (req, l); - } + // If module directives appear directly in the server configuration + // scope, Apache creates a special directory context for them. This + // context appears at the same hierarchy level as the user-defined + // directory contexts of the same server scope. + // + bool special; + + // Create the server configuration context. + // + context (): server (nullptr), special (false) {} + + // Create the directory configuration context. Due to the Apache API + // implementation details it is not possible to detect the enclosing + // server configuration context at the time of directory context + // creation. As a result, the server member is set by the module's + // parse_option() function. + // + context (bool s): server (nullptr), special (s) {} + + // Ensure the object is only destroyed by Apache. + // + ~context () = delete; + }; + + // Type of the key for configuration options and module exemplar maps. + // + using context_id = const context*; + + static bool + is_null (context_id id) noexcept {return id == nullptr;} + + static context_id + make_context_id (const context* c) noexcept {return c;} + + // Convert Apache-provided configuration pointer to the context id. + // + static context_id + make_context_id (void* config) noexcept + {return make_context_id (static_cast<const context*> (config));} private: void init_directives (); - void - init_worker (log& l) noexcept; + // Create the server configuration context. Called by the Apache API + // whenever a new object of that type is required. + // + static void* + create_server_context (apr_pool_t*, server_rec*) noexcept; + + // Create the server directory configuration context. Called by the + // Apache API whenever a new object of that type is required. + // + static void* + create_dir_context (apr_pool_t*, char* dir) noexcept; + + template <typename M> + static void* + merge_server_context (apr_pool_t*, void* enclosing, void* enclosed) + noexcept + { + // Complement the enclosed context with options of the enclosing one. + // + instance<M> ()->complement ( + make_context_id (enclosed), make_context_id (enclosing)); + + return enclosed; + } static const char* - parse_option (cmd_parms* parms, void* mconfig, const char* args) noexcept; + parse_option (cmd_parms* parms, void* conf, const char* args) noexcept; const char* - add_option (const char* name, optional<std::string> value); + add_option (context_id id, const char* name, optional<std::string> value); + + void + finalize_config (server_rec*); + + void + clear_config (); + + void + complement (context_id enclosed, context_id enclosing); + + template <typename M> + void + init_worker (log&); template <typename M> int - handle (request& r, log& l) noexcept; + handle (request&, context_id, log&) const; private: std::string name_; module& exemplar_; option_descriptions option_descriptions_; - name_values options_; + + using options = std::map<context_id, name_values>; + options options_; + + using exemplars = std::map<context_id, std::unique_ptr<module>>; + exemplars exemplars_; + bool options_parsed_ = false; + bool version_logged_ = false; }; } } diff --git a/web/apache/service.cxx b/web/apache/service.cxx index 96ff855..2ca8cf0 100644 --- a/web/apache/service.cxx +++ b/web/apache/service.cxx @@ -4,8 +4,7 @@ #include <web/apache/service> -#include <unistd.h> // getppid() -#include <signal.h> // kill() +#include <apr_pools.h> #include <httpd.h> #include <http_config.h> @@ -51,11 +50,17 @@ namespace web i.first->first.c_str (), reinterpret_cast<cmd_func> (parse_option), this, - RSRC_CONF, + + // Allow directives in both server and directory configuration + // scopes. + // + RSRC_CONF | ACCESS_CONF, + // Move away from TAKE1 to be able to handle empty string and // no-value. // RAW_ARGS, + nullptr }; } @@ -64,21 +69,47 @@ namespace web cmds = directives.release (); } - const char* service:: - parse_option (cmd_parms* parms, void*, const char* args) noexcept + void* service:: + create_server_context (apr_pool_t* pool, server_rec*) noexcept { - // @@ Current implementation does not consider configuration context - // (server config, virtual host, directory) for directive parsing, nor - // for request handling. + // Create the object using the configuration memory pool provided by the + // Apache API. The lifetime of the object is equal to the lifetime of the + // pool. + // + void* p (apr_palloc (pool, sizeof (context))); + assert (p != nullptr); + return new (p) context (); + } + + void* service:: + create_dir_context (apr_pool_t* pool, char* dir) noexcept + { + // Create the object using the configuration memory pool provided by the + // Apache API. The lifetime of the object is equal to the lifetime of + // the pool. + // + void* p (apr_palloc (pool, sizeof (context))); + assert (p != nullptr); + + // For the user-defined directory configuration context dir is the path + // of the corresponding directive. For the special server directory + // invented by Apache for server scope directives, dir is NULL. // + return new (p) context (dir == nullptr); + } + + const char* service:: + parse_option (cmd_parms* parms, void* conf, const char* args) noexcept + { service& srv (*reinterpret_cast<service*> (parms->cmd->cmd_data)); if (srv.options_parsed_) - // Apache is inside the second pass of its messy initialization cycle - // (more details at http://wiki.apache.org/httpd/ModuleLife). Just - // ignore it. + // Apache have started the second pass of its messy initialization cycle + // (more details at http://wiki.apache.org/httpd/ModuleLife). This time + // we are parsing for real. Cleanup the existing config, and start + // building the new one. // - return 0; + srv.clear_config (); // 'args' is an optionally double-quoted string. It uses double quotes // to distinguish empty string from no-value case. @@ -91,11 +122,52 @@ namespace web ? string (args + 1, l - 2) : args; - return srv.add_option (parms->cmd->name, move (value)); + // Determine the directory and server configuration contexts for the + // option. + // + context* dir_context (static_cast<context*> (conf)); + assert (dir_context != nullptr); + + server_rec* server (parms->server); + assert (server != nullptr); + assert (server->module_config != nullptr); + + context* srv_context ( + static_cast<context*> ( + ap_get_module_config (server->module_config, &srv))); + + assert (srv_context != nullptr); + + // Associate the directory configuration context with the enclosing + // server configuration context. + // + context*& s (dir_context->server); + if (s == nullptr) + s = srv_context; + else + assert (s == srv_context); + + // If the option appears in the special directory configuration context, + // add it to the enclosing server context instead. This way it will be + // possible to complement all server-enclosed contexts (including this + // special one) with the server scope options. + // + context* c (dir_context->special ? srv_context : dir_context); + + if (dir_context->special) + // + // Make sure the special directory context is also in the option lists + // map. Later the context will be populated with an enclosing server + // context options. + // + srv.options_.emplace (make_context_id (dir_context), name_values ()); + + return srv.add_option ( + make_context_id (c), parms->cmd->name, move (value)); } const char* service:: - add_option (const char* name, optional<string> value) + add_option (context_id id, const char* name, optional<string> value) { auto i (option_descriptions_.find (name)); assert (i != option_descriptions_.end ()); @@ -105,47 +177,54 @@ namespace web if (i->second != static_cast<bool> (value)) return value ? "unexpected value" : "value expected"; - options_.emplace_back (name + name_.length () + 1, move (value)); + options_[id].emplace_back (name + name_.length () + 1, move (value)); return 0; } void service:: - init_worker (log& l) noexcept + complement (context_id enclosed, context_id enclosing) { - const string func_name ( - "web::apache::service<" + name_ + ">::init_worker"); + auto i (options_.find (enclosing)); - try + // The enclosing context may have no options. It can be the context of a + // server having no configuration directives in it's immediate scope, + // but having ones in it's enclosed scope (directory or virtual server). + // + if (i != options_.end ()) { - exemplar_.init (options_, l); + const name_values& src (i->second); + name_values& dest (options_[enclosed]); + dest.insert (dest.begin (), src.begin (), src.end ()); } - catch (const exception& e) + } + + void service:: + finalize_config (server_rec* s) + { + if (!version_logged_) { - l.write (nullptr, 0, func_name.c_str (), APLOG_EMERG, e.what ()); - - // Terminate the root apache process. Indeed we can only try to - // terminate the process, and most likely will fail in a production - // environment where the apache root process usually runs under root, - // and worker processes run under some other user. This is why the - // implementation should consider the possibility of not being - // initialized at the time of HTTP request processing. In such a case - // it should respond with an internal server error (500 HTTP status), - // reporting misconfiguration. - // - ::kill (::getppid (), SIGTERM); + log l (s, this); + exemplar_.version (l); + version_logged_ = true; } - catch (...) - { - l.write (nullptr, - 0, - func_name.c_str (), - APLOG_EMERG, - "unknown error"); - // Terminate the root apache process. - // - ::kill (::getppid (), SIGTERM); - } + // Complement directory configuration contexts with options of the + // enclosing server configuration context. By this time virtual server + // contexts are already complemented with the main server configuration + // context options as a result of the merge_server_context() calls. + // + for (const auto& o: options_) + if (o.first->server != nullptr) // Is a directory configuration context. + complement (o.first, o.first->server); + + options_parsed_ = true; + } + + void service:: + clear_config () + { + options_.clear (); + options_parsed_ = false; } } } diff --git a/web/apache/service.txx b/web/apache/service.txx index 300a2a8..b57befc 100644 --- a/web/apache/service.txx +++ b/web/apache/service.txx @@ -2,8 +2,12 @@ // copyright : Copyright (c) 2014-2016 Code Synthesis Ltd // license : MIT; see accompanying LICENSE file +#include <unistd.h> // getppid() +#include <signal.h> // kill() + #include <http_log.h> +#include <utility> // move() #include <exception> namespace web @@ -11,37 +15,147 @@ namespace web namespace apache { template <typename M> + void service:: + init_worker (log& l) + { + const std::string func_name ( + "web::apache::service<" + name_ + ">::init_worker"); + + try + { + const M* exemplar (dynamic_cast<const M*> (&exemplar_)); + assert (exemplar != nullptr); + + // For each directory configuration context create the module exemplar + // as a deep copy of the exemplar_ member and initialize it with the + // context-specific option list. Note that there can be contexts + // having no module options specified for them and no options + // inherited from enclosing contexts. Such contexts will not appear in + // the options_ map. Meanwhile 'SetHandler <modname>' directive can be + // in effect for such contexts, and we should be ready to handle + // requests for them (by using the "root exemplar"). + // + for (const auto& o: options_) + { + const context* c (o.first); + + if (c->server != nullptr) // Is a directory configuration context. + { + auto r ( + exemplars_.emplace ( + make_context_id (c), + std::unique_ptr<module> (new M (*exemplar)))); + + r.first->second->init (o.second, l); + } + } + + // Options are not needed anymore. Free up the space. + // + options_.clear (); + + // Initialize the "root exemplar" by default (with no options). It + // will be used to handle requests for configuration contexts having + // no options specified, and no options inherited from enclosing + // contexts. + // + exemplar_.init (name_values (), l); + } + catch (const std::exception& e) + { + l.write (nullptr, 0, func_name.c_str (), APLOG_EMERG, e.what ()); + + // Terminate the root apache process. Indeed we can only try to + // terminate the process, and most likely will fail in a production + // environment, where the apache root process usually runs under root, + // and worker processes run under some other user. This is why the + // implementation should consider the possibility of not being + // initialized at the time of HTTP request processing. In such a case + // it should respond with an internal server error (500 HTTP status), + // reporting misconfiguration. + // + kill (getppid (), SIGTERM); + } + catch (...) + { + l.write (nullptr, + 0, + func_name.c_str (), + APLOG_EMERG, + "unknown error"); + + // Terminate the root apache process. + // + kill (getppid (), SIGTERM); + } + } + + template <typename M> int service:: - handle (request& r, log& l) noexcept + request_handler (request_rec* r) noexcept + { + auto srv (instance<M> ()); + if (!r->handler || srv->name_ != r->handler) return DECLINED; + + assert (r->per_dir_config != nullptr); + + // Obtain the request-associated configuration context id. + // + context_id id ( + make_context_id (ap_get_module_config (r->per_dir_config, srv))); + + assert (!is_null (id)); + + request rq (r); + log lg (r->server, srv); + return srv->template handle<M> (rq, id, lg); + } + + template <typename M> + int service:: + handle (request& rq, context_id id, log& lg) const { static const std::string func_name ( "web::apache::service<" + name_ + ">::handle"); try { - M m (static_cast<const M&> (exemplar_)); + auto i (exemplars_.find (id)); + + // Use the context-specific exemplar if found, otherwise use the + // default one. + // + const module* exemplar (i != exemplars_.end () + ? i->second.get () + : &exemplar_); + + const M* e (dynamic_cast<const M*> (exemplar)); + assert (e != nullptr); + + M m (*e); - if (static_cast<module&> (m).handle (r, r, l)) - return r.flush (); + if (static_cast<module&> (m).handle (rq, rq, lg)) + return rq.flush (); - if (!r.get_write_state ()) + if (!rq.get_write_state ()) return DECLINED; - l.write (nullptr, 0, func_name.c_str (), APLOG_ERR, - "handling declined while unbuffered content has been written"); + lg.write (nullptr, 0, func_name.c_str (), APLOG_ERR, + "handling declined while unbuffered content " + "has been written"); } catch (const invalid_request& e) { - if (!e.content.empty () && !r.get_write_state ()) + if (!e.content.empty () && !rq.get_write_state ()) { try { - r.content (e.status, e.type) << e.content; - return r.flush (); + rq.content (e.status, e.type) << e.content; + return rq.flush (); } catch (const std::exception& e) { - l.write (nullptr, 0, func_name.c_str (), APLOG_ERR, e.what ()); + lg.write (nullptr, 0, func_name.c_str (), APLOG_ERR, e.what ()); } } @@ -49,39 +163,39 @@ namespace web } catch (const std::exception& e) { - l.write (nullptr, 0, func_name.c_str (), APLOG_ERR, e.what ()); + lg.write (nullptr, 0, func_name.c_str (), APLOG_ERR, e.what ()); - if (*e.what () && !r.get_write_state ()) + if (*e.what () && !rq.get_write_state ()) { try { - r.content (HTTP_INTERNAL_SERVER_ERROR, "text/plain;charset=utf-8") + rq.content (HTTP_INTERNAL_SERVER_ERROR, "text/plain;charset=utf-8") << e.what (); - return r.flush (); + return rq.flush (); } catch (const std::exception& e) { - l.write (nullptr, 0, func_name.c_str (), APLOG_ERR, e.what ()); + lg.write (nullptr, 0, func_name.c_str (), APLOG_ERR, e.what ()); } } } catch (...) { - l.write (nullptr, 0, func_name.c_str (), APLOG_ERR, "unknown error"); + lg.write (nullptr, 0, func_name.c_str (), APLOG_ERR, "unknown error"); - if (!r.get_write_state ()) + if (!rq.get_write_state ()) { try { - r.content (HTTP_INTERNAL_SERVER_ERROR, "text/plain;charset=utf-8") + rq.content (HTTP_INTERNAL_SERVER_ERROR, "text/plain;charset=utf-8") << "unknown error"; - return r.flush (); + return rq.flush (); } catch (const std::exception& e) { - l.write (nullptr, 0, func_name.c_str (), APLOG_ERR, e.what ()); + lg.write (nullptr, 0, func_name.c_str (), APLOG_ERR, e.what ()); } } } @@ -86,6 +86,9 @@ namespace web public: using path_type = web::path; + virtual + ~request () = default; + // Corresponds to abs_path portion of HTTP URL as described in // "3.2.2 HTTP URL" of http://tools.ietf.org/html/rfc2616. // Returns '/' if no abs_path is present in URL. @@ -120,6 +123,9 @@ namespace web class response { public: + virtual + ~response () = default; + // Set status code, content type, and get the stream to write // the content to. If the buffer argument is true (default), // then buffer the entire content before sending it as a @@ -170,6 +176,9 @@ namespace web class log { public: + virtual + ~log () = default; + virtual void write (const char* msg) = 0; }; @@ -188,6 +197,9 @@ namespace web class module { public: + virtual + ~module () = default; + // Description of configuration options supported by this module. Note: // should be callable during static initialization. // |