passenger 5.0.18 → 5.0.19

data/dev/list_tests

@@ -4,7 +4,7 @@
 #
 # Lists the test names in the given .cpp test file.
 
-require_relative '../lib/phusion_passenger/utils/ansi_colors'
+require_relative '../src/ruby_supportlib/phusion_passenger/utils/ansi_colors'
 
 include PhusionPassenger::Utils::AnsiColors
 

data/dev/runner

@@ -5,7 +5,7 @@
 # Evaluates Ruby code in an environment that has the Phusion Passenger
 # libraries loaded.
 
-require File.expand_path(File.dirname(__FILE__) + "/../lib/phusion_passenger")
+require File.expand_path(File.dirname(__FILE__) + "/../src/ruby_supportlib/phusion_passenger")
 PhusionPassenger.locate_directories
 
 while true

data/dev/vagrant/nginx_rakefile

@@ -23,7 +23,7 @@ end
 desc "Configure Nginx source tree"
 task :configure do
   sh "./configure --prefix=/home/vagrant/nginx/inst" +
-    " --add-module=/vagrant/ext/nginx" +
+    " --add-module=/vagrant/src/nginx_module" +
     " --with-http_ssl_module" +
     " --with-http_gzip_static_module" +
     " --with-http_stub_status_module" +

data/doc/Design and Architecture.html

@@ -1258,7 +1258,7 @@ end</pre>
 <div class="sect3">
 <span class="anchor_helper" id="_web_server_module"></span><h4 data-anchor="_web_server_module">1.2.1. Web server module</h4>
 <div class="paragraph"><p>When an HTTP client sends a request, it is received by the web server (Nginx or Apache). Both Apache and Nginx can be extended with <strong>modules</strong>. Phusion Passenger provides such a module. The module is loaded into Nginx/Apache. It checks whether the request should be handled by a Phusion Passenger-served web application, and if so, forwards the request to the Passenger core. The internal wire protocol used during this forwarding, is a modified version of <a href="http://en.wikipedia.org/wiki/SCGI">SCGI</a>.</p></div>
-<div class="paragraph"><p>The Nginx module and Apache module have an entirely different code base. Their code bases are in <span class="monospaced">ext/nginx</span> and <span class="monospaced">ext/apache2</span>, respectively. Both modules are relatively small because they outsource most logic to the Passenger core, and because they utilize a common library (<span class="monospaced">ext/common</span>). This allows us to support both Nginx and Apache without having to write a lot of things twice.</p></div>
+<div class="paragraph"><p>The Nginx module and Apache module have an entirely different code base. Their code bases are in <span class="monospaced">src/nginx_module</span> and <span class="monospaced">src/apache2_module</span>, respectively. Both modules are relatively small because they outsource most logic to the Passenger core, and because they utilize a common library (<span class="monospaced">src/cxx_supportlib</span>). This allows us to support both Nginx and Apache without having to write a lot of things twice.</p></div>
 </div>
 <div class="sect3">
 <span class="anchor_helper" id="_passenger_core"></span><h4 data-anchor="_passenger_core">1.2.2. Passenger core</h4>
@@ -1291,12 +1291,12 @@ So as a safety measure, they are both monitored by the <strong>Watchdog</strong>
 <div class="ulist"><ul>
 <li>
 <p>
-The web server modules can be found in <span class="monospaced">ext/apache2</span> and <span class="monospaced">ext/nginx</span>.
+The web server modules can be found in <span class="monospaced">src/apache2_module</span> and <span class="monospaced">src/nginx_module</span>.
 </p>
 </li>
 <li>
 <p>
-The Passenger core, UstRouter and Watchdog can be found in <span class="monospaced">ext/common/agent</span>.
+The Passenger core, UstRouter and Watchdog can be found in <span class="monospaced">src/agent</span>.
 </p>
 </li>
 <li>
@@ -1329,24 +1329,24 @@ The Phusion Passenger module inside Nginx/Apache proceeds with starting the Watc
 <div class="ulist"><ul>
 <li>
 <p>
-<span class="monospaced">ext/nginx/ngx_http_passenger_module.c</span>, function <span class="monospaced">start_watchdog()</span>.
+<span class="monospaced">src/nginx_module/ngx_http_passenger_module.c</span>, function <span class="monospaced">start_watchdog()</span>.
 </p>
 </li>
 <li>
 <p>
-<span class="monospaced">ext/apache2/Hooks.cpp</span>, in the constructor for the <span class="monospaced">Hooks</span> class.
+<span class="monospaced">src/apache2_module/Hooks.cpp</span>, in the constructor for the <span class="monospaced">Hooks</span> class.
 </p>
 </li>
 <li>
 <p>
-<span class="monospaced">ext/common/AgentsStarter.h</span> and <span class="monospaced">AgentsStarter.cpp</span>. Most of the logic pertaining starting the Watchdog is in this file.
+<span class="monospaced">src/cxx_supportlib/AgentsStarter.h</span> and <span class="monospaced">AgentsStarter.cpp</span>. Most of the logic pertaining starting the Watchdog is in this file.
 </p>
 </li>
 </ul></div>
 </li>
 <li>
 <p>
-The Watchdog first initializes a <a href="#instance_state_and_communication">"instance directory"</a>, which is a temporary directory containing files that will be used during the life time of this Phusion Passenger instance. For example, the directory contains Unix domain socket files, so that the different Phusion Passenger processes can communicate with each other. The Watchdog is implemented in <span class="monospaced">ext/common/agent/Watchdog/Main.cpp</span>.
+The Watchdog first initializes a <a href="#instance_state_and_communication">"instance directory"</a>, which is a temporary directory containing files that will be used during the life time of this Phusion Passenger instance. For example, the directory contains Unix domain socket files, so that the different Phusion Passenger processes can communicate with each other. The Watchdog is implemented in <span class="monospaced">src/agent/Watchdog/Main.cpp</span>.
 </p>
 </li>
 <li>
@@ -1374,7 +1374,7 @@ The Watchdog reports successful startup back to the Phusion Passenger module tha
 <div class="paragraph"><p><span class="image">
 <img src="images/passenger_core_architecture.png" alt="Passenger core architecture">
 </span></p></div>
