passenger 5.0.0.beta2 → 5.0.0.beta3

data/ext/common/ServerKit/FileBufferedFdSinkChannel.h

@@ -1,6 +1,6 @@
 /*
  *  Phusion Passenger - https://www.phusionpassenger.com/
- *  Copyright (c) 2014 Phusion
+ *  Copyright (c) 2014-2015 Phusion
  *
  *  "Phusion Passenger" is a trademark of Hongli Lai & Ninh Bui.
  *
@@ -193,6 +193,21 @@ public:
 		return watcher.fd;
 	}
 
+	OXT_FORCE_INLINE
+	unsigned int getBytesBuffered() const {
+		return FileBufferedChannel::getBytesBuffered();
+	}
+
+	OXT_FORCE_INLINE
+	boost::uint64_t getBytesBufferedOnDisk() const {
+		return FileBufferedChannel::getBytesBufferedOnDisk();
+	}
+
+	OXT_FORCE_INLINE
+	boost::uint64_t getTotalBytesBuffered() const {
+		return FileBufferedChannel::getTotalBytesBuffered();
+	}
+
 	OXT_FORCE_INLINE
 	bool ended() const {
 		return FileBufferedChannel::ended();
@@ -208,17 +223,34 @@ public:
 		return FileBufferedChannel::getHooks();
 	}
 
+	OXT_FORCE_INLINE
 	void setHooks(Hooks *hooks) {
 		FileBufferedChannel::setHooks(hooks);
 	}
 
+	OXT_FORCE_INLINE
+	Callback getBuffersFlushedCallback() {
+		return FileBufferedChannel::getBuffersFlushedCallback();
+	}
+
+	OXT_FORCE_INLINE
 	void setBuffersFlushedCallback(Callback callback) {
 		FileBufferedChannel::setBuffersFlushedCallback(callback);
 	}
 
+	OXT_FORCE_INLINE
+	Callback getDataFlushedCallback() const {
+		return FileBufferedChannel::getDataFlushedCallback();
+	}
+
+	OXT_FORCE_INLINE
 	void setDataFlushedCallback(Callback callback) {
 		FileBufferedChannel::setDataFlushedCallback(callback);
 	}
+
+	Json::Value inspectAsJson() const {
+		return FileBufferedChannel::inspectAsJson();
+	}
 };
 
 

data/ext/common/ServerKit/HeaderTable.h

@@ -272,9 +272,11 @@ public:
 					}
 					LString::Part *part = header->val.start;
 					header->val.start = NULL;
+					header->val.size  = 0;
 					while (part != NULL) {
+						LString::Part *next = part->next;
 						psg_lstr_append_part(&cell->header->val, part);
-						part = part->next;
+						part = next;
 					}
 					return;
 				} else {

data/ext/common/ServerKit/HttpServer.h

@@ -1,6 +1,6 @@
 /*
  *  Phusion Passenger - https://www.phusionpassenger.com/
- *  Copyright (c) 2014 Phusion
+ *  Copyright (c) 2014-2015 Phusion
  *
  *  "Phusion Passenger" is a trademark of Hongli Lai & Ninh Bui.
  *
@@ -858,6 +858,10 @@ protected:
 			// Call doneWithCurrentRequest() when data flushed
 			SKC_TRACE(c, 2, "Waiting until output is flushed");
 			req->httpState = Request::FLUSHING_OUTPUT;
+			// If the request body is not fully read at this time,
+			// then ensure that onClientDataReceived() discards any
+			// request body data that we receive from now on.
+			req->wantKeepAlive = canKeepAlive(req);
 		}
 
 		return true;
@@ -891,15 +895,31 @@ protected:
 
 		// Moved outside switch() so that the CPU branch predictor can do its work
 		if (req->httpState == Request::PARSING_HEADERS) {
+			assert(!req->ended());
 			return processClientDataWhenParsingHeaders(client, req, buffer, errcode);
 		} else {
-			switch (req->httpState) {
-			case Request::PARSING_BODY:
-				return processClientDataWhenParsingBody(client, req, buffer, errcode);
-			case Request::PARSING_CHUNKED_BODY:
-				return processClientDataWhenParsingChunkedBody(client, req, buffer, errcode);
-			case Request::UPGRADED:
-				return processClientDataWhenUpgraded(client, req, buffer, errcode);
+			switch (req->bodyType) {
+			case Request::RBT_CONTENT_LENGTH:
+				if (req->ended()) {
+					assert(!req->wantKeepAlive);
+					return Channel::Result(buffer.size(), true);
+				} else {
+					return processClientDataWhenParsingBody(client, req, buffer, errcode);
+				}
+			case Request::RBT_CHUNKED:
+				if (req->ended()) {
+					assert(!req->wantKeepAlive);
+					return Channel::Result(buffer.size(), true);
+				} else {
+					return processClientDataWhenParsingChunkedBody(client, req, buffer, errcode);
+				}
+			case Request::RBT_UPGRADE:
+				if (req->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);
 				// Never reached
@@ -1022,6 +1042,14 @@ protected:
 		req->bodyChannel.deinitialize();
 	}
 
+
+	/***** Misc *****/
+
+	OXT_FORCE_INLINE
+	static FileBufferedChannel::Callback getClientOutputDataFlushedCallback() {
+		return _onClientOutputDataFlushed;
+	}
+
 public:
 	HttpServer(Context *context)
 		: ParentClass(context),

