passenger 4.0.60 → 5.0.0.beta1

data/ext/common/BackgroundEventLoop.cpp

@@ -27,6 +27,7 @@
 #include <boost/make_shared.hpp>
 #include <oxt/thread.hpp>
 #include <ev++.h>
+#include <eio.h>
 #include <BackgroundEventLoop.h>
 #include <Exceptions.h>
 #include <SafeLibev.h>
@@ -42,9 +43,15 @@ struct BackgroundEventLoopPrivate {
 	oxt::thread *thr;
 	boost::mutex lock;
 	boost::condition_variable cond;
+	ev_idle eioRepeatWatcher;
+	ev_async eioReadyWatcher;
+	bool useLibeio;
 	bool started;
 };
 
+static BackgroundEventLoop *eioInstanceData = NULL;
+
+
 static void
 signalBackgroundEventLoopExit(struct ev_loop *loop, ev_async *async, int revents) {
 	BackgroundEventLoop *bg = (BackgroundEventLoop *) async->data;
@@ -61,7 +68,28 @@ startBackgroundLoop(BackgroundEventLoop *bg) {
 	ev_run(bg->loop, 0);
 }
 
-BackgroundEventLoop::BackgroundEventLoop(bool scalable) {
+static void
+eioRepeat(EV_P_ ev_idle *w, int revents) {
+	if (eio_poll() != -1) {
+		ev_idle_stop(EV_A_ w);
+	}
+}
+
+/* eio has some results, process them */
+static void
+eioReady(EV_P_ ev_async *w, int revents) {
+	if (eio_poll() == -1) {
+		ev_idle_start(EV_A_ &eioInstanceData->priv->eioRepeatWatcher);
+	}
+}
+
+/* wake up the event loop */
+static void
+eioWantPoll(void) {
+	ev_async_send(eioInstanceData->loop, &eioInstanceData->priv->eioReadyWatcher);
+}
+
+BackgroundEventLoop::BackgroundEventLoop(bool scalable, bool useLibeio) {
 	TRACE_POINT();
 
 	if (scalable) {
@@ -86,11 +114,25 @@ BackgroundEventLoop::BackgroundEventLoop(bool scalable) {
 	safe = boost::make_shared<SafeLibev>(loop);
 	priv = new BackgroundEventLoopPrivate();
 	priv->thr = NULL;
+	priv->useLibeio = useLibeio;
 	priv->started = false;
+
+	if (useLibeio) {
+		eioInstanceData = this;
+		ev_idle_init(&priv->eioRepeatWatcher, eioRepeat);
+		ev_async_init(&priv->eioReadyWatcher, eioReady);
+		ev_async_start(loop, &priv->eioReadyWatcher);
+		eio_init(eioWantPoll, 0);
+	}
 }
 
 BackgroundEventLoop::~BackgroundEventLoop() {
 	stop();
+	if (priv->useLibeio) {
+		ev_idle_stop(loop, &priv->eioRepeatWatcher);
+		ev_async_stop(loop, &priv->eioReadyWatcher);
+		eioInstanceData = NULL;
+	}
 	ev_async_stop(loop, async);
 	delete priv;
 	free(async);
@@ -124,5 +166,10 @@ BackgroundEventLoop::isStarted() const {
 	return priv->thr != NULL;
 }
 
+pthread_t
+BackgroundEventLoop::getNativeHandle() const {
+	return priv->thr->native_handle();
+}
+
 
 } // namespace Passenger

data/ext/common/BackgroundEventLoop.h

@@ -27,6 +27,7 @@
 
 #include <boost/shared_ptr.hpp>
 #include <string>
+#include <pthread.h>
 
 extern "C" {
 	struct ev_loop;
@@ -49,12 +50,13 @@ namespace Passenger {
 		boost::shared_ptr<SafeLibev> safe;
 		BackgroundEventLoopPrivate *priv;
 
-		BackgroundEventLoop(bool scalable = false);
+		BackgroundEventLoop(bool scalable = false, bool useLibeio = false);
 		~BackgroundEventLoop();
 
 		void start(const string &threadName = "", unsigned int stackSize = 1024 * 1024);
 		void stop();
 		bool isStarted() const;
+		pthread_t getNativeHandle() const;
 	};
 
 }

data/ext/common/Constants.h

@@ -36,6 +36,8 @@
 #define DEFAULT_BACKEND_ACCOUNT_RIGHTS Account::DETACH
 
 
+	#define AGENT_EXE "PassengerAgent"
+
 	#define APACHE2_DOC_URL "https://www.phusionpassenger.com/documentation/Users%20guide%20Apache.html"
 
 	#define DEB_APACHE_MODULE_PACKAGE "libapache2-mod-passenger"
@@ -52,12 +54,24 @@
 
 	#define DEFAULT_ANALYTICS_LOG_USER "nobody"
 
+	#define DEFAULT_APP_ENV "production"
+
+	#define DEFAULT_APP_THREAD_COUNT 1
+
 	#define DEFAULT_CONCURRENCY_MODEL "process"
 
-	#define DEFAULT_LOG_LEVEL 0
+	#define DEFAULT_HTTP_SERVER_LISTEN_ADDRESS "tcp://127.0.0.1:3000"
+
+	#define DEFAULT_LOGGING_AGENT_ADMIN_LISTEN_ADDRESS "tcp://127.0.0.1:9345"
+
+	#define DEFAULT_LOGGING_AGENT_LISTEN_ADDRESS "tcp://127.0.0.1:9344"
+
+	#define DEFAULT_LOG_LEVEL 3
 
 	#define DEFAULT_MAX_POOL_SIZE 6
 
+	#define DEFAULT_MBUF_CHUNK_SIZE 512
+
 	#define DEFAULT_NODEJS "node"
 
 	#define DEFAULT_POOL_IDLE_TIME 300
@@ -66,11 +80,13 @@
 
 	#define DEFAULT_RUBY "ruby"
 
+	#define DEFAULT_SPAWN_METHOD "smart"
+
 	#define DEFAULT_START_TIMEOUT 90000
 
-	#define DEFAULT_STICKY_SESSIONS_COOKIE_NAME "_passenger_route"
+	#define DEFAULT_STAT_THROTTLE_RATE 10
 
-	#define DEFAULT_THREAD_COUNT 1
+	#define DEFAULT_STICKY_SESSIONS_COOKIE_NAME "_passenger_route"
 
 	#define DEFAULT_UNION_STATION_GATEWAY_ADDRESS "gateway.unionstationapp.com"
 
@@ -82,6 +98,10 @@
 
 	#define FEEDBACK_FD 3
 
+	#define FLYING_PASSENGER_NAME "Flying Passenger"
+
+	#define GLOBAL_NAMESPACE_DIRNAME "passenger"
+
 	#define INDEX_DOC_URL "https://www.phusionpassenger.com/documentation/Users%20guide.html"
 
 	#define MESSAGE_SERVER_MAX_PASSWORD_SIZE 100
@@ -90,7 +110,7 @@
 
 	#define NGINX_DOC_URL "https://www.phusionpassenger.com/documentation/Users%20guide%20Nginx.html"
 
-	#define PASSENGER_VERSION "4.0.60"
+	#define PASSENGER_VERSION "5.0.0.beta1"
 
 	#define POOL_HELPER_THREAD_STACK_SIZE 262144
 
@@ -108,13 +128,13 @@
 
 	#define RPM_NGINX_PACKAGE "nginx"
 
-	#define SERVER_INSTANCE_DIR_GENERATION_STRUCTURE_MAJOR_VERSION 3
+	#define SERVER_INSTANCE_DIR_STRUCTURE_MAJOR_VERSION 2
 
-	#define SERVER_INSTANCE_DIR_GENERATION_STRUCTURE_MINOR_VERSION 0
+	#define SERVER_INSTANCE_DIR_STRUCTURE_MINOR_VERSION 0
 
-	#define SERVER_INSTANCE_DIR_STRUCTURE_MAJOR_VERSION 1
+	#define SERVER_KIT_MAX_SERVER_ENDPOINTS 4
 
-	#define SERVER_INSTANCE_DIR_STRUCTURE_MINOR_VERSION 0
+	#define SERVER_TOKEN_NAME "Phusion_Passenger"
 
 	#define STANDALONE_DOC_URL "https://www.phusionpassenger.com/documentation/Users%20guide%20Standalone.html"
 
@@ -122,5 +142,7 @@
 
 	#define SUPPORT_URL "https://www.phusionpassenger.com/documentation_and_support"
 
+	#define USER_NAMESPACE_DIRNAME ".passenger"
+
 
 #endif /* _PASSENGER_CONSTANTS_H */

data/ext/common/DataStructures/HashedStaticString.h

@@ -0,0 +1,103 @@
+/*
+ *  Phusion Passenger - https://www.phusionpassenger.com/
+ *  Copyright (c) 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_HASHED_STATIC_STRING_H_
+#define _PASSENGER_HASHED_STATIC_STRING_H_
+
+#include <boost/cstdint.hpp>
+#include <oxt/macros.hpp>
+#include <string>
+#include <StaticString.h>
+#include <Utils/Hasher.h>
+
+namespace Passenger {
+
+using namespace std;
+
+
+class HashedStaticString: public StaticString {
+private:
+	boost::uint32_t m_hash;
+
+public:
+	HashedStaticString()
+		: StaticString(),
+		  m_hash(Hasher::EMPTY_STRING_HASH)
+		{ }
+
+	HashedStaticString(const StaticString &b)
+		: StaticString(b)
+	{
+		rehash();
+	}
+
+	HashedStaticString(const HashedStaticString &b)
+		: StaticString(b),
+		  m_hash(b.m_hash)
+		{ }
+
+	HashedStaticString(const string &s)
+		: StaticString(s)
+	{
+		rehash();
+	}
+
+	HashedStaticString(const char *data)
+		: StaticString(data)
+	{
+		rehash();
+	}
+
+	HashedStaticString(const char *data, string::size_type len)
+		: StaticString(data, len)
+	{
+		rehash();
+	}
+
+	HashedStaticString(const char *data, string::size_type len,
+		boost::uint32_t hash)
+		: StaticString(data, len),
+		  m_hash(hash)
+		{ }
+
+	void rehash() {
+		Hasher h;
+		h.update(data(), size());
+		m_hash = h.finalize();
+	}
+
+	void setHash(boost::uint32_t value) {
+		m_hash = value;
+	}
+
+	OXT_FORCE_INLINE
+	boost::uint32_t hash() const {
+		return m_hash;
+	}
+};
+
+
+} // namespace Passenger
+
+#endif /* _PASSENGER_HASHED_STATIC_STRING_H_ */

data/ext/common/DataStructures/LString.h

@@ -0,0 +1,396 @@
+/*
+ *  Phusion Passenger - https://www.phusionpassenger.com/
+ *  Copyright (c) 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_DATA_STRUCTURES_LSTRING_H_
+#define _PASSENGER_DATA_STRUCTURES_LSTRING_H_
+
+#include <boost/cstdint.hpp>
+#include <cstring>
+#include <cassert>
+#include <algorithm>
+#include <MemoryKit/palloc.h>
+#include <MemoryKit/mbuf.h>
+#include <StaticString.h>
+#include <Utils/StrIntUtils.h>
+#include <Utils/Hasher.h>
+
+namespace Passenger {
+
+using namespace std;
+
+
+/**
+ * A string data structure that consists of singly-linked parts. Its purpose
+ * is to allow us to parse and store HTTP headers in a zero-copy manner.
+ * Instead of copying parsed HTTP headers in order to make them contiguous,
+ * we just store the headers non-contiguously using LString. Each LString
+ * references the mbuf_block that the HTTP header data comes from.
+ *
+ * The empty string is repesented by `size == 0 && start == NULL && end == NULL`.
+ * Parts may never contain the empty string.
+ *
+ * This struct must be a POD so that we can allocate it with psg_pool_t.
+ */
+struct LString {
+	struct Part {
+		Part *next;
+		struct MemoryKit::mbuf_block *mbuf_block;
+		/** May never be the empty string. */
+		const char *data;
+		unsigned int size;
+	};
+
+	Part *start;
+	Part *end;
+	unsigned int size;
+};
+
+
+namespace {
+	OXT_FORCE_INLINE char
+	psg_lstr_first_byte(const LString *str) {
+		return str->start->data[0];
+	}
+
+	OXT_FORCE_INLINE char
+	psg_lstr_last_byte(const LString *str) {
+		return str->end->data[str->end->size - 1];
+	}
+}
+
+
+inline void psg_lstr_append(LString *str, psg_pool_t *pool, const char *data,
+	unsigned int size);
+
+
+inline void
+psg_lstr_init(LString *str) {
+	str->start = NULL;
+	str->end   = NULL;
+	str->size  = 0;
+}
+
+inline LString *
+psg_lstr_create(psg_pool_t *pool, const char *data, unsigned int size) {
+	LString *result = (LString *) psg_palloc(pool, sizeof(LString));
+	psg_lstr_init(result);
+	psg_lstr_append(result, pool, data, size);
+	return result;
+}
+
+inline LString *
+psg_lstr_create(psg_pool_t *pool, const StaticString &str) {
+	return psg_lstr_create(pool, str.data(), str.size());
+}
+
+inline void
+psg_lstr_append_part(LString *str, LString::Part *part) {
+	if (str->end == NULL) {
+		str->start = part;
+		str->end = part;
+	} else {
+		str->end->next = part;
+		str->end = part;
+	}
+	str->size += part->size;
+	part->next = NULL;
+}
+
+inline void
+psg_lstr_append(LString *str, psg_pool_t *pool, const MemoryKit::mbuf &buffer,
+	const char *data, unsigned int size)
+{
+	if (size == 0) {
+		return;
+	}
+	LString::Part *part = (LString::Part *) psg_palloc(pool, sizeof(LString::Part));
+	part->mbuf_block = buffer.mbuf_block;
+	part->data = data;
+	part->size = size;
+	mbuf_block_ref(buffer.mbuf_block);
+	psg_lstr_append_part(str, part);
+}
+
+inline void
+psg_lstr_append(LString *str, psg_pool_t *pool, const MemoryKit::mbuf &buffer) {
+	psg_lstr_append(str, pool, buffer, buffer.start, buffer.size());
+}
+
+inline void
+psg_lstr_append(LString *str, psg_pool_t *pool, const char *data, unsigned int size) {
+	if (size == 0) {
+		return;
+	}
+	LString::Part *part = (LString::Part *) psg_palloc(pool, sizeof(LString::Part));
+	part->next = NULL;
+	part->mbuf_block = NULL;
+	part->data = data;
+	part->size = size;
+	psg_lstr_append_part(str, part);
+}
+
+inline void
+psg_lstr_append(LString *str, psg_pool_t *pool, const char *data) {
+	psg_lstr_append(str, pool, data, strlen(data));
+}
+
+inline LString *
+psg_lstr_null_terminate(const LString *str, psg_pool_t *pool) {
+	LString *newstr;
+	LString::Part *part;
+	char *data, *pos;
+
+	data = (char *) psg_pnalloc(pool, str->size + 1);
+	pos = data;
+	part = str->start;
+	while (part != NULL) {
+		memcpy(pos, part->data, part->size);
+		pos += part->size;
+		part = part->next;
+	}
+	*pos = '\0';
+
+	newstr = (LString *) psg_palloc(pool, sizeof(LString));
+	psg_lstr_init(newstr);
+	psg_lstr_append(newstr, pool, data, str->size);
+	return newstr;
+}
+
+inline LString *
+psg_lstr_make_contiguous(LString *str, psg_pool_t *pool) {
+	if (str->size == 0 || str->start == str->end) {
+		return str;
+	} else {
+		return psg_lstr_null_terminate(str, pool);
+	}
+}
+
+inline const LString *
+psg_lstr_make_contiguous(const LString *str, psg_pool_t *pool) {
+	if (str->size == 0 || str->start == str->end) {
+		return str;
+	} else {
+		return psg_lstr_null_terminate(str, pool);
+	}
+}
+
+inline bool
+psg_lstr_cmp(const LString *str, const StaticString &other) {
+	const LString::Part *part;
+	const char *b;
+
+	// Fast check: check length match
+	if (str->size != other.size()) {
+		return false;
+	}
+	// Fast check: check first and last bytes match
+	if (str->size > 0
+	 && (psg_lstr_first_byte(str) != other[0]
+	  || psg_lstr_last_byte(str) != other[other.size() - 1]))
+	{
+		return false;
+	}
+
+	part = str->start;
+	b = other.data();
+	while (part != NULL) {
+		if (memcmp(part->data, b, part->size) != 0) {
+			return false;
+		}
+		b += part->size;
+		part = part->next;
+	}
+	return true;
+}
+
+// Check whether the first `size` bytes of both `str` and `other` are equal.
+inline bool
+psg_lstr_cmp(const LString *str, const StaticString &other, unsigned int size) {
+	const LString::Part *part;
+	const char *b;
+	unsigned int checked;
+
+	if (size > str->size && size > other.size()) {
+		size = std::max<size_t>(str->size, other.size());
+	}
+
+	// Fast check: check lengths
+	if (size == 0) {
+		return true;
+	}
+	if (str->size < size || other.size() < size) {
+		return false;
+	}
+	assert(str->size > 0 && other.size() > 0);
+
+	// Fast check: check first bytes of both strings match
+	if (psg_lstr_first_byte(str) != other[0]) {
+		return false;
+	}
+	// Fast check: in the common case where the LString only has 1 part,
+	// check whether the last bytes of both strings match
+	if (str->start == str->end
+	 && str->start->data[size - 1] != other[size - 1])
+	{
+		return false;
+	}
+
+	checked = 0;
+	part = str->start;
+	b = other.data();
+	while (part != NULL && checked < size) {
+		unsigned int localSize = std::min(size - checked, part->size);
+		if (memcmp(part->data, b, localSize) != 0) {
+			return false;
+		}
+		b += localSize;
+		checked += localSize;
+		part = part->next;
+	}
+	return true;
+}
+
+inline bool
+psg_lstr_cmp(const LString *str, const LString *other) {
+	const LString::Part *a_part, *b_part;
+	const char *a_start, *a_end;
+	const char *b_start, *b_end;
+	unsigned int chunklen;
+
+	// Fast check: check length match
+	if (str->size != other->size) {
+		return false;
+	}
+	// Fast check: check both strings empty
+	if (str->size == 0) {
+		return true;
+	}
+	// Fast check: check first and last bytes match
+	if (str->size > 0
+	 && (psg_lstr_first_byte(str) != psg_lstr_first_byte(other)
+	  || psg_lstr_last_byte(str) != psg_lstr_last_byte(other)))
+	{
+		return false;
+	}
+
+	a_part   = str->start;
+	b_part   = other->start;
+	a_start  = a_part->data;
+	b_start  = b_part->data;
+	chunklen = std::min(a_part->size, b_part->size);
+	a_end    = a_start + chunklen;
+	b_end    = b_start + chunklen;
+
+	while (true) {
+		if (memcmp(a_start, b_start, chunklen) != 0) {
+			return false;
+		}
+
+		// End of part A or B reached?
+		if (a_end == a_part->data + a_part->size || b_end == b_part->data + b_part->size) {
+			if (((a_end == a_part->data + a_part->size) && a_part->next == NULL)
+			 || ((b_end == b_part->data + b_part->size) && b_part->next == NULL))
+			{
+				// End of entire LString reached.
+				assert(a_end == a_part->data + a_part->size);
+				assert(b_end == b_part->data + b_part->size);
+				assert(a_part->next == NULL);
+				assert(b_part->next == NULL);
+				return true;
+			}
+
+			unsigned int a_len, b_len;
+
+			if (a_end == a_part->data + a_part->size) {
+				// End of part A reached.
+				a_part  = a_part->next;
+				a_len   = a_part->size;
+				a_start = a_part->data;
+				a_end   = a_start + a_len;
+			} else {
+				a_len   = a_part->size - (a_end - a_part->data);
+				a_start = a_end;
+				a_end   = a_start + a_len;
+			}
+
+			if (b_end == b_part->data + b_part->size) {
+				// End of part B reached.
+				b_part  = b_part->next;
+				b_len   = b_part->size;
+				b_start = b_part->data;
+				b_end   = b_start + b_len;
+			} else {
+				b_len   = b_part->size - (b_end - b_part->data);
+				b_start = b_end;
+				b_end   = b_start + b_len;
+			}
+
+			chunklen = std::min(a_len, b_len);
+			a_end = a_start + chunklen;
+			b_end = b_start + chunklen;
+		}
+	}
+
+	return true; // Never reached.
+}
+
+inline boost::uint32_t
+psg_lstr_hash(const LString *str) {
+	const LString::Part *part = str->start;
+	Hasher h;
+
+	while (part != NULL) {
+		h.update(part->data, part->size);
+		part = part->next;
+	}
+	return h.finalize();
+}
+
+inline void
+psg_lstr_deinit(LString *str) {
+	LString::Part *part;
+
+	for (part = str->start; part != NULL; part = part->next) {
+		if (part->mbuf_block != NULL) {
+			mbuf_block_unref(part->mbuf_block);
+		}
+	}
+
+	psg_lstr_init(str);
+}
+
+inline char *
+appendData(char *pos, const char *end, const LString *str) {
+	const LString::Part *part = str->start;
+	while (part != NULL) {
+		pos = appendData(pos, end, part->data, part->size);
+		part = part->next;
+	}
+	return pos;
+}
+
+
+} // namespace Passenger
+
+#endif /* _PASSENGER_DATA_STRUCTURES_LSTRING_H_ */