-<div class="paragraph"><p>The Passenger core consists of two subsystems. One is the <strong>request handling subsystem</strong>. The other is <strong>the ApplicationPool subsystem</strong>, which performs the bulk of process management. The core also uses a number of support libraries. The largest third-party support libraries are shown in the diagram. Many more — internal — support libraries are used, but they’re omitted from the diagram. You can find these internal support libraries in the directory <span class="monospaced">ext/common/Utils</span>.</p></div>
+<div class="paragraph"><p>The Passenger core consists of two subsystems. One is the <strong>request handling subsystem</strong>. The other is <strong>the ApplicationPool subsystem</strong>, which performs the bulk of process management. The core also uses a number of support libraries. The largest third-party support libraries are shown in the diagram. Many more — internal — support libraries are used, but they’re omitted from the diagram. You can find these internal support libraries in the directory <span class="monospaced">src/cxx_supportlib/Utils</span>.</p></div>
 <div class="sect2">
 <span class="anchor_helper" id="_request_handling"></span><h3 data-anchor="_request_handling">3.1. Request handling</h3>
 <div class="paragraph"><p>Recall that requests are first received from the web server. The web server serializes the request into a slightly modified version of <a href="http://en.wikipedia.org/wiki/SCGI">the SCGI format</a>, and sends it to the core’s RequestHandler. The RequestHandler performs some work, and eventually sends back a regular HTTP response. The web server parses the RequestHandler response, and sends a response to the original HTTP client.</p></div>
@@ -1718,7 +1718,7 @@ The unbundled Meteor loader does it by executing the <span class="monospaced">me
 <div class="ulist"><ul>
 <li>
 <p>
-A Phusion Passenger internal protocol which we call the <em>session</em> protocol. This protocol is used by the Ruby loaders and the Python loader. A description of this protocol is outside the scope of this document, but if you’re interested in how it looks like and how it behaves, you can study the source code of the Ruby and Python loaders, as well as <span class="monospaced">ext/common/Utils/MessageIO.h</span>.
+A Phusion Passenger internal protocol which we call the <em>session</em> protocol. This protocol is used by the Ruby loaders and the Python loader. A description of this protocol is outside the scope of this document, but if you’re interested in how it looks like and how it behaves, you can study the source code of the Ruby and Python loaders, as well as <span class="monospaced">src/cxx_supportlib/Utils/MessageIO.h</span>.
 </p>
 </li>
 <li>
@@ -1844,22 +1844,22 @@ It sends a response back to the Spawner. This is similar to how the loader does
 <div class="ulist"><ul>
 <li>
 <p>
-The constant <span class="monospaced">appTypeDefinitions</span> in the file <span class="monospaced">ext/common/ApplicationPool2/AppTypes.cpp</span> keeps a list of supported languages. It also specifies the default startup file name belonging to each language.
+The constant <span class="monospaced">appTypeDefinitions</span> in the file <span class="monospaced">src/cxx_supportlib/AppTypes.cpp</span> keeps a list of supported languages. It also specifies the default startup file name belonging to each language.
 </p>
 </li>
 <li>
 <p>
-The method <span class="monospaced">getStartCommand()</span> in the file <span class="monospaced">ext/common/ApplicationPool2/Options.h</span> defines the loaders that should be used for each language.
+The method <span class="monospaced">getStartCommand()</span> in the file <span class="monospaced">src/agent/Core/ApplicationPool2/Options.h</span> defines the loaders that should be used for each language.
 </p>
 </li>
 <li>
 <p>
-The method <span class="monospaced">tryCreateSmartSpawner()</span> in the file <span class="monospaced">ext/common/ApplicationPool2/SpawnerFactory.h</span> defines the preloaders that should be used for each language.
+The method <span class="monospaced">tryCreateSmartSpawner()</span> in the file <span class="monospaced">src/agent/Core/SpawningKit/Factory.h</span> defines the preloaders that should be used for each language.
 </p>
 </li>
 <li>
 <p>
-The method <span class="monospaced">looks_like_app_directory?</span> in the file <span class="monospaced">lib/phusion_passenger/standalone/app_finder.rb</span> keeps a list of supported startup files. This is only used within Passenger Standalone.
+The method <span class="monospaced">looks_like_app_directory?</span> in the file <span class="monospaced">src/ruby_supportlib/phusion_passenger/standalone/app_finder.rb</span> keeps a list of supported startup files. This is only used within Passenger Standalone.
 </p>
 </li>
 </ul></div>
@@ -1871,7 +1871,7 @@ The method <span class="monospaced">looks_like_app_directory?</span> in the file
 <div class="sectionbody">
 <div class="paragraph"><p>Every time you start Phusion Passenger, you’ve created a new <strong>instance</strong>. Every instance consists of multiple processes that work together (Watchdog, Passenger core, UstRouter, application processes). All those processes have to be able to communicate with each other. Those processes must also <strong>not</strong> communicate with the processes belonging to other instances. For example, if you start Apache+Passenger <strong>and</strong> Nginx+Passenger, then we don’t want the Passenger core that’s started from Apache to use UstRouter that’s started from Nginx.</p></div>
 <div class="paragraph"><p>Clearly, the processes can’t listen on a specific TCP port for communication. Nor can they listen on a fixed Unix domain socket filename.</p></div>
-<div class="paragraph"><p>That is where the <em>instance directory</em> comes in. Every Phusion Passenger instance has its own, unique temporary directory. That directory is removed when the instance halts. The directory contains Unix domain socket files that the processes listen on. Every Phusion Passenger related process knows where its own instance directory is, and thus, knows how to communicate with other processes belonging to the same instance. The instance directory is implemented in <span class="monospaced">ext/common/InstanceDirectory.h</span>.</p></div>
+<div class="paragraph"><p>That is where the <em>instance directory</em> comes in. Every Phusion Passenger instance has its own, unique temporary directory. That directory is removed when the instance halts. The directory contains Unix domain socket files that the processes listen on. Every Phusion Passenger related process knows where its own instance directory is, and thus, knows how to communicate with other processes belonging to the same instance. The instance directory is implemented in <span class="monospaced">src/cxx_supportlib/InstanceDirectory.h</span>.</p></div>
 <div class="paragraph"><p>Administration tools such as <span class="monospaced">passenger-status</span> query information using instance directories. First, they check which instance directories exist on the system. If they find only one, then they query the sockets inside that sole instance directory. Otherwise, they abort with an error and ask the user to specifically select the instance to query.</p></div>
 </div>
 </div>

data/doc/Design and Architecture.txt

@@ -98,7 +98,7 @@ Thus, if the Passenger core crashes, or if an application process crashes, they
 
 When an HTTP client sends a request, it is received by the web server (Nginx or Apache). Both Apache and Nginx can be extended with **modules**. Phusion Passenger provides such a module. The module is loaded into Nginx/Apache. It checks whether the request should be handled by a Phusion Passenger-served web application, and if so, forwards the request to the Passenger core. The internal wire protocol used during this forwarding, is a modified version of link:http://en.wikipedia.org/wiki/SCGI[SCGI].
 
