passenger 5.1.10 → 5.1.11

data/src/cxx_supportlib/ProcessManagement/Ruby.cpp

@@ -0,0 +1,106 @@
+/*
+ *  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.
+ */
+
+#include <string>
+#include <vector>
+#include <cstddef>
+#include <cstdio>
+
+#include <ProcessManagement/Spawn.h>
+#include <ProcessManagement/Ruby.h>
+#include <ResourceLocator.h>
+#include <Exceptions.h>
+
+namespace Passenger {
+
+using namespace std;
+
+
+void
+runInternalRubyTool(const ResourceLocator &resourceLocator,
+	const string &ruby, const vector<string> &args, int *status,
+	string *output)
+{
+	string locationConfigFileEnv = "PASSENGER_LOCATION_CONFIGURATION_FILE="
+		+ resourceLocator.getInstallSpec();
+	string fullProgramPath;
+	bool isRubyProgram;
+	const char *command[
+		4 // env, locationConfigEnvFile, ruby, fullProgramPath
+		+ (args.size() - 1)
+		+ 1 // NULL
+	];
+	unsigned int i = 0, j;
+
+	if (args[0][0] == '/') {
+		fullProgramPath = args[0];
+	} else {
+		fullProgramPath = resourceLocator.getBinDir() + "/" + args[0];
+	}
+
+	// The tool may be a wrapper script, e.g. one generated by Homebrew.
+	// If it's a non-Ruby wrapper script then don't invoke it with Ruby.
+	FILE *f = fopen(fullProgramPath.c_str(), "r");
+	if (f == NULL) {
+		throw RuntimeException("Unable to open " + fullProgramPath);
+	}
+	char line[1024];
+	if (fgets(line, sizeof(line), f) == NULL) {
+		if (ferror(f) != 0) {
+			fclose(f);
+			throw RuntimeException("Unable to read " + fullProgramPath);
+		} else {
+			throw RuntimeException(fullProgramPath + " is empty");
+		}
+	} else {
+		isRubyProgram = strstr(line, "ruby") != NULL;
+	}
+	fclose(f);
+
+	command[i++] = "env";
+	command[i++] = locationConfigFileEnv.c_str();
+	if (isRubyProgram) {
+		command[i++] = ruby.c_str();
+	}
+	command[i++] = fullProgramPath.c_str();
+	for (j = 1; j < args.size(); j++) {
+		command[i++] = args[j].c_str();
+	}
+	command[i++] = NULL;
+
+	SubprocessInfo info;
+	if (output == NULL) {
+		runCommand(command, info);
+	} else {
+		runCommandAndCaptureOutput(command, info, *output);
+	}
+	if (status != NULL) {
+		*status = info.status;
+	}
+}
+
+
+} // namespace Passenger

data/src/{agent/UstRouter/FileSink.h → cxx_supportlib/ProcessManagement/Ruby.h}

@@ -23,63 +23,39 @@
  *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  *  THE SOFTWARE.
  */
-#ifndef _PASSENGER_UST_ROUTER_FILE_SINK_H_
-#define _PASSENGER_UST_ROUTER_FILE_SINK_H_
+#ifndef _PASSENGER_PROCESS_MANAGEMENT_RUBY_H_
+#define _PASSENGER_PROCESS_MANAGEMENT_RUBY_H_
 
 #include <string>
