passenger 3.0.21 → 3.9.1.beta

data/ext/common/{LoggingAgent → agents/LoggingAgent}/FilterSupport.cpp

@@ -56,7 +56,7 @@ passenger_filter_validate(const char *source, int size) {
 		size = strlen(source);
 	}
 	try {
-		FilterSupport::Filter(StaticString(source, size));
+		(void) FilterSupport::Filter(StaticString(source, size));
 		return NULL;
 	} catch (const SyntaxError &e) {
 		return strdup(e.what());

data/ext/common/{LoggingAgent → agents/LoggingAgent}/LoggingServer.h

@@ -42,20 +42,22 @@
 #include <ctime>
 #include <cassert>
 
-#include "DataStoreId.h"
-#include "RemoteSender.h"
-#include "FilterSupport.h"
-#include "../EventedMessageServer.h"
-#include "../MessageReadersWriters.h"
-#include "../StaticString.h"
-#include "../Exceptions.h"
-#include "../Constants.h"
-#include "../Utils.h"
-#include "../Utils/MD5.h"
-#include "../Utils/IOUtils.h"
-#include "../Utils/MessageIO.h"
-#include "../Utils/StrIntUtils.h"
-#include "../Utils/StringMap.h"
+#include <agents/LoggingAgent/DataStoreId.h>
+#include <agents/LoggingAgent/RemoteSender.h>
+#include <agents/LoggingAgent/FilterSupport.h>
+
+#include <EventedMessageServer.h>
+#include <MessageReadersWriters.h>
+#include <RandomGenerator.h>
+#include <StaticString.h>
+#include <Exceptions.h>
+#include <Constants.h>
+#include <Utils.h>
+#include <Utils/MD5.h>
+#include <Utils/IOUtils.h>
+#include <Utils/MessageIO.h>
+#include <Utils/StrIntUtils.h>
+#include <Utils/StringMap.h>
 
 
 namespace Passenger {
@@ -862,7 +864,7 @@ private:
 			exitTimer.stop();
 			exitRequested = false;
 			refuseNewConnections = false;
-			ev_unloop(getLoop(), EVUNLOOP_ONE);
+			ev_break(getLoop(), EVBREAK_ONE);
 		}
 	}
 	