-The Nginx module and Apache module have an entirely different code base. Their code bases are in `ext/nginx` and `ext/apache2`, respectively. Both modules are relatively small because they outsource most logic to the Passenger core, and because they utilize a common library (`ext/common`). This allows us to support both Nginx and Apache without having to write a lot of things twice.
+The Nginx module and Apache module have an entirely different code base. Their code bases are in `src/nginx_module` and `src/apache2_module`, respectively. Both modules are relatively small because they outsource most logic to the Passenger core, and because they utilize a common library (`src/cxx_supportlib`). This allows us to support both Nginx and Apache without having to write a lot of things twice.
 
 ==== Passenger core
 
@@ -131,8 +131,8 @@ You might have noticed that Phusion Passenger Standalone is not part of the diag
 
 Phusion Passenger is written mostly in C\++ and Ruby. The web server modules, core, UstRouter and Watchdog are written in C++. Most command line tools are written in Ruby. You can find each component here:
 
- * The web server modules can be found in `ext/apache2` and `ext/nginx`.
- * The Passenger core, UstRouter and Watchdog can be found in `ext/common/agent`.
+ * The web server modules can be found in `src/apache2_module` and `src/nginx_module`.
+ * The Passenger core, UstRouter and Watchdog can be found in `src/agent`.
  * The command line tools can be found in `bin`, with some parts of their code in `lib`.
 
 More information can be found in the link:https://github.com/phusion/passenger/blob/master/CONTRIBUTING.md[Contributors Guide]. This guide also teaches you how to compile Phusion Passenger.
@@ -148,11 +148,11 @@ Phusion Passenger initializes as follows.
 
 2. The Phusion Passenger module inside Nginx/Apache proceeds with starting the Watchdog. This is implemented in:
 +
- * `ext/nginx/ngx_http_passenger_module.c`, function `start_watchdog()`.
- * `ext/apache2/Hooks.cpp`, in the constructor for the `Hooks` class.
- * `ext/common/AgentsStarter.h` and `AgentsStarter.cpp`. Most of the logic pertaining starting the Watchdog is in this file.
+ * `src/nginx_module/ngx_http_passenger_module.c`, function `start_watchdog()`.
+ * `src/apache2_module/Hooks.cpp`, in the constructor for the `Hooks` class.
+ * `src/cxx_supportlib/AgentsStarter.h` and `AgentsStarter.cpp`. Most of the logic pertaining starting the Watchdog is in this file.
 
-3. The Watchdog first initializes a <<instance_state_and_communication,"instance directory">>, which is a temporary directory containing files that will be used during the life time of this Phusion Passenger instance. For example, the directory contains Unix domain socket files, so that the different Phusion Passenger processes can communicate with each other. The Watchdog is implemented in `ext/common/agent/Watchdog/Main.cpp`.
+3. The Watchdog first initializes a <<instance_state_and_communication,"instance directory">>, which is a temporary directory containing files that will be used during the life time of this Phusion Passenger instance. For example, the directory contains Unix domain socket files, so that the different Phusion Passenger processes can communicate with each other. The Watchdog is implemented in `src/agent/Watchdog/Main.cpp`.
 
 4. The Watchdog starts the Passenger core and the UstRouter simultaneously. Each performs its own initialization.
 
@@ -168,7 +168,7 @@ After initialization, Phusion Passenger is ready to receive and to process reque
 
 image:images/passenger_core_architecture.png[Passenger core architecture]
 
-The Passenger core consists of two subsystems. One is the *request handling subsystem*. The other is *the ApplicationPool subsystem*, which performs the bulk of process management. The core also uses a number of support libraries. The largest third-party support libraries are shown in the diagram. Many more -- internal -- support libraries are used, but they're omitted from the diagram. You can find these internal support libraries in the directory `ext/common/Utils`.
+The Passenger core consists of two subsystems. One is the *request handling subsystem*. The other is *the ApplicationPool subsystem*, which performs the bulk of process management. The core also uses a number of support libraries. The largest third-party support libraries are shown in the diagram. Many more -- internal -- support libraries are used, but they're omitted from the diagram. You can find these internal support libraries in the directory `src/cxx_supportlib/Utils`.
 
 === Request handling
 
@@ -383,7 +383,7 @@ The loader sets up a server on which the application listens for requests. The S
 
 As explained in <<request_handler_forwarding_to_app,section 'Request handling' and subsection 'Forwarding to the application'>>, the RequestHandler can talk with the application process in a protocol that the application prefers. The RequestHandler supports two protocols:
 
- * A Phusion Passenger internal protocol which we call the 'session' protocol. This protocol is used by the Ruby loaders and the Python loader. A description of this protocol is outside the scope of this document, but if you're interested in how it looks like and how it behaves, you can study the source code of the Ruby and Python loaders, as well as `ext/common/Utils/MessageIO.h`.
+ * A Phusion Passenger internal protocol which we call the 'session' protocol. This protocol is used by the Ruby loaders and the Python loader. A description of this protocol is outside the scope of this document, but if you're interested in how it looks like and how it behaves, you can study the source code of the Ruby and Python loaders, as well as `src/cxx_supportlib/Utils/MessageIO.h`.
  * The HTTP protocol. This protocol is used by the Node.js and Meteor loaders. If you're writing a new loader then, it's probably easiest to use this protocol, together with whatever HTTP library is available for the loader's target language.
 
 Typically, the server is setup to listen on a Unix domain socket file, inside the `backends` subdirectory of the 'generation directory'. The path to the generation directory was passed during handshake. However the server may also listen on a TCP socket.
@@ -465,10 +465,10 @@ Given an application type, the associated loader and preloader can be looked up.
 
 Information about the supported application types, startup files, loaders and preloaders are defined in the following places:
 
