passenger 5.2.3 → 5.3.0

data/src/agent/Core/SpawningKit/Handshake/Session.h

@@ -0,0 +1,91 @@
+/*
+ *  Phusion Passenger - https://www.phusionpassenger.com/
+ *  Copyright (c) 2016-2017 Phusion Holding B.V.
+ *
+ *  "Passenger", "Phusion Passenger" and "Union Station" are registered
+ *  trademarks of Phusion Holding B.V.
+ *
+ *  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_SPAWNING_KIT_HANDSHAKE_SESSION_H_
+#define _PASSENGER_SPAWNING_KIT_HANDSHAKE_SESSION_H_
+
+#include <boost/scoped_ptr.hpp>
+#include <string>
+
+#include <Utils.h>
+#include <Core/SpawningKit/Context.h>
+#include <Core/SpawningKit/Config.h>
+#include <Core/SpawningKit/Journey.h>
+#include <Core/SpawningKit/Result.h>
+#include <Core/SpawningKit/Handshake/WorkDir.h>
+
+
+namespace Passenger {
+namespace SpawningKit {
+
+using namespace std;
+
+
+struct HandshakeSession {
+	Context *context;
+	Config *config;
+
+	boost::scoped_ptr<HandshakeWorkDir> workDir;
+	string responseDir;
+	string envDumpDir;
+	Journey journey;
+	Result result;
+
+	uid_t uid;
+	gid_t gid;
+	string homedir;
+	string shell;
+
+	unsigned long long timeoutUsec;
+
+	/**
+	 * The port that the application is expected to start on. Only meaningful
+	 * if `config->genericApp || config->findFreePort`.
+	 */
+	unsigned int expectedStartPort;
+
+	HandshakeSession(Context &_context, Config &_config, JourneyType journeyType)
+		: context(&_context),
+		  config(&_config),
+		  journey(journeyType, !_config.genericApp && _config.startsUsingWrapper),
+		  uid(USER_NOT_GIVEN),
+		  gid(GROUP_NOT_GIVEN),
+		  timeoutUsec(_config.startTimeoutMsec * 1000),
+		  expectedStartPort(0)
+		{ }
+
+	~HandshakeSession() {
+		if (config->debugWorkDir && workDir != NULL) {
+			string path = workDir->dontRemoveOnDestruction();
+			P_NOTICE("Work directory " << path << " preserved for debugging");
+		}
+	}
+};
+
+
+} // namespace SpawningKit
+} // namespace Passenger
+
+#endif /* _PASSENGER_SPAWNING_KIT_HANDSHAKE_SESSION_H_ */

data/src/agent/Core/SpawningKit/Handshake/WorkDir.h

@@ -0,0 +1,100 @@
+/*
+ *  Phusion Passenger - https://www.phusionpassenger.com/
+ *  Copyright (c) 2011-2018 Phusion Holding B.V.
+ *
+ *  "Passenger", "Phusion Passenger" and "Union Station" are registered
+ *  trademarks of Phusion Holding B.V.
+ *
+ *  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_SPAWNING_KIT_HANDSHAKE_WORKDIR_H_
+#define _PASSENGER_SPAWNING_KIT_HANDSHAKE_WORKDIR_H_
+
+#include <oxt/system_calls.hpp>
+#include <string>
+#include <cerrno>
+
+#include <sys/types.h>
+#include <limits.h>
+#include <unistd.h>
+
+#include <Exceptions.h>
+#include <Utils.h>
+#include <Utils/StrIntUtils.h>
+
+namespace Passenger {
+namespace SpawningKit {
+
+using namespace std;
+
+
+/**
+ * A temporary directory for handshaking with a child process
+ * during spawning. It is removed after spawning is finished
+ * or has failed.
+ */
+class HandshakeWorkDir {
+private:
+	string path;
+
+public:
+	HandshakeWorkDir(uid_t uid, gid_t gid) {
+		char buf[PATH_MAX + 1];
+		char *pos = buf;
+		const char *end = buf + PATH_MAX;
+
+		pos = appendData(pos, end, getSystemTempDir());
+		pos = appendData(pos, end, "/passenger.spawn.XXXXXXXXXX");
+		*pos = '\0';
+
+		const char *result = mkdtemp(buf);
+		if (result == NULL) {
+			int e = errno;
+			throw SystemException("Cannot create a temporary directory "
+				"in the format of '" + StaticString(buf) + "'", e);
+		} else {
+			path = result;
+			boost::this_thread::disable_interruption di;
+			boost::this_thread::disable_syscall_interruption dsi;
+			syscalls::chown(result, uid, gid);
+		}
+	}
+
+	~HandshakeWorkDir() {
+		if (!path.empty()) {
+			removeDirTree(path);
+		}
+	}
+
+	const string &getPath() const {
+		return path;
+	}
+
+	string dontRemoveOnDestruction() {
+		string result = path;
+		path.clear();
+		return result;
+	}
+};
+
+
+} // namespace SpawningKit
+} // namespace Passenger
+
+#endif /* _PASSENGER_SPAWNING_KIT_HANDSHAKE_WORKDIR_H_ */