-#include <ctime>
-#include <oxt/system_calls.hpp>
-#include <Exceptions.h>
-#include <FileDescriptor.h>
-#include <UstRouter/LogSink.h>
-#include <Utils/StrIntUtils.h>
+#include <vector>
+#include <cstddef>
 
 namespace Passenger {
-namespace UstRouter {
 
 using namespace std;
-using namespace oxt;
 
+class ResourceLocator;
 
-class FileSink: public LogSink {
-public:
-	string filename;
-	FileDescriptor fd;
 
-	FileSink(Controller *controller, const string &_filename)
-		: LogSink(controller),
-		  filename(_filename)
-	{
-		fd.assign(syscalls::open(_filename.c_str(),
-			O_CREAT | O_WRONLY | O_APPEND,
-			0600), __FILE__, __LINE__);
-		if (fd == -1) {
-			int e = errno;
-			throw FileSystemException("Cannnot open file '" +
-				filename + "' for appending", e, filename);
-		}
-	}
-
-	virtual void append(const TransactionPtr &transaction) {
-		StaticString data = transaction->getBody();
-		LogSink::append(transaction);
-		syscalls::write(fd, data.data(), data.size());
-	}
-
-	virtual Json::Value inspectStateAsJson() const {
-		Json::Value doc = LogSink::inspectStateAsJson();
-		doc["type"] = "file";
-		doc["filename"] = filename;
-		return doc;
-	}
-
-	string inspect() const {
-		return "FileSink(" + filename + ")";
-	}
-};
+/**
+ * Run a Passenger-internal Ruby tool, e.g. passenger-config, and optionally capture
+ * its stdout output. This function does not care whether the command fails.
+ *
+ * @param resourceLocator
+ * @param ruby The Ruby interpreter to attempt to use for running the tool.
+ * @param args The command as an array of strings, e.g. ["passenger-config", "system-properties"].
+ * @param status The status of the child process will be stored here, if non-NULL.
+ *               When unable to waitpid() the child process because of an ECHILD
+ *               or ESRCH, this will be set to -1.
+ * @param output The output of the child process will be stored here, if non-NULL.
+ * @throws RuntimeException
+ * @throws SystemException
+ */
+void runInternalRubyTool(const ResourceLocator &resourceLocator,
+	const string &ruby, const vector<string> &args,
+	int *status = NULL, string *output = NULL);
 
 
-} // namespace UstRouter
 } // namespace Passenger
 
-#endif /* _PASSENGER_UST_ROUTER_FILE_SINK_H_ */
+#endif /* _PASSENGER_PROCESS_MANAGEMENT_RUBY_H_ */

data/src/cxx_supportlib/ProcessManagement/Spawn.cpp

