passenger 5.0.25 → 5.0.26

data/src/cxx_supportlib/ServerKit/Errors.h

@@ -1,6 +1,6 @@
 /*
  *  Phusion Passenger - https://www.phusionpassenger.com/
- *  Copyright (c) 2012-2014 Phusion Holding B.V.
+ *  Copyright (c) 2012-2016 Phusion Holding B.V.
  *
  *  "Passenger", "Phusion Passenger" and "Union Station" are registered
  *  trademarks of Phusion Holding B.V.
@@ -52,6 +52,9 @@ enum Error {
 	ERROR_SECURE_HEADER_NOT_ALLOWED                        = -1017,
 	NORMAL_HEADER_NOT_ALLOWED_AFTER_SECURITY_PASSWORD      = -1018,
 
+	// HttpServer special errors
+	EARLY_EOF_DETECTED          = -1020,
+
 	// Error codes below -2000 are http_parser errors
 	HTTP_PARSER_ERRNO_BEGIN     = -2000,
 };
@@ -87,6 +90,8 @@ getErrorDesc(int errcode) {
 		return "A secure header was provided, but no security password was provided";
 	case NORMAL_HEADER_NOT_ALLOWED_AFTER_SECURITY_PASSWORD:
 		return "A normal header was encountered after the security password header";
+	case EARLY_EOF_DETECTED:
+		return "The client connection is closed before the request is done processing";
 	default:
 		if (errcode <= HTTP_PARSER_ERRNO_BEGIN) {
 			return http_errno_description((enum http_errno)

data/src/cxx_supportlib/ServerKit/HttpRequest.h

@@ -1,6 +1,6 @@
 /*
  *  Phusion Passenger - https://www.phusionpassenger.com/
- *  Copyright (c) 2014-2015 Phusion Holding B.V.
+ *  Copyright (c) 2014-2016 Phusion Holding B.V.
  *
  *  "Passenger", "Phusion Passenger" and "Union Station" are registered
  *  trademarks of Phusion Holding B.V.
@@ -102,6 +102,7 @@ public:
 	http_method method: 5;
 	bool wantKeepAlive: 1;
 	bool responseBegun: 1;
+	bool detectingNextRequestEarlyReadError: 1;
 
 	boost::atomic<int> refcount;
 
@@ -139,6 +140,9 @@ public:
 	} aux;
 	boost::uint64_t bodyAlreadyRead;
 
+	ev_tstamp lastDataReceiveTime;
+	ev_tstamp lastDataSendTime;
+
 	/**
 	 * The start index of the '?' character in `path`. -1 when it doesn't exist.
 	 */
@@ -149,6 +153,21 @@ public:
 	 */
 	int bodyError;
 
+	/**
+	 * When a request body read error, or a client socket EOF, has been detected
+	 * after the current request body has already fully received, the error code is
+	 * temporarily stored here so that it may be processed at the next request. The
+	 * error is not passed to the bodyChannel immediately because it isn't an error
+	 * part of the current request's body. But users of HttpServer can still query
+	 * this field to see that an error is imminent, and may choose to abort early.
+	 *
+	 * The value is either the body read error code, or EARLY_EOF_DETECTED. The
+	 * latter means that a client socket EOF has been detected.
+	 *
+	 * A value of 0 means that everthing is ok.
+	 */
+	int nextRequestEarlyReadError;
+
 
 	BaseHttpRequest()
 		: refcount(1),

data/src/cxx_supportlib/ServerKit/HttpServer.h