- * The constant `appTypeDefinitions` in the file `ext/common/ApplicationPool2/AppTypes.cpp` keeps a list of supported languages. It also specifies the default startup file name belonging to each language.
- * The method `getStartCommand()` in the file `ext/common/ApplicationPool2/Options.h` defines the loaders that should be used for each language.
- * The method `tryCreateSmartSpawner()` in the file `ext/common/ApplicationPool2/SpawnerFactory.h` defines the preloaders that should be used for each language.
- * The method `looks_like_app_directory?` in the file `lib/phusion_passenger/standalone/app_finder.rb` keeps a list of supported startup files. This is only used within Passenger Standalone.
+ * The constant `appTypeDefinitions` in the file `src/cxx_supportlib/AppTypes.cpp` keeps a list of supported languages. It also specifies the default startup file name belonging to each language.
+ * The method `getStartCommand()` in the file `src/agent/Core/ApplicationPool2/Options.h` defines the loaders that should be used for each language.
+ * The method `tryCreateSmartSpawner()` in the file `src/agent/Core/SpawningKit/Factory.h` defines the preloaders that should be used for each language.
+ * The method `looks_like_app_directory?` in the file `src/ruby_supportlib/phusion_passenger/standalone/app_finder.rb` keeps a list of supported startup files. This is only used within Passenger Standalone.
 
 
 [[instance_state_and_communication]]
@@ -478,7 +478,7 @@ Every time you start Phusion Passenger, you've created a new *instance*. Every i
 
 Clearly, the processes can't listen on a specific TCP port for communication. Nor can they listen on a fixed Unix domain socket filename.
 
-That is where the 'instance directory' comes in. Every Phusion Passenger instance has its own, unique temporary directory. That directory is removed when the instance halts. The directory contains Unix domain socket files that the processes listen on. Every Phusion Passenger related process knows where its own instance directory is, and thus, knows how to communicate with other processes belonging to the same instance. The instance directory is implemented in `ext/common/InstanceDirectory.h`.
+That is where the 'instance directory' comes in. Every Phusion Passenger instance has its own, unique temporary directory. That directory is removed when the instance halts. The directory contains Unix domain socket files that the processes listen on. Every Phusion Passenger related process knows where its own instance directory is, and thus, knows how to communicate with other processes belonging to the same instance. The instance directory is implemented in `src/cxx_supportlib/InstanceDirectory.h`.
 
 Administration tools such as `passenger-status` query information using instance directories. First, they check which instance directories exist on the system. If they find only one, then they query the sockets inside that sole instance directory. Otherwise, they abort with an error and ask the user to specifically select the instance to query.
 

data/doc/Packaging.html

@@ -267,7 +267,7 @@ used by packagers.</li>
 <p>The Phusion Passenger administration tools are written in Ruby. So the first thing
 they do is trying to load <code>phusion_passenger.rb</code>, which is the source file
 responsible for figuring out where all the other Phusion Passenger files are. It
-tries to look for phusion<em>passenger.rb in <code>&lt;OWN_DIRECTORY&gt;/../lib</code> where
+tries to look for phusion<em>passenger.rb in <code>&lt;OWN_DIRECTORY&gt;/../src/ruby_supportlib</code> where
 <code>&lt;OWN_DIRECTORY&gt;</code> is the directory that the tool is located in. If
 phusion</em>passenger.rb is not there, then it tries to load it from the normal Ruby
 load path.</p>
@@ -350,7 +350,7 @@ configuration file templates.</p>
 <p>A directory that contains the Phusion Passenger header files that are
 necessary for compiling Nginx.</p>
 
-<p>Value when originally packaged: <code>&lt;SOURCE_ROOT&gt;/ext</code></p></li>
+<p>Value when originally packaged: <code>&lt;SOURCE_ROOT&gt;/src</code></p></li>
 <li><p><code>lib_dir</code></p>
 
 <p>A directory that contains the Phusion Passenger library files, e.g.
@@ -365,7 +365,7 @@ as described in the section "The Phusion Passenger Ruby libraries",
 irregardless of the value of this key in the location configuration file.
 The value is only useful to non-Ruby Phusion Passenger code.</p>
 
-<p>Value when originally packaged: <code>&lt;SOURCE_ROOT&gt;/lib</code>.</p></li>
+<p>Value when originally packaged: <code>&lt;SOURCE_ROOT&gt;/src/ruby_supportlib</code>.</p></li>
 <li><p><code>apache2_module_path</code></p>
 
 <p>The filename of the Apache 2 module, or the filename that the Apache 2 module
@@ -380,14 +380,14 @@ extension. Phusion Passenger uses these sources to build a Ruby extension,
 when it detects that the user is using a new Ruby interpreter for which
 no Ruby extension has been compiled.</p>
 
-<p>Value when originally packaged: <code>&lt;SOURCE_ROOT&gt;/ext/ruby</code>.</p></li>
+<p>Value when originally packaged: <code>&lt;SOURCE_ROOT&gt;/src/ruby_native_extension</code>.</p></li>
 <li><p><code>nginx_module_source_dir</code></p>
 
 <p>The directory that contains the source code for the Phusion Passenger Nginx
 module. passenger-install-nginx-module uses these sources to build Nginx
 with Phusion Passenger support.</p>
 
-<p>Value when originally packaged: <code>&lt;SOURCE_ROOT&gt;/ext/nginx</code>.</p></li>
+<p>Value when originally packaged: <code>&lt;SOURCE_ROOT&gt;/src/nginx_module</code>.</p></li>
 </ul>
 
 

data/doc/Packaging.txt.md

@@ -120,7 +120,7 @@ Thus, if you're packaging Phusion Passenger, then we recommend the following:
 The Phusion Passenger administration tools are written in Ruby. So the first thing
 they do is trying to load `phusion_passenger.rb`, which is the source file
 responsible for figuring out where all the other Phusion Passenger files are. It
-tries to look for phusion_passenger.rb in `<OWN_DIRECTORY>/../lib` where
+tries to look for phusion_passenger.rb in `<OWN_DIRECTORY>/../src/ruby_supportlib` where
 `<OWN_DIRECTORY>` is the directory that the tool is located in. If
 phusion_passenger.rb is not there, then it tries to load it from the normal Ruby
 load path.
@@ -202,7 +202,7 @@ a list of all possible assets and asset directories.
    A directory that contains the Phusion Passenger header files that are
    necessary for compiling Nginx.
 
-   Value when originally packaged: `<SOURCE_ROOT>/ext`
+   Value when originally packaged: `<SOURCE_ROOT>/src`
 
  * `lib_dir`
 
@@ -219,7 +219,7 @@ a list of all possible assets and asset directories.
    irregardless of the value of this key in the location configuration file.
    The value is only useful to non-Ruby Phusion Passenger code.
 
-   Value when originally packaged: `<SOURCE_ROOT>/lib`.
+   Value when originally packaged: `<SOURCE_ROOT>/src/ruby_supportlib`.
 
  * `apache2_module_path`
 