@@ -0,0 +1,199 @@
+/*
+ *  Phusion Passenger - https://www.phusionpassenger.com/
+ *  Copyright (c) 2010-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.
+ */
+
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <signal.h>
+
+#include <boost/thread.hpp>
+#include <oxt/system_calls.hpp>
+#include <string>
+#include <cerrno>
+
+#include <ProcessManagement/Spawn.h>
+#include <ProcessManagement/Utils.h>
+#include <StaticString.h>
+#include <Exceptions.h>
+#include <Utils/IOUtils.h>
+
+namespace Passenger {
+
+using namespace std;
+
+
+int
+runShellCommand(const StaticString &command) {
+	string commandNt = command;
+	const char *argv[] = {
+		"/bin/sh",
+		"-c",
+		commandNt.c_str(),
+		NULL
+	};
+	SubprocessInfo info;
+	runCommand(argv, info);
+	return info.status;
+}
+
+void
+runCommand(const char **command, SubprocessInfo &info, bool wait, bool killSubprocessOnInterruption,
+	const boost::function<void ()> &afterFork,
+	const boost::function<void (const char **, int errcode)> &onExecFail)
+{
+	int e, waitStatus;
+	pid_t waitRet;
+
+	info.pid = asyncFork();
+	if (info.pid == 0) {
+		resetSignalHandlersAndMask();
+		disableMallocDebugging();
+		if (afterFork) {
+			afterFork();
+		}
+		closeAllFileDescriptors(2, true);
+		execvp(command[0], (char * const *) command);
+		if (onExecFail) {
+			onExecFail(command, errno);
+		}
+		_exit(1);
+	} else if (info.pid == -1) {
+		e = errno;
+		throw SystemException("Cannot fork() a new process", e);
+	} else if (wait) {
+		try {
+			waitRet = syscalls::waitpid(info.pid, &waitStatus, 0);
+		} catch (const boost::thread_interrupted &) {
+			if (killSubprocessOnInterruption) {
+				boost::this_thread::disable_syscall_interruption dsi;
+				syscalls::kill(SIGKILL, info.pid);
+				syscalls::waitpid(info.pid, NULL, 0);
+			}
+			throw;
+		}
+
+		if (waitRet != -1) {
+			info.status = waitStatus;
+		} else if (errno == ECHILD || errno == ESRCH) {
+			info.status = -2;
+		} else {
+			int e = errno;
+			throw SystemException(string("Error waiting for the '") +
+				command[0] + "' command", e);
+		}
+	}
+}
+
+void
+runCommandAndCaptureOutput(const char **command, SubprocessInfo &info,
+	string &output, bool killSubprocessOnInterruption,
+	const boost::function<void ()> &afterFork,
+	const boost::function<void (const char **command, int errcode)> &onExecFail)
+{
+	pid_t waitRet;
+	int e, waitStatus;
+	Pipe p;
+
+	p = createPipe(__FILE__, __LINE__);
+
+	info.pid = asyncFork();
+	if (info.pid == 0) {
+		dup2(p[1], 1);
+		close(p[0]);
+		close(p[1]);
+		resetSignalHandlersAndMask();
+		disableMallocDebugging();
+		if (afterFork) {
+			afterFork();
+		}
+		closeAllFileDescriptors(2, true);
+		execvp(command[0], (char * const *) command);
+		if (onExecFail) {
+			onExecFail(command, errno);
+		}
+		_exit(1);
+	} else if (info.pid == -1) {
+		e = errno;
+		throw SystemException("Cannot fork() a new process", e);
+	} else {
+		bool done = false;
+
+		p[1].close();
+		while (!done) {
+			char buf[1024 * 4];
+			ssize_t ret;
+
+			try {
+				ret = syscalls::read(p[0], buf, sizeof(buf));
+			} catch (const boost::thread_interrupted &) {
+				if (killSubprocessOnInterruption) {
+					boost::this_thread::disable_syscall_interruption dsi;
+					syscalls::kill(SIGKILL, info.pid);
+					syscalls::waitpid(info.pid, NULL, 0);
+				}
+				throw;
+			}
+			if (ret == -1) {
+				e = errno;
+				if (killSubprocessOnInterruption) {
+					boost::this_thread::disable_syscall_interruption dsi;
+					syscalls::kill(SIGKILL, info.pid);
+					syscalls::waitpid(info.pid, NULL, 0);
+				}
+				throw SystemException(string("Cannot read output from the '") +
+					command[0] + "' command", e);
+			}
+			done = ret == 0;
+			output.append(buf, ret);
+		}
+		p[0].close();
+
+		try {
+			waitRet = syscalls::waitpid(info.pid, &waitStatus, 0);
+		} catch (const boost::thread_interrupted &) {
+			if (killSubprocessOnInterruption) {
+				boost::this_thread::disable_syscall_interruption dsi;
+				syscalls::kill(SIGKILL, info.pid);
+				syscalls::waitpid(info.pid, NULL, 0);
+			}
+			throw;
+		}
+
+		if (waitRet != -1) {
+			info.status = waitStatus;
+		} else if (errno == ECHILD || errno == ESRCH) {
+			info.status = -2;
+		} else {
+			int e = errno;
+			throw SystemException(string("Error waiting for the '") +
+				command[0] + "' command", e);
+		}
+	}
+}
+
+
+} // namespace Passenger

data/src/cxx_supportlib/ProcessManagement/Spawn.h

