passenger 5.0.18 → 5.0.19

data/ext/common/ApplicationPool2/Pool/StateInspection.cpp

@@ -1,299 +0,0 @@
-/*
- *  Phusion Passenger - https://www.phusionpassenger.com/
- *  Copyright (c) 2011-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.
- */
-#include <ApplicationPool2/Pool.h>
-
-/*************************************************************************
- *
- * State inspection functions for ApplicationPool2::Pool
- *
- *************************************************************************/
-
-namespace Passenger {
-namespace ApplicationPool2 {
-
-using namespace std;
-using namespace boost;
-
-
-/****************************
- *
- * Private methods
- *
- ****************************/
-
-
-unsigned int
-Pool::capacityUsedUnlocked() const {
-	if (groups.size() == 1) {
-		GroupPtr *group;
-		groups.lookupRandom(NULL, &group);
-		return (*group)->capacityUsed();
-	} else {
-		GroupMap::ConstIterator g_it(groups);
-		int result = 0;
-		while (*g_it != NULL) {
-			const GroupPtr &group = g_it.getValue();
-			result += group->capacityUsed();
-			g_it.next();
-		}
-		return result;
-	}
-}
-
-bool
-Pool::atFullCapacityUnlocked() const {
-	return capacityUsedUnlocked() >= max;
-}
-
-void
-Pool::inspectProcessList(const InspectOptions &options, stringstream &result,
-	const Group *group, const ProcessList &processes) const
-{
-	ProcessList::const_iterator p_it;
-	for (p_it = processes.begin(); p_it != processes.end(); p_it++) {
-		const ProcessPtr &process = *p_it;
-		char buf[128];
-		char cpubuf[10];
-		char membuf[10];
-
-		 if (process->metrics.isValid()) {
-			snprintf(cpubuf, sizeof(cpubuf), "%d%%", (int) process->metrics.cpu);
-			snprintf(membuf, sizeof(membuf), "%ldM",
-				(unsigned long) (process->metrics.realMemory() / 1024));
-		} else {
-			snprintf(cpubuf, sizeof(cpubuf), "0%%");
-			snprintf(membuf, sizeof(membuf), "0M");
-		}
-		snprintf(buf, sizeof(buf),
-			"  * PID: %-5lu   Sessions: %-2u      Processed: %-5u   Uptime: %s\n"
-			"    CPU: %-5s   Memory  : %-5s   Last used: %s ago",
-			(unsigned long) process->getPid(),
-			process->sessions,
-			process->processed,
-			process->uptime().c_str(),
-			cpubuf,
-			membuf,
-			distanceOfTimeInWords(process->lastUsed / 1000000).c_str());
-		result << buf << endl;
-
-		if (process->enabled == Process::DISABLING) {
-			result << "    Disabling..." << endl;
-		} else if (process->enabled == Process::DISABLED) {
-			result << "    DISABLED" << endl;
-		} else if (process->enabled == Process::DETACHED) {
-			result << "    Shutting down..." << endl;
-		}
-
-		const Socket *socket;
-		if (options.verbose && (socket = process->getSockets().findSocketWithName("http")) != NULL) {
-			result << "    URL     : http://" << replaceString(socket->address, "tcp://", "") << endl;
-			result << "    Password: " << group->getApiKey().toStaticString() << endl;
-		}
-	}
-}
-
-
-/****************************
- *
- * Public methods
- *
- ****************************/
-
-
-string
-Pool::inspect(const InspectOptions &options, bool lock) const {
-	DynamicScopedLock l(syncher, lock);
-	stringstream result;
-	const char *headerColor = maybeColorize(options, ANSI_COLOR_YELLOW ANSI_COLOR_BLUE_BG ANSI_COLOR_BOLD);
-	const char *resetColor  = maybeColorize(options, ANSI_COLOR_RESET);
-
-	if (!authorizeByUid(options.uid, false)
-	 && !authorizeByApiKey(options.apiKey, false))
-	{
-		throw SecurityException("Operation unauthorized");
-	}
-
-	result << headerColor << "----------- General information -----------" << resetColor << endl;
-	result << "Max pool size : " << max << endl;
-	result << "App groups    : " << groups.size() << endl;
-	result << "Processes     : " << getProcessCount(false) << endl;
-	result << "Requests in top-level queue : " << getWaitlist.size() << endl;
-	if (options.verbose) {
-		unsigned int i = 0;
-		foreach (const GetWaiter &waiter, getWaitlist) {
-			result << "  " << i << ": " << waiter.options.getAppGroupName() << endl;
-			i++;
-		}
-	}
-	result << endl;
-
-	result << headerColor << "----------- Application groups -----------" << resetColor << endl;
-	GroupMap::ConstIterator g_it(groups);
-	while (*g_it != NULL) {
-		const GroupPtr &group = g_it.getValue();
-		if (!group->authorizeByUid(options.uid)
-		 && !group->authorizeByApiKey(options.apiKey))
-		{
-			g_it.next();
-			continue;
-		}
-
-		ProcessList::const_iterator p_it;
-
-		result << group->getName() << ":" << endl;
-		result << "  App root: " << group->options.appRoot << endl;
-		if (group->restarting()) {
-			result << "  (restarting...)" << endl;
-		}
-		if (group->spawning()) {
-			if (group->processesBeingSpawned == 0) {
-				result << "  (spawning...)" << endl;
-			} else {
-				result << "  (spawning " << group->processesBeingSpawned << " new " <<
-					maybePluralize(group->processesBeingSpawned, "process", "processes") <<
-					"...)" << endl;
-			}
-		}
-		result << "  Requests in queue: " << group->getWaitlist.size() << endl;
-		inspectProcessList(options, result, group.get(), group->enabledProcesses);
-		inspectProcessList(options, result, group.get(), group->disablingProcesses);
-		inspectProcessList(options, result, group.get(), group->disabledProcesses);
-		inspectProcessList(options, result, group.get(), group->detachedProcesses);
-		result << endl;
-
-		g_it.next();
-	}
-	return result.str();
-}
-
-string
-Pool::toXml(const ToXmlOptions &options, bool lock) const {
-	DynamicScopedLock l(syncher, lock);
-	stringstream result;
-	GroupMap::ConstIterator g_it(groups);
-	ProcessList::const_iterator p_it;
-
-	if (!authorizeByUid(options.uid, false)
-	 && !authorizeByApiKey(options.apiKey, false))
-	{
-		throw SecurityException("Operation unauthorized");
-	}
-
-	result << "<?xml version=\"1.0\" encoding=\"iso8859-1\" ?>\n";
-	result << "<info version=\"3\">";
-
-	result << "<passenger_version>" << PASSENGER_VERSION << "</passenger_version>";
-	result << "<group_count>" << groups.size() << "</group_count>";
-	result << "<process_count>" << getProcessCount(false) << "</process_count>";
-	result << "<max>" << max << "</max>";
-	result << "<capacity_used>" << capacityUsedUnlocked() << "</capacity_used>";
-	result << "<get_wait_list_size>" << getWaitlist.size() << "</get_wait_list_size>";
-
-	if (options.secrets) {
-		vector<GetWaiter>::const_iterator w_it, w_end = getWaitlist.end();
-
-		result << "<get_wait_list>";
-		for (w_it = getWaitlist.begin(); w_it != w_end; w_it++) {
-			const GetWaiter &waiter = *w_it;
-			result << "<item>";
-			result << "<app_group_name>" << escapeForXml(waiter.options.getAppGroupName()) << "</app_group_name>";
-			result << "</item>";
-		}
-		result << "</get_wait_list>";
-	}
-
-	result << "<supergroups>";
-	while (*g_it != NULL) {
-		const GroupPtr &group = g_it.getValue();
-		if (!group->authorizeByUid(options.uid)
-		 && !group->authorizeByApiKey(options.apiKey))
-		{
-			g_it.next();
-			continue;
-		}
-
-		result << "<supergroup>";
-		result << "<name>" << escapeForXml(group->getName()) << "</name>";
-		result << "<state>READY</state>";
-		result << "<get_wait_list_size>0</get_wait_list_size>";
-		result << "<capacity_used>" << group->capacityUsed() << "</capacity_used>";
-		if (options.secrets) {
-			result << "<secret>" << escapeForXml(group->getApiKey().toStaticString()) << "</secret>";
-		}
-
-		result << "<group default=\"true\">";
-		group->inspectXml(result, options.secrets);
-		result << "</group>";
-
-		result << "</supergroup>";
-
-		g_it.next();
-	}
-	result << "</supergroups>";
-
-	result << "</info>";
-	return result.str();
-}
-
-
-unsigned int
-Pool::capacityUsed() const {
-	LockGuard l(syncher);
-	return capacityUsedUnlocked();
-}
-
-bool
-Pool::atFullCapacity() const {
-	LockGuard l(syncher);
-	return atFullCapacityUnlocked();
-}
-
-/**
- * Returns the total number of processes in the pool, including all disabling and
- * disabled processes, but excluding processes that are shutting down and excluding
- * processes that are being spawned.
- */
-unsigned int
-Pool::getProcessCount(bool lock) const {
-	DynamicScopedLock l(syncher, lock);
-	unsigned int result = 0;
-	GroupMap::ConstIterator g_it(groups);
-	while (*g_it != NULL) {
-		const GroupPtr &group = g_it.getValue();
-		result += group->getProcessCount();
-		g_it.next();
-	}
-	return result;
-}
-
-unsigned int
-Pool::getGroupCount() const {
-	LockGuard l(syncher);
-	return groups.size();
-}
-
-
-} // namespace ApplicationPool2
-} // namespace Passenger

