passenger 4.0.42 → 4.0.43

data/ext/common/ApplicationPool2/SmartSpawner.h

@@ -65,10 +65,6 @@ private:
 		BufferedIO io;
 	};
 
-	/** The event loop that created Process objects should use, and that I/O forwarding
-	 * functions should use. For example data on the error pipe is forwarded using this event loop.
-	 */
-	SafeLibevPtr libev;
 	const vector<string> preloaderCommand;
 	map<string, string> preloaderAnnotations;
 	Options options;
@@ -703,14 +699,12 @@ protected:
 	}
 
 public:
-	SmartSpawner(const SafeLibevPtr &_libev,
-		const ResourceLocator &_resourceLocator,
+	SmartSpawner(const ResourceLocator &_resourceLocator,
 		const ServerInstanceDir::GenerationPtr &_generation,
 		const vector<string> &_preloaderCommand,
 		const Options &_options,
 		const SpawnerConfigPtr &_config = SpawnerConfigPtr())
 		: Spawner(_resourceLocator),
-		  libev(_libev),
 		  preloaderCommand(_preloaderCommand)
 	{
 		if (preloaderCommand.size() < 2) {
@@ -718,7 +712,7 @@ public:
 		}
 		
 		generation = _generation;
-		options    = _options.copyAndPersist().clearLogger();
+		options    = _options.copyAndPersist().detachFromUnionStationTransaction();
 		pid        = -1;
 		m_lastUsed = SystemTime::getUsec();
 
@@ -768,7 +762,6 @@ public:
 		UPDATE_TRACE_POINT();
 		NegotiationDetails details;
 		details.preparation = &preparation;
-		details.libev = libev;
 		details.pid = result.pid;
 		details.adminSocket = result.adminSocket;
 		details.io = result.io;

data/ext/common/ApplicationPool2/Spawner.h

@@ -77,7 +77,6 @@
 #include <ApplicationPool2/Options.h>
 #include <ApplicationPool2/PipeWatcher.h>
 #include <FileDescriptor.h>
-#include <SafeLibev.h>
 #include <Exceptions.h>
 #include <ResourceLocator.h>
 #include <StaticString.h>
@@ -334,8 +333,6 @@ protected:
 		 * by security validators to check whether the information sent back by the
 		 * process make any sense. */
 		SpawnPreparationInfo *preparation;
-		/** The SafeLibev that the returned Process should be initialized with. */
-		SafeLibevPtr libev;
 		/** This object captures the process's stderr while negotiation is in progress.
 		 * (Recall that negotiation is performed over the process's stdout while stderr
 		 * is used purely for outputting messages.)
@@ -530,7 +527,7 @@ private:
 		}
 		
 		ProcessPtr process = boost::make_shared<Process>(
-			details.libev, details.pid,
+			details.pid,
 			details.gupid, details.connectPassword,
 			details.adminSocket, details.errorPipe,
 			sockets, creationTime, details.spawnStartTime,

data/ext/common/ApplicationPool2/SpawnerFactory.h

@@ -40,7 +40,6 @@ using namespace oxt;
 
 class SpawnerFactory {
 private:
-	SafeLibevPtr libev;
 	ResourceLocator resourceLocator;
 	ServerInstanceDir::GenerationPtr generation;
 	RandomGeneratorPtr randomGenerator;
@@ -60,17 +59,15 @@ private:
 		} else {
 			return SpawnerPtr();
 		}
-		return boost::make_shared<SmartSpawner>(libev, resourceLocator,
+		return boost::make_shared<SmartSpawner>(resourceLocator,
 			generation, preloaderCommand, options, config);
 	}
 	
 public:
-	SpawnerFactory(const SafeLibevPtr &_libev,
-		const ResourceLocator &_resourceLocator,
+	SpawnerFactory(const ResourceLocator &_resourceLocator,
 		const ServerInstanceDir::GenerationPtr &_generation,
 		const SpawnerConfigPtr &_config = SpawnerConfigPtr())
-		: libev(_libev),
-		  resourceLocator(_resourceLocator),
+		: resourceLocator(_resourceLocator),
 		  generation(_generation)
 	{
 		if (_config == NULL) {
@@ -86,13 +83,13 @@ public:
 		if (options.spawnMethod == "smart" || options.spawnMethod == "smart-lv2") {
 			SpawnerPtr spawner = tryCreateSmartSpawner(options);
 			if (spawner == NULL) {
-				spawner = boost::make_shared<DirectSpawner>(libev,
-					resourceLocator, generation, config);
+				spawner = boost::make_shared<DirectSpawner>(resourceLocator,
+					generation, config);
 			}
 			return spawner;
 		} else if (options.spawnMethod == "direct" || options.spawnMethod == "conservative") {
 			boost::shared_ptr<DirectSpawner> spawner = boost::make_shared<DirectSpawner>(
-				libev, resourceLocator, generation, config);
+				resourceLocator, generation, config);
 			return spawner;
 		} else if (options.spawnMethod == "dummy") {
 			syscalls::usleep(config->spawnerCreationSleepTime);

data/ext/common/ApplicationPool2/SuperGroup.h

@@ -420,7 +420,7 @@ public:
 	SuperGroup(const PoolPtr &_pool, const Options &options)
 		: pool(_pool)
 	{
-		this->options = options.copyAndPersist().clearLogger();
+		this->options = options.copyAndPersist().detachFromUnionStationTransaction();
 		this->name = options.getAppGroupName();
 		secret = generateSecret();
 		state = INITIALIZING;
@@ -605,7 +605,7 @@ public:
 				boost::bind(
 					doInitialize,
 					shared_from_this(),
-					newOptions.copyAndPersist().clearLogger(),
+					newOptions.copyAndPersist().detachFromUnionStationTransaction(),
 					generation),
 				"SuperGroup initializer: " + name,
 				POOL_HELPER_THREAD_STACK_SIZE);
@@ -656,7 +656,7 @@ public:
 					doRestart,
 					// Keep reference to self to prevent destruction.
 					shared_from_this(),
-					options.copyAndPersist().clearLogger(),
+					options.copyAndPersist().detachFromUnionStationTransaction(),
 					generation),
 				"SuperGroup restarter: " + name,
 				POOL_HELPER_THREAD_STACK_SIZE);

data/ext/common/Constants.h

@@ -88,7 +88,7 @@
 
 	#define NGINX_DOC_URL "http://www.modrails.com/documentation/Users%20guide%20Nginx.html"
 
-	#define PASSENGER_VERSION "4.0.42"
+	#define PASSENGER_VERSION "4.0.43"
 
 	#define POOL_HELPER_THREAD_STACK_SIZE 262144
 

data/ext/common/UnionStation/Connection.h

@@ -0,0 +1,227 @@
+/*
+ *  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_CONNECTION_H_
+#define _PASSENGER_UNION_STATION_CONNECTION_H_
+
+#include <boost/thread.hpp>
+#include <boost/shared_ptr.hpp>
+#include <boost/noncopyable.hpp>
+#include <oxt/system_calls.hpp>
+#include <oxt/backtrace.hpp>
+
+#include <string>
+#include <vector>
+
+#include <errno.h>
+
+#include <Exceptions.h>
+#include <Utils/IOUtils.h>
+#include <Utils/MessageIO.h>
+
+namespace Passenger {
+namespace UnionStation {
+
+using namespace std;
+using namespace boost;
+
+
+struct Connection;
+typedef boost::shared_ptr<Connection> ConnectionPtr;
+
+inline void _disconnectConnection(Connection *connection);
+
+
+/**
+ * A scope guard which closes the given Connection on destruction unless cleared.
+ * Note that this class does not hold a shared_ptr to the Connection object,
+ * so make sure that the Connection outlives the guard object.
+ */
+class ConnectionGuard: public boost::noncopyable {
+private:
+	Connection * const connection;
+	bool cleared;
+
+public:
+	ConnectionGuard(Connection *_connection)
+		: connection(_connection),
+		  cleared(false)
+		{ }
+
+	~ConnectionGuard() {
+		if (!cleared) {
+			_disconnectConnection(connection);
+		}
+	}
+
+	void clear() {
+		cleared = true;
+	}
+};
+
+
+/**
+ * Represents a connection to the logging server.
+ * All access to the file descriptor must be synchronized through the syncher.
+ * You can use the ConnectionLock to do that.
+ */
+struct Connection: public boost::noncopyable {
+	mutable boost::mutex syncher;
+	int fd;
+
+	Connection(int _fd)
+		: fd(_fd)
+		{ }
+
+	~Connection() {
+		disconnect();
+	}
+
+	bool connected() const {
+		return fd != -1;
+	}
+
+	/**
+	 * Disconnect from the server. If the server sent an error response
+	 * right before closing the connection, try to read it and return it
+	 * through `errorResponse`. Returns whether an error response was read.
+	 *
+	 * Reading the error response might result in an exception, e.g.
+	 * because of networking and protocol exceptions. In such an event,
+	 * the connection is still guaranteed to be disconnected.
+	 */
+	bool disconnect(string &errorResponse) {
+		if (!connected()) {
+			return false;
+		}
+
+		ConnectionGuard guard(this);
+
+		/* The server might send an "error" array message
+		 * just before disconnecting. Try to read it.
+		 */
+		TRACE_POINT();
+		vector<string> response;
+		try {
+			unsigned long long timeout = 20000000;
+			while (true) {
+				response = readArrayMessage(fd, &timeout);
+			}
+		} catch (const TimeoutException &) {
+			/* This means that the last message isn't an array
+			 * message or that the server didn't send it quickly
+			 * enough. In any case, discard whatever previous
+			 * array messages we were able to read because they're
+			 * guaranteed not to be the error message we're expecting.
+			 */
+			response.clear();
+		} catch (const SystemException &e) {
+			/* We treat ECONNRESET the same as EOFException.
+			 * Other errors are treated as TimeoutException.
+			 */
+			if (e.code() != ECONNRESET) {
+				response.clear();
+			}
+		} catch (const EOFException &) {
+			/* Do nothing. We've successfully read the last array message. */
+		}
+
+		UPDATE_TRACE_POINT();
+		if (response.size() == 2 && response[0] == "error") {
+			errorResponse = response[1];
+			return true;
+		} else {
+			return false;
+		}
+	}
+
+	/** Disconnect from the server, ignoring any error responses the
+	 * server might have sent.
+	 */
+	void disconnect() {
+		if (fd != -1) {
+			this_thread::disable_interruption di;
+			this_thread::disable_syscall_interruption dsi;
+			safelyClose(fd);
+			fd = -1;
+		}
+	}
+};
+
+typedef boost::shared_ptr<Connection> ConnectionPtr;
+
+
+/**
+ * A special lock type for Connection that also keeps a smart
+ * pointer to the data structure so that the mutex is not destroyed
+ * prematurely.
+ */
+struct ConnectionLock: public boost::noncopyable {
+	ConnectionPtr connection;
+	bool locked;
+
+	ConnectionLock(const ConnectionPtr &c)
+		: connection(c)
+	{
+		c->syncher.lock();
+		locked = true;
+	}
+
+	~ConnectionLock() {
+		if (locked) {
+			connection->syncher.unlock();
+		}
+	}
+
+	void reset(const ConnectionPtr &c, bool lockNow = true) {
+		if (locked) {
+			connection->syncher.unlock();
+		}
+		connection = c;
+		if (lockNow) {
+			connection->syncher.lock();
+			locked = true;
+		} else {
+			locked = false;
+		}
+	}
+
+	void lock() {
+		assert(!locked);
+		connection->syncher.lock();
+		locked = true;
+	}
+};
+
+
+inline void
+_disconnectConnection(Connection *connection) {
+	connection->disconnect();
+}
+
+
+} // namespace UnionStation
+} // namespace Passenger
+
+#endif /* _PASSENGER_UNION_STATION_CONNECTION_H_ */