@@ -0,0 +1,150 @@
+/*
+ *  Phusion Passenger - https://www.phusionpassenger.com/
+ *  Copyright (c) 2010-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_PROCESS_MANAGEMENT_SPAWN_H_
+#define _PASSENGER_PROCESS_MANAGEMENT_SPAWN_H_
+
+#include <sys/types.h>
+#include <boost/function.hpp>
+#include <string>
+#include <StaticString.h>
+
+namespace Passenger {
+
+using namespace std;
+
+struct SubprocessInfo {
+	/**
+	 * The PID of the subprocess. This is set to -1 on
+	 * object creation. If fork fails or is interrupted,
+	 * then this field is unmodified.
+	 *
+	 * Attention: if you called `runCommand()` with `wait = true`,
+	 * or if you called `runCommandAndCaptureOutput()`,
+	 * then when that function returns, this PID no longer
+	 * exists.
+	 */
+	pid_t pid;
+
+	/**
+	 * The status of the subprocess, as returned by waitpid().
+	 * This is set to -1 on object creation.
+	 *
+	 * Only if `runCommand()` is done waiting for the subprocess
+	 * will this field be set. So if you call `runCommand()` with
+	 * `wait = false` then this field will never be modified.
+	 *
+	 * When unable to waitpid() the subprocess because of
+	 * an ECHILD or ESRCH, then this field is set to -2.
+	 */
+	int status;
+
+	SubprocessInfo()
+		: pid(-1),
+		  status(-1)
+		{ }
+};
+
+
+// See ProcessManagement/Utils.h for definition
+void printExecError(const char **command, int errcode);
+
+/**
+ * Like system(), but properly resets the signal handler mask,
+ * disables malloc debugging and closes file descriptors > 2.
+ *
+ * This is like `runCommand()` but runs something through the shell.
+ *
+ * @throws SystemException
+ * @throws boost::thread_interrupted
+ */
+int runShellCommand(const StaticString &command);
+
+/**
+ * Run a command and (if so configured) wait for it. You can see this function
+ * as a more flexible version of system(): it accepts a command array
+ * instead of a shell command string, and you can choose whether to wait
+ * for the subprocess or not.
+ *
+ * In addition, this function also properly resets the signal handler mask,
+ * disables malloc debugging and closes file descriptors > 2.
+ *
+ * Information about the subprocess is stored inside `info`. See the comments
+ * for the `SubprocessInfo` structure to learn more about it.
+ *
+ * If this function encounters an error or is interrupted, then it ensures
+ * that as much information as possible about the current state of things
+ * is stored in `info` so that the caller can clean things up appropriately.
+ *
+ * @param command The argument array to pass to execvp(). Must be null-terminated.
+ * @param info
+ * @param wait Whether to wait for the subprocess before returning.
+ * @param killSubprocessOnInterruption Whether to automatically kill the subprocess
+ *   when this function is interrupted.
+ * @param afterFork A function object to be called right after forking.
+ * @throws SystemException
+ * @throws boost::thread_interrupted
+ */
+void runCommand(const char **command, SubprocessInfo &info,
+	bool wait = true, bool killSubprocessOnInterruption = true,
+	const boost::function<void ()> &afterFork = boost::function<void ()>(),
+	const boost::function<void (const char **command, int errcode)> &onExecFail = printExecError);
+
+/**
+ * Run a command, wait for it, and capture its stdout output.
+ * This function does not care whether the command fails.
+ *
+ * In addition (like `runCommand()`), this function also properly
+ * resets the signal handler mask, disables malloc debugging and
+ * closes file descriptors > 2.
+ *
+ * If something goes wrong or when interrupted while capturing the
+ * output, then `output` contains the output captured so far.
+ *
+ * Information about the subprocess is stored inside `info`. See the comments
+ * for the `SubprocessInfo` structure to learn more about it.
+ *
+ * If this function encounters an error or is interrupted, then it ensures
+ * that as much information as possible about the current state of things
+ * is stored in `info` so that the caller can clean things up appropriately.
+ *
+ * @param command The argument array to pass to execvp(). Must be null-terminated.
+ * @param info
+ * @param killSubprocessOnInterruption Whether to automatically kill the subprocess
+ *   when this function is interrupted.
+ * @param afterFork A function object to be called right after forking.
+ * @param onExecFail A function object to be called if exec fails.
+ * @throws SystemException
+ * @throws boost::thread_interrupted
+ */
+void runCommandAndCaptureOutput(const char **command, SubprocessInfo &info,
+	string &output, bool killSubprocessOnInterruption = true,
+	const boost::function<void ()> &afterFork = boost::function<void ()>(),
+	const boost::function<void (const char **command, int errcode)> &onExecFail = printExecError);
+
+
+} // namespace Passenger
+
+#endif /* _PASSENGER_PROCESS_MANAGEMENT_SPAWN_H_ */