passenger 5.2.3 → 5.3.0

data/src/agent/Core/ApplicationPool/Session.h

@@ -110,8 +110,8 @@ private:
 
 	void destroySelf() const {
 		this->~Session();
-		LockGuard l(context->getMmSyncher());
-		context->getSessionObjectPool().free(const_cast<Session *>(this));
+		LockGuard l(context->memoryManagementSyncher);
+		context->sessionObjectPool.free(const_cast<Session *>(this));
 	}
 
 public:

data/src/agent/Core/ApplicationPool/Socket.h

@@ -98,11 +98,17 @@ private:
 
 public:
 	// Socket properties. Read-only.
-	StaticString name;
 	StaticString address;
 	StaticString protocol;
+	StaticString description;
 	pid_t pid;
+	/**
+	 * Special values:
+	 * 0 = unlimited concurrency
+	 * -1 = unknown
+	 */
 	int concurrency;
+	bool acceptHttpRequests;
 
 	// Private. In public section as alignment optimization.
 	int totalConnections;
@@ -113,16 +119,18 @@ public:
 
 	Socket()
 		: pid(-1),
-		  concurrency(0)
+		  concurrency(-1),
+		  acceptHttpRequests(0)
 		{ }
 
-	Socket(pid_t _pid, const StaticString &_name, const StaticString &_address,
-		const StaticString &_protocol, int _concurrency)
-		: name(_name),
-		  address(_address),
+	Socket(pid_t _pid, const StaticString &_address, const StaticString &_protocol,
+		const StaticString &_description, int _concurrency, bool _acceptHttpRequests)
+		: address(_address),
 		  protocol(_protocol),
+		  description(_description),
 		  pid(_pid),
 		  concurrency(_concurrency),
+		  acceptHttpRequests(_acceptHttpRequests),
 		  totalConnections(0),
 		  totalIdleConnections(0),
 		  sessions(0)
@@ -130,11 +138,12 @@ public:
 
 	Socket(const Socket &other)
 		: idleConnections(other.idleConnections),
-		  name(other.name),
 		  address(other.address),
 		  protocol(other.protocol),
+		  description(other.description),
 		  pid(other.pid),
 		  concurrency(other.concurrency),
+		  acceptHttpRequests(other.acceptHttpRequests),
 		  totalConnections(other.totalConnections),
 		  totalIdleConnections(other.totalIdleConnections),
 		  sessions(other.sessions)
@@ -144,11 +153,12 @@ public:
 		totalConnections = other.totalConnections;
 		totalIdleConnections = other.totalIdleConnections;
 		idleConnections = other.idleConnections;
-		name = other.name;
 		address = other.address;
 		protocol = other.protocol;
+		description = other.description;
 		pid = other.pid;
 		concurrency = other.concurrency;
+		acceptHttpRequests = other.acceptHttpRequests;
 		sessions = other.sessions;
 		return *this;
 	}
@@ -227,15 +237,15 @@ public:
 		/* Different sockets within a Process may have different
 		 * 'concurrency' values. We want:
 		 * - the socket with the smallest busyness to be be picked for routing.
-		 * - to give sockets with concurrency == 0 more priority (in general)
+		 * - to give sockets with concurrency == 0 or -1 more priority (in general)
 		 *   over sockets with concurrency > 0.
 		 * Therefore, in case of sockets with concurrency > 0, we describe our
 		 * busyness as a percentage of 'concurrency', with the percentage value
 		 * in [0..INT_MAX] instead of [0..1]. That way, the busyness value
 		 * of sockets with concurrency > 0 is usually higher than that of sockets
-		 * with concurrency == 0.
+		 * with concurrency == 0 or -1.
 		 */