@@ -1,6 +1,6 @@
 /*
  *  Phusion Passenger - https://www.phusionpassenger.com/
- *  Copyright (c) 2014-2015 Phusion Holding B.V.
+ *  Copyright (c) 2014-2016 Phusion Holding B.V.
  *
  *  "Passenger", "Phusion Passenger" and "Union Station" are registered
  *  trademarks of Phusion Holding B.V.
@@ -32,6 +32,7 @@
 #include <oxt/macros.hpp>
 #include <algorithm>
 #include <cstdio>
+#include <cmath>
 #include <cassert>
 #include <pthread.h>
 #include <Logging.h>
@@ -41,10 +42,12 @@
 #include <ServerKit/HttpRequestRef.h>
 #include <ServerKit/HttpHeaderParser.h>
 #include <ServerKit/HttpChunkedBodyParser.h>
+#include <Algorithms/MovingAverage.h>
 #include <Utils/SystemTime.h>
 #include <Utils/StrIntUtils.h>
 #include <Utils/HttpConstants.h>
 #include <Utils/Hasher.h>
+#include <Utils/SystemTime.h>
 
 namespace Passenger {
 namespace ServerKit {
@@ -65,7 +68,8 @@ public:
 
 	FreeRequestList freeRequests;
 	unsigned int freeRequestCount, requestFreelistLimit;
-	unsigned long totalRequestsBegun;
+	unsigned long totalRequestsBegun, lastTotalRequestsBegun;
+	double requestBeginSpeed1m, requestBeginSpeed1h;
 
 private:
 	/***** Types and nested classes *****/
@@ -209,6 +213,7 @@ private:
 		assert(c->currentRequest != NULL);
 		Request *req = c->currentRequest;
 		bool keepAlive = canKeepAlive(req);
+		int nextRequestEarlyReadError = req->nextRequestEarlyReadError;
 
 		P_ASSERT_EQ(req->httpState, Request::WAITING_FOR_REFERENCES);
 		assert(req->pool != NULL);
