passenger 4.0.60 → 5.0.0.beta1

data/ext/common/ServerKit/FileBufferedFdSinkChannel.h

@@ -0,0 +1,228 @@
+/*
+ *  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_SERVER_KIT_FILE_BUFFERED_FD_SINK_CHANNEL_H_
+#define _PASSENGER_SERVER_KIT_FILE_BUFFERED_FD_SINK_CHANNEL_H_
+
+#include <oxt/macros.hpp>
+#include <sys/types.h>
+#include <unistd.h>
+#include <Logging.h>
+#include <MemoryKit/mbuf.h>
+#include <ServerKit/FileBufferedChannel.h>
+
+namespace Passenger {
+namespace ServerKit {
+
+
+class FileBufferedFdSinkChannel: protected FileBufferedChannel {
+public:
+	typedef void (*ErrorCallback)(FileBufferedFdSinkChannel *channel, int errcode);
+
+private:
+	ev_io watcher;
+
+	static Channel::Result onDataCallback(Channel *channel, const MemoryKit::mbuf &buffer,
+		int errcode)
+	{
+		FileBufferedFdSinkChannel *self = static_cast<FileBufferedFdSinkChannel *>(channel);
+		// A RefGuard is not necessary here. Both Channel and FileBufferedChannel
+		// install a RefGuard before calling this callback.
+
+		if (buffer.size() > 0) {
+			ssize_t ret;
+			do {
+				ret = ::write(self->watcher.fd, buffer.start, buffer.size());
+			} while (OXT_UNLIKELY(ret == -1 && errno == EINTR));
+			if (ret != -1) {
+				return Channel::Result(ret, false);
+			} else if (errno == EAGAIN || errno == EWOULDBLOCK) {
+				ev_io_start(self->ctx->libev->getLoop(), &self->watcher);
+				return Channel::Result(-1, false);
+			} else {
+				errcode = errno;
+				unsigned int generation = self->generation;
+				self->feedError(errcode, __FILE__, __LINE__);
+				if (generation != self->generation) {
+					return Channel::Result(0, true);
+				}
+				self->callOnError(errcode);
+				return Channel::Result(0, true);
+			}
+		} else if (errcode == 0) {
+			return Channel::Result(0, false);
+		} else {
+			self->callOnError(errcode);
+			return Channel::Result(0, false);
+		}
+	}
+
+	static void onWritable(EV_P_ ev_io *io, int revents) {
+		FileBufferedFdSinkChannel *self = static_cast<FileBufferedFdSinkChannel *>(io->data);
+		ev_io_stop(self->ctx->libev->getLoop(), &self->watcher);
+		self->consumed(0, false);
+	}
+
+	void callOnError(int errcode) {
+		if (errorCallback != NULL) {
+			errorCallback(this, errcode);
+		}
+	}
+
+public:
+	ErrorCallback errorCallback;
+
+	FileBufferedFdSinkChannel()
+		: errorCallback(NULL)
+	{
+		FileBufferedChannel::setDataCallback(onDataCallback);
+		watcher.fd = -1;
+		watcher.data = this;
+	}
+
+	~FileBufferedFdSinkChannel() {
+		ev_io_stop(ctx->libev->getLoop(), &watcher);
+	}
+
+	// May only be called right after construction.
+	void setContext(Context *context) {
+		FileBufferedChannel::setContext(context);
+	}
+
+	OXT_FORCE_INLINE
+	void feed(const MemoryKit::mbuf &buffer) {
+		FileBufferedChannel::feed(buffer);
+	}
+
+	OXT_FORCE_INLINE
+	void feed(const char *data, unsigned int size) {
+		FileBufferedChannel::feed(data, size);
+	}
+
+	OXT_FORCE_INLINE
+	void feed(const char *data) {
+		FileBufferedChannel::feed(data);
+	}
+
+	OXT_FORCE_INLINE
+	void feedWithoutRefGuard(const MemoryKit::mbuf &buffer) {
+		FileBufferedChannel::feedWithoutRefGuard(buffer);
+	}
+
+	OXT_FORCE_INLINE
+	void feedWithoutRefGuard(const char *data, unsigned int size) {
+		FileBufferedChannel::feedWithoutRefGuard(data, size);
+	}
+
+	void feedError(int errcode, const char *file = NULL, unsigned int line = 0) {
+		FileBufferedChannel::feedError(errcode, file, line);
+	}
+
+	/**
+	 * Reinitialize the channel without a file descriptor. The channel
+	 * will be reinitialized in a stopped state. To start it, you must
+	 * first call `setFd()`, then `start()`.
+	 *
+	 * @post getFd() == fd
+	 */
+	void reinitialize() {
+		FileBufferedChannel::reinitialize();
+		stop();
+	}
+
+	/**
+	 * Reinitialize the channel with a file descriptor. Unlike `reinitialize()`,
+	 * this reinitializes the channel in the started state.
+	 *
+	 * @post getFd() == fd
+	 */
+	void reinitialize(int fd) {
+		FileBufferedChannel::reinitialize();
+		setFd(fd);
+	}
+
+	void deinitialize() {
+		ev_io_stop(ctx->libev->getLoop(), &watcher);
+		watcher.fd = -1;
+		FileBufferedChannel::deinitialize();
+	}
+
+	void start() {
+		FileBufferedChannel::start();
+	}
+
+	void stop() {
+		FileBufferedChannel::stop();
+	}
+
+	Channel::State getState() const {
+		return FileBufferedChannel::getState();
+	}
+
+	bool passedThreshold() const {
+		return FileBufferedChannel::passedThreshold();
+	}
+
+	void setFd(int fd) {
+		P_ASSERT_EQ(watcher.fd, -1);
+		ev_io_init(&watcher, onWritable, fd, EV_WRITE);
+	}
+
+	int getFd() const {
+		return watcher.fd;
+	}
+
+	OXT_FORCE_INLINE
+	bool ended() const {
+		return FileBufferedChannel::ended();
+	}
+
+	OXT_FORCE_INLINE
+	bool endAcked() const {
+		return FileBufferedChannel::endAcked();
+	}
+
+	OXT_FORCE_INLINE
+	Hooks *getHooks() const {
+		return FileBufferedChannel::getHooks();
+	}
+
+	void setHooks(Hooks *hooks) {
+		FileBufferedChannel::setHooks(hooks);
+	}
+
+	void setBuffersFlushedCallback(Callback callback) {
+		FileBufferedChannel::setBuffersFlushedCallback(callback);
+	}
+
+	void setDataFlushedCallback(Callback callback) {
+		FileBufferedChannel::setDataFlushedCallback(callback);
+	}
+};
+
+
+} // namespace ServerKit
+} // namespace Passenger
+
+#endif /* _PASSENGER_SERVER_KIT_FILE_BUFFERED_FD_SINK_CHANNEL_H_ */