@@ -1109,7 +1111,7 @@ protected:
 			}
 			if (args.size() == 2 && args[1] == "immediately") {
 				// Immediate exit.
-				ev_unloop(getLoop(), EVUNLOOP_ONE);
+				ev_break(getLoop(), EVBREAK_ONE);
 			} else if (args.size() == 2 && args[1] == "semi-gracefully") {
 				// Semi-graceful exit: refuse new connections, shut down
 				// a few seconds after the last client has disconnected.

data/ext/common/{LoggingAgent → agents/LoggingAgent}/Main.cpp

@@ -36,17 +36,18 @@
 #include <cerrno>
 #include <signal.h>
 
-#include "../AgentBase.h"
-#include "../AccountsDatabase.h"
-#include "../Account.h"
-#include "../ServerInstanceDir.h"
-#include "LoggingServer.h"
-#include "../Exceptions.h"
-#include "../Utils.h"
-#include "../Utils/IOUtils.h"
-#include "../Utils/MessageIO.h"
-#include "../Utils/Base64.h"
-#include "../Utils/VariantMap.h"
+#include <agents/Base.h>
+#include <agents/LoggingAgent/LoggingServer.h>
+
+#include <AccountsDatabase.h>
+#include <Account.h>
+#include <ServerInstanceDir.h>
+#include <Exceptions.h>
+#include <Utils.h>
+#include <Utils/IOUtils.h>
+#include <Utils/MessageIO.h>
+#include <Utils/Base64.h>
+#include <Utils/VariantMap.h>
 
 using namespace oxt;
 using namespace Passenger;
@@ -120,7 +121,7 @@ feedbackFdBecameReadable(ev::io &watcher, int revents) {
 void
 caughtExitSignal(ev::sig &watcher, int revents) {
 	P_DEBUG("Caught signal, exiting...");
-	ev_unloop(eventLoop, EVUNLOOP_ONE);
+	ev_break(eventLoop, EVBREAK_ONE);
 	/* We only consider the "exit" command to be a graceful way to shut down
 	 * the logging agent, so upon receiving an exit signal we want to return
 	 * a non-zero exit code. This is because we want the watchdog to restart
@@ -281,7 +282,8 @@ main(int argc, char *argv[]) {
 		/********** Initialized! Enter main loop... **********/
 		
 		P_DEBUG("Logging agent online, listening at " << socketAddress);
-		ev_loop(eventLoop, 0);
+		ev_run(eventLoop, 0);
+		P_DEBUG("Logging agent exiting with code " << exitCode << ".");
 		return exitCode;
 	} catch (const tracable_exception &e) {
 		P_ERROR("*** ERROR: " << e.what() << "\n" << e.backtrace());

data/ext/common/{LoggingAgent → agents/LoggingAgent}/RemoteSender.h

@@ -37,12 +37,12 @@
 #include <string>
 #include <list>
 
-#include "../Logging.h"
-#include "../StaticString.h"
-#include "../Utils/BlockingQueue.h"
-#include "../Utils/SystemTime.h"
-#include "../Utils/ScopeGuard.h"
-#include "../Utils/Base64.h"
+#include <Logging.h>
+#include <StaticString.h>
+#include <Utils/BlockingQueue.h>
+#include <Utils/SystemTime.h>
+#include <Utils/ScopeGuard.h>
+#include <Utils/Base64.h>
 
 namespace Passenger {
 

data/ext/common/agents/SpawnPreparer.cpp

@@ -0,0 +1,127 @@
+/*
+ * Sets given environment variables, dumps the entire environment to
+ * a given file (for diagnostics purposes), then execs the given command.
+ *
+ * This is a separate executable because it does quite
+ * some non-async-signal-safe stuff that we can't do after
+ * fork()ing from the Spawner and before exec()ing.
+ */
+
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <cerrno>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <unistd.h>
+#include <string>
+#include <Utils/Base64.h>
+
+using namespace std;
+using namespace Passenger;
+
+extern "C" {
+	extern char **environ;
+}
+
+static void
+setGivenEnvVars(const char *envvarsData) {
+	string envvars = Base64::decode(envvarsData);
+	const char *key = envvars.data();
+	const char *end = envvars.data() + envvars.size();
+	
+	while (key < end) {
+		const char *keyEnd = (const char *) memchr(key, '\0', end - key);
+		if (keyEnd != NULL) {
+			const char *value = keyEnd + 1;
+			if (value < end) {
+				const char *valueEnd = (const char *) memchr(value, '\0', end - value);
+				if (valueEnd != NULL) {
+					setenv(key, value, 1);
+					key = valueEnd + 1;
+				} else {
+					break;
+				}
+			} else {
+				break;
+			}
+		} else {
+			break;
+		}
+	}
+}
+
+static void
+dumpInformation() {
+	const char *dir;
+	if ((dir = getenv("PASSENGER_DEBUG_DIR")) != NULL) {
+		FILE *f;
+
+		f = fopen((string(dir) + "/envvars").c_str(), "w");
+		if (f != NULL) {
+			int i = 0;
+			while (environ[i] != NULL) {
+				fputs(environ[i], f);
+				putc('\n', f);
+				i++;
+			}
+			fclose(f);
+		}
+
+		f = fopen((string(dir) + "/user_info").c_str(), "w");
+		if (f != NULL) {
+			pid_t pid = fork();
+			if (pid == 0) {
+				dup2(fileno(f), 1);
+				execlp("id", "id", (char *) 0);
+				_exit(1);
+			} else if (pid == -1) {
+				int e = errno;
+				fprintf(stderr, "Error: cannot fork a new process: %s (errno=%d)\n",
+					strerror(e), e);
+			} else {
+				waitpid(pid, NULL, 0);
+			}
+			fclose(f);
+		}
+
+		f = fopen((string(dir) + "/ulimit").c_str(), "w");
+		if (f != NULL) {
+			pid_t pid = fork();
+			if (pid == 0) {
+				dup2(fileno(f), 1);
+				execlp("ulimit", "ulimit", "-a", (char *) 0);
+				_exit(1);
+			} else if (pid == -1) {
+				int e = errno;
+				fprintf(stderr, "Error: cannot fork a new process: %s (errno=%d)\n",
+					strerror(e), e);
+			} else {
+				waitpid(pid, NULL, 0);
+			}
+			fclose(f);
+		}
+	}
+}
+
+// Usage: SpawnPreparer <envvars> <executable> <exec args...>
+int
+main(int argc, char *argv[]) {
+	if (argc < 4) {
+		fprintf(stderr, "Too few arguments.\n");
+		exit(1);
+	}
+	
+	const char *envvars = argv[1];
+	const char *executable = argv[2];
+	char **execArgs = &argv[3];
+	
+	setGivenEnvVars(envvars);
+	dumpInformation();
+	
+	execvp(executable, (char * const *) execArgs);
+	int e = errno;
+	fprintf(stderr, "*** ERROR ***: Cannot execute %s: %s (%d)\n",
+		executable, strerror(e), e);
+	return 1;
+}

data/ext/common/{Watchdog.cpp → agents/Watchdog/Main.cpp}

@@ -1,6 +1,6 @@
 /*
  *  Phusion Passenger - http://www.modrails.com/
- *  Copyright (c) 2010 Phusion
+ *  Copyright (c) 2010-2012 Phusion
  *
  *  "Phusion Passenger" is a trademark of Hongli Lai & Ninh Bui.
  *
@@ -38,11 +38,10 @@
 #include <cstring>
 #include <cerrno>
 
+#include <agents/Base.h>
 #include <Constants.h>
-#include <AgentBase.h>
 #include <ServerInstanceDir.h>
 #include <FileDescriptor.h>
-#include <Constants.h>
 #include <RandomGenerator.h>
 #include <Logging.h>
 #include <Exceptions.h>
@@ -64,7 +63,6 @@ using namespace Passenger;
 
 /** The options that were passed to AgentsStarter. */
 static VariantMap     agentsOptions;
-static string         webServerType;        // "apache" or "nginx"
 static unsigned int   logLevel;
 static pid_t   webServerPid;
 static string  tempDir;
@@ -90,6 +88,7 @@ static EventFd *errorEvent;
 
 #define REQUEST_SOCKET_PASSWORD_SIZE     64
 
+static bool hasEnvOption(const char *name, bool defaultValue = false);
 static void setOomScore(const StaticString &score);
 
 
@@ -125,7 +124,8 @@ private:
 					 */
 					ret = pid;
 					status = 0;
-					P_WARN("waitpid() on " << name() << " return -1 with " <<
+					P_WARN("waitpid() on " << name() << " (pid=" << pid <<
+						") returned -1 with " <<
 						"errno = ECHILD, falling back to kill polling");
 					waitpidUsingKillPolling(pid);
 					e = 0;
@@ -141,7 +141,7 @@ private:
 				this_thread::disable_interruption di;
 				this_thread::disable_syscall_interruption dsi;
 				if (ret == -1) {
-					P_WARN(name() << " crashed or killed for "
+					P_WARN(name() << " (pid=" << pid << ") crashed or killed for "
 						"an unknown reason (errno = " <<
 						strerror(e) << "), restarting it...");
 				} else if (WIFEXITED(status)) {
@@ -154,14 +154,21 @@ private:
 						 */
 						return;
 					} else {
-						P_WARN(name() << " crashed with exit status " <<
+						P_WARN(name() << " (pid=" << pid <<
+							") crashed with exit status " <<
 							WEXITSTATUS(status) << ", restarting it...");
 					}
 				} else {
-					P_WARN(name() << " crashed with signal " <<
+					P_WARN(name() << " (pid=" << pid <<
+						") crashed with signal " <<
 						getSignalName(WTERMSIG(status)) <<
 						", restarting it...");
 				}
+
+				const char *sleepTime;
+				if ((sleepTime = getenv("PASSENGER_AGENT_RESTART_SLEEP")) != NULL) {
+					sleep(atoi(sleepTime));
+				}
 			}
 		} catch (const boost::thread_interrupted &) {
 		} catch (const tracable_exception &e) {
@@ -503,11 +510,8 @@ public:
 			throw RuntimeException("Already started watching.");
 		}
 		
-		/* Don't make the stack any smaller, getpwnam() on OS
-		 * X needs a lot of stack space.
-		 */
 		thr = new oxt::thread(boost::bind(&AgentWatcher::threadMain, this),
-			name(), 64 * 1024);
+			name(), 256 * 1024);
 	}
 	
 	static void stopWatching(vector<AgentWatcher *> &watchers) {
@@ -584,7 +588,12 @@ protected:
 	}
 	
 	virtual void execProgram() const {
-		execl(helperAgentFilename.c_str(), "PassengerHelperAgent", (char *) 0);
+		if (hasEnvOption("PASSENGER_RUN_HELPER_AGENT_IN_VALGRIND", false)) {
+			execlp("valgrind", "valgrind", "--dsymutil=yes",
+				helperAgentFilename.c_str(), (char *) 0);
+		} else {
+			execl(helperAgentFilename.c_str(), "PassengerHelperAgent", (char *) 0);
+		}
 	}
 	
 	virtual void sendStartupArguments(pid_t pid, FileDescriptor &fd) {
@@ -608,11 +617,7 @@ protected:
 	
 public:
 	HelperAgentWatcher(const ResourceLocator &resourceLocator) {
-		if (agentsOptions.get("web_server_type") == "apache") {
-			helperAgentFilename = resourceLocator.getAgentsDir() + "/apache2/PassengerHelperAgent";
-		} else {
-			helperAgentFilename = resourceLocator.getAgentsDir() + "/nginx/PassengerHelperAgent";
-		}
+		helperAgentFilename = resourceLocator.getAgentsDir() + "/PassengerHelperAgent";
 		requestSocketPassword = randomGenerator->generateByteString(REQUEST_SOCKET_PASSWORD_SIZE);
 		messageSocketPassword = randomGenerator->generateByteString(MESSAGE_SERVER_MAX_PASSWORD_SIZE);
 	}
@@ -754,7 +759,7 @@ private:
 
 public:
 	ServerInstanceDirToucher() {
-		thr = new oxt::thread(threadMain, "Server instance dir toucher", 96 * 1024);
+		thr = new oxt::thread(threadMain, "Server instance dir toucher", 256 * 1024);
 	}
 	
 	~ServerInstanceDirToucher() {
@@ -764,6 +769,24 @@ public:
 };
 
 
+static bool
+hasEnvOption(const char *name, bool defaultValue) {
+	const char *value = getenv(name);
+	if (value != NULL) {
+		if (*value != '\0') {
+			return strcmp(value, "yes") == 0
+				|| strcmp(value, "y") == 0
+				|| strcmp(value, "1") == 0
+				|| strcmp(value, "on") == 0
+				|| strcmp(value, "true") == 0;
+		} else {
+			return defaultValue;
+		}
+	} else {
+		return defaultValue;
+	}
+}
+
 enum OomFileType {
 	OOM_ADJ,
 	OOM_SCORE_ADJ
@@ -959,12 +982,12 @@ cleanupAgentsInBackground(vector<AgentWatcher *> &watchers) {
 			// processes.
 			P_WARN("Some Phusion Passenger agent processes did not exit " <<
 				"in time, forcefully shutting down all.");
-			for (it = watchers.begin(); it != watchers.end(); it++) {
-				(*it)->forceShutdown();
-			}
 		} else {
-			P_DEBUG("All Phusion Passenger agent processes have exited.");
+			P_DEBUG("All Phusion Passenger agent processes have exited. Forcing all subprocesses to shut down.");
 		}
+		for (it = watchers.begin(); it != watchers.end(); it++) {
+				(*it)->forceShutdown();
+			}
 		
 		// Now clean up the server instance directory.
 		delete generation.get();
@@ -997,6 +1020,14 @@ forceAllAgentsShutdown(vector<AgentWatcher *> &watchers) {
 
 int
 main(int argc, char *argv[]) {
+	/*
+	 * Some Apache installations (like on OS X) redirect stdout to /dev/null,
+	 * so that only stderr is redirected to the log file. We therefore
+	 * forcefully redirect stdout to stderr so that everything ends up in the
+	 * same place.
+	 */
+	dup2(2, 1);
+
 	/*
 	 * Most operating systems overcommit memory. We *know* that this watchdog process
 	 * doesn't use much memory; on OS X it uses about 200 KB of private RSS. If the
@@ -1024,6 +1055,8 @@ main(int argc, char *argv[]) {
 	poolIdleTime       = agentsOptions.getInt("pool_idle_time");
 	serializedPrestartURLs  = agentsOptions.get("prestart_urls");
 	
+	P_DEBUG("Starting Watchdog...");
+	
 	try {
 		randomGenerator = new RandomGenerator();
 		errorEvent = new EventFd();
@@ -1093,20 +1126,25 @@ main(int argc, char *argv[]) {
 		}
 		
 		writeArrayMessage(FEEDBACK_FD, "All agents started", NULL);
+		P_DEBUG("All Phusion Passenger agents started!");
 		
 		this_thread::disable_interruption di;
 		this_thread::disable_syscall_interruption dsi;
 		bool exitGracefully = waitForStarterProcessOrWatchers(watchers);
-		AgentWatcher::stopWatching(watchers);
 		if (exitGracefully) {
 			/* Fork a child process which cleans up all the agent processes in
 			 * the background and exit this watchdog process so that we don't block
 			 * the web server.
 			 */
+			P_DEBUG("Web server exited gracefully; gracefully shutting down all agents...");
+		} else {
+			P_DEBUG("Web server did not exit gracefully, forcing shutdown of all agents...");
+		}
+		AgentWatcher::stopWatching(watchers);
+		if (exitGracefully) {
 			cleanupAgentsInBackground(watchers);
 			return 0;
 		} else {
-			P_DEBUG("Web server did not exit gracefully, forcing shutdown of all service processes...");
 			forceAllAgentsShutdown(watchers);
 			return 1;
 		}