@@ -221,6 +226,9 @@ private:
 		if (keepAlive) {
 			SKC_TRACE(c, 3, "Keeping alive connection, handling next request");
 			handleNextRequest(c);
+			if (nextRequestEarlyReadError != 0) {
+				onClientDataReceived(c, MemoryKit::mbuf(), nextRequestEarlyReadError);
+			}
 		} else {
 			SKC_TRACE(c, 3, "Not keeping alive connection, disconnecting client");
 			this->disconnect(client);
@@ -278,7 +286,7 @@ private:
 
 			switch (req->httpState) {
 			case Request::COMPLETE:
-				client->input.stop();
+				req->detectingNextRequestEarlyReadError = true;
 				onRequestBegin(client, req);
 				return Channel::Result(ret, false);
 			case Request::PARSING_BODY:
@@ -338,39 +346,34 @@ private:
 
 			boost::uint64_t maxRemaining, remaining;
 
+			assert(req->aux.bodyInfo.contentLength > 0);
 			maxRemaining = req->aux.bodyInfo.contentLength - req->bodyAlreadyRead;
+			assert(maxRemaining > 0);
 			remaining = std::min<boost::uint64_t>(buffer.size(), maxRemaining);
 			req->bodyAlreadyRead += remaining;
 			SKC_TRACE(client, 3, "Request body: " <<
 				req->bodyAlreadyRead << " of " <<
 				req->aux.bodyInfo.contentLength << " bytes already read");
 
-			if (remaining > 0) {
-				req->bodyChannel.feed(MemoryKit::mbuf(buffer, 0, remaining));
-				if (req->ended()) {
-					return Channel::Result(remaining, false);
-				}
+			req->bodyChannel.feed(MemoryKit::mbuf(buffer, 0, remaining));
+			if (req->ended()) {
+				return Channel::Result(remaining, false);
+			}
 
-				if (req->bodyChannel.acceptingInput()) {
-					if (req->bodyFullyRead()) {
-						SKC_TRACE(client, 2, "End of request body reached");
-						client->input.stop();
-						req->bodyChannel.feed(MemoryKit::mbuf());
-					}
-					return Channel::Result(remaining, false);
-				} else if (req->bodyChannel.mayAcceptInputLater()) {
-					client->input.stop();
-					req->bodyChannel.consumedCallback =
-						onRequestBodyChannelConsumed;
-					return Channel::Result(remaining, false);
-				} else {
-					return Channel::Result(remaining, true);
+			if (req->bodyChannel.acceptingInput()) {
+				if (req->bodyFullyRead()) {
+					SKC_TRACE(client, 2, "End of request body reached");
+					req->detectingNextRequestEarlyReadError = true;
+					req->bodyChannel.feed(MemoryKit::mbuf());
 				}
-			} else {
-				SKC_TRACE(client, 2, "End of request body reached");
+				return Channel::Result(remaining, false);
+			} else if (req->bodyChannel.mayAcceptInputLater()) {
 				client->input.stop();
-				req->bodyChannel.feed(MemoryKit::mbuf());
-				return Channel::Result(0, false);
+				req->bodyChannel.consumedCallback =
+					onRequestBodyChannelConsumed;
+				return Channel::Result(remaining, false);
+			} else {
+				return Channel::Result(remaining, true);
 			}
 		} else if (errcode == 0) {
 			// Premature EOF. This cannot be an expected EOF because we
@@ -430,7 +433,7 @@ private:
 				}
 			case HttpChunkedEvent::END:
 				assert(event.end);
-				client->input.stop();
+				req->detectingNextRequestEarlyReadError = true;
 				req->aux.bodyInfo.endChunkReached = true;
 				req->bodyChannel.feed(MemoryKit::mbuf());
 				return Channel::Result(event.consumed, false);
@@ -583,6 +586,38 @@ private:
 		createChunkedBodyParser(req).initialize();
 	}
 
+	bool detectNextRequestEarlyReadError(Client *client, Request *req, const MemoryKit::mbuf &buffer,
+		int errcode)
+	{
+		if (req->detectingNextRequestEarlyReadError) {
+			// When we have previously fully read the expected request body,
+			// the above flag is set to true. This tells us to detect whether
+			// an EOF or an error on the socket has occurred before we are done
+			// processing the request.
+
+			req->detectingNextRequestEarlyReadError = false;
+			client->input.stop();
+
+			if (!req->ended() && buffer.empty()) {
+				if (errcode == 0) {
+					SKC_TRACE(client, 3, "Early read EOF detected");
+					req->nextRequestEarlyReadError = EARLY_EOF_DETECTED;
+				} else {
+					SKC_TRACE(client, 3, "Early body receive error detected: "
+						<< getErrorDesc(errcode) << " (errno=" << errcode << ")");
+					req->nextRequestEarlyReadError = errcode;
+				}
+				onNextRequestEarlyReadError(client, req, req->nextRequestEarlyReadError);
+			} else {
+				SKC_TRACE(client, 3, "No early read EOF or body receive error detected");
+			}
+
+			return true;
+		} else {
+			return false;
+		}
+	}
+
 
 	/***** Channel callbacks *****/
 
@@ -678,36 +713,44 @@ protected:
 		assert(client->currentRequest != NULL);
 		Request *req = client->currentRequest;
 		RequestRef ref(req, __FILE__, __LINE__);
+		bool ended = req->ended();
+
+		if (!ended) {
+			req->lastDataReceiveTime = ev_now(this->getLoop());
+		}
+		if (detectNextRequestEarlyReadError(client, req, buffer, errcode)) {
+			return Channel::Result(0, false);
+		}
 
 		// Moved outside switch() so that the CPU branch predictor can do its work
 		if (req->httpState == Request::PARSING_HEADERS) {
-			assert(!req->ended());
+			assert(!ended);
 			return processClientDataWhenParsingHeaders(client, req, buffer, errcode);
 		} else {
 			switch (req->bodyType) {
 			case Request::RBT_CONTENT_LENGTH:
-				if (req->ended()) {
+				if (ended) {
 					assert(!req->wantKeepAlive);
 					return Channel::Result(buffer.size(), true);
 				} else {
 					return processClientDataWhenParsingBody(client, req, buffer, errcode);
 				}
 			case Request::RBT_CHUNKED:
-				if (req->ended()) {
+				if (ended) {
 					assert(!req->wantKeepAlive);
 					return Channel::Result(buffer.size(), true);
 				} else {
 					return processClientDataWhenParsingChunkedBody(client, req, buffer, errcode);
 				}
 			case Request::RBT_UPGRADE:
-				if (req->ended()) {
+				if (ended) {
 					assert(!req->wantKeepAlive);
 					return Channel::Result(buffer.size(), true);
 				} else {
 					return processClientDataWhenUpgraded(client, req, buffer, errcode);
 				}
 			default:
-				P_BUG("Invalid request HTTP state " << (int) req->httpState);
+				P_BUG("Invalid request body type " << (int) req->bodyType);
 				// Never reached
 				return Channel::Result(0, false);
 			}
@@ -737,6 +780,29 @@ protected:
 			|| client->currentRequest->upgraded();
 	}
 
+	virtual void onUpdateStatistics() {
+		ParentClass::onUpdateStatistics();
+		ev_tstamp now = ev_now(this->getLoop());
+		ev_tstamp duration = now - this->lastStatisticsUpdateTime;
+
+		// Statistics are updated about every 5 seconds, so about 12 updates
+		// per minute. We want the old average to decay to 5% after 1 minute
+		// and 1 hour, respectively, so:
+		// 1 minute: 1 - exp(ln(0.05) / 12) = 0.22092219194555585
+		// 1 hour  : 1 - exp(ln(0.05) / (60 * 12)) = 0.0041520953856636345
+		requestBeginSpeed1m = expMovingAverage(requestBeginSpeed1m,
+			(totalRequestsBegun - lastTotalRequestsBegun) / duration,
+			0.22092219194555585);
+		requestBeginSpeed1h = expMovingAverage(requestBeginSpeed1h,
+			(totalRequestsBegun - lastTotalRequestsBegun) / duration,
+			0.0041520953856636345);
+	}
+
+	virtual void onFinalizeStatisticsUpdate() {
+		ParentClass::onFinalizeStatisticsUpdate();
+		lastTotalRequestsBegun = totalRequestsBegun;
+	}
+
 
 	/***** New hooks *****/
 
@@ -762,6 +828,10 @@ protected:
 		return Channel::Result(buffer.size(), false);
 	}
 
+	virtual void onNextRequestEarlyReadError(Client *client, Request *req, int errcode) {
+		// Do nothing.
+	}
+
 	virtual bool supportsUpgrade(Client *client, Request *req) {
 		return false;
 	}
@@ -790,6 +860,7 @@ protected:
 		req->method    = HTTP_GET;
 		req->wantKeepAlive = false;
 		req->responseBegun = false;
+		req->detectingNextRequestEarlyReadError = false;
 		req->parserState.headerParser = headerParserStatePool.construct();
 		createRequestHeaderParser(this->getContext(), req).initialize();
 		if (OXT_UNLIKELY(req->pool == NULL)) {
@@ -801,7 +872,11 @@ protected:
 		req->bodyChannel.reinitialize();
 		req->aux.bodyInfo.contentLength = 0; // Sets the entire union to 0.
 		req->bodyAlreadyRead = 0;
+		req->lastDataReceiveTime = 0;
+		req->lastDataSendTime = 0;
 		req->queryStringIndex = -1;
+		req->bodyError = 0;
+		req->nextRequestEarlyReadError = 0;
 	}
 
 	/**
@@ -860,6 +935,9 @@ public:
 		  freeRequestCount(0),
 		  requestFreelistLimit(1024),
 		  totalRequestsBegun(0),
+		  lastTotalRequestsBegun(0),
+		  requestBeginSpeed1m(-1),
+		  requestBeginSpeed1h(-1),
 		  headerParserStatePool(16, 256)
 	{
 		STAILQ_INIT(&freeRequests);
@@ -928,6 +1006,7 @@ public:
 
 	void writeResponse(Client *client, const MemoryKit::mbuf &buffer) {
 		client->currentRequest->responseBegun = true;
+		client->currentRequest->lastDataSendTime = ev_now(this->getLoop());
 		client->output.feedWithoutRefGuard(buffer);
 	}
 
@@ -1120,6 +1199,12 @@ public:
 		Json::Value doc = ParentClass::inspectStateAsJson();
 		doc["free_request_count"] = freeRequestCount;
 		doc["total_requests_begun"] = (Json::UInt64) totalRequestsBegun;
+		doc["request_begin_speed"]["1m"] = averageSpeedToJson(
+			capFloatPrecision(requestBeginSpeed1m * 60),
+			"minute", "1 minute", -1);
+		doc["request_begin_speed"]["1h"] = averageSpeedToJson(
+			capFloatPrecision(requestBeginSpeed1h * 60),
+			"minute", "1 hour", -1);
 		return doc;
 	}
 
@@ -1149,6 +1234,8 @@ public:
 			doc["request_body_fully_read"] = req->bodyFullyRead();
 			doc["request_body_already_read"] = (Json::Value::UInt64) req->bodyAlreadyRead;
 			doc["response_begun"] = req->responseBegun;
+			doc["last_data_receive_time"] = timeToJson(req->lastDataReceiveTime * 1000000);
+			doc["last_data_send_time"] = timeToJson(req->lastDataSendTime * 1000000);
 			doc["method"] = http_method_str(req->method);
 			if (req->httpState != Request::ERROR) {
 				if (req->bodyType == Request::RBT_CONTENT_LENGTH) {
@@ -1162,6 +1249,11 @@ public:
 				doc["parse_error"] = getErrorDesc(req->aux.parseError);
 			}
 
+			if (req->nextRequestEarlyReadError != 0) {
+				doc["next_request_early_read_error"] = getErrorDesc(req->nextRequestEarlyReadError)
+					+ string(" (errno=") + toString(req->nextRequestEarlyReadError) + ")";
+			}
+
 			string str;
 			str.reserve(req->path.size);
 			part = req->path.start;

data/src/cxx_supportlib/ServerKit/Server.h

@@ -56,10 +56,12 @@
 #include <ServerKit/Hooks.h>
 #include <ServerKit/Client.h>
 #include <ServerKit/ClientRef.h>
+#include <Algorithms/MovingAverage.h>
 #include <Utils.h>
 #include <Utils/ScopeGuard.h>
 #include <Utils/StrIntUtils.h>
 #include <Utils/IOUtils.h>
+#include <Utils/SystemTime.h>
 
 namespace Passenger {
 namespace ServerKit {
@@ -212,8 +214,11 @@ public:
 	FreeClientList freeClients;
 	ClientList activeClients, disconnectedClients;
 	unsigned int freeClientCount, activeClientCount, disconnectedClientCount;
-	unsigned long totalClientsAccepted;
+	unsigned int peakActiveClientCount;
+	unsigned long totalClientsAccepted, lastTotalClientsAccepted;
 	unsigned long long totalBytesConsumed;
+	ev_tstamp lastStatisticsUpdateTime;
+	double clientAcceptSpeed1m, clientAcceptSpeed1h;
 
 private:
 	Context *ctx;
@@ -221,6 +226,7 @@ private:
 	uint8_t nEndpoints: 3;
 	bool accept4Available: 1;
 	ev::timer acceptResumptionWatcher;
+	ev::timer statisticsUpdateWatcher;
 	ev::io endpoints[SERVER_KIT_MAX_SERVER_ENDPOINTS];
 
 
@@ -335,6 +341,16 @@ private:
 		}
 	}
 
+	void onStatisticsUpdateTimeout(ev::timer &timer, int revents) {
+		TRACE_POINT();
+
+		this->onUpdateStatistics();
+		this->onFinalizeStatisticsUpdate();
+
+		timer.repeat = timeToNextMultipleD(5, ev_now(this->getLoop()));
+		timer.again();
+	}
+
 	unsigned int getNextClientNumber() {
 		return nextClientNumber++;
 	}
@@ -442,6 +458,9 @@ private:
 		TRACE_POINT();
 		compact(LVL_INFO);
 
+		acceptResumptionWatcher.stop();
+		statisticsUpdateWatcher.stop();
+
 		SKS_NOTICE("Shutdown finished");
 		serverState = FINISHED_SHUTDOWN;
 		if (shutdownFinishCallback != NULL) {
@@ -513,6 +532,8 @@ protected:
 	virtual void onClientsAccepted(Client **clients, unsigned int size) {
 		unsigned int i;
 
+		peakActiveClientCount = std::max(peakActiveClientCount, activeClientCount);
+
 		for (i = 0; i < size; i++) {
 			Client *client = clients[i];
 
@@ -572,6 +593,29 @@ protected:
 		return LVL_WARN;
 	}
 
+	virtual void onUpdateStatistics() {
+		SKS_DEBUG("Updating statistics");
+		ev_tstamp now = ev_now(this->getLoop());
+		ev_tstamp duration = now - lastStatisticsUpdateTime;
+
+		// Statistics are updated about every 5 seconds, so about 12 updates
+		// per minute. We want the old average to decay to 5% after 1 minute
+		// and 1 hour, respectively, so:
+		// 1 minute: 1 - exp(ln(0.05) / 12) = 0.22092219194555585
+		// 1 hour  : 1 - exp(ln(0.05) / (60 * 12)) = 0.0041520953856636345
+		clientAcceptSpeed1m = expMovingAverage(clientAcceptSpeed1m,
+			(totalClientsAccepted - lastTotalClientsAccepted) / duration,
+			0.22092219194555585);
+		clientAcceptSpeed1h = expMovingAverage(clientAcceptSpeed1h,
+			(totalClientsAccepted - lastTotalClientsAccepted) / duration,
+			0.0041520953856636345);
+	}
+
+	virtual void onFinalizeStatisticsUpdate() {
+		lastTotalClientsAccepted = totalClientsAccepted;
+		lastStatisticsUpdateTime = ev_now(this->getLoop());
+	}
+
 	virtual void reinitializeClient(Client *client, int fd) {
 		client->setConnState(Client::ACTIVE);
 		SKC_TRACE(client, 2, "Client associated with file descriptor: " << fd);
@@ -601,8 +645,13 @@ public:
 		  freeClientCount(0),
 		  activeClientCount(0),
 		  disconnectedClientCount(0),
+		  peakActiveClientCount(0),
 		  totalClientsAccepted(0),
+		  lastTotalClientsAccepted(0),
 		  totalBytesConsumed(0),
+		  lastStatisticsUpdateTime(ev_time()),
+		  clientAcceptSpeed1m(-1),
+		  clientAcceptSpeed1h(-1),
 		  ctx(context),
 		  nextClientNumber(1),
 		  nEndpoints(0),
@@ -611,10 +660,18 @@ public:
 		STAILQ_INIT(&freeClients);
 		TAILQ_INIT(&activeClients);
 		TAILQ_INIT(&disconnectedClients);
+
 		acceptResumptionWatcher.set(context->libev->getLoop());
 		acceptResumptionWatcher.set<
 			BaseServer<DerivedServer, Client>,
 			&BaseServer<DerivedServer, Client>::onAcceptResumeTimeout>(this);
+
+		statisticsUpdateWatcher.set(context->libev->getLoop());
+		statisticsUpdateWatcher.set<
+			BaseServer<DerivedServer, Client>,
+			&BaseServer<DerivedServer, Client>::onStatisticsUpdateTimeout>(this);
+		statisticsUpdateWatcher.set(5, 5);
+		statisticsUpdateWatcher.start();
 	}
 
 	virtual ~BaseServer() {
@@ -995,6 +1052,13 @@ public:
 		doc["active_client_count"] = activeClientCount;
 		Json::Value &disconnectedClientsDoc = doc["disconnected_clients"] = Json::Value(Json::objectValue);
 		doc["disconnected_client_count"] = disconnectedClientCount;
+		doc["peak_active_client_count"] = peakActiveClientCount;
+		doc["client_accept_speed"]["1m"] = averageSpeedToJson(
+			capFloatPrecision(clientAcceptSpeed1m * 60),
+			"minute", "1 minute", -1);
+		doc["client_accept_speed"]["1h"] = averageSpeedToJson(
+			capFloatPrecision(clientAcceptSpeed1h * 60),
+			"minute", "1 hour", -1);
 		doc["total_clients_accepted"] = (Json::UInt64) totalClientsAccepted;
 		doc["total_bytes_consumed"] = (Json::UInt64) totalBytesConsumed;