@@ -236,7 +236,7 @@ a list of all possible assets and asset directories.
    when it detects that the user is using a new Ruby interpreter for which
    no Ruby extension has been compiled.
 
-   Value when originally packaged: `<SOURCE_ROOT>/ext/ruby`.
+   Value when originally packaged: `<SOURCE_ROOT>/src/ruby_native_extension`.
 
  * `nginx_module_source_dir`
 
@@ -244,7 +244,7 @@ a list of all possible assets and asset directories.
    module. passenger-install-nginx-module uses these sources to build Nginx
    with Phusion Passenger support.
 
-   Value when originally packaged: `<SOURCE_ROOT>/ext/nginx`.
+   Value when originally packaged: `<SOURCE_ROOT>/src/nginx_module`.
 
 Optional fields:
 

data/passenger.gemspec

@@ -1,5 +1,5 @@
 source_root = File.expand_path(File.dirname(__FILE__))
-$LOAD_PATH.unshift("#{source_root}/lib")
+$LOAD_PATH.unshift("#{source_root}/src/ruby_supportlib")
 require 'phusion_passenger'
 PhusionPassenger.locate_directories
 PhusionPassenger.require_passenger_lib 'packaging'
@@ -13,7 +13,7 @@ Gem::Specification.new do |s|
   s.rubyforge_project = "passenger"
   s.author = "Phusion - http://www.phusion.nl/"
   s.email = "software-signing@phusion.nl"
-  s.require_paths = ["lib"]
+  s.require_paths = ["src/ruby_supportlib"]
   s.add_dependency 'rake', '>= 0.8.1'
   s.add_dependency 'rack'
   s.files = Dir[*PhusionPassenger::Packaging::GLOB] -
@@ -24,6 +24,6 @@ Gem::Specification.new do |s|
     "optimized for performance, low memory usage and ease of use."
 
   if ENV['OFFICIAL_RELEASE']
-    s.extensions = ["helper-scripts/download_binaries/extconf.rb"]
+    s.extensions = ["src/helper-scripts/download_binaries/extconf.rb"]
   end
 end

data/src/README.md