-		if (concurrency == 0) {
+		if (concurrency <= 0) {
 			return sessions;
 		} else {
 			return (int) (((long long) sessions * INT_MAX) / (double) concurrency);
@@ -247,39 +257,30 @@ public:
 	}
 
 	void recreateStrings(psg_pool_t *newPool) {
-		recreateString(newPool, name);
 		recreateString(newPool, address);
 		recreateString(newPool, protocol);
+		recreateString(newPool, description);
 	}
 };
 
 class SocketList: public SmallVector<Socket, 1> {
 public:
-	void add(pid_t pid, const StaticString &name, const StaticString &address,
-		const StaticString &protocol, int concurrency)
+	void add(pid_t pid, const StaticString &address, const StaticString &protocol,
+		const StaticString &description, int concurrency, bool acceptHttpRequests)
 	{
-		push_back(Socket(pid, name, address, protocol, concurrency));
+		push_back(Socket(pid, address, protocol, description, concurrency,
+			acceptHttpRequests));
 	}
 
-	const Socket *findSocketWithName(const StaticString &name) const {
+	const Socket *findFirstSocketWithProtocol(const StaticString &protocol) const {
 		const_iterator it, end = this->end();
 		for (it = begin(); it != end; it++) {
-			if (it->name == name) {
+			if (it->protocol == protocol) {
 				return &(*it);
 			}
 		}
 		return NULL;
 	}
-
-	bool hasSessionSockets() const {
-		const_iterator it;
-		for (it = begin(); it != end(); it++) {
-			if (it->protocol == "session" || it->protocol == "http_session") {
-				return true;
-			}
-		}
-		return false;
-	}
 };
 
 typedef boost::shared_ptr<SocketList> SocketListPtr;

data/src/agent/Core/Config.h

@@ -153,7 +153,7 @@ using namespace std;
  *   security_update_checker_interval                                unsigned integer   -          default(86400)
  *   security_update_checker_proxy_url                               string             -          -
  *   security_update_checker_url                                     string             -          default("https://securitycheck.phusionpassenger.com/v1/check.json")
- *   server_software                                                 string             -          default("Phusion_Passenger/5.2.3")
+ *   server_software                                                 string             -          default("Phusion_Passenger/5.3.0")
  *   show_version_in_header                                          boolean            -          default(true)
  *   single_app_mode_app_root                                        string             -          default,read_only
  *   single_app_mode_app_type                                        string             -          read_only
@@ -162,8 +162,6 @@ using namespace std;
  *   stat_throttle_rate                                              unsigned integer   -          default(10)
  *   turbocaching                                                    boolean            -          default(true),read_only
  *   user_switching                                                  boolean            -          default(true)
- *   ust_router_address                                              string             -          -
- *   ust_router_password                                             string             -          secret
  *   vary_turbocache_by_cookie                                       string             -          -
  *   watchdog_fd_passing_password                                    string             -          secret
  *   web_server_module_version                                       string             -          read_only

data/src/agent/Core/ConfigChange.cpp

@@ -291,11 +291,9 @@ asyncCommitConfigChange(ConfigChangeRequest *req, const CommitConfigChangeCallba
 	wo->appPool->setMax(coreConfig->get("max_pool_size").asInt());
 	wo->appPool->setMaxIdleTime(coreConfig->get("pool_idle_time").asInt() * 1000000ULL);
 	wo->appPool->enableSelfChecking(coreConfig->get("pool_selfchecks").asBool());
-	wo->appPool->setAgentConfig(coreConfig->inspectEffectiveValues());
-
 	{
-		boost::lock_guard<boost::mutex> l(wo->spawningKitConfig->agentConfigSyncher);
-		wo->spawningKitConfig->agentConfig = coreConfig->inspectEffectiveValues();
+		LockGuard l(wo->appPoolContext->agentConfigSyncher);
+		wo->appPoolContext->agentConfig = coreConfig->inspectEffectiveValues();
 	}
 
 	for (unsigned int i = 0; i < wo->threadWorkingObjects.size(); i++) {

data/src/agent/Core/Controller.h

@@ -78,12 +78,10 @@
 #include <Utils/JsonUtils.h>
 #include <Utils/HttpConstants.h>
 #include <Utils/Timer.h>
-#include <Core/ApplicationPool/ErrorRenderer.h>
 #include <Core/Controller/Config.h>
 #include <Core/Controller/Client.h>
 #include <Core/Controller/AppResponse.h>
 #include <Core/Controller/TurboCaching.h>
-#include <Core/UnionStation/Context.h>
 
 namespace Passenger {
 
@@ -125,7 +123,6 @@ private:
 	HashedStaticString PASSENGER_STICKY_SESSIONS;
 	HashedStaticString PASSENGER_STICKY_SESSIONS_COOKIE_NAME;
 	HashedStaticString PASSENGER_REQUEST_OOB_WORK;
-	HashedStaticString UNION_STATION_SUPPORT;
 	HashedStaticString REMOTE_ADDR;
 	HashedStaticString REMOTE_PORT;
 	HashedStaticString REMOTE_USER;
@@ -182,7 +179,6 @@ private:
 		const HashedStaticString &name);
 	void createNewPoolOptions(Client *client, Request *req,
 		const HashedStaticString &appGroupName);
-	void initializeUnionStation(Client *client, Request *req, RequestAnalysis &analysis);
 	void setStickySessionId(Client *client, Request *req);
 	const LString *getStickySessionCookieName(Request *req);
 
@@ -212,11 +208,11 @@ private:
 	void writeRequestQueueFullExceptionErrorResponse(Client *client,
 		Request *req, const boost::shared_ptr<RequestQueueFullException> &e);
 	void writeSpawnExceptionErrorResponse(Client *client, Request *req,
-		const boost::shared_ptr<SpawnException> &e);
+		const boost::shared_ptr<SpawningKit::SpawnException> &e);
 	void writeOtherExceptionErrorResponse(Client *client, Request *req,
 		const ExceptionPtr &e);
 	void endRequestWithErrorResponse(Client **c, Request **r,
-		const StaticString &message, const SpawnException *e = NULL);
+		const SpawningKit::SpawnException &e);
 	bool friendlyErrorPagesEnabled(Request *req);
 
 
@@ -293,7 +289,6 @@ private:
 	void handleAppResponseBodyEnd(Client *client, Request *req);
 	OXT_FORCE_INLINE void keepAliveAppConnection(Client *client, Request *req);
 	void storeAppResponseInTurboCache(Client *client, Request *req);
-	void finalizeUnionStationWithSuccess(Client *client, Request *req);
 
 
 	/***** Hooks ******/
@@ -370,7 +365,6 @@ public:
 	// Dependencies
 	ResourceLocator *resourceLocator;
 	PoolPtr appPool;
-	UnionStation::ContextPtr unionStationContext;
 
 
 	/****** Initialization and shutdown ******/

data/src/agent/Core/Controller/BufferBody.cpp

@@ -53,7 +53,6 @@ Controller::beginBufferingBody(Client *client, Request *req) {
 	req->bodyChannel.start();
 	req->bodyBuffer.reinitialize();
 	req->bodyBuffer.stop();
-	req->beginStopwatchLog(&req->stopwatchLogs.bufferingRequestBody, "buffering request body");
 }
 
 /**
@@ -128,7 +127,6 @@ Controller::whenBufferingBody_onRequestBody(Client *client, Request *req,
 			req->headers.erase(HTTP_TRANSFER_ENCODING);
 			req->headers.insert(&header, req->pool);
 		}
-		req->endStopwatchLog(&req->stopwatchLogs.bufferingRequestBody);
 		checkoutSession(client, req);
 		return Channel::Result(0, true);
 	} else {

data/src/agent/Core/Controller/CheckoutSession.cpp

@@ -24,6 +24,7 @@
  *  THE SOFTWARE.
  */
 #include <Core/Controller.h>
+#include <Core/SpawningKit/ErrorRenderer.h>
 
 /*************************************************************************
  *
@@ -83,10 +84,7 @@ Controller::checkoutSession(Client *client, Request *req) {
 
 void
 Controller::asyncGetFromApplicationPool(Request *req, ApplicationPool2::GetCallback callback) {
-	appPool->asyncGet(req->options, callback, true,
-		req->useUnionStation()
-		? &req->stopwatchLogs.getFromPool
-		: NULL);
+	appPool->asyncGet(req->options, callback, true);
 }
 
 void
@@ -146,7 +144,6 @@ Controller::sessionCheckedOutFromEventLoopThread(Client *client, Request *req,
 		initiateSession(client, req);
 	} else {
 		UPDATE_TRACE_POINT();
-		req->endStopwatchLog(&req->stopwatchLogs.getFromPool, false);
 		reportSessionCheckoutError(client, req, e);
 	}
 }
@@ -197,13 +194,6 @@ Controller::initiateSession(Client *client, Request *req) {
 	}
 
 	UPDATE_TRACE_POINT();
-	if (req->useUnionStation()) {
-		req->endStopwatchLog(&req->stopwatchLogs.getFromPool);
-		req->logMessage("Application PID: " +
-			toString(req->session->getPid()) +
-			" (GUPID: " + req->session->getGupid() + ")");
-		req->beginStopwatchLog(&req->stopwatchLogs.requestProxying, "request proxying");
-	}
 
 	UPDATE_TRACE_POINT();
 	SKC_DEBUG(client, "Session initiated: fd=" << req->session->fd());
@@ -242,7 +232,8 @@ Controller::reportSessionCheckoutError(Client *client, Request *req,
 		}
 	}
 	{
-		boost::shared_ptr<SpawnException> e2 = dynamic_pointer_cast<SpawnException>(e);
+		boost::shared_ptr<SpawningKit::SpawnException> e2 =
+			dynamic_pointer_cast<SpawningKit::SpawnException>(e);
 		if (e2 != NULL) {
 			writeSpawnExceptionErrorResponse(client, req, e2);
 			return;
@@ -277,13 +268,13 @@ Controller::writeRequestQueueFullExceptionErrorResponse(Client *client, Request
 
 void
 Controller::writeSpawnExceptionErrorResponse(Client *client, Request *req,
-	const boost::shared_ptr<SpawnException> &e)
+	const boost::shared_ptr<SpawningKit::SpawnException> &e)
 {
 	TRACE_POINT();
 	SKC_ERROR(client, "Cannot checkout session because a spawning error occurred. " <<
-		"The identifier of the error is " << e->get("error_id") << ". Please see earlier logs for " <<
+		"The identifier of the error is " << e->getId() << ". Please see earlier logs for " <<
 		"details about the error.");
-	endRequestWithErrorResponse(&client, &req, e->getErrorPage(), e.get());
+	endRequestWithErrorResponse(&client, &req, *e);
 }
 
 void
@@ -340,26 +331,23 @@ Controller::writeOtherExceptionErrorResponse(Client *client, Request *req, const
 	}
 }
 
-/**
- * `message` will be copied and doesn't need to outlive the request.
- */
 void
-Controller::endRequestWithErrorResponse(Client **c, Request **r, const StaticString &message,
-	const SpawnException *e)
+Controller::endRequestWithErrorResponse(Client **c, Request **r,
+	const SpawningKit::SpawnException &e)
 {
 	TRACE_POINT();
 	Client *client = *c;
 	Request *req = *r;
-	ErrorRenderer renderer(*resourceLocator);
+	SpawningKit::ErrorRenderer renderer(*appPool->getSpawningKitContext());
 	string data;
 
 	if (friendlyErrorPagesEnabled(req)) {
 		try {
-			data = renderer.renderWithDetails(message, req->options, e);
+			data = renderer.renderWithDetails(e);
 		} catch (const SystemException &e2) {
 			SKC_ERROR(client, "Cannot render an error page: " << e2.what() <<
 				"\n" << e2.backtrace());
-			data = message;
+			data = e.getSummary();
 		}
 	} else {
 		try {

data/src/agent/Core/Controller/Config.h

@@ -111,15 +111,13 @@ parseControllerBenchmarkMode(const StaticString &mode) {
  *   multi_app                                           boolean            -          default(true),read_only
  *   request_freelist_limit                              unsigned integer   -          default(1024)
  *   response_buffer_high_watermark                      unsigned integer   -          default(134217728)
- *   server_software                                     string             -          default("Phusion_Passenger/5.2.3")
+ *   server_software                                     string             -          default("Phusion_Passenger/5.3.0")
  *   show_version_in_header                              boolean            -          default(true)
  *   start_reading_after_accept                          boolean            -          default(true)
  *   stat_throttle_rate                                  unsigned integer   -          default(10)
  *   thread_number                                       unsigned integer   required   read_only
  *   turbocaching                                        boolean            -          default(true),read_only
  *   user_switching                                      boolean            -          default(true)
- *   ust_router_address                                  string             -          -
- *   ust_router_password                                 string             -          secret
  *   vary_turbocache_by_cookie                           string             -          -
  *
  * END
@@ -144,8 +142,6 @@ private:
 		add("default_ruby", STRING_TYPE, OPTIONAL, DEFAULT_RUBY);
 		add("default_python", STRING_TYPE, OPTIONAL, DEFAULT_PYTHON);
 		add("default_nodejs", STRING_TYPE, OPTIONAL, DEFAULT_NODEJS);
-		add("ust_router_address", STRING_TYPE, OPTIONAL);
-		add("ust_router_password", STRING_TYPE, OPTIONAL | SECRET);
 		add("default_user", STRING_TYPE, OPTIONAL, DEFAULT_WEB_APP_USER);
 		addWithDynamicDefault(
 			"default_group", STRING_TYPE, OPTIONAL | CACHE_DEFAULT_VALUE,
@@ -387,8 +383,6 @@ public:
 	StaticString defaultRuby;
 	StaticString defaultPython;
 	StaticString defaultNodejs;
-	StaticString ustRouterAddress;
-	StaticString ustRouterPassword;
 	StaticString defaultUser;
 	StaticString defaultGroup;
 	StaticString defaultServerName;
@@ -421,8 +415,6 @@ public:
 		  defaultRuby(psg_pstrdup(pool, config["default_ruby"].asString())),
 		  defaultPython(psg_pstrdup(pool, config["default_python"].asString())),
 		  defaultNodejs(psg_pstrdup(pool, config["default_nodejs"].asString())),
-		  ustRouterAddress(psg_pstrdup(pool, config["ust_router_address"].asString())),
-		  ustRouterPassword(psg_pstrdup(pool, config["ust_router_password"].asString())),
 		  defaultUser(psg_pstrdup(pool, config["default_user"].asString())),
 		  defaultGroup(psg_pstrdup(pool, config["default_group"].asString())),
 		  defaultServerName(psg_pstrdup(pool, config["default_server_name"].asString())),

data/src/agent/Core/Controller/ForwardResponse.cpp

@@ -894,33 +894,6 @@ Controller::logResponseHeaders(Client *client, Request *req, struct iovec *buffe
 		SKC_TRACE(client, 3, "Sending response headers: \"" <<
 			cEscapeString(StaticString(buffer, dataSize)) << "\"");
 	}
-
-	if (req->useUnionStation()) {
-		TRACE_POINT();
-		const char *status = getStatusCodeAndReasonPhrase(req->appResponse.statusCode);
-		if (status != NULL) {
-			req->logMessage("Status: " + StaticString(status));
-		} else {
-			req->logMessage("Status: " + toString(req->appResponse.statusCode));
-		}
-
-		if (req->appResponse.statusCode >= 400 && req->appResponse.statusCode <= 599) {
-			// Log the request headers like Request headers: { header1: values1-concatenated, header2: values2-concatenated } (single line)
-			// Concatenation was already done by HeaderTable.h:insert (using a comma ',' for joining, or a semicolon ';' for Cookie headers
-			UPDATE_TRACE_POINT();
-			ServerKit::HeaderTable::Iterator it(req->headers);
-			Json::Value json;
-			while (*it != NULL) {
-				const LString *hdr = psg_lstr_make_contiguous(&it->header->key, req->pool);
-				const LString *val = psg_lstr_make_contiguous(&it->header->val, req->pool);
-				// Due to the above mentioned concatenation, header keys are unique and we don't need to worry
-				// about encountering multiple of the same key, so we can just assign.
-				json[std::string(hdr->start->data, hdr->size)] = std::string(val->start->data, val->size);
-				it.next();
-			}
-			req->logMessage("Request headers: " + stringifyJson(json));
-		}
-	}
 }
 
 void
@@ -1082,7 +1055,6 @@ void
 Controller::handleAppResponseBodyEnd(Client *client, Request *req) {
 	keepAliveAppConnection(client, req);
 	storeAppResponseInTurboCache(client, req);
-	finalizeUnionStationWithSuccess(client, req);
 	assert(!req->ended());
 }
 
@@ -1145,12 +1117,6 @@ Controller::storeAppResponseInTurboCache(Client *client, Request *req) {
 	}
 }
 
-void
-Controller::finalizeUnionStationWithSuccess(Client *client, Request *req) {
-	req->endStopwatchLog(&req->stopwatchLogs.requestProxying, true);
-	req->endStopwatchLog(&req->stopwatchLogs.requestProcessing, true);
-}
-
 
 } // namespace Core
 } // namespace Passenger

data/src/agent/Core/Controller/Hooks.cpp

@@ -157,13 +157,6 @@ Controller::deinitializeRequest(Client *client, Request *req) {
 	req->session.reset();
 	req->config.reset();
 
-	req->endStopwatchLog(&req->stopwatchLogs.getFromPool, false);
-	req->endStopwatchLog(&req->stopwatchLogs.bufferingRequestBody, false);
-	req->endStopwatchLog(&req->stopwatchLogs.requestProxying, false);
-	req->endStopwatchLog(&req->stopwatchLogs.requestProcessing, false);
-
-	req->options.transaction.reset();
-
 	req->appSink.setConsumedCallback(NULL);
 	req->appSink.deinitialize();
 	req->appSource.deinitialize();