passenger 4.0.60 → 5.0.0.beta1

data/ext/common/agents/TempDirToucher/Main.cpp

@@ -0,0 +1,429 @@
+/*
+ *  Phusion Passenger - https://www.phusionpassenger.com/
+ *  Copyright (c) 2013-2014 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.
+ */
+
+/* This tool touches everything in a directory every 30 minutes to prevent
+ * /tmp cleaners from removing it.
+ */
+
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <signal.h>
+#include <fcntl.h>
+#include <limits.h>
+#include <errno.h>
+#include <string.h>
+#include <Constants.h>
+
+#define ERROR_PREFIX "*** TempDirToucher error"
+
+static char *dir;
+/**
+ * When Passenger Standalone is started with --daemonize, then it will
+ * pass --cleanup to this tool so that this tool is responsible
+ * for cleaning up the Standalone temp dir. This is because Passenger
+ * Standalone may be started in daemonize mode, which makes it exit asap
+ * in order to conserve memory. Passenger Standalone can therefore not
+ * be responsible for cleaning up the temp dir.
+ */
+static int shouldCleanup = 0;
+static int shouldDaemonize = 0;
+static bool verbose = false;
+static const char *pidFile = NULL;
+static const char *logFile = NULL;
+static int sleepInterval = 1800;
+static int terminationPipe[2];
+static sig_atomic_t shouldIgnoreNextTermSignal = 0;
+
+#define DEBUG(message) \
+	do { \
+		if (verbose) { \
+			puts(message); \
+		} \
+	} while (false)
+
+
+static void
+usage() {
+	printf("Usage: " AGENT_EXE " temp-dir-watcher <DIRECTORY> [OPTIONS...]\n");
+	printf("Touches everything in a directory every 30 minutes, to "
+		"prevent /tmp cleaners from removing the directory.\n");
+	printf("\n");
+	printf("Options:\n");
+	printf("  --cleanup           Remove directory on exit\n");
+	printf("  --daemonize         Daemonize into background\n");
+	printf("  --interval SECONDS  Customize interval\n");
+	printf("  --pid-file PATH     Save PID into the given file\n");
+	printf("  --log-file PATH     Use the given log file\n");
+	printf("  --verbose           Print debugging messages\n");
+}
+
+static void
+parseArguments(int argc, char *argv[], int offset) {
+	dir = argv[offset];
+	int i;
+
+	if (dir == NULL) {
+		usage();
+		exit(1);
+	}
+
+	for (i = offset + 1; i < argc; i++) {
+		if (strcmp(argv[i], "--cleanup") == 0) {
+			shouldCleanup = 1;
+		} else if (strcmp(argv[i], "--daemonize") == 0) {
+			shouldDaemonize = 1;
+		} else if (strcmp(argv[i], "--interval") == 0) {
+			if (i == argc - 1) {
+				fprintf(stderr, ERROR_PREFIX ": --interval requires an argument\n");
+				exit(1);
+			}
+			sleepInterval = atoi(argv[i + 1]);
+			i++;
+		} else if (strcmp(argv[i], "--pid-file") == 0) {
+			pidFile = argv[i + 1];
+			i++;
+		} else if (strcmp(argv[i], "--log-file") == 0) {
+			logFile = argv[i + 1];
+			i++;
+		} else if (strcmp(argv[i], "--verbose") == 0) {
+			verbose = true;
+		} else {
+			fprintf(stderr, ERROR_PREFIX ": unrecognized argument %s\n",
+				argv[i]);
+			exit(1);
+		}
+	}
+}
+
+static void
+setNonBlocking(int fd) {
+	int flags, ret, e;
+
+	do {
+		flags = fcntl(fd, F_GETFL);
+	} while (flags == -1 && errno == EINTR);
+	if (flags == -1) {
+		e = errno;
+		fprintf(stderr, ERROR_PREFIX
+			": cannot set pipe to non-blocking mode: "
+			"cannot get file descriptor flags. Error: %s (errno %d)\n",
+			strerror(e), e);
+		exit(1);
+	}
+	do {
+		ret = fcntl(fd, F_SETFL, flags | O_NONBLOCK);
+	} while (ret == -1 && errno == EINTR);
+	if (ret == -1) {
+		e = errno;
+		fprintf(stderr, ERROR_PREFIX
+			": cannot set pipe to non-blocking mode: "
+			"cannot set file descriptor flags. Error: %s (errno %d)\n",
+			strerror(e), e);
+		exit(1);
+	}
+}
+
+static void
+initialize(int argc, char *argv[], int offset) {
+	int e, fd;
+
+	parseArguments(argc, argv, offset);
+
+	if (logFile != NULL) {
+		fd = open(logFile, O_WRONLY | O_APPEND | O_CREAT, 0644);
+		if (fd == -1) {
+			e = errno;
+			fprintf(stderr, ERROR_PREFIX
+				": cannot open log file %s for writing: %s (errno %d)\n",
+				logFile, strerror(e), e);
+			exit(1);
+		}
+
+		if (dup2(fd, 1) == -1) {
+			e = errno;
+			fprintf(stderr, ERROR_PREFIX ": cannot dup2(%d, 1): %s (errno %d)\n",
+				fd, strerror(e), e);
+		}
+		if (dup2(fd, 2) == -1) {
+			e = errno;
+			fprintf(stderr, ERROR_PREFIX ": cannot dup2(%d, 2): %s (errno %d)\n",
+				fd, strerror(e), e);
+		}
+		close(fd);
+	}
+
+	if (pipe(terminationPipe) == -1) {
+		e = errno;
+		fprintf(stderr, ERROR_PREFIX ": cannot create a pipe: %s (errno %d)\n",
+			strerror(e), e);
+		exit(1);
+	}
+
+	setNonBlocking(terminationPipe[1]);
+
+	setvbuf(stdout, NULL, _IONBF, 0);
+	setvbuf(stderr, NULL, _IONBF, 0);
+}
+
+static void
+exitHandler(int signo) {
+	if (shouldIgnoreNextTermSignal) {
+		shouldIgnoreNextTermSignal = 0;
+	} else {
+		int ret = write(terminationPipe[1], "x", 1);
+		// We can't do anything about failures, so ignore
+		// compiler warnings about not using the result.
+		(void) ret;
+	}
+}
+
+static void
+ignoreNextTermSignalHandler(int signo) {
+	shouldIgnoreNextTermSignal = 1;
+}
+
+static void
+installSignalHandlers() {
+	struct sigaction action;
+
+	action.sa_handler = exitHandler;
+	action.sa_flags = SA_RESTART;
+	sigemptyset(&action.sa_mask);
+	sigaction(SIGINT, &action, NULL);
+	sigaction(SIGTERM, &action, NULL);
+
+	action.sa_handler = ignoreNextTermSignalHandler;
+	action.sa_flags = SA_RESTART;
+	sigaction(SIGHUP, &action, NULL);
+}
+
+static void
+redirectStdinToNull() {
+	int fd = open("/dev/null", O_RDONLY);
+	if (fd != -1) {
+		dup2(fd, 0);
+		close(fd);
+	}
+}
+
+static void
+maybeDaemonize() {
+	pid_t pid;
+	int e;
+
+	if (shouldDaemonize) {
+		pid = fork();
+		if (pid == 0) {
+			setsid();
+			if (chdir("/") == -1) {
+				e = errno;
+				fprintf(stderr, ERROR_PREFIX
+					": cannot change working directory to /: %s (errno=%d)\n",
+					strerror(e), e);
+				_exit(1);
+			}
+			redirectStdinToNull();
+		} else if (pid == -1) {
+			e = errno;
+			fprintf(stderr, ERROR_PREFIX ": cannot fork: %s (errno=%d)\n",
+				strerror(e), e);
+			exit(1);
+		} else {
+			_exit(0);
+		}
+	}
+}
+
+static void
+maybeWritePidfile() {
+	FILE *f;
+
+	if (pidFile != NULL) {
+		f = fopen(pidFile, "w");
+		if (f != NULL) {
+			fprintf(f, "%d\n", (int) getpid());
+			fclose(f);
+		} else {
+			fprintf(stderr, ERROR_PREFIX ": cannot open PID file %s for writing\n",
+				pidFile);
+			exit(1);
+		}
+	}
+}
+
+static int
+dirExists(const char *dir) {
+	struct stat buf;
+	return stat(dir, &buf) == 0 && S_ISDIR(buf.st_mode);
+}
+
+static void
+touchDir(const char *dir) {
+	pid_t pid;
+	int e, status;
+
+	pid = fork();
+	if (pid == 0) {
+		close(terminationPipe[0]);
+		close(terminationPipe[1]);
+		if (chdir(dir) == -1) {
+			e = errno;
+			fprintf(stderr, ERROR_PREFIX
+				": cannot change working directory to %s: %s (errno %d)\n",
+				dir, strerror(e), e);
+			_exit(1);
+		}
+		execlp("/bin/sh", "/bin/sh", "-c",
+			"find \"$1\" | xargs touch", "/bin/sh", ".",
+			(const char * const) 0);
+		e = errno;
+		fprintf(stderr, ERROR_PREFIX ": cannot execute /bin/sh: %s (errno %d)\n",
+			strerror(e), e);
+		_exit(1);
+	} else if (pid == -1) {
+		e = errno;
+		fprintf(stderr, ERROR_PREFIX ": cannot fork: %s (errno %d)\n",
+			strerror(e), e);
+		exit(1);
+	} else {
+		if (waitpid(pid, &status, 0) == -1) {
+			if (errno != ESRCH && errno != EPERM) {
+				fprintf(stderr, ERROR_PREFIX
+					": unable to wait for shell command 'find %s | xargs touch'\n",
+					dir);
+				exit(1);
+			}
+		} else if (WEXITSTATUS(status) != 0) {
+			fprintf(stderr, ERROR_PREFIX
+				": shell command 'find %s | xargs touch' failed with exit status %d\n",
+				dir, WEXITSTATUS(status));
+			exit(1);
+		}
+	}
+}
+
+static int
+doSleep(int sec) {
+	fd_set readfds;
+	struct timeval timeout;
+	int ret, e;
+
+	FD_ZERO(&readfds);
+	FD_SET(terminationPipe[0], &readfds);
+	timeout.tv_sec = sec;
+	timeout.tv_usec = 0;
+	do {
+		ret = select(terminationPipe[0] + 1, &readfds, NULL, NULL, &timeout);
+	} while (ret == -1 && errno == EINTR);
+	if (ret == -1) {
+		e = errno;
+		fprintf(stderr, ERROR_PREFIX ": cannot select(): %s (errno %d)\n",
+			strerror(e), e);
+		exit(1);
+		return -1; /* Never reached */
+	} else {
+		return ret == 0;
+	}
+}
+
+static void
+maybeDeletePidFile() {
+	if (pidFile != NULL) {
+		unlink(pidFile);
+	}
+}
+
+static void
+performCleanup(const char *dir) {
+	pid_t pid;
+	int e, status;
+
+	pid = fork();
+	if (pid == 0) {
+		close(terminationPipe[0]);
+		close(terminationPipe[1]);
+		execlp("/bin/sh", "/bin/sh", "-c",
+			"rm -rf \"$1\"", "/bin/sh", dir,
+			(const char * const) 0);
+		e = errno;
+		fprintf(stderr, ERROR_PREFIX ": cannot execute /bin/sh: %s (errno %d)\n",
+			strerror(e), e);
+		_exit(1);
+	} else if (pid == -1) {
+		e = errno;
+		fprintf(stderr, ERROR_PREFIX ": cannot fork: %s (errno %d)\n",
+			strerror(e), e);
+		exit(1);
+	} else {
+		if (waitpid(pid, &status, 0) == -1) {
+			if (errno != ESRCH && errno != EPERM) {
+				fprintf(stderr, ERROR_PREFIX
+					": unable to wait for shell command 'rm -rf %s'\n",
+					dir);
+				exit(1);
+			}
+		} else if (WEXITSTATUS(status) != 0) {
+			fprintf(stderr, ERROR_PREFIX
+				": shell command 'rm -rf %s' failed with exit status %d\n",
+				dir, WEXITSTATUS(status));
+			exit(1);
+		}
+	}
+}
+
+int
+tempDirToucherMain(int argc, char *argv[]) {
+	initialize(argc, argv, 2);
+	installSignalHandlers();
+	maybeDaemonize();
+	maybeWritePidfile();
+
+	DEBUG("TempDirToucher started");
+
+	while (1) {
+		if (dirExists(dir)) {
+			DEBUG("Touching directory");
+			touchDir(dir);
+			if (!doSleep(sleepInterval)) {
+				break;
+			}
+		} else {
+			DEBUG("Directory no longer exists, exiting");
+			break;
+		}
+	}
+
+	maybeDeletePidFile();
+	if (shouldCleanup) {
+		DEBUG("Cleaning up directory");
+		performCleanup(dir);
+	}
+
+	return 0;
+}