data/ext/common/ApplicationPool2/Process.h

@@ -1,906 +0,0 @@
-/*
- *  Phusion Passenger - https://www.phusionpassenger.com/
- *  Copyright (c) 2011-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_APPLICATION_POOL_PROCESS_H_
-#define _PASSENGER_APPLICATION_POOL_PROCESS_H_
-
-#include <string>
-#include <vector>
-#include <algorithm>
-#include <boost/intrusive_ptr.hpp>
-#include <boost/move/core.hpp>
-#include <boost/container/vector.hpp>
-#include <oxt/system_calls.hpp>
-#include <oxt/spin_lock.hpp>
-#include <oxt/macros.hpp>
-#include <sys/types.h>
-#include <cstdio>
-#include <climits>
-#include <cassert>
-#include <cstring>
-#include <ApplicationPool2/Common.h>
-#include <ApplicationPool2/Socket.h>
-#include <ApplicationPool2/Session.h>
-#include <SpawningKit/PipeWatcher.h>
-#include <SpawningKit/Result.h>
-#include <Constants.h>
-#include <FileDescriptor.h>
-#include <Logging.h>
-#include <Utils/SystemTime.h>
-#include <Utils/StrIntUtils.h>
-#include <Utils/Lock.h>
-#include <Utils/ProcessMetricsCollector.h>
-
-namespace Passenger {
-namespace ApplicationPool2 {
-
-using namespace std;
-using namespace boost;
-
-
-typedef boost::container::vector<ProcessPtr> ProcessList;
-
-/**
- * Represents an application process, as spawned by a SpawningKit::Spawner. Every
- * Process has a PID, an admin socket and a list of sockets on which it listens for
- * connections. A Process object is contained inside a Group.
- *
- * The admin socket, an anonymous Unix domain socket, is mapped to the process's
- * STDIN and STDOUT and has two functions.
- *
- *  1. It acts as the main communication channel with the process. Commands are
- *     sent to and responses are received from it.
- *  2. It's used for garbage collection: closing the STDIN part causes the process
- *     to gracefully terminate itself.
- *
- * Except for the otherwise documented parts, this class is not thread-safe,
- * so only use within the Pool lock.
- *
- * ## Normal usage
- *
- *  1. Create a session with newSession().
- *  2. Initiate the session by calling initiate() on it.
- *  3. Perform I/O through session->fd().
- *  4. When done, close the session by calling close() on it.
- *  5. Call process.sessionClosed().
- *
- * ## Life time
- *
- * A Process object lives until the containing Group calls `detach(process)`,
- * which indicates that it wants this Process to shut down. The Process object
- * is stored in the `detachedProcesses` collection in the Group and is no longer
- * eligible for receiving requests. Once all requests on this Process have finished,
- * `triggerShutdown()` will be called, which will send a message to the
- * OS process telling it to shut down. Once the OS process is gone, `cleanup()` is
- * called, and the Process object is removed from the collection.
- *
- * This means that a Group outlives all its Processes, a Process outlives all
- * its Sessions, and a Process also outlives the OS process.
- */
-class Process {
-public:
-	static const unsigned int MAX_SESSION_SOCKETS = 3;
-
-private:
-	/*************************************************************
-	 * Read-only fields, set once during initialization and never
-	 * written to again. Reading is thread-safe.
-	 *************************************************************/
-
-	BasicProcessInfo info;
-	DynamicBuffer stringBuffer;
-	SocketList sockets;
-
-	/**
-	 * The maximum amount of concurrent sessions this process can handle.
-	 * 0 means unlimited. Automatically inferred from the sockets.
-	 */
-	int concurrency;
-
-	/**
-	 * A subset of 'sockets': all sockets that speak the
-	 * "session" or "http_session" protocol.
-	 */
-	unsigned int sessionSocketCount;
-	Socket *sessionSockets[MAX_SESSION_SOCKETS];
-
-	/** Admin socket. See Process class description. */
-	FileDescriptor adminSocket;
-
-	/**
-	 * Pipe on which this process outputs errors. Mapped to the process's STDERR.
-	 * Only Processes spawned by DirectSpawner have this set.
-	 * SmartSpawner-spawned Processes use the same STDERR as their parent preloader processes.
-	 */
-	FileDescriptor errorPipe;
-
-	/**
-	 * The code revision of the application, inferred through various means.
-	 * See Spawner::prepareSpawn() to learn how this is determined.
-	 * May be an empty string if no code revision has been inferred.
-	 */
-	StaticString codeRevision;
-
-	/**
-	 * Time at which the Spawner that created this process was created.
-	 * Microseconds resolution.
-	 */
-	unsigned long long spawnerCreationTime;
-
-	/** Time at which we started spawning this process. Microseconds resolution. */
-	unsigned long long spawnStartTime;
-
-	/**
-	 * Time at which we finished spawning this process, i.e. when this
-	 * process was finished initializing. Microseconds resolution.
-	 */
-	unsigned long long spawnEndTime;
-
-	/**
-	 * If true, then indicates that this Process does not refer to a real OS
-	 * process. The sockets in the socket list are fake and need not be deleted,
-	 * the admin socket need not be closed, etc.
-	 */
-	bool dummy;
-
-	/**
-	 * Whether it is required that triggerShutdown() and cleanup() must be called
-	 * before destroying this Process. Normally true, except for dummy Process
-	 * objects created by Pool::asyncGet() with options.noop == true, because those
-	 * processes are never added to Group.enabledProcesses.
-	 */
-	bool requiresShutdown;
-
-
-	/*************************************************************
-	 * Read-write fields.
-	 *************************************************************/
-
-	mutable boost::atomic<int> refcount;
-
-	/** A mutex to protect access to `lifeStatus`. */
-	mutable oxt::spin_lock lifetimeSyncher;
-
-	/** The index inside the associated Group's process list. */
-	unsigned int index;
-
-
-	/*************************************************************
-	 * Methods
-	 *************************************************************/
-
-	/****** Initialization and destruction ******/
-
-	struct InitializationLog {
-		struct String {
-			unsigned int offset;
-			unsigned int size;
-		};
-
-		struct SocketStringOffsets {
-			String name;
-			String address;
-			String protocol;
-		};
-
-		vector<SocketStringOffsets> socketStringOffsets;
-		String codeRevision;
-	};
-
-	void appendJsonFieldToBuffer(std::string &buffer, const Json::Value &json,
-		const char *key, InitializationLog::String &str) const
-	{
-		StaticString value = getJsonStaticStringField(json, key);
-		str.offset = buffer.size();
-		str.size   = value.size();
-		buffer.append(value.data(), value.size());
-		buffer.append(1, '\0');
-	}
-
-	void initializeSocketsAndStringFields(const Json::Value &json) {
-		InitializationLog log;
-		string buffer;
-
-
-		// Step 1: append strings to temporary buffer and take note of their
-		// offsets within the temporary buffer.
-
-		Json::Value sockets = getJsonField(json, "sockets");
-		// The const_cast here works around a jsoncpp bug.
-		Json::Value::const_iterator it = const_cast<const Json::Value &>(sockets).begin();
-		Json::Value::const_iterator end = const_cast<const Json::Value &>(sockets).end();
-		buffer.reserve(1024);
-
-		for (it = sockets.begin(); it != end; it++) {
-			const Json::Value &socket = *it;
-			InitializationLog::SocketStringOffsets offsets;
-
-			appendJsonFieldToBuffer(buffer, socket, "name", offsets.name);
-			appendJsonFieldToBuffer(buffer, socket, "address", offsets.address);
-			appendJsonFieldToBuffer(buffer, socket, "protocol", offsets.protocol);
-
-			log.socketStringOffsets.push_back(offsets);
-		}
-
-		if (json.isMember("code_revision")) {
-			appendJsonFieldToBuffer(buffer, json, "code_revision", log.codeRevision);
-		}
-
-
-		// Step 2: allocate the real buffer.
-
-		this->stringBuffer = DynamicBuffer(buffer.size());
-		memcpy(this->stringBuffer.data, buffer.data(), buffer.size());
-
-
-		// Step 3: initialize the string fields and point them to
-		// addresses within the real buffer.
-
-		unsigned int i;
-		const char *base = this->stringBuffer.data;
-
-		it = const_cast<const Json::Value &>(sockets).begin();
-		for (i = 0; it != end; it++, i++) {
-			const Json::Value &socket = *it;
-			this->sockets.add(
-				info.pid,
-				StaticString(base + log.socketStringOffsets[i].name.offset,
-					log.socketStringOffsets[i].name.size),
-				StaticString(base + log.socketStringOffsets[i].address.offset,
-					log.socketStringOffsets[i].address.size),
-				StaticString(base + log.socketStringOffsets[i].protocol.offset,
-					log.socketStringOffsets[i].protocol.size),
-				getJsonIntField(socket, "concurrency")
-			);
-		}
-
-		if (json.isMember("code_revision")) {
-			codeRevision = StaticString(base + log.codeRevision.offset,
-				log.codeRevision.size);
-		}
-	}
-
-	void indexSessionSockets() {
-		SocketList::iterator it;
-
-		concurrency = 0;
-		memset(sessionSockets, 0, sizeof(sessionSockets));
-
-		for (it = sockets.begin(); it != sockets.end(); it++) {
-			Socket *socket = &(*it);
-			if (socket->protocol == "session" || socket->protocol == "http_session") {
-				if (sessionSocketCount == MAX_SESSION_SOCKETS) {
-					throw RuntimeException("The process has many session sockets. "
-						"A maximum of " + toString(MAX_SESSION_SOCKETS) + " is allowed");
-				}
-				sessionSockets[sessionSocketCount] = socket;
-				sessionSocketCount++;
-
-				if (concurrency != -1) {
-					if (socket->concurrency == 0) {
-						// If one of the sockets has a concurrency of
-						// 0 (unlimited) then we mark this entire Process
-						// as having a concurrency of 0.
-						concurrency = -1;
-					} else {
-						concurrency += socket->concurrency;
-					}
-				}
-			}
-		}
-
-		if (concurrency == -1) {
-			concurrency = 0;
-		}
-	}
-
-	void destroySelf() const {
-		this->~Process();
-		LockGuard l(getContext()->getMmSyncher());
-		getContext()->getProcessObjectPool().free(const_cast<Process *>(this));
-	}
-
-
-	/****** Miscellaneous ******/
-
-	static bool isZombie(pid_t pid) {
-		string filename = "/proc/" + toString(pid) + "/status";
-		FILE *f = fopen(filename.c_str(), "r");
-		if (f == NULL) {
-			// Don't know.
-			return false;
-		}
-
-		bool result = false;
-		while (!feof(f)) {
-			char buf[512];
-			const char *line;
-
-			line = fgets(buf, sizeof(buf), f);
-			if (line == NULL) {
-				break;
-			}
-			if (strcmp(line, "State:	Z (zombie)\n") == 0) {
-				// Is a zombie.
-				result = true;
-				break;
-			}
-		}
-		fclose(f);
-		return result;
-	}
-
-public:
-	/*************************************************************
-	 * Information used by Pool. Do not write to these from
-	 * outside the Pool. If you read these make sure the Pool
-	 * isn't concurrently modifying.
-	 *************************************************************/
-
-	/** Last time when a session was opened for this Process. */
-	unsigned long long lastUsed;
-	/** Number of sessions currently open.
-	 * @invariant session >= 0
-	 */
-	int sessions;
-	/** Number of sessions opened so far. */
-	unsigned int processed;
-	/** Do not access directly, always use `isAlive()`/`isDead()`/`getLifeStatus()` or
-	 * through `lifetimeSyncher`. */
-	enum LifeStatus {
-		/** Up and operational. */
-		ALIVE,
-		/** This process has been detached, and the detached processes checker has
-		 * verified that there are no active sessions left and has told the process
-		 * to shut down. In this state we're supposed to wait until the process
-		 * has actually shutdown, after which cleanup() must be called. */
-		SHUTDOWN_TRIGGERED,
-		/**
-		 * The process has exited and cleanup() has been called. In this state,
-		 * this object is no longer usable.
-		 */
-		DEAD
-	} lifeStatus;
-	enum EnabledStatus {
-		/** Up and operational. */
-		ENABLED,
-		/** Process is being disabled. The containing Group is waiting for
-		 * all sessions on this Process to finish. It may in some corner
-		 * cases still be selected for processing requests.
-		 */
-		DISABLING,
-		/** Process is fully disabled and should not be handling any
-		 * requests. It *may* still handle some requests, e.g. by
-		 * the Out-of-Band-Work trigger.
-		 */
-		DISABLED,
-		/**
-		 * Process has been detached. It will be removed from the Group
-		 * as soon we have detected that the OS process has exited. Detached
-		 * processes are allowed to finish their requests, but are not
-		 * eligible for new requests.
-		 */
-		DETACHED
-	} enabled;
-	enum OobwStatus {
-		/** Process is not using out-of-band work. */
-		OOBW_NOT_ACTIVE,
-		/** The process has requested out-of-band work. At some point, the code
-		 * will see this and set the status to OOBW_IN_PROGRESS. */
-		OOBW_REQUESTED,
-		/** An out-of-band work is in progress. We need to wait until all
-		 * sessions have ended and the process has been disabled before the
-		 * out-of-band work can be performed. */
-		OOBW_IN_PROGRESS,
-	} oobwStatus;
-	/** Caches whether or not the OS process still exists. */
-	mutable bool m_osProcessExists: 1;
-	bool longRunningConnectionsAborted: 1;
-	/** Time at which shutdown began. */
-	time_t shutdownStartTime;
-	/** Collected by Pool::collectAnalytics(). */
-	ProcessMetrics metrics;
-
-
-	Process(const BasicGroupInfo *groupInfo, const Json::Value &json)
-		: info(this, groupInfo, json),
-		  sessionSocketCount(0),
-		  spawnerCreationTime(getJsonUint64Field(json, "spawner_creation_time")),
-		  spawnStartTime(getJsonUint64Field(json, "spawn_start_time")),
-		  spawnEndTime(SystemTime::getUsec()),
-		  dummy(json["type"] == "dummy"),
-		  requiresShutdown(false),
-		  refcount(1),
-		  index(-1),
-		  lastUsed(spawnEndTime),
-		  sessions(0),
-		  processed(0),
-		  lifeStatus(ALIVE),
-		  enabled(ENABLED),
-		  oobwStatus(OOBW_NOT_ACTIVE),
-		  m_osProcessExists(true),
-		  longRunningConnectionsAborted(false),
-		  shutdownStartTime(0)
-	{
-		initializeSocketsAndStringFields(json);
-		indexSessionSockets();
-
-		const SpawningKit::Result *skResult = dynamic_cast<const SpawningKit::Result *>(&json);
-		if (skResult != NULL) {
-			adminSocket = skResult->adminSocket;
-			errorPipe = skResult->errorPipe;
-
-			if (adminSocket != -1) {
-				SpawningKit::PipeWatcherPtr watcher = boost::make_shared<SpawningKit::PipeWatcher>(
-					getContext()->getSpawningKitConfig(), adminSocket, "stdout", info.pid);
-				watcher->initialize();
-				watcher->start();
-			}
-
-			if (errorPipe != -1) {
-				SpawningKit::PipeWatcherPtr watcher = boost::make_shared<SpawningKit::PipeWatcher>(
-					getContext()->getSpawningKitConfig(), errorPipe, "stderr", info.pid);
-				watcher->initialize();
-				watcher->start();
-			}
-		}
-	}
-
-	~Process() {
-		if (OXT_UNLIKELY(requiresShutdown && !isDead())) {
-			P_BUG("You must call Process::triggerShutdown() and Process::cleanup() before actually "
-				"destroying the Process object.");
-		}
-	}
-
-	void initializeStickySessionId(unsigned int value) {
-		info.stickySessionId = value;
-	}
-
-	void shutdownNotRequired() {
-		requiresShutdown = false;
-	}
-
-
-	/****** Memory and life time management ******/
-
-	void ref() const {
-		refcount.fetch_add(1, boost::memory_order_relaxed);
-	}
-
-	void unref() const {
-		if (refcount.fetch_sub(1, boost::memory_order_release) == 1) {
-			boost::atomic_thread_fence(boost::memory_order_acquire);
-			destroySelf();
-		}
-	}
-
-	ProcessPtr shared_from_this() {
-		return ProcessPtr(this);
-	}
-
-	static void forceTriggerShutdownAndCleanup(ProcessPtr process) {
-		if (process != NULL) {
-			process->triggerShutdown();
-			// Pretend like the OS process has exited so
-			// that the canCleanup() precondition is true.
-			process->m_osProcessExists = false;
-			process->cleanup();
-		}
-	}
-
-	// Thread-safe.
-	bool isAlive() const {
-		oxt::spin_lock::scoped_lock lock(lifetimeSyncher);
-		return lifeStatus == ALIVE;
-	}
-
-	// Thread-safe.
-	bool hasTriggeredShutdown() const {
-		oxt::spin_lock::scoped_lock lock(lifetimeSyncher);
-		return lifeStatus == SHUTDOWN_TRIGGERED;
-	}
-
-	// Thread-safe.
-	bool isDead() const {
-		oxt::spin_lock::scoped_lock lock(lifetimeSyncher);
-		return lifeStatus == DEAD;
-	}
-
-	// Thread-safe.
-	LifeStatus getLifeStatus() const {
-		oxt::spin_lock::scoped_lock lock(lifetimeSyncher);
-		return lifeStatus;
-	}
-
-	bool canTriggerShutdown() const {
-		return getLifeStatus() == ALIVE && sessions == 0;
-	}
-
-	void triggerShutdown() {
-		assert(canTriggerShutdown());
-		{
-			time_t now = SystemTime::get();
-			oxt::spin_lock::scoped_lock lock(lifetimeSyncher);
-			assert(lifeStatus == ALIVE);
-			lifeStatus = SHUTDOWN_TRIGGERED;
-			shutdownStartTime = now;
-		}
-		if (!dummy) {
-			syscalls::shutdown(adminSocket, SHUT_WR);
-		}
-	}
-
-	bool shutdownTimeoutExpired() const {
-		return SystemTime::get() >= shutdownStartTime + PROCESS_SHUTDOWN_TIMEOUT;
-	}
-
-	bool canCleanup() const {
-		return getLifeStatus() == SHUTDOWN_TRIGGERED && !osProcessExists();
-	}
-
-	void cleanup() {
-		assert(canCleanup());
-
-		P_TRACE(2, "Cleaning up process " << inspect());
-		if (!dummy) {
-			SocketList::iterator it, end = sockets.end();
-			for (it = sockets.begin(); it != end; it++) {
-				if (getSocketAddressType(it->address) == SAT_UNIX) {
-					string filename = parseUnixSocketAddress(it->address);
-					syscalls::unlink(filename.c_str());
-				}
-				it->closeAllConnections();
-			}
-		}
-
-		oxt::spin_lock::scoped_lock lock(lifetimeSyncher);
-		lifeStatus = DEAD;
-	}
-
-
-	/****** Basic information queries ******/
-
-	OXT_FORCE_INLINE
-	Context *getContext() const {
-		return info.groupInfo->context;
-	}
-
-	Group *getGroup() const {
-		return info.groupInfo->group;
-	}
-
-	StaticString getGroupName() const {
-		return info.groupInfo->name;
-	}
-
-	const ApiKey &getApiKey() const {
-		return info.groupInfo->apiKey;
-	}
-
-	const BasicProcessInfo &getInfo() const {
-		return info;
-	}
-
-	pid_t getPid() const {
-		return info.pid;
-	}
-
-	StaticString getGupid() const {
-		return StaticString(info.gupid, info.gupidSize);
-	}
-
-	unsigned int getStickySessionId() const {
-		return info.stickySessionId;
-	}
-
-	unsigned long long getSpawnerCreationTime() const {
-		return spawnerCreationTime;
-	}
-
-	bool isDummy() const {
-		return dummy;
-	}
-
-
-	/****** Miscellaneous ******/
-
-	unsigned int getIndex() const {
-		return index;
-	}
-
-	void setIndex(unsigned int i) {
-		index = i;
-	}
-
-	const SocketList &getSockets() const {
-		return sockets;
-	}
-
-	Socket *findSessionSocketWithLowestBusyness() const {
-		if (OXT_UNLIKELY(sessionSocketCount == 0)) {
-			return NULL;
-		} else if (sessionSocketCount == 1) {
-			return sessionSockets[0];
-		} else {
-			int leastBusySessionSocketIndex = 0;
-			int lowestBusyness = sessionSockets[0]->busyness();
-
-			for (unsigned i = 1; i < sessionSocketCount; i++) {
-				if (sessionSockets[i]->busyness() < lowestBusyness) {
-					leastBusySessionSocketIndex = i;
-					lowestBusyness = sessionSockets[i]->busyness();
-				}
-			}
-
-			return sessionSockets[leastBusySessionSocketIndex];
-		}
-	}
-
-	/** Checks whether the OS process exists.
-	 * Once it has been detected that it doesn't, that event is remembered
-	 * so that we don't accidentally ping any new processes that have the
-	 * same PID.
-	 */
-	bool osProcessExists() const {
-		if (!dummy && m_osProcessExists) {
-			if (syscalls::kill(getPid(), 0) == 0) {
-				/* On some environments, e.g. Heroku, the init process does
-				 * not properly reap adopted zombie processes, which can interfere
-				 * with our process existance check. To work around this, we
-				 * explicitly check whether or not the process has become a zombie.
-				 */
-				m_osProcessExists = !isZombie(getPid());
-			} else {
-				m_osProcessExists = errno != ESRCH;
-			}
-			return m_osProcessExists;
-		} else {
-			return false;
-		}
-	}
-
-	/** Kill the OS process with the given signal. */
-	int kill(int signo) {
-		if (osProcessExists()) {
-			return syscalls::kill(getPid(), signo);
-		} else {
-			return 0;
-		}
-	}
-
-	int busyness() const {
-		/* Different processes within a Group may have different
-		 * 'concurrency' values. We want:
-		 * - the process with the smallest busyness to be be picked for routing.
-		 * - to give processes with concurrency == 0 more priority (in general)
-		 *   over processes with concurrency > 0.
-		 * Therefore, in case of processes with concurrency > 0, we describe our
-		 * busyness as a percentage of 'concurrency', with the percentage value
-		 * in [0..INT_MAX] instead of [0..1]. That way, the busyness value
-		 * of processes with concurrency > 0 is usually higher than that of processes
-		 * with concurrency == 0.
-		 */
-		if (concurrency == 0) {
-			return sessions;
-		} else {
-			return (int) (((long long) sessions * INT_MAX) / (double) concurrency);
-		}
-	}
-
-	/**
-	 * Whether we've reached the maximum number of concurrent sessions for this
-	 * process.
-	 */
-	bool isTotallyBusy() const {
-		return concurrency != 0 && sessions >= concurrency;
-	}
-
-	/**
-	 * Whether a get() request can be routed to this process, assuming that
-	 * the sticky session ID (if any) matches. This is only not the case
-	 * if this process is totally busy.
-	 */
-	bool canBeRoutedTo() const {
-		return !isTotallyBusy();
-	}
-
-	/**
-	 * Create a new communication session with this process. This will connect to one
-	 * of the session sockets or reuse an existing connection. See Session for
-	 * more information about sessions.
-	 *
-	 * If you know the current time (in microseconds), pass it to `now`, which
-	 * prevents this function from having to query the time.
-	 *
-	 * You SHOULD call sessionClosed() when one's done with the session.
-	 * Failure to do so will mess up internal statistics but will otherwise
-	 * not result in any harmful behavior.
-	 */
-	SessionPtr newSession(unsigned long long now = 0) {
-		Socket *socket = findSessionSocketWithLowestBusyness();
-		if (socket->isTotallyBusy()) {
-			return SessionPtr();
-		} else {
-			socket->sessions++;
-			this->sessions++;
-			if (now != 0) {
-				lastUsed = now;
-			} else {
-				lastUsed = SystemTime::getUsec();
-			}
-			return createSessionObject(socket);
-		}
-	}
-
-	SessionPtr createSessionObject(Socket *socket) {
-		struct Guard {
-			Context *context;
-			Session *session;
-
-			Guard(Context *c, Session *s)
-				: context(c),
-				  session(s)
-				{ }
-
-			~Guard() {
-				if (session != NULL) {
-					context->getSessionObjectPool().free(session);
-				}
-			}
-
-			void clear() {
-				session = NULL;
-			}
-		};
-
-		Context *context = getContext();
-		LockGuard l(context->getMmSyncher());
-		Session *session = context->getSessionObjectPool().malloc();
-		Guard guard(context, session);
-		session = new (session) Session(context, &info, socket);
-		guard.clear();
-		return SessionPtr(session, false);
-	}
-
-	void sessionClosed(Session *session) {
-		Socket *socket = session->getSocket();
-
-		assert(socket->sessions > 0);
-		assert(sessions > 0);
-
-		socket->sessions--;
-		this->sessions--;
-		processed++;
-		assert(!isTotallyBusy());
-	}
-
-	/**
-	 * Returns the uptime of this process so far, as a string.
-	 */
-	string uptime() const {
-		return distanceOfTimeInWords(spawnEndTime / 1000000);
-	}
-
-	string inspect() const {
-		assert(getLifeStatus() != DEAD);
-		stringstream result;
-		result << "(pid=" << getPid() << ", group=" << getGroupName() << ")";
-		return result.str();
-	}
-
-	template<typename Stream>
-	void inspectXml(Stream &stream, bool includeSockets = true) const {
-		stream << "<pid>" << getPid() << "</pid>";
-		stream << "<sticky_session_id>" << getStickySessionId() << "</sticky_session_id>";
-		stream << "<gupid>" << getGupid() << "</gupid>";
-		stream << "<concurrency>" << concurrency << "</concurrency>";
-		stream << "<sessions>" << sessions << "</sessions>";
-		stream << "<busyness>" << busyness() << "</busyness>";
-		stream << "<processed>" << processed << "</processed>";
-		stream << "<spawner_creation_time>" << spawnerCreationTime << "</spawner_creation_time>";
-		stream << "<spawn_start_time>" << spawnStartTime << "</spawn_start_time>";
-		stream << "<spawn_end_time>" << spawnEndTime << "</spawn_end_time>";
-		stream << "<last_used>" << lastUsed << "</last_used>";
-		stream << "<last_used_desc>" << distanceOfTimeInWords(lastUsed / 1000000).c_str() << " ago</last_used_desc>";
-		stream << "<uptime>" << uptime() << "</uptime>";
-		if (!codeRevision.empty()) {
-			stream << "<code_revision>" << escapeForXml(codeRevision) << "</code_revision>";
-		}
-		switch (lifeStatus) {
-		case ALIVE:
-			stream << "<life_status>ALIVE</life_status>";
-			break;
-		case SHUTDOWN_TRIGGERED:
-			stream << "<life_status>SHUTDOWN_TRIGGERED</life_status>";
-			break;
-		case DEAD:
-			stream << "<life_status>DEAD</life_status>";
-			break;
-		default:
-			P_BUG("Unknown 'lifeStatus' state " << (int) lifeStatus);
-		}
-		switch (enabled) {
-		case ENABLED:
-			stream << "<enabled>ENABLED</enabled>";
-			break;
-		case DISABLING:
-			stream << "<enabled>DISABLING</enabled>";
-			break;
-		case DISABLED:
-			stream << "<enabled>DISABLED</enabled>";
-			break;
-		case DETACHED:
-			stream << "<enabled>DETACHED</enabled>";
-			break;
-		default:
-			P_BUG("Unknown 'enabled' state " << (int) enabled);
-		}
-		if (metrics.isValid()) {
-			stream << "<has_metrics>true</has_metrics>";
-			stream << "<cpu>" << (int) metrics.cpu << "</cpu>";
-			stream << "<rss>" << metrics.rss << "</rss>";
-			stream << "<pss>" << metrics.pss << "</pss>";
-			stream << "<private_dirty>" << metrics.privateDirty << "</private_dirty>";
-			stream << "<swap>" << metrics.swap << "</swap>";
-			stream << "<real_memory>" << metrics.realMemory() << "</real_memory>";
-			stream << "<vmsize>" << metrics.vmsize << "</vmsize>";
-			stream << "<process_group_id>" << metrics.processGroupId << "</process_group_id>";
-			stream << "<command>" << escapeForXml(metrics.command) << "</command>";
-		}
-		if (includeSockets) {
-			SocketList::const_iterator it;
-
-			stream << "<sockets>";
-			for (it = sockets.begin(); it != sockets.end(); it++) {
-				const Socket &socket = *it;
-				stream << "<socket>";
-				stream << "<name>" << escapeForXml(socket.name) << "</name>";
-				stream << "<address>" << escapeForXml(socket.address) << "</address>";
-				stream << "<protocol>" << escapeForXml(socket.protocol) << "</protocol>";
-				stream << "<concurrency>" << socket.concurrency << "</concurrency>";
-				stream << "<sessions>" << socket.sessions << "</sessions>";
-				stream << "</socket>";
-			}
-			stream << "</sockets>";
-		}
-	}
-};
-
-
-inline void
-intrusive_ptr_add_ref(const Process *process) {
-	process->ref();
-}
-
-inline void
-intrusive_ptr_release(const Process *process) {
-	process->unref();
-}
-
-
-} // namespace ApplicationPool2
-} // namespace Passenger
-
-#endif /* _PASSENGER_APPLICATION_POOL2_PROCESS_H_ */