@@ -0,0 +1,7 @@
+This directory contains the Passenger main source code. There are source files written in various programming languages, including C++, Ruby and Javascript. Browse to a subdirectory for a README which explains that particular subdirectory.
+
+If you aren't familiar with the Passenger codebase then we encourage you to read these first:
+
+ * [Contributors Guide](https://github.com/phusion/passenger/blob/master/CONTRIBUTING.md)
+ * [Design & Architecture](https://www.phusionpassenger.com/documentation/Design%20and%20Architecture.html)
+ * [Code walkthrough](http://vimeo.com/phusionnl/review/98027409/03ba678684)

data/src/agent/Core/ApiServer.h

@@ -0,0 +1,624 @@
+/*
+ *  Phusion Passenger - https://www.phusionpassenger.com/
+ *  Copyright (c) 2013-2015 Phusion
+ *
+ *  "Phusion Passenger" is a trademark of Hongli Lai & Ninh Bui.
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in
+ *  all copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ *  THE SOFTWARE.
+ */
+#ifndef _PASSENGER_CORE_API_SERVER_H_
+#define _PASSENGER_CORE_API_SERVER_H_
+
+#include <boost/regex.hpp>
+#include <oxt/thread.hpp>
+#include <sstream>
+#include <string>
+#include <cstring>
+#include <sys/types.h>
+
+#include <jsoncpp/json.h>
+#include <modp_b64.h>
+
+#include <Core/RequestHandler.h>
+#include <Core/ApplicationPool/Pool.h>
+#include <Shared/ApiServerUtils.h>
+#include <ServerKit/HttpServer.h>
+#include <DataStructures/LString.h>
+#include <Exceptions.h>
+#include <StaticString.h>
+#include <Logging.h>
+#include <Constants.h>
+#include <Utils/StrIntUtils.h>
+#include <Utils/BufferedIO.h>
+#include <Utils/MessageIO.h>
+
+namespace Passenger {
+namespace Core {
+
+using namespace std;
+
+
+class Request: public ServerKit::BaseHttpRequest {
+public:
+	string body;
+	Json::Value jsonBody;
+	Authorization authorization;
+
+	DEFINE_SERVER_KIT_BASE_HTTP_REQUEST_FOOTER(Request);
+};
+
+class ApiServer: public ServerKit::HttpServer<ApiServer, ServerKit::HttpClient<Request> > {
+private:
+	typedef ServerKit::HttpServer<ApiServer, ServerKit::HttpClient<Request> > ParentClass;
+	typedef ServerKit::HttpClient<Request> Client;
+	typedef ServerKit::HeaderTable HeaderTable;
+
+	boost::regex serverConnectionPath;
+
+	bool regex_match(const StaticString &str, const boost::regex &e) const {
+		return boost::regex_match(str.data(), str.data() + str.size(), e);
+	}
+
+	int extractThreadNumberFromClientName(const string &clientName) const {
+		boost::smatch results;
+		boost::regex re("^([0-9]+)-.*");
+
+		if (!boost::regex_match(clientName, results, re)) {
+			return -1;
+		}
+		if (results.size() != 2) {
+			return -1;
+		}
+		return stringToUint(results.str(1));
+	}
+
+	static void disconnectClient(RequestHandler *rh, string clientName) {
+		rh->disconnect(clientName);
+	}
+
+	void route(Client *client, Request *req, const StaticString &path) {
+		if (path == P_STATIC_STRING("/server.json")) {
+			processServerStatus(client, req);
+		} else if (regex_match(path, serverConnectionPath)) {
+			processServerConnectionOperation(client, req);
+		} else if (path == P_STATIC_STRING("/pool.xml")) {
+			processPoolStatusXml(client, req);
+		} else if (path == P_STATIC_STRING("/pool.txt")) {
+			processPoolStatusTxt(client, req);
+		} else if (path == P_STATIC_STRING("/pool/restart_app_group.json")) {
+			processPoolRestartAppGroup(client, req);
+		} else if (path == P_STATIC_STRING("/pool/detach_process.json")) {
+			processPoolDetachProcess(client, req);
+		} else if (path == P_STATIC_STRING("/backtraces.txt")) {
+			apiServerProcessBacktraces(this, client, req);
+		} else if (path == P_STATIC_STRING("/ping.json")) {
+			apiServerProcessPing(this, client, req);
+		} else if (path == P_STATIC_STRING("/version.json")) {
+			apiServerProcessVersion(this, client, req);
+		} else if (path == P_STATIC_STRING("/shutdown.json")) {
+			apiServerProcessShutdown(this, client, req);
+		} else if (path == P_STATIC_STRING("/gc.json")) {
+			processGc(client, req);
+		} else if (path == P_STATIC_STRING("/config.json")) {
+			processConfig(client, req);
+		} else if (path == P_STATIC_STRING("/reinherit_logs.json")) {
+			apiServerProcessReinheritLogs(this, client, req,
+				instanceDir, fdPassingPassword);
+		} else if (path == P_STATIC_STRING("/reopen_logs.json")) {
+			apiServerProcessReopenLogs(this, client, req);
+		} else {
+			apiServerRespondWith404(this, client, req);
+		}
+	}
+
+	void processServerConnectionOperation(Client *client, Request *req) {
+		if (!authorizeAdminOperation(this, client, req)) {
+			apiServerRespondWith401(this, client, req);
+		} else if (req->method == HTTP_DELETE) {
+			StaticString path = req->getPathWithoutQueryString();
+			boost::smatch results;
+
+			boost::regex_match(path.toString(), results, serverConnectionPath);
+			if (results.size() != 2) {
+				endAsBadRequest(&client, &req, "Invalid URI");
+				return;
+			}
+
+			int threadNumber = extractThreadNumberFromClientName(results.str(1));
+			if (threadNumber < 1 || (unsigned int) threadNumber > requestHandlers.size()) {
+				HeaderTable headers;
+				headers.insert(req->pool, "Content-Type", "application/json");
+				writeSimpleResponse(client, 400, &headers,
+					"{ \"status\": \"error\", \"reason\": \"Invalid thread number\" }");
+				if (!req->ended()) {
+					endRequest(&client, &req);
+				}
+				return;
+			}
+
+			requestHandlers[threadNumber - 1]->getContext()->libev->runLater(boost::bind(
+				disconnectClient, requestHandlers[threadNumber - 1], results.str(1)));
+
+			HeaderTable headers;
+			headers.insert(req->pool, "Content-Type", "application/json");
+			writeSimpleResponse(client, 200, &headers,
+				"{ \"status\": \"ok\" }");
+			if (!req->ended()) {
+				endRequest(&client, &req);
+			}
+		} else {
+			apiServerRespondWith405(this, client, req);
+		}
+	}
+
+	static void inspectRequestHandlerState(RequestHandler *rh, Json::Value *json) {
+		*json = rh->inspectStateAsJson();
+	}
+
+	void processServerStatus(Client *client, Request *req) {
+		if (authorizeStateInspectionOperation(this, client, req)) {
+			HeaderTable headers;
+			headers.insert(req->pool, "Content-Type", "application/json");
+
+			Json::Value doc;
+			doc["threads"] = (Json::UInt) requestHandlers.size();
+			for (unsigned int i = 0; i < requestHandlers.size(); i++) {
+				Json::Value json;
+				string key = "thread" + toString(i + 1);
+
+				requestHandlers[i]->getContext()->libev->runSync(boost::bind(
+					inspectRequestHandlerState, requestHandlers[i], &json));
+				doc[key] = json;
+			}
+
+			writeSimpleResponse(client, 200, &headers,
+				psg_pstrdup(req->pool, doc.toStyledString()));
+			if (!req->ended()) {
+				endRequest(&client, &req);
+			}
+		} else {
+			apiServerRespondWith401(this, client, req);
+		}
+	}
+
+	void processPoolStatusXml(Client *client, Request *req) {
+		Authorization auth(authorize(this, client, req));
+		if (auth.canReadPool) {
+			ApplicationPool2::Pool::ToXmlOptions options(
+				parseQueryString(req->getQueryString()));
+			options.uid = auth.uid;
+			options.apiKey = auth.apiKey;
+
+			HeaderTable headers;
+			headers.insert(req->pool, "Content-Type", "text/xml");
+			writeSimpleResponse(client, 200, &headers,
+				psg_pstrdup(req->pool, appPool->toXml(options)));
+			if (!req->ended()) {
+				endRequest(&client, &req);
+			}
+		} else {
+			HeaderTable headers;
+			headers.insert(req->pool, "Cache-Control", "no-cache, no-store, must-revalidate");
+			headers.insert(req->pool, "WWW-Authenticate", "Basic realm=\"api\"");
+			if (clientOnUnixDomainSocket(client) && appPool->getGroupCount() == 0) {
+				// Allow admin tools that connected through the Unix domain socket
+				// to know that this authorization error is caused by the fact
+				// that the pool is empty.
+				headers.insert(req->pool, "Pool-Empty", "true");
+			}
+			writeSimpleResponse(client, 401, &headers, "Unauthorized");
+			if (!req->ended()) {
+				endRequest(&client, &req);
+			}
+		}
+	}
+
+	void processPoolStatusTxt(Client *client, Request *req) {
+		Authorization auth(authorize(this, client, req));
+		if (auth.canReadPool) {
+			ApplicationPool2::Pool::InspectOptions options(
+				parseQueryString(req->getQueryString()));
+			options.uid = auth.uid;
+			options.apiKey = auth.apiKey;
+
+			HeaderTable headers;
+			headers.insert(req->pool, "Content-Type", "text/plain");
+			writeSimpleResponse(client, 200, &headers,
+				psg_pstrdup(req->pool, appPool->inspect(options)));
+			if (!req->ended()) {
+				endRequest(&client, &req);
+			}
+		} else {
+			HeaderTable headers;
+			headers.insert(req->pool, "Cache-Control", "no-cache, no-store, must-revalidate");
+			headers.insert(req->pool, "WWW-Authenticate", "Basic realm=\"api\"");
+			if (clientOnUnixDomainSocket(client) && appPool->getGroupCount() == 0) {
+				// Allow admin tools that connected through the Unix domain socket
+				// to know that this authorization error is caused by the fact
+				// that the pool is empty.
+				headers.insert(req->pool, "Pool-Empty", "true");
+			}
+			writeSimpleResponse(client, 401, &headers, "Unauthorized");
+			if (!req->ended()) {
+				endRequest(&client, &req);
+			}
+		}
+	}
+
+	void processPoolRestartAppGroup(Client *client, Request *req) {
+		Authorization auth(authorize(this, client, req));
+		if (!auth.canModifyPool) {
+			apiServerRespondWith401(this, client, req);
+		} else if (req->method != HTTP_POST) {
+			apiServerRespondWith405(this, client, req);
+		} else if (!req->hasBody()) {
+			endAsBadRequest(&client, &req, "Body required");
+		} else if (requestBodyExceedsLimit(client, req)) {
+			apiServerRespondWith413(this, client, req);
+		} else {
+			req->authorization = auth;
+			// Continues in processPoolRestartAppGroupBody().
+		}
+	}
+
+	void processPoolRestartAppGroupBody(Client *client, Request *req) {
+		if (!req->jsonBody.isMember("name")) {
+			endAsBadRequest(&client, &req, "Name required");
+			return;
+		}
+
+		ApplicationPool2::Pool::RestartOptions options;
+		options.uid = req->authorization.uid;
+		options.apiKey = req->authorization.apiKey;
+		if (req->jsonBody.isMember("restart_method")) {
+			string restartMethodString = req->jsonBody["restart_method"].asString();
+			if (restartMethodString == "blocking") {
+				options.method = RM_BLOCKING;
+			} else if (restartMethodString == "rolling") {
+				options.method = RM_ROLLING;
+			} else {
+				endAsBadRequest(&client, &req, "Unsupported restart method");
+				return;
+			}
+		}
+
+		bool result;
+		const char *response;
+		try {
+			result = appPool->restartGroupByName(req->jsonBody["name"].asString(),
+				options);
+		} catch (const SecurityException &) {
+			apiServerRespondWith401(this, client, req);
+			return;
+		}
+		if (result) {
+			response = "{ \"restarted\": true }";
+		} else {
+			response = "{ \"restarted\": false }";
+		}
+
+		HeaderTable headers;
+		headers.insert(req->pool, "Content-Type", "application/json");
+		headers.insert(req->pool, "Cache-Control", "no-cache, no-store, must-revalidate");
+		writeSimpleResponse(client, 200, &headers, response);
+
+		if (!req->ended()) {
+			endRequest(&client, &req);
+		}
+	}
+
+	void processPoolDetachProcess(Client *client, Request *req) {
+		Authorization auth(authorize(this, client, req));
+		if (!auth.canModifyPool) {
+			apiServerRespondWith401(this, client, req);
+		} else if (req->method != HTTP_POST) {
+			apiServerRespondWith405(this, client, req);
+		} else if (!req->hasBody()) {
+			endAsBadRequest(&client, &req, "Body required");
+		} else if (requestBodyExceedsLimit(client, req)) {
+			apiServerRespondWith413(this, client, req);
+		} else {
+			req->authorization = auth;
+			// Continues in processPoolDetachProcessBody().
+		}
+	}
+
+	void processPoolDetachProcessBody(Client *client, Request *req) {
+		if (req->jsonBody.isMember("pid")) {
+			pid_t pid = (pid_t) req->jsonBody["pid"].asUInt();
+			ApplicationPool2::Pool::AuthenticationOptions options;
+			options.uid = req->authorization.uid;
+			options.apiKey = req->authorization.apiKey;
+
+			bool result;
+			try {
+				result = appPool->detachProcess(pid, options);
+			} catch (const SecurityException &) {
+				apiServerRespondWith401(this, client, req);
+				return;
+			}
+
+			const char *response;
+			if (result) {
+				response = "{ \"detached\": true }";
+			} else {
+				response = "{ \"detached\": false }";
+			}
+
+			HeaderTable headers;
+			headers.insert(req->pool, "Content-Type", "application/json");
+			headers.insert(req->pool, "Cache-Control", "no-cache, no-store, must-revalidate");
+			writeSimpleResponse(client, 200, &headers, response);
+			if (!req->ended()) {
+				endRequest(&client, &req);
+			}
+		} else {
+			endAsBadRequest(&client, &req, "PID required");
+		}
+	}
+
+	static void garbageCollect(RequestHandler *rh) {
+		ServerKit::Context *ctx = rh->getContext();
+		unsigned int count;
+
+		count = mbuf_pool_compact(&ctx->mbuf_pool);
+		SKS_NOTICE_FROM_STATIC(rh, "Freed " << count << " mbufs");
+
+		rh->compact(LVL_NOTICE);
+	}
+
+	void processGc(Client *client, Request *req) {
+		if (req->method != HTTP_PUT) {
+			apiServerRespondWith405(this, client, req);
+		} else if (authorizeAdminOperation(this, client, req)) {
+			HeaderTable headers;
+			headers.insert(req->pool, "Content-Type", "application/json");
+			for (unsigned int i = 0; i < requestHandlers.size(); i++) {
+				requestHandlers[i]->getContext()->libev->runLater(boost::bind(
+					garbageCollect, requestHandlers[i]));
+			}
+			writeSimpleResponse(client, 200, &headers, "{ \"status\": \"ok\" }");
+			if (!req->ended()) {
+				endRequest(&client, &req);
+			}
+		} else {
+			apiServerRespondWith401(this, client, req);
+		}
+	}
+
+	static void getRequestHandlerConfig(RequestHandler *rh, Json::Value *json) {
+		*json = rh->getConfigAsJson();
+	}
+
+	void processConfig(Client *client, Request *req) {
+		if (req->method == HTTP_GET) {
+			if (!authorizeStateInspectionOperation(this, client, req)) {
+				apiServerRespondWith401(this, client, req);
+			}
+
+			HeaderTable headers;
+			string logFile = getLogFile();
+			string fileDescriptorLogFile = getFileDescriptorLogFile();
+
+			headers.insert(req->pool, "Content-Type", "application/json");
+			Json::Value doc;
+			requestHandlers[0]->getContext()->libev->runSync(boost::bind(
+				getRequestHandlerConfig, requestHandlers[0], &doc));
+			doc["log_level"] = getLogLevel();
+			if (!logFile.empty()) {
+				doc["log_file"] = logFile;
+			}
+			if (!fileDescriptorLogFile.empty()) {
+				doc["file_descriptor_log_file"] = fileDescriptorLogFile;
+			}
+
+			writeSimpleResponse(client, 200, &headers,
+				psg_pstrdup(req->pool, doc.toStyledString()));
+			if (!req->ended()) {
+				endRequest(&client, &req);
+			}
+		} else if (req->method == HTTP_PUT) {
+			if (!authorizeAdminOperation(this, client, req)) {
+				apiServerRespondWith401(this, client, req);
+			} else if (!req->hasBody()) {
+				endAsBadRequest(&client, &req, "Body required");
+			}
+			// Continue in processConfigBody()
+		} else {
+			apiServerRespondWith405(this, client, req);
+		}
+	}
+
+	static void configureRequestHandler(RequestHandler *rh, Json::Value json) {
+		rh->configure(json);
+	}
+
+	void processConfigBody(Client *client, Request *req) {
+		HeaderTable headers;
+		Json::Value &json = req->jsonBody;
+
+		headers.insert(req->pool, "Content-Type", "application/json");
+		headers.insert(req->pool, "Cache-Control", "no-cache, no-store, must-revalidate");
+
+		if (json.isMember("log_level")) {
+			setLogLevel(json["log_level"].asInt());
+		}
+		if (json.isMember("log_file")) {
+			string logFile = json["log_file"].asString();
+			try {
+				logFile = absolutizePath(logFile);
+			} catch (const SystemException &e) {
+				unsigned int bufsize = 1024;
+				char *message = (char *) psg_pnalloc(req->pool, bufsize);
+				snprintf(message, bufsize, "{ \"status\": \"error\", "
+					"\"message\": \"Cannot absolutize log file filename: %s\" }",
+					e.what());
+				writeSimpleResponse(client, 500, &headers, message);
+				if (!req->ended()) {
+					endRequest(&client, &req);
+				}
+				return;
+			}
+
+			int e;
+			if (!setLogFile(logFile, &e)) {
+				unsigned int bufsize = 1024;
+				char *message = (char *) psg_pnalloc(req->pool, bufsize);
+				snprintf(message, bufsize, "{ \"status\": \"error\", "
+					"\"message\": \"Cannot open log file: %s (errno=%d)\" }",
+					strerror(e), e);
+				writeSimpleResponse(client, 500, &headers, message);
+				if (!req->ended()) {
+					endRequest(&client, &req);
+				}
+				return;
+			}
+			P_NOTICE("Log file opened.");
+		}
+		for (unsigned int i = 0; i < requestHandlers.size(); i++) {
+			requestHandlers[i]->getContext()->libev->runLater(boost::bind(
+				configureRequestHandler, requestHandlers[i], json));
+		}
+
+		writeSimpleResponse(client, 200, &headers, "{ \"status\": \"ok\" }");
+		if (!req->ended()) {
+			endRequest(&client, &req);
+		}
+	}
+
+	bool requestBodyExceedsLimit(Client *client, Request *req, unsigned int limit = 1024 * 128) {
+		return (req->bodyType == Request::RBT_CONTENT_LENGTH
+				&& req->aux.bodyInfo.contentLength > limit)
+			|| (req->bodyType == Request::RBT_CHUNKED
+				&& req->body.size() > limit);
+	}
+
+protected:
+	virtual void onRequestBegin(Client *client, Request *req) {
+		TRACE_POINT();
+		StaticString path = req->getPathWithoutQueryString();
+
+		P_INFO("API request: " << http_method_str(req->method) <<
+			" " << StaticString(req->path.start->data, req->path.size));
+
+		try {
+			route(client, req, path);
+		} catch (const oxt::tracable_exception &e) {
+			SKC_ERROR(client, "Exception: " << e.what() << "\n" << e.backtrace());
+			if (!req->ended()) {
+				req->wantKeepAlive = false;
+				endRequest(&client, &req);
+			}
+		}
+	}
+
+	virtual ServerKit::Channel::Result onRequestBody(Client *client, Request *req,
+		const MemoryKit::mbuf &buffer, int errcode)
+	{
+		TRACE_POINT();
+		if (buffer.size() > 0) {
+			// Data
+			req->body.append(buffer.start, buffer.size());
+			if (requestBodyExceedsLimit(client, req)) {
+				apiServerRespondWith413(this, client, req);
+			}
+		} else if (errcode == 0) {
+			// EOF
+			Json::Reader reader;
+			if (reader.parse(req->body, req->jsonBody)) {
+				StaticString path = req->getPathWithoutQueryString();
+				try {
+					if (path == P_STATIC_STRING("/pool/restart_app_group.json")) {
+						processPoolRestartAppGroupBody(client, req);
+					} else if (path == P_STATIC_STRING("/pool/detach_process.json")) {
+						processPoolDetachProcessBody(client, req);
+					} else if (path == P_STATIC_STRING("/config.json")) {
+						processConfigBody(client, req);
+					} else {
+						P_BUG("Unknown path for body processing: " << path);
+					}
+				} catch (const oxt::tracable_exception &e) {
+					SKC_ERROR(client, "Exception: " << e.what() << "\n" << e.backtrace());
+					if (!req->ended()) {
+						req->wantKeepAlive = false;
+						endRequest(&client, &req);
+					}
+				}
+			} else {
+				apiServerRespondWith422(this, client, req, reader.getFormattedErrorMessages());
+			}
+		} else {
+			// Error
+			disconnect(&client);
+		}
+		return ServerKit::Channel::Result(buffer.size(), false);
+	}
+
+	virtual void deinitializeRequest(Client *client, Request *req) {
+		req->body.clear();
+		if (!req->jsonBody.isNull()) {
+			req->jsonBody = Json::Value();
+		}
+		req->authorization = Authorization();
+		ParentClass::deinitializeRequest(client, req);
+	}
+
+public:
+	vector<RequestHandler *> requestHandlers;
+	ApiAccountDatabase *apiAccountDatabase;
+	ApplicationPool2::PoolPtr appPool;
+	string instanceDir;
+	string fdPassingPassword;
+	EventFd *exitEvent;
+	vector<Authorization> authorizations;
+
+	ApiServer(ServerKit::Context *context)
+		: ParentClass(context),
+		  serverConnectionPath("^/server/(.+)\\.json$"),
+		  apiAccountDatabase(NULL),
+		  exitEvent(NULL)
+		{ }
+
+	virtual StaticString getServerName() const {
+		return P_STATIC_STRING("ApiServer");
+	}
+
+	virtual unsigned int getClientName(const Client *client, char *buf, size_t size) const {
+		char *pos = buf;
+		const char *end = buf + size - 1;
+		pos = appendData(pos, end, "Adm.", 1);
+		pos += uintToString(client->number, pos, end - pos);
+		*pos = '\0';
+		return pos - buf;
+	}
+
+	bool authorizeByUid(uid_t uid) const {
+		return appPool->authorizeByUid(uid);
+	}
+
+	bool authorizeByApiKey(const ApplicationPool2::ApiKey &apiKey) const {
+		return appPool->authorizeByApiKey(apiKey);
+	}
+};
+
+
+} // namespace Core
+} // namespace Passenger
+
+#endif /* _PASSENGER_CORE_API_SERVER_H_ */