data/ext/common/agents/Watchdog/AdminServer.h

@@ -0,0 +1,390 @@
+/*
+ *  Phusion Passenger - https://www.phusionpassenger.com/
+ *  Copyright (c) 2014 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_WATCHDOG_AGENT_ADMIN_SERVER_H_
+#define _PASSENGER_WATCHDOG_AGENT_ADMIN_SERVER_H_
+
+#include <sstream>
+#include <string>
+#include <cstring>
+
+#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/modp_b64.h>
+#include <Utils/json.h>
+
+namespace Passenger {
+namespace WatchdogAgent {
+
+using namespace std;
+
+
+class Request: public ServerKit::BaseHttpRequest {
+public:
+	string body;
+	Json::Value jsonBody;
+
+	DEFINE_SERVER_KIT_BASE_HTTP_REQUEST_FOOTER(Request);
+};
+
+class AdminServer: public ServerKit::HttpServer<AdminServer, ServerKit::HttpClient<Request> > {
+public:
+	enum PrivilegeLevel {
+		NONE,
+		READONLY,
+		FULL
+	};
+
+	struct Authorization {
+		PrivilegeLevel level;
+		string username;
+		string password;
+	};
+
+private:
+	typedef ServerKit::HttpServer<AdminServer, ServerKit::HttpClient<Request> > ParentClass;
+	typedef ServerKit::HttpClient<Request> Client;
+	typedef ServerKit::HeaderTable HeaderTable;
+
+	bool parseAuthorizationHeader(Request *req, string &username,
+		string &password) const
+	{
+		const LString *auth = req->headers.lookup("authorization");
+
+		if (auth == NULL || auth->size <= 6 || !psg_lstr_cmp(auth, "Basic ", 6)) {
+			return false;
+		}
+
+		auth = psg_lstr_make_contiguous(auth, req->pool);
+		string authData = modp::b64_decode(
+			auth->start->data + sizeof("Basic ") - 1,
+			auth->size - (sizeof("Basic ") - 1));
+		string::size_type pos = authData.find(':');
+		if (pos == string::npos) {
+			return false;
+		}
+
+		username = authData.substr(0, pos);
+		password = authData.substr(pos + 1);
+		return true;
+	}
+
+	const Authorization *lookupAuthorizationRecord(const StaticString &username) const {
+		vector<Authorization>::const_iterator it, end = authorizations.end();
+
+		for (it = authorizations.begin(); it != end; it++) {
+			if (it->username == username) {
+				return &(*it);
+			}
+		}
+
+		return NULL;
+	}
+
+	bool authorize(Client *client, Request *req, PrivilegeLevel level) const {
+		if (authorizations.empty()) {
+			return true;
+		}
+
+		string username, password;
+		if (!parseAuthorizationHeader(req, username, password)) {
+			return false;
+		}
+
+		const Authorization *auth = lookupAuthorizationRecord(username);
+		return auth != NULL
+			&& auth->level >= level
+			&& constantTimeCompare(password, auth->password);
+	}
+
+	void processStatusTxt(Client *client, Request *req) {
+		if (authorize(client, req, READONLY)) {
+			HeaderTable headers;
+			//stringstream stream;
+			headers.insert(req->pool, "content-type", "text/plain");
+			//loggingServer->dump(stream);
+			//writeSimpleResponse(client, 200, &headers, stream.str());
+			if (!req->ended()) {
+				endRequest(&client, &req);
+			}
+		} else {
+			respondWith401(client, req);
+		}
+	}
+
+	void processPing(Client *client, Request *req) {
+		if (authorize(client, req, READONLY)) {
+			HeaderTable headers;
+			headers.insert(req->pool, "cache-control", "no-cache, no-store, must-revalidate");
+			headers.insert(req->pool, "content-type", "application/json");
+			writeSimpleResponse(client, 200, &headers, "{ \"status\": \"ok\" }");
+			if (!req->ended()) {
+				endRequest(&client, &req);
+			}
+		} else {
+			respondWith401(client, req);
+		}
+	}
+
+	void processShutdown(Client *client, Request *req) {
+		if (req->method != HTTP_POST) {
+			respondWith405(client, req);
+		} else if (authorize(client, req, FULL)) {
+			HeaderTable headers;
+			headers.insert(req->pool, "content-type", "application/json");
+			exitEvent->notify();
+			writeSimpleResponse(client, 200, &headers, "{ \"status\": \"ok\" }");
+			if (!req->ended()) {
+				endRequest(&client, &req);
+			}
+		} else {
+			respondWith401(client, req);
+		}
+	}
+
+	void processConfig(Client *client, Request *req) {
+		if (req->method == HTTP_GET) {
+			if (!authorize(client, req, READONLY)) {
+				respondWith401(client, req);
+			}
+
+			HeaderTable headers;
+			Json::Value doc;
+			string logFile = getLogFile();
+
+			headers.insert(req->pool, "content-type", "application/json");
+			doc["log_level"] = getLogLevel();
+			if (!logFile.empty()) {
+				doc["log_file"] = logFile;
+			}
+
+			writeSimpleResponse(client, 200, &headers, doc.toStyledString());
+			if (!req->ended()) {
+				endRequest(&client, &req);
+			}
+		} else if (req->method == HTTP_PUT) {
+			if (!authorize(client, req, FULL)) {
+				respondWith401(client, req);
+			} else if (!req->hasBody()) {
+				endAsBadRequest(&client, &req, "Body required");
+			}
+			// Continue in processConfigBody()
+		} else {
+			respondWith405(client, req);
+		}
+	}
+
+	void processConfigBody(Client *client, Request *req) {
+		HeaderTable headers;
+		Json::Value &json = req->jsonBody;
+
+		headers.insert(req->pool, "content-type", "application/json");
+
+		if (json.isMember("log_level")) {
+			setLogLevel(json["log_level"].asInt());
+		}
+		if (json.isMember("log_file")) {
+			if (!setLogFile(json["log_file"].asCString())) {
+				int e = errno;
+				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.");
+		}
+
+		writeSimpleResponse(client, 200, &headers, "{ \"status\": \"ok\" }");
+		if (!req->ended()) {
+			endRequest(&client, &req);
+		}
+	}
+
+	void processReopenLogs(Client *client, Request *req) {
+		if (req->method != HTTP_POST) {
+			respondWith405(client, req);
+		} else if (authorize(client, req, FULL)) {
+			HeaderTable headers;
+			headers.insert(req->pool, "content-type", "application/json");
+
+			string logFile = getLogFile();
+			if (logFile.empty()) {
+				writeSimpleResponse(client, 500, &headers, "{ \"status\": \"error\", "
+					"\"code\": \"NO_LOG_FILE\", "
+					"\"message\": \"" PROGRAM_NAME " was not configured with a log file.\" }\n");
+			} else {
+				if (!setLogFile(logFile.c_str())) {
+					int e = errno;
+					unsigned int bufsize = 1024;
+					char *message = (char *) psg_pnalloc(req->pool, bufsize);
+					snprintf(message, bufsize, "{ \"status\": \"error\", "
+						"\"code\": \"LOG_FILE_OPEN_ERROR\", "
+						"\"message\": \"Cannot reopen log file: %s (errno=%d)\" }",
+						strerror(e), e);
+					writeSimpleResponse(client, 500, &headers, message);
+					if (!req->ended()) {
+						endRequest(&client, &req);
+					}
+					return;
+				}
+				P_NOTICE("Log file reopened.");
+				writeSimpleResponse(client, 200, &headers, "{ \"status\": \"ok\" }\n");
+			}
+
+			if (!req->ended()) {
+				endRequest(&client, &req);
+			}
+		} else {
+			respondWith401(client, req);
+		}
+	}
+
+	void respondWith401(Client *client, Request *req) {
+		HeaderTable headers;
+		headers.insert(req->pool, "cache-control", "no-cache, no-store, must-revalidate");
+		headers.insert(req->pool, "www-authenticate", "Basic realm=\"admin\"");
+		writeSimpleResponse(client, 401, &headers, "Unauthorized");
+		if (!req->ended()) {
+			endRequest(&client, &req);
+		}
+	}
+
+	void respondWith404(Client *client, Request *req) {
+		HeaderTable headers;
+		headers.insert(req->pool, "cache-control", "no-cache, no-store, must-revalidate");
+		writeSimpleResponse(client, 404, &headers, "Not found");
+		if (!req->ended()) {
+			endRequest(&client, &req);
+		}
+	}
+
+	void respondWith405(Client *client, Request *req) {
+		HeaderTable headers;
+		headers.insert(req->pool, "cache-control", "no-cache, no-store, must-revalidate");
+		writeSimpleResponse(client, 405, &headers, "Method not allowed");
+		if (!req->ended()) {
+			endRequest(&client, &req);
+		}
+	}
+
+	void respondWith422(Client *client, Request *req, const StaticString &body) {
+		HeaderTable headers;
+		headers.insert(req->pool, "cache-control", "no-cache, no-store, must-revalidate");
+		headers.insert(req->pool, "content-type", "text/plain; charset=utf-8");
+		writeSimpleResponse(client, 422, &headers, body);
+		if (!req->ended()) {
+			endRequest(&client, &req);
+		}
+	}
+
+protected:
+	virtual void onRequestBegin(Client *client, Request *req) {
+		const StaticString path(req->path.start->data, req->path.size);
+
+		P_INFO("Admin request: " << path);
+
+		if (path == P_STATIC_STRING("/status.txt")) {
+			processStatusTxt(client, req);
+		} else if (path == P_STATIC_STRING("/ping.json")) {
+			processPing(client, req);
+		} else if (path == P_STATIC_STRING("/shutdown.json")) {
+			processShutdown(client, req);
+		} else if (path == P_STATIC_STRING("/config.json")) {
+			processConfig(client, req);
+		} else if (path == P_STATIC_STRING("/reopen_logs.json")) {
+			processReopenLogs(client, req);
+		} else {
+			respondWith404(client, req);
+		}
+	}
+
+	virtual ServerKit::Channel::Result onRequestBody(Client *client, Request *req,
+		const MemoryKit::mbuf &buffer, int errcode)
+	{
+		if (buffer.size() > 0) {
+			// Data
+			req->body.append(buffer.start, buffer.size());
+		} else if (errcode == 0) {
+			// EOF
+			Json::Reader reader;
+			if (reader.parse(req->body, req->jsonBody)) {
+				processConfigBody(client, req);
+			} else {
+				respondWith422(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();
+		}
+		ParentClass::deinitializeRequest(client, req);
+	}
+
+public:
+	EventFd *exitEvent;
+	vector<Authorization> authorizations;
+
+	AdminServer(ServerKit::Context *context)
+		: ParentClass(context),
+		  exitEvent(NULL)
+		{ }
+
+	virtual StaticString getServerName() const {
+		return P_STATIC_STRING("WatchdogAdminServer");
+	}
+
+	static PrivilegeLevel parseLevel(const StaticString &level) {
+		if (level == "readonly") {
+			return READONLY;
+		} else if (level == "full") {
+			return FULL;
+		} else {
+			throw RuntimeException("Invalid privilege level " + level);
+		}
+	}
+};
+
+
+} // namespace WatchdogAgent
+} // namespace Passenger
+
+#endif /* _PASSENGER_WATCHDOG_AGENT_ADMIN_SERVER_H_ */