data/src/agent/Core/SpawningKit/Journey.h

@@ -0,0 +1,561 @@
+/*
+ *  Phusion Passenger - https://www.phusionpassenger.com/
+ *  Copyright (c) 2017 Phusion Holding B.V.
+ *
+ *  "Passenger", "Phusion Passenger" and "Union Station" are registered
+ *  trademarks of Phusion Holding B.V.
+ *
+ *  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_SPAWNING_KIT_HANDSHAKE_JOURNEY_H_
+#define _PASSENGER_SPAWNING_KIT_HANDSHAKE_JOURNEY_H_
+
+#include <map>
+#include <utility>
+
+#include <oxt/macros.hpp>
+#include <oxt/backtrace.hpp>
+
+#include <jsoncpp/json.h>
+
+#include <LoggingKit/LoggingKit.h>
+#include <StaticString.h>
+#include <Utils/SystemTime.h>
+#include <Utils/JsonUtils.h>
+#include <Utils/StrIntUtils.h>
+#include <Utils/SystemTime.h>
+
+namespace Passenger {
+namespace SpawningKit {
+
+using namespace std;
+
+
+/**
+ * As explained in README.md, there are three possible journeys,
+ * although each journey can have small variations (based on whether
+ * a wrapper is used or not).
+ */
+enum JourneyType {
+	SPAWN_DIRECTLY,
+	START_PRELOADER,
+	SPAWN_THROUGH_PRELOADER
+};
+
+enum JourneyStep {
+	// Steps in Passenger Core / SpawningKit
+	SPAWNING_KIT_PREPARATION,
+	SPAWNING_KIT_FORK_SUBPROCESS,
+	SPAWNING_KIT_CONNECT_TO_PRELOADER,
+	SPAWNING_KIT_SEND_COMMAND_TO_PRELOADER,
+	SPAWNING_KIT_READ_RESPONSE_FROM_PRELOADER,
+	SPAWNING_KIT_PARSE_RESPONSE_FROM_PRELOADER,
+	SPAWNING_KIT_PROCESS_RESPONSE_FROM_PRELOADER,
+	SPAWNING_KIT_HANDSHAKE_PERFORM,
+	SPAWNING_KIT_FINISH,
+
+	// Steps in preloader (when spawning a worker process)
+	PRELOADER_PREPARATION,
+	PRELOADER_FORK_SUBPROCESS,
+	PRELOADER_SEND_RESPONSE,
+	PRELOADER_FINISH,
+
+	// Steps in subprocess
+	SUBPROCESS_BEFORE_FIRST_EXEC,
+	SUBPROCESS_SPAWN_ENV_SETUPPER_BEFORE_SHELL,
+	SUBPROCESS_OS_SHELL,
+	SUBPROCESS_SPAWN_ENV_SETUPPER_AFTER_SHELL,
+	SUBPROCESS_EXEC_WRAPPER,
+	SUBPROCESS_WRAPPER_PREPARATION,
+	SUBPROCESS_APP_LOAD_OR_EXEC,
+	SUBPROCESS_PREPARE_AFTER_FORKING_FROM_PRELOADER,
+	SUBPROCESS_LISTEN,
+	SUBPROCESS_FINISH,
+
+	// Other
+	UNKNOWN_JOURNEY_STEP
+};
+
+enum JourneyStepState {
+	/**
+	 * This step has not started yet. Will be visualized with an empty
+	 * placeholder.
+	 */
+	STEP_NOT_STARTED,
+
+	/**
+	 * This step is currently in progress. Will be visualized with a spinner.
+	 */
+	STEP_IN_PROGRESS,
+
+	/**
+	 * This step has already been performed successfully. Will be
+	 * visualized with a green tick.
+	 */
+	STEP_PERFORMED,
+
+	/**
+	 * This step has failed. Will be visualized with a red mark.
+	 */
+	STEP_ERRORED,
+
+	UNKNOWN_JOURNEY_STEP_STATE
+};
+
+
+inline OXT_PURE StaticString journeyTypeToString(JourneyType type);
+inline OXT_PURE StaticString journeyStepToString(JourneyStep step);
+inline OXT_PURE string journeyStepToStringLowerCase(JourneyStep step);
+inline OXT_PURE StaticString journeyStepStateToString(JourneyStepState state);
+inline OXT_PURE JourneyStepState stringToJourneyStepState(const StaticString &value);
+
+inline OXT_PURE JourneyStep getFirstCoreJourneyStep() { return SPAWNING_KIT_PREPARATION; }
+inline OXT_PURE JourneyStep getLastCoreJourneyStep() { return SPAWNING_KIT_FINISH; }
+inline OXT_PURE JourneyStep getFirstPreloaderJourneyStep() { return PRELOADER_PREPARATION; }
+inline OXT_PURE JourneyStep getLastPreloaderJourneyStep() { return PRELOADER_FINISH; }
+inline OXT_PURE JourneyStep getFirstSubprocessJourneyStep() { return SUBPROCESS_BEFORE_FIRST_EXEC; }
+inline OXT_PURE JourneyStep getLastSubprocessJourneyStep() { return SUBPROCESS_FINISH; }
+
+
+class JourneyStepInfo {
+private:
+	MonotonicTimeUsec getEndTime(const JourneyStepInfo *nextStepInfo) const {
+		if (nextStepInfo != NULL && nextStepInfo->beginTime != 0) {
+			return nextStepInfo->beginTime;
+		} else {
+			return endTime;
+		}
+	}
+
+public:
+	JourneyStep step, nextStep;
+	JourneyStepState state;
+	MonotonicTimeUsec beginTime;
+	MonotonicTimeUsec endTime;
+
+	JourneyStepInfo(JourneyStep _step, JourneyStepState _state = STEP_NOT_STARTED)
+		: step(_step),
+		  nextStep(UNKNOWN_JOURNEY_STEP),
+		  state(_state),
+		  beginTime(0),
+		  endTime(0)
+		{ }
+
+	unsigned long long usecDuration(const JourneyStepInfo *nextStepInfo) const {
+		if (getEndTime(nextStepInfo) >= beginTime) {
+			return getEndTime(nextStepInfo) - beginTime;
+		} else {
+			return 0;
+		}
+	}
+
+	Json::Value inspectAsJson(const JourneyStepInfo *nextStepInfo, MonotonicTimeUsec monoNow,
+		unsigned long long now) const
+	{
+		Json::Value doc;
+
+		doc["state"] = journeyStepStateToString(state).toString();
+		if (beginTime != 0) {
+			doc["begin_time"] = monoTimeToJson(beginTime, monoNow, now);
+		}
+		if (endTime != 0) {
+			doc["end_time"] = monoTimeToJson(endTime, monoNow, now);
+			doc["duration"] = usecDuration(nextStepInfo) / 1000000.0;
+		}
+		return doc;
+	}
+};
+
+
+/**
+ * For an introduction see README.md, sections:
+ *
+ *  - "The Journey class"
+ *  - "Subprocess journey logging"
+ */
+class Journey {
+public:
+	typedef map<JourneyStep, JourneyStepInfo> Map;
+
+private:
+	JourneyType type;
+	bool usingWrapper;
+	Map steps;
+
+	void insertStep(JourneyStep step, bool first = false) {
+		steps.insert(make_pair(step, JourneyStepInfo(step)));
+		if (!first) {
+			Map::iterator prev = steps.end();
+			prev--;
+			prev--;
+			prev->second.nextStep = step;
+		}
+	}
+
+	void fillInStepsForSpawnDirectlyJourney() {
+		insertStep(SPAWNING_KIT_PREPARATION, true);
+		insertStep(SPAWNING_KIT_FORK_SUBPROCESS);
+		insertStep(SPAWNING_KIT_HANDSHAKE_PERFORM);
+		insertStep(SPAWNING_KIT_FINISH);
+
+		insertStep(SUBPROCESS_BEFORE_FIRST_EXEC, true);
+		insertStep(SUBPROCESS_SPAWN_ENV_SETUPPER_BEFORE_SHELL);
+		insertStep(SUBPROCESS_OS_SHELL);
+		insertStep(SUBPROCESS_SPAWN_ENV_SETUPPER_AFTER_SHELL);
+		if (usingWrapper) {
+			insertStep(SUBPROCESS_EXEC_WRAPPER);
+			insertStep(SUBPROCESS_WRAPPER_PREPARATION);
+		}
+		insertStep(SUBPROCESS_APP_LOAD_OR_EXEC);
+		insertStep(SUBPROCESS_LISTEN);
+		insertStep(SUBPROCESS_FINISH);
+	}
+
+	void fillInStepsForPreloaderStartJourney() {
+		insertStep(SPAWNING_KIT_PREPARATION, true);
+		insertStep(SPAWNING_KIT_FORK_SUBPROCESS);
+		insertStep(SPAWNING_KIT_HANDSHAKE_PERFORM);
+		insertStep(SPAWNING_KIT_FINISH);
+
+		insertStep(SUBPROCESS_BEFORE_FIRST_EXEC, true);
+		insertStep(SUBPROCESS_SPAWN_ENV_SETUPPER_BEFORE_SHELL);
+		insertStep(SUBPROCESS_OS_SHELL);
+		insertStep(SUBPROCESS_SPAWN_ENV_SETUPPER_AFTER_SHELL);
+		if (usingWrapper) {
+			insertStep(SUBPROCESS_EXEC_WRAPPER);
+			insertStep(SUBPROCESS_WRAPPER_PREPARATION);
+		}
+		insertStep(SUBPROCESS_APP_LOAD_OR_EXEC);
+		insertStep(SUBPROCESS_LISTEN);
+		insertStep(SUBPROCESS_FINISH);
+	}
+
+	void fillInStepsForSpawnThroughPreloaderJourney() {
+		insertStep(SPAWNING_KIT_PREPARATION, true);
+		insertStep(SPAWNING_KIT_CONNECT_TO_PRELOADER);
+		insertStep(SPAWNING_KIT_SEND_COMMAND_TO_PRELOADER);
+		insertStep(SPAWNING_KIT_READ_RESPONSE_FROM_PRELOADER);
+		insertStep(SPAWNING_KIT_PARSE_RESPONSE_FROM_PRELOADER);
+		insertStep(SPAWNING_KIT_PROCESS_RESPONSE_FROM_PRELOADER);
+		insertStep(SPAWNING_KIT_HANDSHAKE_PERFORM);
+		insertStep(SPAWNING_KIT_FINISH);
+
+		insertStep(PRELOADER_PREPARATION, true);
+		insertStep(PRELOADER_FORK_SUBPROCESS);
+		insertStep(PRELOADER_SEND_RESPONSE);
+		insertStep(PRELOADER_FINISH);
+
+		insertStep(SUBPROCESS_PREPARE_AFTER_FORKING_FROM_PRELOADER, true);
+		insertStep(SUBPROCESS_LISTEN);
+		insertStep(SUBPROCESS_FINISH);
+	}
+
+	JourneyStepInfo &getStepInfoMutable(JourneyStep step) {
+		Map::iterator it = steps.find(step);
+		if (it == steps.end()) {
+			throw RuntimeException("Invalid step " + journeyStepToString(step));
+		}
+
+		return it->second;
+	}
+
+public:
+	Journey(JourneyType _type, bool _usingWrapper)
+		: type(_type),
+		  usingWrapper(_usingWrapper)
+	{
+		switch (_type) {
+		case SPAWN_DIRECTLY:
+			fillInStepsForSpawnDirectlyJourney();
+			break;
+		case START_PRELOADER:
+			fillInStepsForPreloaderStartJourney();
+			break;
+		case SPAWN_THROUGH_PRELOADER:
+			fillInStepsForSpawnThroughPreloaderJourney();
+			break;
+		default:
+			P_BUG("Unknown journey type " << toString((int) _type));
+			break;
+		}
+	}
+
+	JourneyType getType() const {
+		return type;
+	}
+
+	bool isUsingWrapper() const {
+		return usingWrapper;
+	}
+
+	bool hasStep(JourneyStep step) const {
+		Map::const_iterator it = steps.find(step);
+		return it != steps.end();
+	}
+
+	const JourneyStepInfo &getStepInfo(JourneyStep step) const {
+		Map::const_iterator it = steps.find(step);
+		if (it == steps.end()) {
+			throw RuntimeException("Invalid step " + journeyStepToString(step));
+		}
+
+		return it->second;
+	}
+
+	JourneyStep getFirstFailedStep() const {
+		Map::const_iterator it, end = steps.end();
+		for (it = steps.begin(); it != end; it++) {
+			if (it->second.state == STEP_ERRORED) {
+				return it->first;
+			}
+		}
+
+		return UNKNOWN_JOURNEY_STEP;
+	}
+
+	void setStepNotStarted(JourneyStep step, bool force = false) {
+		JourneyStepInfo &info = getStepInfoMutable(step);
+		if (info.state == STEP_NOT_STARTED || info.state == STEP_IN_PROGRESS || force) {
+			info.state = STEP_NOT_STARTED;
+			info.beginTime = 0;
+			info.endTime = 0;
+		} else {
+			throw RuntimeException("Unable to change state for journey step "
+				+ journeyStepToString(step) + " because it wasn't already in progress");
+		}
+	}
+
+	void setStepInProgress(JourneyStep step, bool force = false) {
+		JourneyStepInfo &info = getStepInfoMutable(step);
+		if (info.state == STEP_IN_PROGRESS) {
+			return;
+		} else if (info.state == STEP_NOT_STARTED || force) {
+			info.state = STEP_IN_PROGRESS;
+			// When `force` is true, we don't want to overwrite the previous endTime.
+			if (info.endTime == 0) {
+				info.beginTime =
+					SystemTime::getMonotonicUsecWithGranularity<SystemTime::GRAN_10MSEC>();
+			}
+		} else {
+			throw RuntimeException("Unable to change state for journey step "
+				+ journeyStepToString(step)
+				+ " because it was already in progress or completed");
+		}
+	}
+
+	void setStepPerformed(JourneyStep step, bool force = false) {
+		JourneyStepInfo &info = getStepInfoMutable(step);
+		if (info.state == STEP_PERFORMED) {
+			return;
+		} else if (info.state == STEP_IN_PROGRESS || true) {
+			info.state = STEP_PERFORMED;
+			// When `force` is true, we don't want to overwrite the previous endTime.
+			if (info.endTime == 0) {
+				info.endTime =
+					SystemTime::getMonotonicUsecWithGranularity<SystemTime::GRAN_10MSEC>();
+				if (info.beginTime == 0) {
+					info.beginTime = info.endTime;
+				}
+			}
+		} else {
+			throw RuntimeException("Unable to change state for journey step "
+				+ journeyStepToString(step) + " because it wasn't already in progress");
+		}
+	}
+
+	void setStepErrored(JourneyStep step, bool force = false) {
+		JourneyStepInfo &info = getStepInfoMutable(step);
+		if (info.state == STEP_ERRORED) {
+			return;
+		} else if (info.state == STEP_IN_PROGRESS || force) {
+			info.state = STEP_ERRORED;
+			// When `force` is true, we don't want to overwrite the previous endTime.
+			if (info.endTime == 0) {
+				info.endTime =
+					SystemTime::getMonotonicUsecWithGranularity<SystemTime::GRAN_10MSEC>();
+				if (info.beginTime == 0) {
+					info.beginTime = info.endTime;
+				}
+			}
+		} else {
+			throw RuntimeException("Unable to change state for journey step "
+				+ journeyStepToString(step) + " because it wasn't already in progress");
+		}
+	}
+
+	void setStepBeginTime(JourneyStep step, MonotonicTimeUsec timestamp) {
+		JourneyStepInfo &info = getStepInfoMutable(step);
+		info.beginTime = timestamp;
+	}
+
+	void setStepEndTime(JourneyStep step, MonotonicTimeUsec timestamp) {
+		JourneyStepInfo &info = getStepInfoMutable(step);
+		info.endTime = timestamp;
+	}
+
+	void reset() {
+		Map::iterator it, end = steps.end();
+		for (it = steps.begin(); it != end; it++) {
+			it->second.state = STEP_NOT_STARTED;
+			it->second.beginTime = 0;
+			it->second.endTime = 0;
+		}
+	}
+
+	Json::Value inspectAsJson() const {
+		Json::Value doc, steps;
+		MonotonicTimeUsec monoNow = SystemTime::getMonotonicUsec();
+		unsigned long long now = SystemTime::getUsec();
+
+		doc["type"] = journeyTypeToString(type).toString();
+
+		Map::const_iterator it, end = this->steps.end();
+		for (it = this->steps.begin(); it != end; it++) {
+			const JourneyStep step = it->first;
+			const JourneyStepInfo &info = it->second;
+			const JourneyStepInfo *nextStepInfo = NULL;
+			if (info.nextStep != UNKNOWN_JOURNEY_STEP) {
+				nextStepInfo = &this->steps.find(info.nextStep)->second;
+			}
+			steps[journeyStepToString(step).toString()] =
+				info.inspectAsJson(nextStepInfo, monoNow, now);
+		}
+		doc["steps"] = steps;
+
+		return doc;
+	}
+};
+
+
+inline OXT_PURE StaticString
+journeyTypeToString(JourneyType type) {
+	switch (type) {
+	case SPAWN_DIRECTLY:
+		return P_STATIC_STRING("SPAWN_DIRECTLY");
+	case START_PRELOADER:
+		return P_STATIC_STRING("START_PRELOADER");
+	case SPAWN_THROUGH_PRELOADER:
+		return P_STATIC_STRING("SPAWN_THROUGH_PRELOADER");
+	default:
+		return P_STATIC_STRING("UNKNOWN_JOURNEY_TYPE");
+	}
+}
+
+inline OXT_PURE StaticString
+journeyStepToString(JourneyStep step) {
+	switch (step) {
+	case SPAWNING_KIT_PREPARATION:
+		return P_STATIC_STRING("SPAWNING_KIT_PREPARATION");
+	case SPAWNING_KIT_FORK_SUBPROCESS:
+		return P_STATIC_STRING("SPAWNING_KIT_FORK_SUBPROCESS");
+	case SPAWNING_KIT_CONNECT_TO_PRELOADER:
+		return P_STATIC_STRING("SPAWNING_KIT_CONNECT_TO_PRELOADER");
+	case SPAWNING_KIT_SEND_COMMAND_TO_PRELOADER:
+		return P_STATIC_STRING("SPAWNING_KIT_SEND_COMMAND_TO_PRELOADER");
+	case SPAWNING_KIT_READ_RESPONSE_FROM_PRELOADER:
+		return P_STATIC_STRING("SPAWNING_KIT_READ_RESPONSE_FROM_PRELOADER");
+	case SPAWNING_KIT_PARSE_RESPONSE_FROM_PRELOADER:
+		return P_STATIC_STRING("SPAWNING_KIT_PARSE_RESPONSE_FROM_PRELOADER");
+	case SPAWNING_KIT_PROCESS_RESPONSE_FROM_PRELOADER:
+		return P_STATIC_STRING("SPAWNING_KIT_PROCESS_RESPONSE_FROM_PRELOADER");
+	case SPAWNING_KIT_HANDSHAKE_PERFORM:
+		return P_STATIC_STRING("SPAWNING_KIT_HANDSHAKE_PERFORM");
+	case SPAWNING_KIT_FINISH:
+		return P_STATIC_STRING("SPAWNING_KIT_FINISH");
+
+	case PRELOADER_PREPARATION:
+		return P_STATIC_STRING("PRELOADER_PREPARATION");
+	case PRELOADER_FORK_SUBPROCESS:
+		return P_STATIC_STRING("PRELOADER_FORK_SUBPROCESS");
+	case PRELOADER_SEND_RESPONSE:
+		return P_STATIC_STRING("PRELOADER_SEND_RESPONSE");
+	case PRELOADER_FINISH:
+		return P_STATIC_STRING("PRELOADER_FINISH");
+
+	case SUBPROCESS_BEFORE_FIRST_EXEC:
+		return P_STATIC_STRING("SUBPROCESS_BEFORE_FIRST_EXEC");
+	case SUBPROCESS_SPAWN_ENV_SETUPPER_BEFORE_SHELL:
+		return P_STATIC_STRING("SUBPROCESS_SPAWN_ENV_SETUPPER_BEFORE_SHELL");
+	case SUBPROCESS_OS_SHELL:
+		return P_STATIC_STRING("SUBPROCESS_OS_SHELL");
+	case SUBPROCESS_SPAWN_ENV_SETUPPER_AFTER_SHELL:
+		return P_STATIC_STRING("SUBPROCESS_SPAWN_ENV_SETUPPER_AFTER_SHELL");
+	case SUBPROCESS_EXEC_WRAPPER:
+		return P_STATIC_STRING("SUBPROCESS_EXEC_WRAPPER");
+	case SUBPROCESS_WRAPPER_PREPARATION:
+		return P_STATIC_STRING("SUBPROCESS_WRAPPER_PREPARATION");
+	case SUBPROCESS_APP_LOAD_OR_EXEC:
+		return P_STATIC_STRING("SUBPROCESS_APP_LOAD_OR_EXEC");
+	case SUBPROCESS_PREPARE_AFTER_FORKING_FROM_PRELOADER:
+		return P_STATIC_STRING("SUBPROCESS_PREPARE_AFTER_FORKING_FROM_PRELOADER");
+	case SUBPROCESS_LISTEN:
+		return P_STATIC_STRING("SUBPROCESS_LISTEN");
+	case SUBPROCESS_FINISH:
+		return P_STATIC_STRING("SUBPROCESS_FINISH");
+
+	default:
+		return P_STATIC_STRING("UNKNOWN_JOURNEY_STEP");
+	}
+}
+
+inline OXT_PURE string
+journeyStepToStringLowerCase(JourneyStep step) {
+	StaticString stepString = journeyStepToString(step);
+	DynamicBuffer stepStringLcBuffer(stepString.size());
+	convertLowerCase((const unsigned char *) stepString.data(),
+		(unsigned char *) stepStringLcBuffer.data, stepString.size());
+	return string(stepStringLcBuffer.data, stepString.size());
+}
+
+inline OXT_PURE StaticString
+journeyStepStateToString(JourneyStepState state) {
+	switch (state) {
+	case STEP_NOT_STARTED:
+		return P_STATIC_STRING("STEP_NOT_STARTED");
+	case STEP_IN_PROGRESS:
+		return P_STATIC_STRING("STEP_IN_PROGRESS");
+	case STEP_PERFORMED:
+		return P_STATIC_STRING("STEP_PERFORMED");
+	case STEP_ERRORED:
+		return P_STATIC_STRING("STEP_ERRORED");
+	default:
+		return P_STATIC_STRING("UNKNOWN_JOURNEY_STEP_STATE");
+	}
+}
+
+inline OXT_PURE JourneyStepState
+stringToJourneyStepState(const StaticString &value) {
+	if (value == P_STATIC_STRING("STEP_NOT_STARTED")) {
+		return STEP_NOT_STARTED;
+	} else if (value == P_STATIC_STRING("STEP_IN_PROGRESS")) {
+		return STEP_IN_PROGRESS;
+	} else if (value == P_STATIC_STRING("STEP_PERFORMED")) {
+		return STEP_PERFORMED;
+	} else if (value == P_STATIC_STRING("STEP_ERRORED")) {
+		return STEP_ERRORED;
+	} else {
+		return UNKNOWN_JOURNEY_STEP_STATE;
+	}
+}
+
+
+} // namespace SpawningKit
+} // namespace Passenger
+
+#endif /* _PASSENGER_SPAWNING_KIT_HANDSHAKE_JOURNEY_H_ */