data/ext/common/ServerKit/Server.h

@@ -982,6 +982,7 @@ public:
 		doc["name"] = clientName;
 		doc["number"] = client->number;
 		doc["refcount"] = client->refcount.load(boost::memory_order_relaxed);
+		doc["output_channel_state"] = client->output.inspectAsJson();
 
 		return doc;
 	}

data/ext/common/Utils.cpp

@@ -812,7 +812,8 @@ prestartWebApps(const ResourceLocator &locator, const string &ruby,
 				it->c_str(),
 				(char *) 0);
 			e = errno;
-			fprintf(stderr, "Cannot execute '%s %s': %s (%d)\n",
+			fprintf(stderr, "Cannot execute '%s %s %s': %s (%d)\n",
+				ruby.c_str(),
 				prespawnScript.c_str(), it->c_str(),
 				strerror(e), e);
 			fflush(stderr);

data/ext/common/Utils/DateParsing.h

@@ -1,6 +1,6 @@
 /*
  *  Phusion Passenger - https://www.phusionpassenger.com/
- *  Copyright (c) 2014 Phusion
+ *  Copyright (c) 2014-2015 Phusion
  *
  *  "Phusion Passenger" is a trademark of Hongli Lai & Ninh Bui.
  *
@@ -50,6 +50,7 @@ inline bool parseImfFixdate_zone(const char **pos, const char *end, int &zone);
 
 /**
  * Parses an IMF-fixdate, as defined by RFC 5322.
+ * Returns whether parsing succeeded.
  */
 inline bool
 parseImfFixdate(const char *date, const char *end, struct tm &tm, int &zone) {
@@ -57,7 +58,7 @@ parseImfFixdate(const char *date, const char *end, struct tm &tm, int &zone) {
 	// It's too complicated and nobody uses CFWS.
 
 	tm.tm_yday = -1;
-	tm.tm_yday = 0; // Pretend that DST is not in effect. Caller should use time zone information.
+	tm.tm_isdst = 0;
 
 	if (!parseImfFixdate_dayOfWeek(&date, end, tm)) {
 		return false;
@@ -72,6 +73,18 @@ parseImfFixdate(const char *date, const char *end, struct tm &tm, int &zone) {
 	return parseImfFixdate_time(&date, end, tm, zone);
 }
 
+/**
+ * Converts a parsed IMF-fixdate, as outputted by `parseImfFixdate()`,
+ * into a Unix timestamp.
+ */
+inline time_t
+parsedDateToTimestamp(struct tm &tm, int zone) {
+	time_t result = mktime(&tm);
+	result -= zone / 100 * 60 * 60 + zone % 100 * 60;
+	result += tm.tm_gmtoff;
+	return result;
+}
+
 inline void
 skipImfFixdate_FWS(const char **pos, const char *end) {
 	while (*pos < end && (**pos == '\r' || **pos == '\n' || **pos == ' ' || **pos == '\t')) {

data/ext/common/Utils/JsonUtils.h

@@ -1,6 +1,6 @@
 /*
  *  Phusion Passenger - https://www.phusionpassenger.com/
- *  Copyright (c) 2014 Phusion
+ *  Copyright (c) 2014-2015 Phusion
  *
  *  "Phusion Passenger" is a trademark of Hongli Lai & Ninh Bui.
  *
@@ -26,6 +26,8 @@
 #define _PASSENGER_UTILS_JSON_UTILS_H_
 
 #include <string>
+#include <cstdio>
+#include <cstddef>
 #include <StaticString.h>
 #include <Utils/json.h>
 #include <Utils/StrIntUtils.h>
@@ -69,6 +71,42 @@ timeToJson(unsigned long long timestamp) {
 	return doc;
 }
 
+inline string
+formatFloat(double val) {
+	char buf[64];
+	int size = snprintf(buf, sizeof(buf), "%.1f", val);
+	return string(buf, size);
+}
+
+inline Json::Value
+byteSizeToJson(size_t size) {
+	Json::Value doc;
+	doc["bytes"] = (Json::UInt64) size;
+	if (size < 1024) {
+		doc["human_readable"] = toString(size) + " bytes";
+	} else if (size < 1024 * 1024) {
+		doc["human_readable"] = formatFloat(size / 1024.0) + " KB";
+	} else {
+		doc["human_readable"] = formatFloat(size / 1024.0 / 1024.0) + " MB";
+	}
+	return doc;
+}
+
+inline Json::Value
+signedByteSizeToJson(long long size) {
+	Json::Value doc;
+	long long absSize = (size < 0) ? -size : size;
+	doc["bytes"] = (Json::Int64) size;
+	if (absSize < 1024) {
+		doc["human_readable"] = toString(size) + " bytes";
+	} else if (absSize < 1024 * 1024) {
+		doc["human_readable"] = formatFloat(size / 1024.0) + " KB";
+	} else {
+		doc["human_readable"] = formatFloat(size / 1024.0 / 1024.0) + " MB";
+	}
+	return doc;
+}
+
 } // namespace Passenger
 
 #endif /* _PASSENGER_UTILS_JSON_UTILS_H_ */

data/ext/common/agents/HelperAgent/Main.cpp

@@ -1,6 +1,6 @@
 /*
  *  Phusion Passenger - https://www.phusionpassenger.com/
- *  Copyright (c) 2010-2014 Phusion
+ *  Copyright (c) 2010-2015 Phusion
  *
  *  "Phusion Passenger" is a trademark of Hongli Lai & Ninh Bui.
  *
@@ -504,7 +504,7 @@ initializeNonPrivilegedWorkingObjects() {
 	wo->appPool = boost::make_shared<Pool>(wo->spawnerFactory, agentsOptions);
 	wo->appPool->initialize();
 	wo->appPool->setMax(options.getInt("max_pool_size"));
-	wo->appPool->setMaxIdleTime(options.getInt("pool_idle_time") * 1000000);
+	wo->appPool->setMaxIdleTime(options.getInt("pool_idle_time") * 1000000ULL);
 	wo->appPool->enableSelfChecking(options.getBool("selfchecks"));
 	wo->appPool->abortLongRunningConnectionsCallback = abortLongRunningConnections;
 
@@ -975,8 +975,10 @@ setAgentsOptionsDefaults() {
 	options.setDefaultInt("stat_throttle_rate", DEFAULT_STAT_THROTTLE_RATE);
 	options.setDefault("server_software", SERVER_TOKEN_NAME "/" PASSENGER_VERSION);
 	options.setDefaultBool("show_version_in_header", true);
+	options.setDefault("sticky_sessions_cookie_name", DEFAULT_STICKY_SESSIONS_COOKIE_NAME);
 	options.setDefaultBool("turbocaching", true);
 	options.setDefault("data_buffer_dir", getSystemTempDir());
+	options.setDefaultInt("response_buffer_high_watermark", DEFAULT_RESPONSE_BUFFER_HIGH_WATERMARK);
 	options.setDefaultBool("selfchecks", false);
 	options.setDefaultBool("server_graceful_exit", true);
 	options.setDefaultInt("server_threads", boost::thread::hardware_concurrency());

data/ext/common/agents/HelperAgent/OptionParser.h

@@ -108,8 +108,6 @@ serverUsage() {
 	printf("                            Force friendly error pages to be always on\n");
 	printf("      --disable-friendly-error-pages\n");
 	printf("                            Force friendly error pages to be always off\n");
-	printf("      --disable-turbocaching\n");
-	printf("                            Disable turbocaching\n");
 	printf("\n");
 	printf("      --ruby PATH           Default Ruby interpreter to use.\n");
 	printf("\n");
@@ -123,6 +121,14 @@ serverUsage() {
 	printf("                            may be idle. Default: %d\n", DEFAULT_POOL_IDLE_TIME);
 	printf("      --min-instances N     Minimum number of application processes. Default: 1\n");
 	printf("\n");
+	printf("Request handling options (optional):\n");
+	printf("      --sticky-sessions-cookie-name NAME\n");
+	printf("                            Cookie name to use for sticky sessions\n");
+	printf("      --vary-turbocache-by-cookie NAME\n");
+	printf("                            Vary the turbocache by the cookie of the given name\n");
+	printf("      --disable-turbocaching\n");
+	printf("                            Disable turbocaching\n");
+	printf("\n");
 	printf("Other options (optional):\n");
 	printf("      --log-file PATH       Log to the given file.\n");
 	printf("      --log-level LEVEL     Logging level. Default: %d\n", DEFAULT_LOG_LEVEL);
@@ -262,6 +268,12 @@ parseServerOption(int argc, const char *argv[], int &i, VariantMap &options) {
 	} else if (p.isFlag(argv[i], '\0', "--disable-friendly-error-pages")) {
 		options.set("friendly_error_pages", "false");
 		i++;
+	} else if (p.isValueFlag(argc, i, argv[i], '\0', "--sticky-sessions-cookie-name")) {
+		options.set("sticky_sessions_cookie_name", argv[i + 1]);
+		i += 2;
+	} else if (p.isValueFlag(argc, i, argv[i], '\0', "--vary-turbocache-by-cookie")) {
+		options.set("vary_turbocache_by_cookie", argv[i + 1]);
+		i += 2;
 	} else if (p.isFlag(argv[i], '\0', "--disable-turbocaching")) {
 		options.setBool("turbocaching", false);
 		i++;

data/ext/common/agents/HelperAgent/RequestHandler.h

@@ -1,6 +1,6 @@
 /*
  *  Phusion Passenger - https://www.phusionpassenger.com/
- *  Copyright (c) 2011-2014 Phusion
+ *  Copyright (c) 2011-2015 Phusion
  *
  *  "Phusion Passenger" is a trademark of Hongli Lai & Ninh Bui.
  *
@@ -189,6 +189,7 @@ private:
 	static const unsigned int MAX_SESSION_CHECKOUT_TRY = 10;
 
 	unsigned int statThrottleRate;
+	unsigned int responseBufferHighWatermark;
 	BenchmarkMode benchmarkMode: 3;
 	bool singleAppMode: 1;
 	bool showVersionInHeader: 1;
@@ -206,6 +207,8 @@ private:
 	StaticString defaultServerName;
 	StaticString defaultServerPort;
 	StaticString serverSoftware;
+	StaticString defaultStickySessionsCookieName;
+	StaticString defaultVaryTurbocacheByCookie;
 
 	HashedStaticString PASSENGER_APP_GROUP_NAME;
 	HashedStaticString PASSENGER_MAX_REQUESTS;
@@ -231,6 +234,7 @@ private:
 	StaticString serverLogName;
 
 	friend class TurboCaching<Request>;
+	friend class ResponseCache<Request>;
 	struct ev_check checkWatcher;
 	TurboCaching<Request> turboCaching;
 
@@ -259,6 +263,7 @@ public:
 		: ParentClass(context),
 
 		  statThrottleRate(_agentsOptions->getInt("stat_throttle_rate")),
+		  responseBufferHighWatermark(_agentsOptions->getInt("response_buffer_high_watermark")),
 		  benchmarkMode(parseBenchmarkMode(_agentsOptions->get("benchmark_mode", false))),
 		  singleAppMode(false),
 		  showVersionInHeader(_agentsOptions->getBool("show_version_in_header")),
@@ -307,6 +312,13 @@ public:
 			agentsOptions->get("default_server_port"));
 		serverSoftware = psg_pstrdup(stringPool,
 			agentsOptions->get("server_software"));
+		defaultStickySessionsCookieName = psg_pstrdup(stringPool,
+			agentsOptions->get("sticky_sessions_cookie_name"));
+
+		if (agentsOptions->has("vary_turbocache_by_cookie")) {
+			defaultVaryTurbocacheByCookie = psg_pstrdup(stringPool,
+				agentsOptions->get("vary_turbocache_by_cookie"));
+		}
 
 		generateServerLogName(_threadNumber);
 
@@ -465,6 +477,7 @@ public:
 	virtual Json::Value inspectRequestStateAsJson(const Request *req) const {
 		Json::Value doc = ParentClass::inspectRequestStateAsJson(req);
 		Json::Value flags;
+		const AppResponse *resp = &req->appResponse;
 
 		if (req->startedAt != 0) {
 			doc["started_at"] = timeToJson(req->startedAt * 1000000.0);
@@ -482,13 +495,12 @@ public:
 		doc["flags"] = flags;
 
 		if (req->requestBodyBuffering) {
-			doc["body_bytes_buffered"] = (Json::Value::UInt64) req->bodyBytesBuffered;
+			doc["body_bytes_buffered"] = byteSizeToJson(req->bodyBytesBuffered);
 		}
 
 		if (req->session != NULL) {
 			Json::Value &sessionDoc = doc["session"] = Json::Value(Json::objectValue);
 			const Session *session = req->session.get();
-			const AppResponse *resp = &req->appResponse;
 
 			if (req->session->isClosed()) {
 				sessionDoc["closed"] = true;
@@ -496,24 +508,26 @@ public:
 				sessionDoc["pid"] = session->getPid();
 				sessionDoc["gupid"] = session->getGupid().toString();
 			}
+		}
 
+		if (req->session != NULL || resp->httpState != AppResponse::PARSING_HEADERS) {
 			doc["app_response_http_state"] = resp->getHttpStateString();
 			doc["app_response_http_major"] = resp->httpMajor;
 			doc["app_response_http_minor"] = resp->httpMinor;
 			doc["app_response_want_keep_alive"] = resp->wantKeepAlive;
 			doc["app_response_body_type"] = resp->getBodyTypeString();
 			doc["app_response_body_fully_read"] = resp->bodyFullyRead();
-			doc["app_response_body_already_read"] = (Json::Value::UInt64)
-				resp->bodyAlreadyRead;
+			doc["app_response_body_already_read"] = byteSizeToJson(
+				resp->bodyAlreadyRead);
 			if (resp->httpState != AppResponse::ERROR) {
 				if (resp->bodyType == AppResponse::RBT_CONTENT_LENGTH) {
-					doc["app_response_content_length"] = (Json::Value::UInt64)
-						resp->aux.bodyInfo.contentLength;
+					doc["app_response_content_length"] = byteSizeToJson(
+						resp->aux.bodyInfo.contentLength);
 				} else if (resp->bodyType == AppResponse::RBT_CHUNKED) {
 					doc["app_response_end_chunk_reached"] = resp->aux.bodyInfo.endChunkReached;
 				}
 			} else {
-				doc["parse_error"] = ServerKit::getErrorDesc(resp->aux.parseError);
+				doc["app_response_parse_error"] = ServerKit::getErrorDesc(resp->aux.parseError);
 			}
 		}
 

data/ext/common/agents/HelperAgent/RequestHandler/ForwardResponse.cpp

@@ -1,6 +1,6 @@
 /*
  *  Phusion Passenger - https://www.phusionpassenger.com/
- *  Copyright (c) 2011-2014 Phusion
+ *  Copyright (c) 2011-2015 Phusion
  *
  *  "Phusion Passenger" is a trademark of Hongli Lai & Ninh Bui.
  *
@@ -73,11 +73,12 @@ onAppSourceData(Client *client, Request *req, const MemoryKit::mbuf &buffer, int
 				onAppResponseBegin(client, req);
 				return Channel::Result(ret, false);
 			case AppResponse::PARSING_BODY_WITH_LENGTH:
+				SKC_TRACE(client, 2, "Expecting an app response body with fixed length");
+				onAppResponseBegin(client, req);
+				return Channel::Result(ret, false);
 			case AppResponse::PARSING_BODY_UNTIL_EOF:
-				SKC_TRACE(client, 2,
-					((resp->httpState == AppResponse::PARSING_BODY_WITH_LENGTH)
-					? "Expecting an app response body with fixed length"
-					: "Expecting app response body until end of stream"));
+				SKC_TRACE(client, 2, "Expecting app response body until end of stream");
+				req->wantKeepAlive = false;
 				onAppResponseBegin(client, req);
 				return Channel::Result(ret, false);
 			case AppResponse::PARSING_CHUNKED_BODY:
@@ -87,7 +88,7 @@ onAppSourceData(Client *client, Request *req, const MemoryKit::mbuf &buffer, int
 				return Channel::Result(ret, false);
 			case AppResponse::UPGRADED:
 				SKC_TRACE(client, 2, "Application upgraded connection");
-				assert(!req->wantKeepAlive);
+				req->wantKeepAlive = false;
 				onAppResponseBegin(client, req);
 				return Channel::Result(ret, false);
 			case AppResponse::ONEHUNDRED_CONTINUE:
@@ -138,10 +139,14 @@ onAppSourceData(Client *client, Request *req, const MemoryKit::mbuf &buffer, int
 				UPDATE_TRACE_POINT();
 				writeResponseAndMarkForTurboCaching(client, req,
 					MemoryKit::mbuf(buffer, 0, remaining));
-				if (!req->ended() && resp->bodyFullyRead()) {
-					SKC_TRACE(client, 2, "End of application response body reached");
-					handleAppResponseBodyEnd(client, req);
-					endRequest(&client, &req);
+				if (!req->ended()) {
+					if (resp->bodyFullyRead()) {
+						SKC_TRACE(client, 2, "End of application response body reached");
+						handleAppResponseBodyEnd(client, req);
+						endRequest(&client, &req);
+					} else {
+						maybeThrottleAppSource(client, req);
+					}
 				}
 			} else {
 				UPDATE_TRACE_POINT();
@@ -191,6 +196,7 @@ onAppSourceData(Client *client, Request *req, const MemoryKit::mbuf &buffer, int
 				case ServerKit::HttpChunkedEvent::DATA:
 					assert(!event.end);
 					writeResponseAndMarkForTurboCaching(client, req, event.data);
+					maybeThrottleAppSource(client, req);
 					return Channel::Result(event.consumed, false);
 				case ServerKit::HttpChunkedEvent::END:
 					assert(event.end);
@@ -216,6 +222,7 @@ onAppSourceData(Client *client, Request *req, const MemoryKit::mbuf &buffer, int
 					assert(!event.end);
 					writeResponse(client, MemoryKit::mbuf(buffer, 0, event.consumed));
 					markResponsePartForTurboCaching(client, req, event.data);
+					maybeThrottleAppSource(client, req);
 					return Channel::Result(event.consumed, false);
 				case ServerKit::HttpChunkedEvent::END:
 					assert(event.end);
@@ -261,6 +268,7 @@ onAppSourceData(Client *client, Request *req, const MemoryKit::mbuf &buffer, int
 					buffer.start, buffer.size())) << "\"");
 			resp->bodyAlreadyRead += buffer.size();
 			writeResponseAndMarkForTurboCaching(client, req, buffer);
+			maybeThrottleAppSource(client, req);
 			return Channel::Result(buffer.size(), false);
 		} else if (errcode == 0 || errcode == ECONNRESET) {
 			// EOF
@@ -360,7 +368,7 @@ void prepareAppResponseCaching(Client *client, Request *req) {
 	if (turboCaching.isEnabled() && !req->cacheKey.empty()) {
 		TRACE_POINT();
 		AppResponse *resp = &req->appResponse;
-		SKC_TRACE(client, 2, "Preparing response caching");
+		SKC_TRACE(client, 2, "Turbocache: preparing response caching");
 		if (turboCaching.responseCache.requestAllowsStoring(req)
 		 && turboCaching.responseCache.prepareRequestForStoring(req))
 		{
@@ -379,6 +387,11 @@ void prepareAppResponseCaching(Client *client, Request *req) {
 			turboCaching.responseCache.invalidate(req);
 			req->cacheKey = HashedStaticString();
 			SKC_TRACE(client, 2, "Turbocache entries:\n" << turboCaching.responseCache.inspect());
+		} else {
+			SKC_TRACE(client, 2, "Turbocache: response not eligible for turbocaching");
+			// Decrease store success ratio.
+			turboCaching.responseCache.incStores();
+			req->cacheKey = HashedStaticString();
 		}
 	}
 }
@@ -835,6 +848,74 @@ markResponsePartForTurboCaching(Client *client, Request *req, const MemoryKit::m
 	}
 }
 
+void
+maybeThrottleAppSource(Client *client, Request *req) {
+	if (!req->ended()) {
+		assert(client->output.getBuffersFlushedCallback() == NULL);
+		assert(client->output.getDataFlushedCallback() == getClientOutputDataFlushedCallback());
+		if (responseBufferHighWatermark > 0
+		 && client->output.getTotalBytesBuffered() >= responseBufferHighWatermark)
+		{
+			SKC_TRACE(client, 2, "Application is sending response data quicker than the client "
+				"can keep up with. Throttling application socket");
+			client->output.setDataFlushedCallback(_outputDataFlushed);
+			req->appSource.stop();
+		} else if (client->output.passedThreshold()) {
+			SKC_TRACE(client, 2, "Application is sending response data quicker than the on-disk "
+				"buffer can keep up with (currently buffered " << client->output.getBytesBuffered() <<
+				" bytes). Throttling application socket");
+			client->output.setBuffersFlushedCallback(_outputBuffersFlushed);
+			req->appSource.stop();
+		}
+	}
+}
+
+static void
+_outputBuffersFlushed(FileBufferedChannel *_channel) {
+	FileBufferedFdSinkChannel *channel = reinterpret_cast<FileBufferedFdSinkChannel *>(_channel);
+	Client *client = static_cast<Client *>(static_cast<
+		ServerKit::BaseClient *>(channel->getHooks()->userData));
+	Request *req = static_cast<Request *>(client->currentRequest);
+	RequestHandler *self = static_cast<RequestHandler *>(getServerFromClient(client));
+	if (client->connected() && req != NULL) {
+		self->outputBuffersFlushed(client, req);
+	}
+}
+
+void
+outputBuffersFlushed(Client *client, Request *req) {
+	if (!req->ended()) {
+		assert(!req->appSource.isStarted());
+		SKC_TRACE(client, 2, "Buffered response data has been written to disk. Resuming application socket");
+		client->output.setBuffersFlushedCallback(NULL);
+		req->appSource.start();
+	}
+}
+
+static void
+_outputDataFlushed(FileBufferedChannel *_channel) {
+	FileBufferedFdSinkChannel *channel = reinterpret_cast<FileBufferedFdSinkChannel *>(_channel);
+	Client *client = static_cast<Client *>(static_cast<
+		ServerKit::BaseClient *>(channel->getHooks()->userData));
+	Request *req = static_cast<Request *>(client->currentRequest);
+	RequestHandler *self = static_cast<RequestHandler *>(getServerFromClient(client));
+
+	getClientOutputDataFlushedCallback()(_channel);
+	if (client->connected() && req != NULL) {
+		self->outputDataFlushed(client, req);
+	}
+}
+
+void
+outputDataFlushed(Client *client, Request *req) {
+	if (!req->ended()) {
+		assert(!req->appSource.isStarted());
+		SKC_TRACE(client, 2, "The client is ready to receive more data. Resuming application socket");
+		client->output.setDataFlushedCallback(getClientOutputDataFlushedCallback());
+		req->appSource.start();
+	}
+}
+
 void
 handleAppResponseBodyEnd(Client *client, Request *req) {
 	keepAliveAppConnection(client, req);