passenger 4.0.42 → 4.0.43

data/ext/common/UnionStation/ScopeLog.h

@@ -0,0 +1,172 @@
+/*
+ *  Phusion Passenger - https://www.phusionpassenger.com/
+ *  Copyright (c) 2010-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_UNION_STATION_SCOPE_LOG_H_
+#define _PASSENGER_UNION_STATION_SCOPE_LOG_H_
+
+#include <boost/noncopyable.hpp>
+
+#include <sys/resource.h>
+
+#include <string>
+
+#include <StaticString.h>
+#include <Exceptions.h>
+#include <UnionStation/Transaction.h>
+#include <Utils/StrIntUtils.h>
+#include <Utils/SystemTime.h>
+
+namespace Passenger {
+namespace UnionStation {
+
+using namespace std;
+using namespace boost;
+
+
+class ScopeLog: public noncopyable {
+private:
+	Transaction * const transaction;
+	union {
+		const char *name;
+		struct {
+			const char *endMessage;
+			const char *abortMessage;
+		} granular;
+	} data;
+	enum {
+		NAME,
+		GRANULAR
+	} type: 1;
+	bool ok;
+
+	static string timevalToString(struct timeval &tv) {
+		unsigned long long i = (unsigned long long) tv.tv_sec * 1000000 + tv.tv_usec;
+		return usecToString(i);
+	}
+
+	static string usecToString(unsigned long long usec) {
+		char timestamp[2 * sizeof(unsigned long long) + 1];
+		integerToHexatri<unsigned long long>(usec, timestamp);
+		return timestamp;
+	}
+
+public:
+	ScopeLog()
+		: transaction(NULL)
+		{ }
+
+	ScopeLog(const TransactionPtr &_transaction, const char *name)
+		: transaction(_transaction.get())
+	{
+		type = NAME;
+		data.name = name;
+		ok = false;
+
+		char message[150];
+		char *pos = message;
+		const char *end = message + sizeof(message);
+		struct rusage usage;
+
+		pos = appendData(pos, end, "BEGIN: ");
+		pos = appendData(pos, end, name);
+		pos = appendData(pos, end, " (");
+		pos = appendData(pos, end, usecToString(SystemTime::getUsec()));
+		pos = appendData(pos, end, ",");
+		if (getrusage(RUSAGE_SELF, &usage) == -1) {
+			int e = errno;
+			throw SystemException("getrusage() failed", e);
+		}
+		pos = appendData(pos, end, timevalToString(usage.ru_utime));
+		pos = appendData(pos, end, ",");
+		pos = appendData(pos, end, timevalToString(usage.ru_stime));
+		pos = appendData(pos, end, ") ");
+
+		if (transaction != NULL) {
+			transaction->message(StaticString(message, pos - message));
+		}
+	}
+
+	ScopeLog(const TransactionPtr &_transaction,
+		const char *beginMessage,
+		const char *endMessage,
+		const char *abortMessage = NULL)
+		: transaction(_transaction.get())
+	{
+		if (_transaction != NULL) {
+			type = GRANULAR;
+			data.granular.endMessage = endMessage;
+			data.granular.abortMessage = abortMessage;
+			ok = abortMessage == NULL;
+			_transaction->message(beginMessage);
+		}
+	}
+
+	~ScopeLog() {
+		if (transaction == NULL) {
+			return;
+		}
+		if (type == NAME) {
+			char message[150];
+			char *pos = message;
+			const char *end = message + sizeof(message);
+			struct rusage usage;
+
+			if (ok) {
+				pos = appendData(pos, end, "END: ");
+			} else {
+				pos = appendData(pos, end, "FAIL: ");
+			}
+			pos = appendData(pos, end, data.name);
+			pos = appendData(pos, end, " (");
+			pos = appendData(pos, end, usecToString(SystemTime::getUsec()));
+			pos = appendData(pos, end, ",");
+			if (getrusage(RUSAGE_SELF, &usage) == -1) {
+				int e = errno;
+				throw SystemException("getrusage() failed", e);
+			}
+			pos = appendData(pos, end, timevalToString(usage.ru_utime));
+			pos = appendData(pos, end, ",");
+			pos = appendData(pos, end, timevalToString(usage.ru_stime));
+			pos = appendData(pos, end, ")");
+
+			transaction->message(StaticString(message, pos - message));
+		} else {
+			if (ok) {
+				transaction->message(data.granular.endMessage);
+			} else {
+				transaction->message(data.granular.abortMessage);
+			}
+		}
+	}
+
+	void success() {
+		ok = true;
+	}
+};
+
+
+} // namespace UnionStation
+} // namespace Passenger
+
+#endif /* _PASSENGER_UNION_STATION_SCOPE_LOG_H_ */