data/ext/common/ServerKit/HeaderTable.h

@@ -0,0 +1,472 @@
+/*
+ *  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_SERVER_KIT_HEADER_TABLE_H_
+#define _PASSENGER_SERVER_KIT_HEADER_TABLE_H_
+
+#include <boost/cstdint.hpp>
+#include <cstring>
+#include <cassert>
+
+#include <DataStructures/LString.h>
+#include <DataStructures/HashedStaticString.h>
+#include <StaticString.h>
+
+namespace Passenger {
+namespace ServerKit {
+
+using namespace std;
+
+
+struct Header {
+	LString key;
+	LString val;
+	boost::uint32_t hash;
+};
+
+
+/**
+ * A hash table, optimized for storing HTTP headers. It assumes the following workload:
+ *
+ *  * Inserts happen in bulk, soon after hash table creation or clearing.
+ *  * Once the bulk insertion phase is over, lookups are frequent, but modifications
+ *    are not.
+ *  * The hash table does not contain a lot of elements. Maybe 35 or so.
+ *
+ * The hash table uses open addressing and linear probing for cache friendliness. It
+ * supports keys that are non-contigunous in memory, through the use of LString.
+ *
+ * It supports at most 2^16-1 keys.
+ *
+ * The hash table automatically doubles in size when it becomes 75% full.
+ * The hash table never shrinks in size, even after clear(), unless you explicitly call
+ * compact(). This allows you to reuse hash table memory over multiple requests.
+ *
+ * This implementation is based on https://github.com/preshing/CompareIntegerMaps.
+ * See also http://preshing.com/20130107/this-hash-table-is-faster-than-a-judy-array
+ */
+class HeaderTable {
+public:
+	#define PHT_FIRST_CELL(hash) (m_cells + ((hash) & (m_arraySize - 1)))
+	#define PHT_CIRCULAR_NEXT(c) ((c) + 1 != m_cells + m_arraySize ? (c) + 1 : m_cells)
+	#define PHT_CIRCULAR_OFFSET(a, b) ((b) >= (a) ? (b) - (a) : m_arraySize + (b) - (a))
+
+	static const unsigned int MAX_KEY_LENGTH = 65535;
+	static const unsigned int DEFAULT_SIZE = 64;
+
+	struct Cell {
+		Header *header;
+	};
+
+private:
+	Cell *m_cells;
+	boost::uint16_t m_arraySize;
+	boost::uint16_t m_population;
+
+	bool shouldRepopulateOnInsert() const {
+		return (m_population + 1) * 4 >= m_arraySize * 3;
+	}
+
+	OXT_FORCE_INLINE
+	bool cellIsEmpty(const Cell * const cell) const {
+		return cell->header == NULL;
+	}
+
+	static boost::uint32_t upper_power_of_two(boost::uint32_t v) {
+		v--;
+		v |= v >> 1;
+		v |= v >> 2;
+		v |= v >> 4;
+		v |= v >> 8;
+		v |= v >> 16;
+		v++;
+		return v;
+	}
+
+	void repopulate(unsigned int desiredSize) {
+		assert((desiredSize & (desiredSize - 1)) == 0);   // Must be a power of 2
+		assert(m_population * 4  <= desiredSize * 3);
+
+		// Get start/end pointers of old array
+		Cell *oldCells = m_cells;
+		Cell *end = m_cells + m_arraySize;
+
+		// Allocate new array
+		m_arraySize = desiredSize;
+		m_cells = new Cell[m_arraySize];
+		memset(m_cells, 0, sizeof(Cell) * m_arraySize);
+
+		if (oldCells == NULL) {
+			return;
+		}
+
+		// Iterate through old array
+		for (Cell *oldCell = oldCells; oldCell != end; oldCell++) {
+			if (!cellIsEmpty(oldCell)) {
+				// Insert this element into new array
+				Cell *newCell = PHT_FIRST_CELL(oldCell->header->hash);
+				while (true) {
+					if (cellIsEmpty(newCell)) {
+						// Insert here
+						*newCell = *oldCell;
+						break;
+					} else {
+						newCell = PHT_CIRCULAR_NEXT(newCell);
+					}
+				}
+			}
+		}
+
+		// Delete old array
+		delete[] oldCells;
+	}
+
+	void copyFrom(const HeaderTable &other) {
+		m_arraySize  = other.m_arraySize;
+		m_population = other.m_population;
+		m_cells      = new Cell[other.m_arraySize];
+		memcpy(m_cells, other.m_cells, other.m_arraySize * sizeof(Cell));
+	}
+
+public:
+	HeaderTable(unsigned int initialSize = DEFAULT_SIZE)
+	{
+		init(initialSize);
+	}
+
+	HeaderTable(const HeaderTable &other) {
+		copyFrom(other);
+	}
+
+	~HeaderTable() {
+		delete[] m_cells;
+	}
+
+	HeaderTable &operator=(const HeaderTable &other) {
+		delete[] m_cells;
+		copyFrom(other);
+		return *this;
+	}
+
+	void init(unsigned int initialSize) {
+		assert((initialSize & (initialSize - 1)) == 0);   // Must be a power of 2
+
+		m_arraySize = initialSize;
+		if (initialSize == 0) {
+			m_cells = NULL;
+		} else {
+			m_cells = new Cell[m_arraySize];
+			memset(m_cells, 0, sizeof(Cell) * m_arraySize);
+		}
+		m_population = 0;
+	}
+
+	const Cell *lookupCell(const HashedStaticString &key) const {
+		assert(!key.empty());
+		assert(key.size() < MAX_KEY_LENGTH);
+
+		if (m_cells == NULL) {
+			return NULL;
+		}
+
+		const Cell *cell = PHT_FIRST_CELL(key.hash());
+		while (true) {
+			if (cellIsEmpty(cell)) {
+				// Empty cell found.
+				return NULL;
+			} else if (psg_lstr_cmp(&cell->header->key, key)) {
+				// Non-empty cell found.
+				return cell;
+			} else {
+				// Keep probing.
+				cell = PHT_CIRCULAR_NEXT(cell);
+			}
+		}
+	}
+
+	OXT_FORCE_INLINE
+	Cell *lookupCell(const HashedStaticString &key) {
+		return const_cast<Cell *>(static_cast<const HeaderTable *>(this)->lookupCell(key));
+	}
+
+	const LString *lookup(const HashedStaticString &key) const {
+		const Cell * const cell = lookupCell(key);
+		if (cell != NULL) {
+			return &cell->header->val;
+		} else {
+			return NULL;
+		}
+	}
+
+	OXT_FORCE_INLINE
+	LString *lookup(const HashedStaticString &key) {
+		return const_cast<LString *>(static_cast<const HeaderTable *>(this)->lookup(key));
+	}
+
+	/** header must stay alive */
+	void insert(Header *header, psg_pool_t *pool) {
+		assert(header->key.size < MAX_KEY_LENGTH);
+
+		if (m_cells == NULL) {
+			repopulate(DEFAULT_SIZE);
+		}
+
+		while (true) {
+			Cell *cell = PHT_FIRST_CELL(header->hash);
+			while (true) {
+				if (cellIsEmpty(cell)) {
+					// Cell is empty. Insert here.
+					if (shouldRepopulateOnInsert()) {
+						// Time to resize
+						repopulate(m_arraySize * 2);
+						break;
+					}
+					m_population++;
+
+					cell->header = header;
+					return;
+				} else if (psg_lstr_cmp(&cell->header->key, &header->key)) {
+					// Cell matches, so merge value into header.
+					// TODO: we need to merge Set-Cookie headers differently
+					psg_lstr_append(&cell->header->val, pool, ",", 1);
+					LString::Part *part = header->val.start;
+					header->val.start = NULL;
+					while (part != NULL) {
+						psg_lstr_append_part(&cell->header->val, part);
+						part = part->next;
+					}
+					return;
+				} else {
+					cell = PHT_CIRCULAR_NEXT(cell);
+				}
+			}
+		}
+	}
+
+	Header *insert(psg_pool_t *pool, const HashedStaticString &name,
+		const StaticString &value)
+	{
+		Header *header = (Header *) psg_palloc(pool, sizeof(Header));
+		psg_lstr_init(&header->key);
+		psg_lstr_append(&header->key, pool, name.data(), name.size());
+		psg_lstr_init(&header->val);
+		psg_lstr_append(&header->val, pool, value.data(), value.size());
+		header->hash = name.hash();
+		insert(header, pool);
+		return header;
+	}
+
+	void erase(Cell *cell) {
+		assert(cell >= m_cells && cell - m_cells < m_arraySize);
+		assert(!cellIsEmpty(cell));
+
+		// Remove this cell by shuffling neighboring cells so there are no gaps in anyone's probe chain
+		Cell *neighbor = PHT_CIRCULAR_NEXT(cell);
+		while (true) {
+			if (cellIsEmpty(neighbor)) {
+				// There's no neighbor to move. Go ahead and clear this cell, then return.
+				if (cell->header != NULL) {
+					// A previous iteration in this loop
+					// could have made cell->header NULL.
+					psg_lstr_deinit(&cell->header->key);
+					psg_lstr_deinit(&cell->header->val);
+					cell->header = NULL;
+				}
+				m_population--;
+				return;
+			}
+
+			Cell *ideal = PHT_FIRST_CELL(neighbor->header->hash);
+			if (PHT_CIRCULAR_OFFSET(ideal, cell) < PHT_CIRCULAR_OFFSET(ideal, neighbor)) {
+				// Erase current cell and move neighbor into this position,
+				// then make the now-empty neighbor the new cell to remove.
+				psg_lstr_deinit(&cell->header->key);
+				psg_lstr_deinit(&cell->header->val);
+				*cell = *neighbor;
+				cell = neighbor;
+				neighbor->header = NULL;
+			}
+			neighbor = PHT_CIRCULAR_NEXT(neighbor);
+		}
+	}
+
+	void erase(const HashedStaticString &key) {
+		Cell *cell = lookupCell(key);
+		if (cell != NULL) {
+			erase(cell);
+		}
+	}
+
+	/** Does not resize the array. */
+	void clear() {
+		if (m_cells != NULL && m_population != 0) {
+			memset(m_cells, 0, sizeof(Cell) * m_arraySize);
+		}
+		m_population = 0;
+	}
+
+	void freeMemory() {
+		delete[] m_cells;
+		m_cells = NULL;
+		m_arraySize  = 0;
+		m_population = 0;
+	}
+
+	void compact() {
+		repopulate(upper_power_of_two((m_population * 4 + 3) / 3));
+	}
+
+	unsigned int size() const {
+		return m_population;
+	}
+
+	unsigned int arraySize() const {
+		return m_arraySize;
+	}
+
+	void debug(psg_pool_t *pool) const {
+		for (unsigned int i = 0; i < m_arraySize; i++) {
+			int size = -1;
+			int ideal = -1;
+			unsigned int hash = 0;
+			const char *key = "";
+			if (!cellIsEmpty(&m_cells[i])) {
+				size = m_cells[i].header->key.size;
+				hash = m_cells[i].header->hash;
+				ideal = int(PHT_FIRST_CELL(m_cells[i].header->hash) - m_cells);
+				if (size > 0) {
+					const LString *str = psg_lstr_null_terminate(
+						&m_cells[i].header->key, pool);
+					key = str->start->data;
+				}
+			}
+			printf("%u: key=(%s), size=%d, hash=%u, ideal index=%u\n",
+				i, key, size, hash, ideal);
+		}
+	}
+
+
+	friend class Iterator;
+	class Iterator {
+	private:
+		HeaderTable *m_table;
+		Cell *m_cur;
+
+	public:
+		Iterator(HeaderTable &table)
+			: m_table(&table)
+		{
+			if (m_table->m_cells != NULL) {
+				m_cur = &m_table->m_cells[0];
+				if (m_table->cellIsEmpty(m_cur)) {
+					next();
+				}
+			} else {
+				m_cur = NULL;
+			}
+		}
+
+		Cell *next() {
+			if (m_cur == NULL) {
+				// Already finished.
+				return NULL;
+			}
+
+			Cell *end = m_table->m_cells + m_table->m_arraySize;
+			while (++m_cur != end) {
+				if (!m_table->cellIsEmpty(m_cur)) {
+					return m_cur;
+				}
+			}
+
+			// Finished
+			return m_cur = NULL;
+		}
+
+		OXT_FORCE_INLINE
+		Cell *operator*() const {
+			return m_cur;
+		}
+
+		OXT_FORCE_INLINE
+		Cell *operator->() const {
+			return m_cur;
+		}
+	};
+
+	friend class ConstIterator;
+	class ConstIterator {
+	private:
+		const HeaderTable *m_table;
+		const Cell *m_cur;
+
+	public:
+		ConstIterator(const HeaderTable &table)
+			: m_table(&table)
+		{
+			if (m_table->m_cells != NULL) {
+				m_cur = &m_table->m_cells[0];
+				if (m_table->cellIsEmpty(m_cur)) {
+					next();
+				}
+			} else {
+				m_cur = NULL;
+			}
+		}
+
+		const Cell *next() {
+			if (m_cur == NULL) {
+				// Already finished.
+				return NULL;
+			}
+
+			const Cell *end = m_table->m_cells + m_table->m_arraySize;
+			while (++m_cur != end) {
+				if (!m_table->cellIsEmpty(m_cur)) {
+					return m_cur;
+				}
+			}
+
+			// Finished
+			m_cur = NULL;
+			return NULL;
+		}
+
+		OXT_FORCE_INLINE
+		const Cell *operator*() const {
+			return m_cur;
+		}
+
+		OXT_FORCE_INLINE
+		const Cell *operator->() const {
+			return m_cur;
+		}
+	};
+};
+
+
+} // namespace ServerKit
+} // namespace Passenger
+
+#endif /* _PASSENGER_SERVER_KIT_HEADER_TABLE_H_ */