passenger 2.2.15 → 3.0.0.pre1

data/ext/common/LoggingAgent/Main.cpp

@@ -0,0 +1,278 @@
+/*
+ *  Phusion Passenger - http://www.modrails.com/
+ *  Copyright (c) 2010 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.
+ */
+#include <oxt/system_calls.hpp>
+#include <oxt/backtrace.hpp>
+#include <oxt/thread.hpp>
+
+#include <sys/types.h>
+#include <unistd.h>
+#include <pwd.h>
+#include <grp.h>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#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/Base64.h"
+#include "../Utils/VariantMap.h"
+
+using namespace oxt;
+using namespace Passenger;
+
+
+static struct ev_loop *eventLoop;
+static LoggingServer *loggingServer;
+
+static struct ev_loop *
+createEventLoop() {
+	struct ev_loop *loop;
+	
+	// libev doesn't like choosing epoll and kqueue because the author thinks they're broken,
+	// so let's try to force it.
+	loop = ev_default_loop(EVBACKEND_EPOLL);
+	if (loop == NULL) {
+		loop = ev_default_loop(EVBACKEND_KQUEUE);
+	}
+	if (loop == NULL) {
+		loop = ev_default_loop(0);
+	}
+	if (loop == NULL) {
+		throw RuntimeException("Cannot create an event loop");
+	} else {
+		return loop;
+	}
+}
+
+static void
+lowerPrivilege(const string &username, const struct passwd *user, const struct group *group) {
+	int e;
+	
+	if (initgroups(username.c_str(), group->gr_gid) != 0) {
+		e = errno;
+		P_WARN("WARNING: Unable to set supplementary groups for " <<
+			"PassengerLoggingAgent: " << strerror(e) << " (" << e << ")");
+	}
+	if (setgid(group->gr_gid) != 0) {
+		e = errno;
+		P_WARN("WARNING: Unable to lower PassengerLoggingAgent's "
+			"privilege to that of user '" << username <<
+			"': cannot set group ID to " << group->gr_gid <<
+			": " << strerror(e) <<
+			" (" << e << ")");
+	}
+	if (setuid(user->pw_uid) != 0) {
+		e = errno;
+		P_WARN("WARNING: Unable to lower PassengerLoggingAgent's "
+			"privilege to that of user '" << username <<
+			"': cannot set user ID: " << strerror(e) <<
+			" (" << e << ")");
+	}
+}
+
+void
+feedbackFdBecameReadable(ev::io &watcher, int revents) {
+	/* This event indicates that the watchdog has been killed.
+	 * In this case we'll kill all descendant
+	 * processes and exit. There's no point in keeping this agent
+	 * running because we can't detect when the web server exits,
+	 * and because this agent doesn't own the server instance
+	 * directory. As soon as passenger-status is run, the server
+	 * instance directory will be cleaned up, making this agent's
+	 * services inaccessible.
+	 */
+	syscalls::killpg(getpgrp(), SIGKILL);
+	_exit(2); // In case killpg() fails.
+}
+
+void
+caughtExitSignal(ev::sig &watcher, int revents) {
+	P_DEBUG("Caught signal, exiting...");
+	ev_unloop(eventLoop, EVUNLOOP_ONE);
+}
+
+void
+printInfo(ev::sig &watcher, int revents) {
+	loggingServer->dump(cout);
+	cout.flush();
+}
+
+static string
+myself() {
+	struct passwd *entry = getpwuid(geteuid());
+	if (entry != NULL) {
+		return entry->pw_name;
+	} else {
+		throw NonExistentUserException(string("The current user, UID ") +
+			toString(geteuid()) + ", doesn't have a corresponding " +
+			"entry in the system's user database. Please fix your " +
+			"system's user database first.");
+	}
+}
+
+int
+main(int argc, char *argv[]) {
+	VariantMap options        = initializeAgent(argc, argv, "PassengerLoggingAgent");
+	string socketAddress      = options.get("logging_agent_address");
+	string loggingDir         = options.get("analytics_log_dir");
+	string password           = options.get("logging_agent_password");
+	string username           = options.get("analytics_log_user",
+		false, myself());
+	string groupname          = options.get("analytics_log_group", false);
+	string permissions        = options.get("analytics_log_permissions",
+		false, DEFAULT_ANALYTICS_LOG_PERMISSIONS);
+	string unionStationGatewayAddress = options.get("union_station_gateway_address",
+		false, DEFAULT_UNION_STATION_GATEWAY_ADDRESS);
+	int    unionStationGatewayPort = options.getInt("union_station_gateway_port",
+		false, DEFAULT_UNION_STATION_GATEWAY_PORT);
+	string unionStationGatewayCert = options.get("union_station_gateway_cert", false);
+	
+	curl_global_init(CURL_GLOBAL_ALL);
+	
+	try {
+		/********** Now begins the real initialization **********/
+		
+		/* Create all the necessary objects and sockets... */
+		AccountsDatabasePtr  accountsDatabase;
+		FileDescriptor       serverSocketFd;
+		struct passwd       *user;
+		struct group        *group;
+		int                  ret;
+		
+		eventLoop = createEventLoop();
+		accountsDatabase = ptr(new AccountsDatabase());
+		serverSocketFd = createServer(socketAddress.c_str());
+		if (getSocketAddressType(socketAddress) == SAT_UNIX) {
+			do {
+				ret = chmod(parseUnixSocketAddress(socketAddress).c_str(),
+					S_ISVTX |
+					S_IRUSR | S_IWUSR | S_IXUSR |
+					S_IRGRP | S_IWGRP | S_IXGRP |
+					S_IROTH | S_IWOTH | S_IXOTH);
+			} while (ret == -1 && errno == EINTR);
+		}
+		
+		/* Sanity check user accounts. */
+		
+		user = getpwnam(username.c_str());
+		if (user == NULL) {
+			throw NonExistentUserException(string("The configuration option ") +
+				"'PassengerAnalyticsLogUser' (Apache) or " +
+				"'passenger_analytics_log_user' (Nginx) was set to '" +
+				username + "', but this user doesn't exist. Please fix " +
+				"the configuration option.");
+		}
+		
+		if (groupname.empty()) {
+			group = getgrgid(user->pw_gid);
+			if (group == NULL) {
+				throw NonExistentGroupException(string("The configuration option ") +
+					"'PassengerAnalyticsLogGroup' (Apache) or " +
+					"'passenger_analytics_log_group' (Nginx) wasn't set, " +
+					"so PassengerLoggingAgent tried to use the default group " +
+					"for user '" + username + "' - which is GID #" +
+					toString(user->pw_gid) + " - as the group for the analytics " +
+					"log dir, but this GID doesn't exist. " +
+					"You can solve this problem by explicitly " +
+					"setting PassengerAnalyticsLogGroup (Apache) or " +
+					"passenger_analytics_log_group (Nginx) to a group that " +
+					"does exist. In any case, it looks like your system's user " +
+					"database is broken; Phusion Passenger can work fine even " +
+					"with this broken user database, but you should still fix it.");
+			} else {
+				groupname = group->gr_name;
+			}
+		} else {
+			group = getgrnam(groupname.c_str());
+			if (group == NULL) {
+				throw NonExistentGroupException(string("The configuration option ") +
+					"'PassengerAnalyticsLogGroup' (Apache) or " +
+					"'passenger_analytics_log_group' (Nginx) was set to '" +
+					groupname + "', but this group doesn't exist. Please fix " +
+					"the configuration option.");
+			}
+		}
+		
+		/* Create the logging directory if necessary. */
+		if (getFileType(loggingDir) == FT_NONEXISTANT) {
+			if (geteuid() == 0) {
+				makeDirTree(loggingDir, permissions, user->pw_uid, group->gr_gid);
+			} else {
+				makeDirTree(loggingDir, permissions);
+			}
+		}
+		
+		/* Now's a good time to lower the privilege. */
+		if (geteuid() == 0) {
+			lowerPrivilege(username, user, group);
+		}
+		
+		/* Now setup the actual logging server. */
+		accountsDatabase->add("logging", password, false);
+		LoggingServer server(eventLoop, serverSocketFd,
+			accountsDatabase, loggingDir,
+			"u=rwx,g=rx,o=rx", GROUP_NOT_GIVEN,
+			unionStationGatewayAddress,
+			unionStationGatewayPort,
+			unionStationGatewayCert);
+		loggingServer = &server;
+		
+		
+		ev::io feedbackFdWatcher(eventLoop);
+		ev::sig sigintWatcher(eventLoop);
+		ev::sig sigtermWatcher(eventLoop);
+		ev::sig sigquitWatcher(eventLoop);
+		
+		if (feedbackFdAvailable()) {
+			MessageChannel feedbackChannel(FEEDBACK_FD);
+			feedbackFdWatcher.set<&feedbackFdBecameReadable>();
+			feedbackFdWatcher.start(FEEDBACK_FD, ev::READ);
+			feedbackChannel.write("initialized", NULL);
+		}
+		sigintWatcher.set<&caughtExitSignal>();
+		sigintWatcher.start(SIGINT);
+		sigtermWatcher.set<&caughtExitSignal>();
+		sigtermWatcher.start(SIGTERM);
+		sigquitWatcher.set<&printInfo>();
+		sigquitWatcher.start(SIGQUIT);
+		
+		
+		/********** Initialized! Enter main loop... **********/
+		
+		ev_loop(eventLoop, 0);
+		return 0;
+	} catch (const tracable_exception &e) {
+		P_ERROR("*** ERROR: " << e.what() << "\n" << e.backtrace());
+		return 1;
+	}
+}