data/ext/common/UnionStation/Transaction.h

@@ -0,0 +1,276 @@
+/*
+ *  Phusion Passenger - https://www.phusionpassenger.com/
+ *  Copyright (c) 2010-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_UNION_STATION_TRANSACTION_H_
+#define _PASSENGER_UNION_STATION_TRANSACTION_H_
+
+#include <boost/shared_ptr.hpp>
+#include <boost/noncopyable.hpp>
+#include <oxt/backtrace.hpp>
+
+#include <string>
+#include <stdexcept>
+
+#include <cstdio>
+#include <cassert>
+
+#include <Logging.h>
+#include <Exceptions.h>
+#include <StaticString.h>
+#include <UnionStation/Connection.h>
+#include <Utils/IOUtils.h>
+#include <Utils/SystemTime.h>
+#include <Utils/StrIntUtils.h>
+
+namespace Passenger {
+namespace UnionStation {
+
+using namespace std;
+using namespace boost;
+
+
+enum ExceptionHandlingMode {
+	PRINT,
+	THROW,
+	IGNORE
+};
+
+
+class Core;
+typedef boost::shared_ptr<Core> CorePtr;
+
+inline void _checkinConnection(const CorePtr &core, const ConnectionPtr &connection);
+
+
+class Transaction: public boost::noncopyable {
+private:
+	static const int INT64_STR_BUFSIZE = 22; // Long enough for a 64-bit number.
+	static const unsigned long long IO_TIMEOUT = 5000000; // In microseconds.
+
+	const CorePtr core;
+	const ConnectionPtr connection;
+	const string txnId;
+	const string groupName;
+	const string category;
+	const string unionStationKey;
+	const ExceptionHandlingMode exceptionHandlingMode;
+	bool shouldFlushToDiskAfterClose;
+
+	/**
+	 * Buffer must be at least txnId.size() + 1 + INT64_STR_BUFSIZE + 1 bytes.
+	 */
+	char *insertTxnIdAndTimestamp(char *buffer, const char *end) {
+		assert(end - buffer >= int(txnId.size() + 1 + INT64_STR_BUFSIZE + 1));
+		int size;
+
+		// "txn-id-here"
+		buffer = appendData(buffer, end, txnId);
+
+		// "txn-id-here "
+		buffer = appendData(buffer, end, " ", 1);
+
+		// "txn-id-here 123456"
+		assert(end - buffer >= INT64_STR_BUFSIZE);
+		size = snprintf(buffer, INT64_STR_BUFSIZE, "%llu", SystemTime::getUsec());
+		if (size >= INT64_STR_BUFSIZE) {
+			// The buffer is too small.
+			throw IOException("Cannot format a new transaction log message timestamp.");
+		}
+		buffer += size;
+
+		// "txn-id-here 123456 "
+		buffer = appendData(buffer, end, " ", 1);
+
+		return buffer;
+	}
+
+	template<typename ExceptionType>
+	void handleException(const ExceptionType &e) {
+		switch (exceptionHandlingMode) {
+		case THROW:
+			throw e;
+		case PRINT: {
+				const tracable_exception *te =
+					dynamic_cast<const tracable_exception *>(&e);
+				if (te != NULL) {
+					P_WARN(te->what() << "\n" << te->backtrace());
+				} else {
+					P_WARN(e.what());
+				}
+				break;
+			}
+		default:
+			break;
+		}
+	}
+
+public:
+	Transaction()
+		: exceptionHandlingMode(PRINT)
+		{ }
+
+	Transaction(const CorePtr &_core,
+		const ConnectionPtr &_connection,
+		const string &_txnId,
+		const string &_groupName,
+		const string &_category,
+		const string &_unionStationKey,
+		ExceptionHandlingMode _exceptionHandlingMode = PRINT)
+		: core(_core),
+		  connection(_connection),
+		  txnId(_txnId),
+		  groupName(_groupName),
+		  category(_category),
+		  unionStationKey(_unionStationKey),
+		  exceptionHandlingMode(_exceptionHandlingMode),
+		  shouldFlushToDiskAfterClose(false)
+		{ }
+
+	~Transaction() {
+		TRACE_POINT();
+		if (connection == NULL) {
+			return;
+		}
+		ConnectionLock l(connection);
+		if (!connection->connected()) {
+			return;
+		}
+
+		char timestamp[2 * sizeof(unsigned long long) + 1];
+		integerToHexatri<unsigned long long>(SystemTime::getUsec(),
+			timestamp);
+
+		UPDATE_TRACE_POINT();
+		ConnectionGuard guard(connection.get());
+		try {
+			unsigned long long timeout = IO_TIMEOUT;
+			writeArrayMessage(connection->fd, &timeout,
+				"closeTransaction",
+				txnId.c_str(),
+				timestamp,
+				NULL);
+
+			if (shouldFlushToDiskAfterClose) {
+				UPDATE_TRACE_POINT();
+				timeout = IO_TIMEOUT;
+				writeArrayMessage(connection->fd, &timeout,
+					"flush", NULL);
+				readArrayMessage(connection->fd, &timeout);
+			}
+
+			_checkinConnection(core, connection);
+			guard.clear();
+		} catch (const SystemException &e) {
+			string errorResponse;
+
+			UPDATE_TRACE_POINT();
+			guard.clear();
+			if (connection->disconnect(errorResponse)) {
+				handleException(IOException(
+					"Logging agent disconnected with error: " +
+					errorResponse));
+			} else {
+				handleException(e);
+			}
+		}
+	}
+
+	void message(const StaticString &text) {
+		TRACE_POINT();
+		if (connection == NULL) {
+			P_TRACE(3, "[Union Station log to null] " << text);
+			return;
+		}
+		ConnectionLock l(connection);
+		if (!connection->connected()) {
+			P_TRACE(3, "[Union Station log to null] " << text);
+			return;
+		}
+
+		char timestamp[2 * sizeof(unsigned long long) + 1];
+		integerToHexatri<unsigned long long>(SystemTime::getUsec(), timestamp);
+
+		UPDATE_TRACE_POINT();
+		ConnectionGuard guard(connection.get());
+		try {
+			unsigned long long timeout = IO_TIMEOUT;
+			P_TRACE(3, "[Union Station log] " << txnId << " " << timestamp << " " << text);
+			writeArrayMessage(connection->fd, &timeout,
+				"log",
+				txnId.c_str(),
+				timestamp,
+				NULL);
+			writeScalarMessage(connection->fd, text, &timeout);
+			guard.clear();
+		} catch (const std::exception &e) {
+			string errorResponse;
+
+			UPDATE_TRACE_POINT();
+			guard.clear();
+			if (connection->disconnect(errorResponse)) {
+				handleException(IOException(
+					"Logging agent disconnected with error: " +
+					errorResponse));
+			} else {
+				handleException(e);
+			}
+		}
+	}
+
+	void abort(const StaticString &text) {
+		message("ABORT");
+	}
+
+	void flushToDiskAfterClose(bool value) {
+		shouldFlushToDiskAfterClose = value;
+	}
+
+	bool isNull() const {
+		return connection == NULL;
+	}
+
+	const string &getTxnId() const {
+		return txnId;
+	}
+
+	const string &getGroupName() const {
+		return groupName;
+	}
+
+	const string &getCategory() const {
+		return category;
+	}
+
+	const string &getUnionStationKey() const {
+		return unionStationKey;
+	}
+};
+
+typedef boost::shared_ptr<Transaction> TransactionPtr;
+
+
+} // namespace UnionStation
+} // namespace Passenger
+
+#endif /* _PASSENGER_UNION_STATION_TRANSACTION_H_ */