data/ext/common/UnionStation/Core.h

@@ -0,0 +1,497 @@
+/*
+ *  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_CORE_H_
+#define _PASSENGER_UNION_STATION_CORE_H_
+
+#include <boost/shared_ptr.hpp>
+#include <boost/enable_shared_from_this.hpp>
+#include <boost/thread.hpp>
+#include <oxt/backtrace.hpp>
+
+#include <errno.h>
+
+#include <string>
+#include <vector>
+#include <stdexcept>
+
+#include <Logging.h>
+#include <Exceptions.h>
+#include <RandomGenerator.h>
+#include <StaticString.h>
+#include <UnionStation/Connection.h>
+#include <UnionStation/Transaction.h>
+#include <Utils.h>
+#include <Utils/MessageIO.h>
+#include <Utils/SystemTime.h>
+
+namespace Passenger {
+namespace UnionStation {
+
+using namespace std;
+using namespace boost;
+
+
+class Core: public boost::enable_shared_from_this<Core> {
+private:
+	static const unsigned int CONNECTION_POOL_MAX_SIZE = 10;
+	static const unsigned int TXN_ID_MAX_SIZE =
+		2 * sizeof(unsigned int) +    // max hex timestamp size
+		11 +                          // space for a random identifier
+		1;                            // null terminator
+
+	/**** Server information ****/
+	const string serverAddress;
+	const string username;
+	const string password;
+	const string nodeName;
+
+	/**** Working objects ****/
+	RandomGenerator randomGenerator;
+	TransactionPtr nullTransaction;
+
+	/********************** Connection handling fields **********************
+	 * These fields are synchronized through the mutex. The contents
+	 * of the conntection objects are not synchronized through this mutex,
+	 * but through the Connection object's own mutex.
+	 ************************************************************************/
+	mutable boost::mutex syncher;
+	vector<ConnectionPtr> connectionPool;
+	/** How long to wait before reconnecting. */
+	unsigned long long reconnectTimeout;
+	/** Earliest time at which we should attempt a reconnect. Earlier attempts
+	 * will fail. Calculated from reconnectTimeout.
+	 */
+	unsigned long long nextReconnectTime;
+
+	static string determineNodeName(const string &givenNodeName) {
+		if (givenNodeName.empty()) {
+			return getHostName();
+		} else {
+			return givenNodeName;
+		}
+	}
+
+	static bool isNetworkError(int code) {
+		return code == EPIPE || code == ECONNREFUSED || code == ECONNRESET
+			|| code == EHOSTUNREACH || code == ENETDOWN || code == ENETUNREACH
+			|| code == ETIMEDOUT;
+	}
+
+	template<typename T>
+	static bool instanceof(const std::exception &e) {
+		return dynamic_cast<const T *>(&e) != NULL;
+	}
+
+	void initialize() {
+		nullTransaction   = boost::make_shared<Transaction>();
+		reconnectTimeout  = 1000000;
+		nextReconnectTime = 0;
+	}
+
+	/** Creates a transaction ID string. `txnId` MUST be at least TXN_ID_MAX_SIZE bytes. */
+	void createTxnId(char *txnId, char **txnIdEnd, unsigned long long timestamp) {
+		unsigned int timestampSize;
+		char *end;
+
+		// "[timestamp]"
+		// Our timestamp is like a Unix timestamp but with minutes
+		// resolution instead of seconds. 32 bits will last us for
+		// about 8000 years.
+		timestampSize = integerToHexatri<unsigned int>(
+			timestamp / 1000000 / 60,
+			txnId);
+		end = txnId + timestampSize;
+
+		// "[timestamp]-"
+		*end = '-';
+		end++;
+
+		// "[timestamp]-[random id]"
+		randomGenerator.generateAsciiString(end, 11);
+		end += 11;
+		*end = '\0';
+		*txnIdEnd = end;
+	}
+
+	ConnectionPtr createNewConnection() {
+		TRACE_POINT();
+		int fd;
+		vector<string> args;
+		unsigned long long timeout = 15000000;
+
+		// Create socket.
+		fd = connectToServer(serverAddress);
+		FdGuard guard(fd, true);
+		
+		// Handshake: process protocol version number.
+		if (!readArrayMessage(fd, args, &timeout)) {
+			throw IOException("The logging agent closed the connection before sending a version identifier.");
+		}
+		if (args.size() != 2 || args[0] != "version") {
+			throw IOException("The logging agent server didn't sent a valid version identifier.");
+		}
+		if (args[1] != "1") {
+			string message = "Unsupported logging agent protocol version " +
+				args[1] + ".";
+			throw IOException(message);
+		}
+
+		// Handshake: authenticate.
+		UPDATE_TRACE_POINT();
+		writeScalarMessage(fd, username, &timeout);
+		writeScalarMessage(fd, password, &timeout);
+
+		UPDATE_TRACE_POINT();
+		if (!readArrayMessage(fd, args, &timeout)) {
+			throw IOException("The logging agent did not send an authentication response.");
+		} else if (args.size() != 1) {
+			throw IOException("The authentication response that the logging agent sent is not valid.");
+		} else if (args[0] != "ok") {
+			throw SecurityException("The logging agent server denied authentication: " + args[0]);
+		}
+
+		// Initialize session.
+		UPDATE_TRACE_POINT();
+		writeArrayMessage(fd, &timeout, "init", nodeName.c_str(), NULL);
+		if (!readArrayMessage(fd, args, &timeout)) {
+			throw SystemException("Cannot connect to logging server", ECONNREFUSED);
+		} else if (args.size() != 1) {
+			throw IOException("Logging server returned an invalid reply for the 'init' command");
+		} else if (args[0] == "server shutting down") {
+			throw SystemException("Cannot connect to server", ECONNREFUSED);
+		} else if (args[0] != "ok") {
+			throw IOException("Logging server returned an invalid reply for the 'init' command");
+		}
+
+		ConnectionPtr connection = boost::make_shared<Connection>(fd);
+		guard.clear();
+		return connection;
+	}
+
+public:
+	Core() {
+		initialize();
+	}
+
+	Core(const string &_serverAddress, const string &_username,
+	     const string &_password, const string &_nodeName = string())
+		: serverAddress(_serverAddress),
+		  username(_username),
+		  password(_password),
+		  nodeName(determineNodeName(_nodeName))
+	{
+		initialize();
+	}
+
+
+	/***** Connection pool methods *****/
+
+	ConnectionPtr checkoutConnection() {
+		TRACE_POINT();
+		boost::unique_lock<boost::mutex> l(syncher);
+		if (!connectionPool.empty()) {
+			P_TRACE(3, "Checked out existing connection");
+			ConnectionPtr connection = connectionPool.back();
+			connectionPool.pop_back();
+			return connection;
+
+		} else {
+			if (SystemTime::getUsec() < nextReconnectTime) {
+				P_TRACE(3, "Not yet time to reconnect; returning NULL connection");
+				return ConnectionPtr();
+			}
+
+			l.unlock();
+			P_TRACE(3, "Creating new connection with logging agent");
+			ConnectionPtr connection;
+			try {
+				connection = createNewConnection();
+			} catch (const TimeoutException &) {
+				l.lock();
+				P_WARN("Timeout trying to connect to the logging agent at " << serverAddress << "; " <<
+					"will reconnect in " << reconnectTimeout / 1000000 << " second(s).");
+				nextReconnectTime = SystemTime::getUsec() + reconnectTimeout;
+				return ConnectionPtr();
+			} catch (const tracable_exception &e) {
+				l.lock();
+				nextReconnectTime = SystemTime::getUsec() + reconnectTimeout;
+				if (instanceof<IOException>(e) || instanceof<SystemException>(e)) {
+					P_WARN("Cannot connect to the logging agent at " << serverAddress <<
+						" (" << e.what() << "); will reconnect in " <<
+						reconnectTimeout / 1000000 << " second(s).");
+					return ConnectionPtr();
+				} else {
+					throw;
+				}
+			}
+
+			return connection;
+		}
+	}
+
+	void checkinConnection(const ConnectionPtr &connection) {
+		boost::unique_lock<boost::mutex> l(syncher);
+		if (connectionPool.size() < CONNECTION_POOL_MAX_SIZE) {
+			connectionPool.push_back(connection);
+		} else {
+			l.unlock();
+			connection->disconnect();
+		}
+	}
+
+
+	/***** Transaction methods *****/
+
+	TransactionPtr createNullTransaction() const {
+		return nullTransaction;
+	}
+
+	bool sendRequest(const ConnectionPtr &connection, StaticString args[],
+		unsigned int nargs, bool expectAck)
+	{
+		ConnectionLock cl(connection);
+		ConnectionGuard guard(connection.get());
+
+		try {
+			unsigned long long timeout = 15000000;
+
+			writeArrayMessage(connection->fd, args, nargs, &timeout);
+
+			if (expectAck) {
+				vector<string> args;
+				if (!readArrayMessage(connection->fd, args, &timeout)) {
+					boost::lock_guard<boost::mutex> l(syncher);
+					P_WARN("The logging agent at " << serverAddress <<
+						" closed the connection (no error message given);" <<
+						" will reconnect in " << reconnectTimeout / 1000000 <<
+						" second(s).");
+					nextReconnectTime = SystemTime::getUsec() + reconnectTimeout;
+					return false;
+				} else if (args.size() == 2 && args[0] == "error") {
+					boost::lock_guard<boost::mutex> l(syncher);
+					P_WARN("The logging agent at " << serverAddress <<
+						" closed the connection (error message: " << args[1] <<
+						"); will reconnect in " << reconnectTimeout / 1000000 <<
+						" second(s).");
+					nextReconnectTime = SystemTime::getUsec() + reconnectTimeout;
+					return false;
+				} else if (args.empty() || args[0] != "ok") {
+					boost::lock_guard<boost::mutex> l(syncher);
+					P_WARN("The logging agent at " << serverAddress <<
+						" sent an unexpected reply;" <<
+						" will reconnect in " << reconnectTimeout / 1000000 <<
+						" second(s).");
+					nextReconnectTime = SystemTime::getUsec() + reconnectTimeout;
+					return false;
+				}
+			}
+
+			guard.clear();
+			return true;
+
+		} catch (const TimeoutException &) {
+			boost::lock_guard<boost::mutex> l(syncher);
+			P_WARN("Timeout trying to communicate with the logging agent at " << serverAddress << "; " <<
+				"will reconnect in " << reconnectTimeout / 1000000 << " second(s).");
+			nextReconnectTime = SystemTime::getUsec() + reconnectTimeout;
+			return false;
+
+		} catch (const SystemException &e) {
+			if (e.code() == ENOENT || isNetworkError(e.code())) {
+				string errorResponse;
+				bool gotErrorResponse;
+
+				guard.clear();
+				gotErrorResponse = connection->disconnect(errorResponse);
+				boost::lock_guard<boost::mutex> l(syncher);
+				if (gotErrorResponse) {
+					P_WARN("The logging agent at " << serverAddress <<
+						" closed the connection (error message: " << errorResponse <<
+						"); will reconnect in " << reconnectTimeout / 1000000 <<
+						" second(s).");
+				} else {
+					P_WARN("The logging agent at " << serverAddress <<
+						" closed the connection (no error message given);" <<
+						" will reconnect in " << reconnectTimeout / 1000000 <<
+						" second(s).");
+				}
+				nextReconnectTime = SystemTime::getUsec() + reconnectTimeout;
+				return false;
+			} else {
+				throw;
+			}
+		}
+	}
+
+	TransactionPtr newTransaction(const string &groupName,
+		const string &category = "requests",
+		const string &unionStationKey = "-",
+		const string &filters = string())
+	{
+		if (isNull()) {
+			return createNullTransaction();
+		}
+
+		// Prepare parameters.
+		unsigned long long timestamp = SystemTime::getUsec();
+		char txnId[TXN_ID_MAX_SIZE], *txnIdEnd;
+		char timestampStr[2 * sizeof(unsigned long long) + 1];
+
+		createTxnId(txnId, &txnIdEnd, timestamp);
+		integerToHexatri<unsigned long long>(timestamp, timestampStr);
+
+		StaticString params[] = {
+			StaticString("openTransaction", sizeof("openTransaction") - 1),
+			StaticString(txnId, txnIdEnd - txnId),
+			groupName,
+			// empty nodeName, implies using the default
+			// nodeName passed during initialization
+			StaticString(),
+			category,
+			timestampStr,
+			unionStationKey,
+			StaticString("true", 4), // crashProtect
+			StaticString("true", 4), // ack
+			filters
+		};
+		unsigned int nparams = sizeof(params) / sizeof(StaticString);
+
+		// Get a connection to the logging server.
+		ConnectionPtr connection = checkoutConnection();
+		if (connection == NULL) {
+			return createNullTransaction();
+		}
+
+		// Send request, process reply.
+		if (sendRequest(connection, params, nparams, true)) {
+			ConnectionGuard guard(connection.get());
+			TransactionPtr transaction = boost::make_shared<Transaction>(
+				shared_from_this(),
+				connection,
+				string(txnId, txnIdEnd - txnId),
+				groupName,
+				category,
+				unionStationKey);
+			guard.clear();
+			return transaction;
+		} else {
+			return createNullTransaction();
+		}
+	}
+
+	TransactionPtr continueTransaction(const string &txnId,
+		const string &groupName,
+		const string &category = "requests",
+		const string &unionStationKey = "-")
+	{
+		if (isNull() || txnId.empty()) {
+			return createNullTransaction();
+		}
+
+		// Prepare parameters.
+		char timestampStr[2 * sizeof(unsigned long long) + 1];
+		integerToHexatri<unsigned long long>(SystemTime::getUsec(), timestampStr);
+
+		StaticString params[] = {
+			StaticString("openTransaction", sizeof("openTransaction") - 1),
+			txnId,
+			groupName,
+			// empty nodeName, implies using the default
+			// nodeName passed during initialization
+			StaticString(),
+			category,
+			timestampStr,
+			unionStationKey,
+			StaticString("true", 4),  // crashProtect
+			StaticString("false", 4)  // ack
+		};
+		unsigned int nparams = sizeof(params) / sizeof(StaticString);
+
+		// Get a connection to the logging server.
+		ConnectionPtr connection = checkoutConnection();
+		if (connection == NULL) {
+			return createNullTransaction();
+		}
+
+		// Send request.
+		if (sendRequest(connection, params, nparams, false)) {
+			ConnectionGuard guard(connection.get());
+			TransactionPtr transaction = boost::make_shared<Transaction>(
+				shared_from_this(),
+				connection,
+				txnId,
+				groupName,
+				category,
+				unionStationKey);
+			guard.clear();
+			return transaction;
+		} else {
+			return createNullTransaction();
+		}
+	}
+
+
+	/***** Parameter getters and setters *****/
+
+	void setReconnectTimeout(unsigned long long usec) {
+		boost::lock_guard<boost::mutex> l(syncher);
+		reconnectTimeout = usec;
+	}
+
+	bool isNull() const {
+		return serverAddress.empty();
+	}
+
+	const string &getAddress() const {
+		return serverAddress;
+	}
+
+	const string &getUsername() const {
+		return username;
+	}
+
+	const string &getPassword() const {
+		return password;
+	}
+
+	/**
+	 * @post !result.empty()
+	 */
+	const string &getNodeName() const {
+		return nodeName;
+	}
+};
+
+
+inline void
+_checkinConnection(const CorePtr &core, const ConnectionPtr &connection) {
+	core->checkinConnection(connection);
+}
+
+
+} // namespace UnionStation
+} // namespace Passenger
+
+#endif /* _PASSENGER_UNION_STATION_CORE_H_ */