data/ext/common/LoggingAgent/RemoteSender.h

@@ -0,0 +1,457 @@
+/*
+ *  Phusion Passenger - http://www.modrails.com/
+ *  Copyright (c) 2010 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_REMOTE_SENDER_H_
+#define _PASSENGER_REMOTE_SENDER_H_
+
+#include <sys/types.h>
+#include <ctime>
+#include <cassert>
+#include <curl/curl.h>
+#include <zlib.h>
+
+#include <boost/shared_ptr.hpp>
+#include <boost/bind.hpp>
+#include <oxt/thread.hpp>
+#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"
+
+namespace Passenger {
+
+using namespace std;
+using namespace boost;
+using namespace oxt;
+
+
+class RemoteSender {
+private:
+	struct Item {
+		bool exit;
+		bool compressed;
+		string unionStationKey;
+		string nodeName;
+		string category;
+		string data;
+		
+		Item() {
+			exit = false;
+			compressed = false;
+		}
+	};
+	
+	class Server {
+	private:
+		string ip;
+		unsigned short port;
+		string certificate;
+		
+		CURL *curl;
+		struct curl_slist *headers;
+		char lastErrorMessage[CURL_ERROR_SIZE];
+		string hostHeader;
+		string responseBody;
+		
+		void resetConnection() {
+			curl_easy_reset(curl);
+			curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, lastErrorMessage);
+			curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
+			curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, curlDataReceived);
+			curl_easy_setopt(curl, CURLOPT_WRITEDATA, this);
+			if (certificate.empty()) {
+				curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0);
+			} else {
+				curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 1);
+				/* No host name verification because Curl thinks the
+				 * host name is the IP address. Doesn't matter as
+				 * long as we have the certificate.
+				 */
+				curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 0);
+				curl_easy_setopt(curl, CURLOPT_CAINFO, certificate.c_str());
+			}
+			responseBody.clear();
+		}
+		
+		void prepareRequest(const string &uri) {
+			string url = string("https://") + ip + ":" + toString(port) + uri;
+			curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
+			responseBody.clear();
+		}
+		
+		static size_t curlDataReceived(void *buffer, size_t size, size_t nmemb, void *userData) {
+			Server *self = (Server *) userData;
+			self->responseBody.append((const char *) buffer, size * nmemb);
+			return size * nmemb;
+		}
+		
+	public:
+		Server(const string &ip, const string &hostName, unsigned short port, const string &cert) {
+			this->ip = ip;
+			this->port = port;
+			certificate = cert;
+			
+			curl = curl_easy_init();
+			if (curl == NULL) {
+				throw IOException("Unable to create a CURL handle");
+			}
+			
+			hostHeader = "Host: " + hostName;
+			headers = NULL;
+			headers = curl_slist_append(headers, hostHeader.c_str());
+			if (headers == NULL) {
+				throw IOException("Unable to create a CURL linked list");
+			}
+			
+			resetConnection();
+		}
+		
+		~Server() {
+			if (curl != NULL) {
+				curl_easy_cleanup(curl);
+			}
+			curl_slist_free_all(headers);
+		}
+		
+		bool ping() {
+			P_DEBUG("Pinging Union Station gateway " << ip << ":" << port);
+			ScopeGuard guard(boost::bind(&Server::resetConnection, this));
+			prepareRequest("/ping");
+			
+			curl_easy_setopt(curl, CURLOPT_HTTPGET, 1);
+			if (curl_easy_perform(curl) != 0) {
+				P_DEBUG("Could not ping Union Station gateway server " << ip
+					<< ": " << lastErrorMessage);
+				return false;
+			}
+			if (responseBody == "pong") {
+				guard.clear();
+				return true;
+			} else {
+				P_DEBUG("Union Station gateway server " << ip <<
+					" returned an unexpected ping message: " <<
+					responseBody);
+				return false;
+			}
+		}
+		
+		bool send(const Item &item) {
+			ScopeGuard guard(boost::bind(&Server::resetConnection, this));
+			prepareRequest("/sink");
+			
+			struct curl_httppost *post = NULL;
+			struct curl_httppost *last = NULL;
+			string base64_data;
+			
+			curl_formadd(&post, &last,
+				CURLFORM_PTRNAME, "key",
+				CURLFORM_PTRCONTENTS, item.unionStationKey.c_str(),
+				CURLFORM_CONTENTSLENGTH, (long) item.unionStationKey.size(),
+				CURLFORM_END);
+			curl_formadd(&post, &last,
+				CURLFORM_PTRNAME, "node_name",
+				CURLFORM_PTRCONTENTS, item.nodeName.c_str(),
+				CURLFORM_CONTENTSLENGTH, (long) item.nodeName.size(),
+				CURLFORM_END);
+			curl_formadd(&post, &last,
+				CURLFORM_PTRNAME, "category",
+				CURLFORM_PTRCONTENTS, item.category.c_str(),
+				CURLFORM_CONTENTSLENGTH, (long) item.category.size(),
+				CURLFORM_END);
+			if (item.compressed) {
+				base64_data = Base64::encode(item.data);
+				curl_formadd(&post, &last,
+					CURLFORM_PTRNAME, "data",
+					CURLFORM_PTRCONTENTS, base64_data.c_str(),
+					CURLFORM_CONTENTSLENGTH, (long) base64_data.size(),
+					CURLFORM_END);
+				curl_formadd(&post, &last,
+					CURLFORM_PTRNAME, "compressed",
+					CURLFORM_PTRCONTENTS, "1",
+					CURLFORM_END);
+			} else {
+				curl_formadd(&post, &last,
+					CURLFORM_PTRNAME, "data",
+					CURLFORM_PTRCONTENTS, item.data.c_str(),
+					CURLFORM_CONTENTSLENGTH, (long) item.data.size(),
+					CURLFORM_END);
+			}
+			
+			curl_easy_setopt(curl, CURLOPT_HTTPGET, 0);
+			curl_easy_setopt(curl, CURLOPT_HTTPPOST, post);
+			CURLcode code = curl_easy_perform(curl);
+			curl_formfree(post);
+			
+			if (code == 0) {
+				guard.clear();
+				// TODO: check response
+				return true;
+			} else {
+				P_DEBUG("Could not send data to Union Station gateway server " << ip
+					<< ": " << lastErrorMessage);
+				return false;
+			}
+		}
+	};
+	
+	typedef shared_ptr<Server> ServerPtr;
+	
+	string gatewayAddress;
+	unsigned short gatewayPort;
+	string certificate;
+	BlockingQueue<Item> queue;
+	oxt::thread *thr;
+	
+	list<ServerPtr> servers;
+	time_t nextCheckupTime;
+	
+	void threadMain() {
+		ScopeGuard guard(boost::bind(&RemoteSender::freeThreadData, this));
+		nextCheckupTime = 0;
+		
+		while (true) {
+			Item item;
+			bool hasItem;
+			
+			if (firstStarted()) {
+				item = queue.get();
+				hasItem = true;
+			} else {
+				hasItem = queue.timedGet(item, msecUntilNextCheckup());
+			}
+			
+			if (hasItem) {
+				if (item.exit) {
+					return;
+				} else {
+					if (timeForCheckup()) {
+						recheckServers();
+					}
+					sendOut(item);
+				}
+			} else if (timeForCheckup()) {
+				recheckServers();
+			}
+		}
+	}
+	
+	bool firstStarted() const {
+		return nextCheckupTime == 0;
+	}
+	
+	void recheckServers() {
+		P_DEBUG("Rechecking Union Station gateway servers (" << gatewayAddress << ")...");
+		
+		vector<string> ips;
+		vector<string>::const_iterator it;
+		string hostName;
+		bool someServersAreDown = false;
+		
+		ips = resolveHostname(gatewayAddress, gatewayPort);
+		P_DEBUG(ips.size() << " Union Station gateway servers found");
+		
+		servers.clear();
+		for (it = ips.begin(); it != ips.end(); it++) {
+			ServerPtr server(new Server(*it, gatewayAddress, gatewayPort, certificate));
+			if (server->ping()) {
+				servers.push_back(server);
+			} else {
+				someServersAreDown = true;
+			}
+		}
+		
+		if (servers.empty()) {
+			scheduleNextCheckup(5 * 60);
+		} else if (someServersAreDown) {
+			scheduleNextCheckup(60 * 60);
+		} else {
+			scheduleNextCheckup(3 * 60 * 60);
+		}
+	}
+	
+	void freeThreadData() {
+		servers.clear(); // Invoke destructors inside this thread.
+	}
+	
+	/**
+	 * Schedules the next checkup to be run after the given number
+	 * of seconds, unless there's already a checkup scheduled for
+	 * earlier.
+	 */
+	void scheduleNextCheckup(unsigned int seconds) {
+		time_t now = SystemTime::get();
+		if (now > nextCheckupTime || (time_t) (now + seconds) < nextCheckupTime) {
+			nextCheckupTime = now + seconds;
+		}
+	}
+	
+	unsigned int msecUntilNextCheckup() const {
+		time_t now = SystemTime::get();
+		if (now >= nextCheckupTime) {
+			return 0;
+		} else {
+			return (nextCheckupTime - now) * 1000;
+		}
+	}
+	
+	bool timeForCheckup() const {
+		return SystemTime::get() >= nextCheckupTime;
+	}
+	
+	void sendOut(const Item &item) {
+		bool sent = false;
+		bool someServersWentDown = false;
+		
+		while (!sent && !servers.empty()) {
+			// Pick first available server and put it on the back of the list
+			// for round-robin load balancing.
+			ServerPtr server = servers.front();
+			servers.pop_front();
+			if (server->send(item)) {
+				servers.push_back(server);
+				sent = true;
+			} else {
+				someServersWentDown = true;
+			}
+		}
+		
+		if (someServersWentDown) {
+			if (servers.empty()) {
+				scheduleNextCheckup(5 * 60);
+			} else {
+				scheduleNextCheckup(60 * 60);
+			}
+		}
+		
+		/* If all servers went down then all items in the queue will be
+		 * effectively dropped until after the next checkup has detected
+		 * servers that are up.
+		 */
+	}
+	
+	bool compress(const StaticString data[], unsigned int count, string &output) {
+		if (count == 0) {
+			StaticString newdata;
+			return compress(&newdata, 1, output);
+		}
+		
+		unsigned char out[128 * 1024];
+		z_stream strm;
+		int ret, flush;
+		unsigned int i, have;
+		
+		strm.zalloc = Z_NULL;
+		strm.zfree  = Z_NULL;
+		strm.opaque = Z_NULL;
+		ret = deflateInit(&strm, Z_DEFAULT_COMPRESSION);
+		if (ret != Z_OK) {
+			return false;
+		}
+		
+		for (i = 0; i < count; i++) {
+			strm.avail_in = data[i].size();
+			strm.next_in  = (unsigned char *) data[i].c_str();
+			flush = (i == count - 1) ? Z_FINISH : Z_NO_FLUSH;
+			
+			do {
+				strm.avail_out = sizeof(out);
+				strm.next_out  = out;
+				ret = deflate(&strm, flush);
+				assert(ret != Z_STREAM_ERROR);
+				have = sizeof(out) - strm.avail_out;
+				output.append((const char *) out, have);
+			} while (strm.avail_out == 0);
+			assert(strm.avail_in == 0);
+		}
+		assert(ret == Z_STREAM_END);
+		
+		deflateEnd(&strm);
+		return true;
+	}
+	
+public:
+	RemoteSender(const string &gatewayAddress, unsigned short gatewayPort, const string &certificate)
+		: queue(1024)
+	{
+		this->gatewayAddress = gatewayAddress;
+		this->gatewayPort = gatewayPort;
+		this->certificate = certificate;
+		thr = new oxt::thread(
+			boost::bind(&RemoteSender::threadMain, this),
+			"RemoteSender thread",
+			1024 * 64
+		);
+	}
+	
+	~RemoteSender() {
+		Item item;
+		item.exit = true;
+		queue.add(item);
+		/* Wait until the thread sends out all queued items.
+		 * If this cannot be done within a short amount of time,
+		 * e.g. because all servers are down, then we'll get killed
+		 * by the watchdog anyway.
+		 */
+		thr->join();
+		delete thr;
+	}
+	
+	void schedule(const string &unionStationKey, const StaticString &nodeName,
+		const StaticString &category, const StaticString data[],
+		unsigned int count)
+	{
+		Item item;
+		
+		item.unionStationKey = unionStationKey;
+		item.nodeName = nodeName;
+		item.category = category;
+		
+		if (compress(data, count, item.data)) {
+			item.compressed = true;
+		} else {
+			size_t size = 0;
+			unsigned int i;
+			
+			for (i = 0; i < count; i++) {
+				size += data[i].size();
+			}
+			item.data.reserve(size);
+			for (i = 0; i < count; i++) {
+				item.data.append(data[i].c_str(), data[i].size());
+			}
+		}
+		
+		queue.add(item);
+	}
+};
+
+
+} // namespace Passenger
+
+#endif /* _PASSENGER_REMOTE_SENDER_H_ */