data/ext/common/Utils.cpp

@@ -55,6 +55,7 @@
 #include <Utils/Base64.h>
 #include <Utils/CachedFileStat.hpp>
 #include <Utils/StrIntUtils.h>
+#include <Utils/IOUtils.h>
 #include <Utils/HttpHeaderBufferer.h>
 
 #ifndef HOST_NAME_MAX
@@ -338,8 +339,8 @@ extractBaseName(const StaticString &path) {
 }
 
 string
-escapeForXml(const string &input) {
-	string result(input);
+escapeForXml(const StaticString &input) {
+	string result(input.data(), input.size());
 	string::size_type input_pos = 0;
 	string::size_type input_end_pos = input.size();
 	string::size_type result_pos = 0;
@@ -994,6 +995,74 @@ runShellCommand(const StaticString &command) {
 	}
 }
 
+string
+runCommandAndCaptureOutput(const char **command) {
+	pid_t pid;
+	int e;
+	Pipe p;
+	
+	p = createPipe();
+	
+	this_thread::disable_syscall_interruption dsi;
+	pid = syscalls::fork();
+	if (pid == 0) {
+		// Make ps nicer, we want to have as little impact on the rest
+		// of the system as possible while collecting the metrics.
+		int prio = getpriority(PRIO_PROCESS, getpid());
+		prio++;
+		if (prio > 20) {
+			prio = 20;
+		}
+		setpriority(PRIO_PROCESS, getpid(), prio);
+
+		dup2(p[1], 1);
+		close(p[0]);
+		close(p[1]);
+		closeAllFileDescriptors(2);
+		execvp(command[0], (char * const *) command);
+		_exit(1);
+	} else if (pid == -1) {
+		e = errno;
+		throw SystemException("Cannot fork() a new process", e);
+	} else {
+		bool done = false;
+		string result;
+		
+		p[1].close();
+		while (!done) {
+			char buf[1024 * 4];
+			ssize_t ret;
+			
+			try {
+				this_thread::restore_syscall_interruption rsi(dsi);
+				ret = syscalls::read(p[0], buf, sizeof(buf));
+			} catch (const thread_interrupted &) {
+				syscalls::kill(SIGKILL, pid);
+				syscalls::waitpid(pid, NULL, 0);
+				throw;
+			}
+			if (ret == -1) {
+				e = errno;
+				syscalls::kill(SIGKILL, pid);
+				syscalls::waitpid(pid, NULL, 0);
+				throw SystemException(string("Cannot read output from the '") +
+					command[1] + "' command", e);
+			}
+			done = ret == 0;
+			result.append(buf, ret);
+		}
+		p[0].close();
+		syscalls::waitpid(pid, NULL, 0);
+		
+		if (result.empty()) {
+			throw RuntimeException(string("The '") + command[1] +
+				"' command failed");
+		} else {
+			return result;
+		}
+	}
+}
+
 #ifdef __APPLE__
 	// http://www.opensource.apple.com/source/Libc/Libc-825.26/sys/fork.c
 	// This bypasses atfork handlers.
@@ -1054,7 +1123,7 @@ getFileDescriptorLimit() {
 // descriptor that the process is currently using.
 // See also http://stackoverflow.com/questions/899038/getting-the-highest-allocated-file-descriptor
 static int
-getHighestFileDescriptor() {
+getHighestFileDescriptor(bool asyncSignalSafe) {
 #if defined(F_MAXFD)
 	int ret;
 	
@@ -1099,9 +1168,15 @@ getHighestFileDescriptor() {
 		goto done;
 	}
 	
-	do {
-		pid = asyncFork();
-	} while (pid == -1 && errno == EINTR);
+	if (asyncSignalSafe) {
+		do {
+			pid = asyncFork();
+		} while (pid == -1 && errno == EINTR);
+	} else {
+		do {
+			pid = fork();
+		} while (pid == -1 && errno == EINTR);
+	}
 	
 	if (pid == 0) {
 		// Don't close p[0] here or it might affect the result.
@@ -1243,7 +1318,7 @@ done:
 }
 
 void
-closeAllFileDescriptors(int lastToKeepOpen) {
+closeAllFileDescriptors(int lastToKeepOpen, bool asyncSignalSafe) {
 	#if defined(F_CLOSEM)
 		int ret;
 		do {
@@ -1257,7 +1332,7 @@ closeAllFileDescriptors(int lastToKeepOpen) {
 		return;
 	#endif
 	
-	for (int i = getHighestFileDescriptor(); i > lastToKeepOpen; i--) {
+	for (int i = getHighestFileDescriptor(asyncSignalSafe); i > lastToKeepOpen; i--) {
 		/* Even though we normally shouldn't retry on EINTR
 		 * (http://news.ycombinator.com/item?id=3363819)
 		 * it's okay to do that here because because this function