passenger 6.0.25 → 6.0.27

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

@@ -156,22 +156,22 @@ public:
 	}
 
 
-	virtual const ApiKey &getApiKey() const {
+	virtual const ApiKey &getApiKey() const override {
 		assert(!closed);
 		return processInfo->groupInfo->apiKey;
 	}
 
-	virtual pid_t getPid() const {
+	virtual pid_t getPid() const override {
 		assert(!closed);
 		return processInfo->pid;
 	}
 
-	virtual StaticString getGupid() const {
+	virtual StaticString getGupid() const override {
 		assert(!closed);
 		return StaticString(processInfo->gupid, processInfo->gupidSize);
 	}
 
-	virtual unsigned int getStickySessionId() const {
+	virtual unsigned int getStickySessionId() const override {
 		assert(!closed);
 		return processInfo->stickySessionId;
 	}
@@ -181,31 +181,26 @@ public:
 		return socket;
 	}
 
-	virtual StaticString getProtocol() const {
+	virtual StaticString getProtocol() const override {
 		return getSocket()->protocol;
 	}
 
-
-	virtual void initiate(bool blocking = true) {
+	// See AbstractSession.h for docs
+	virtual bool initiate() override {
 		assert(!closed);
 		ScopeGuard g(boost::bind(&Session::callOnInitiateFailure, this));
 		Connection connection = socket->checkoutConnection();
 		connection.fail = true;
-		if (connection.blocking && !blocking) {
-			FdGuard g2(connection.fd, NULL, 0);
-			setNonBlocking(connection.fd);
-			g2.clear();
-			connection.blocking = false;
-		}
 		g.clear();
 		this->connection = connection;
+		return connection.ready;
 	}
 
 	bool initiated() const {
 		return connection.fd != -1;
 	}
 
-	virtual int fd() const {
+	virtual int fd() const override {
 		assert(!closed);
 		return connection.fd;
 	}
@@ -213,7 +208,7 @@ public:
 	/**
 	 * This Session object becomes fully unusable after closing.
 	 */
-	virtual void close(bool success, bool wantKeepAlive = false) {
+	virtual void close(bool success, bool wantKeepAlive = false) override {
 		if (OXT_LIKELY(initiated())) {
 			deinitiate(success, wantKeepAlive);
 		}
@@ -224,18 +219,18 @@ public:
 		socket = NULL;
 	}
 
-	virtual bool isClosed() const {
+	virtual bool isClosed() const override {
 		return closed;
 	}
 
-	virtual void requestOOBW();
+	virtual void requestOOBW() override;
 
 
-	virtual void ref() const {
+	virtual void ref() const override {
 		refcount.fetch_add(1, boost::memory_order_relaxed);
 	}
 
-	virtual void unref() const {
+	virtual void unref() const override {
 		if (refcount.fetch_sub(1, boost::memory_order_release) == 1) {
 			boost::atomic_thread_fence(boost::memory_order_acquire);
 			destroySelf();

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

@@ -51,13 +51,13 @@ struct Connection {
 	int fd;
 	bool wantKeepAlive: 1;
 	bool fail: 1;
-	bool blocking: 1;
+	bool ready: 1;
 
 	Connection()
 		: fd(-1),
 		  wantKeepAlive(false),
 		  fail(false),
-		  blocking(true)
+		  ready(false)
 		{ }
 
 	void close() {
@@ -85,13 +85,15 @@ private:
 		return concurrency;
 	}
 
+	/** Initiates a non-blocking connect. */
 	Connection connect() const {
 		Connection connection;
 		P_TRACE(3, "Connecting to " << address);
-		connection.fd = connectToServer(address, __FILE__, __LINE__);
+		NConnect_State state(address, __FILE__, __LINE__);
+		connection.ready = state.connectToServer();
 		connection.fail = true;
+		connection.fd = state.getFd().detach();
 		connection.wantKeepAlive = false;
-		connection.blocking = true;
 		P_LOG_FILE_DESCRIPTOR_PURPOSE(connection.fd, "App " << pid << " connection");
 		return connection;
 	}
@@ -164,15 +166,22 @@ public:
 	}
 
 	/**
-	 * Connect to this socket or reuse an existing connection.
+	 * Initiates a non-blocking connection to this socket or reuse an existing connection.
+	 * Use `result.ready` to check whether the connect is finished or whether you need
+	 * to wait for it to finish.
 	 *
 	 * One MUST call checkinConnection() when one's done using the Connection.
 	 * Failure to do so will result in a resource leak.
+	 *
+	 * @throws SystemException Something went wrong.
+	 * @throws RuntimeException Something went wrong.
+	 * @throws boost::thread_interrupted A system call has been interrupted.
 	 */
 	Connection checkoutConnection() {
 		boost::unique_lock<boost::mutex> l(connectionPoolLock);
 
 		if (!idleConnections.empty()) {
+			TRACE_POINT();
 			P_TRACE(3, "Socket " << address << ": checking out connection from connection pool (" <<
 				idleConnections.size() << " -> " << (idleConnections.size() - 1) <<
 				" items). Current total number of connections: " << totalConnections);
@@ -181,6 +190,7 @@ public:
 			totalIdleConnections--;
 			return connection;
 		} else {
+			TRACE_POINT();
 			Connection connection = connect();
 			totalConnections++;
 			P_TRACE(3, "Socket " << address << ": there are now " <<

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

@@ -28,10 +28,22 @@
 
 #include <boost/thread.hpp>
 #include <string>
+#include <utility>
 #include <cassert>
+#include <cstring>
+#include <unistd.h>
+#include <LoggingKit/Logging.h>
 #include <IOTools/IOUtils.h>
 #include <IOTools/BufferedIO.h>
+#include <StrIntTools/StrIntUtils.h>
 #include <Core/ApplicationPool/AbstractSession.h>
+#include <Exceptions.h>
+#include <StaticString.h>
+#include <FileDescriptor.h>
+#include <Utils.h>
+#include <Utils/ScopeGuard.h>
+#include <FileTools/FileManip.h>
+#include <oxt/system_calls.hpp>
 
 namespace Passenger {
 namespace ApplicationPool2 {
@@ -57,6 +69,7 @@ private:
 	mutable bool closed;
 	mutable bool success;
 	mutable bool wantKeepAlive;
+	mutable bool forcingNonInstantConnect;
 
 public:
 	TestSession()
@@ -67,16 +80,17 @@ public:
 		  stickySessionId(0),
 		  closed(false),
 		  success(false),
-		  wantKeepAlive(false)
+		  wantKeepAlive(false),
+		  forcingNonInstantConnect(false)
 		{ }
 
-	virtual void ref() const {
+	virtual void ref() const override {
 		boost::lock_guard<boost::mutex> l(syncher);
 		assert(refcount > 0);
 		refcount++;
 	}
 
-	virtual void unref() const {
+	virtual void unref() const override {
 		boost::lock_guard<boost::mutex> l(syncher);
 		assert(refcount > 0);
 		refcount--;
@@ -89,7 +103,7 @@ public:
 		}
 	}
 
-	virtual pid_t getPid() const {
+	virtual pid_t getPid() const override {
 		boost::lock_guard<boost::mutex> l(syncher);
 		return pid;
 	}
@@ -99,7 +113,7 @@ public:
 		pid = p;
 	}
 
-	virtual StaticString getGupid() const {
+	virtual StaticString getGupid() const override {
 		boost::lock_guard<boost::mutex> l(syncher);
 		return gupid;
 	}
@@ -109,7 +123,7 @@ public:
 		gupid = v;
 	}
 
-	virtual StaticString getProtocol() const {
+	virtual StaticString getProtocol() const override {
 		boost::lock_guard<boost::mutex> l(syncher);
 		return protocol;
 	}
@@ -119,7 +133,7 @@ public:
 		protocol = v;
 	}
 
-	virtual unsigned int getStickySessionId() const {
+	virtual unsigned int getStickySessionId() const override {
 		boost::lock_guard<boost::mutex> l(syncher);
 		return stickySessionId;
 	}
@@ -129,11 +143,11 @@ public:
 		stickySessionId = v;
 	}
 
-	virtual const ApiKey &getApiKey() const {
+	virtual const ApiKey &getApiKey() const override {
 		return apiKey;
 	}
 
-	virtual int fd() const {
+	virtual int fd() const override {
 		boost::lock_guard<boost::mutex> l(syncher);
 		return connection.first;
 	}
@@ -148,7 +162,7 @@ public:
 		return peerBufferedIO;
 	}
 
-	virtual bool isClosed() const {
+	virtual bool isClosed() const override {
 		boost::lock_guard<boost::mutex> l(syncher);
 		return closed;
 	}
@@ -163,16 +177,61 @@ public:
 		return wantKeepAlive;
 	}
 
-	virtual void initiate(bool blocking = true) {
+	void forceNonInstantConnect() {
 		boost::lock_guard<boost::mutex> l(syncher);
-		connection = createUnixSocketPair(__FILE__, __LINE__);
+		forcingNonInstantConnect = true;
+	}
+
+	virtual bool initiate() override {
+		boost::lock_guard<boost::mutex> l(syncher);
+
+		// Create a unique temporary directory for the socket
+		string tempDirPathTemplate = StaticString(getSystemTempDir()) + "/passenger.session.XXXXXX";
+		DynamicBuffer tempDirPath(tempDirPathTemplate.size() + 1);
+		memcpy(tempDirPath.data, tempDirPathTemplate.c_str(), tempDirPathTemplate.size() + 1);
+		if (mkdtemp(tempDirPath.data) == NULL) {
+			int e = errno;
+			throw SystemException("Cannot create temporary directory", e);
+		}
+		ScopeGuard g([&]() {
+			try {
+				removeDirTree(tempDirPath.data);
+			} catch (const std::exception &e) {
+				P_ERROR("Error deleting temporary directory " << tempDirPath.data << ": " << e.what());
+			}
+		});
+
+		// Create server socket
+		string socketPath = StaticString(tempDirPath.data) + "/socket";
+		FileDescriptor serverFd(createUnixServer(socketPath.c_str(), 0, true, __FILE__, __LINE__),
+								__FILE__, __LINE__);
+
+		// Create client socket (non-blocking)
+		NUnix_State clientState;
+		setupNonBlockingUnixSocket(clientState, socketPath, __FILE__, __LINE__);
+		bool immediatelyConnected = connectToUnixServer(clientState);
+		connection.first = std::move(clientState.fd);
+
+		// Accept connection (blocking)
+		FileDescriptor serverSideFd(oxt::syscalls::accept(serverFd, NULL, NULL),
+			__FILE__, __LINE__);
+		if (serverSideFd == -1) {
+			int e = errno;
+			throw SystemException("Cannot accept connection", e);
+		}
+
+		// Store the server-side fd.
+		connection.second = std::move(serverSideFd);
 		peerBufferedIO = BufferedIO(connection.second);
-		if (!blocking) {
-			setNonBlocking(connection.first);
+
+		if (forcingNonInstantConnect) {
+			return false;
+		} else {
+			return immediatelyConnected;
 		}
 	}
 
-	virtual void close(bool _success, bool _wantKeepAlive = false) {
+	virtual void close(bool _success, bool _wantKeepAlive = false) override {
 		boost::lock_guard<boost::mutex> l(syncher);
 		closed = true;
 		success = _success;

data/src/agent/Core/Config.h

@@ -47,7 +47,6 @@
 #include <Core/SecurityUpdateChecker.h>
 #include <Core/TelemetryCollector.h>
 #include <Core/ApiServer.h>
-#include <Core/AdminPanelConnector.h>
 #include <Shared/ApiAccountUtils.h>
 #include <Constants.h>
 #include <Utils.h>
@@ -64,23 +63,6 @@ using namespace std;
  * (do not edit: following text is automatically generated
  * by 'rake configkit_schemas_inline_comments')
  *
- *   admin_panel_auth_type                                           string             -          default("basic")
- *   admin_panel_close_timeout                                       float              -          default(10.0)
- *   admin_panel_connect_timeout                                     float              -          default(30.0)
- *   admin_panel_data_debug                                          boolean            -          default(false)
- *   admin_panel_password                                            string             -          secret
- *   admin_panel_password_file                                       string             -          -
- *   admin_panel_ping_interval                                       float              -          default(30.0)
- *   admin_panel_ping_timeout                                        float              -          default(30.0)
- *   admin_panel_proxy_password                                      string             -          secret
- *   admin_panel_proxy_timeout                                       float              -          default(30.0)
- *   admin_panel_proxy_url                                           string             -          -
- *   admin_panel_proxy_username                                      string             -          -
- *   admin_panel_reconnect_timeout                                   float              -          default(5.0)
- *   admin_panel_url                                                 string             -          read_only
- *   admin_panel_username                                            string             -          -
- *   admin_panel_websocketpp_debug_access                            boolean            -          default(false)
- *   admin_panel_websocketpp_debug_error                             boolean            -          default(false)
  *   api_server_accept_burst_count                                   unsigned integer   -          default(32)
  *   api_server_addresses                                            array of strings   -          default([]),read_only
  *   api_server_authorizations                                       array              -          default("[FILTERED]"),secret
@@ -149,7 +131,7 @@ using namespace std;
  *   hook_queue_full_error                                           string             -          read_only
  *   hook_spawn_failed                                               string             -          read_only
  *   instance_dir                                                    string             -          read_only
- *   integration_mode                                                string             -          default("standalone")
+ *   integration_mode                                                string             -          default("standalone"),read_only
  *   log_level                                                       string             -          default("notice")
  *   log_target                                                      any                -          default({"stderr": true})
  *   max_instances_per_app                                           unsigned integer   -          read_only
@@ -168,14 +150,13 @@ 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/6.0.25")
+ *   server_software                                                 string             -          default("Phusion_Passenger/6.0.27")
  *   show_version_in_header                                          boolean            -          default(true)
  *   single_app_mode_app_root                                        string             -          default,read_only
  *   single_app_mode_app_start_command                               string             -          read_only
  *   single_app_mode_app_type                                        string             -          read_only
  *   single_app_mode_startup_file                                    string             -          read_only
  *   spawn_dir                                                       string             -          default,read_only
- *   standalone_engine                                               string             -          default
  *   stat_throttle_rate                                              unsigned integer   -          default(10)
  *   telemetry_collector_ca_certificate_path                         string             -          -
  *   telemetry_collector_debug_curl                                  boolean            -          default(false)
@@ -192,7 +173,6 @@ using namespace std;
  *   user_switching                                                  boolean            -          default(true)
  *   vary_turbocache_by_cookie                                       string             -          -
  *   watchdog_fd_passing_password                                    string             -          secret
- *   web_server_module_version                                       string             -          read_only
  *   web_server_version                                              string             -          read_only
  *
  * END
@@ -417,10 +397,6 @@ public:
 		ServerKit::Schema schema;
 		ConfigKit::PrefixTranslator translator;
 	} apiServerKit;
-	struct {
-		AdminPanelConnector::Schema schema;
-		ConfigKit::TableTranslator translator;
-	} adminPanelConnector;
 
 	Schema(const WrapperRegistry::Registry *wrapperRegistry = NULL)
 		: controllerSingleAppMode(wrapperRegistry)
@@ -478,15 +454,7 @@ public:
 		addSubSchema(apiServerKit.schema, apiServerKit.translator);
 		erase("api_server_secure_mode_password");
 
-		// Add subschema: adminPanelConnector
-		addSubSchemaPrefixTranslations<WebSocketCommandReverseServer::Schema>(
-			adminPanelConnector.translator, "admin_panel_");
-		adminPanelConnector.translator.finalize();
-		addSubSchema(adminPanelConnector.schema, adminPanelConnector.translator);
-		erase("admin_panel_log_prefix");
 		erase("ruby");
-
-		override("admin_panel_url", STRING_TYPE, OPTIONAL | READ_ONLY);
 		override("instance_dir", STRING_TYPE, OPTIONAL | READ_ONLY);
 		override("multi_app", BOOL_TYPE, OPTIONAL | READ_ONLY, false);
 		overrideWithDynamicDefault("default_server_name", STRING_TYPE, OPTIONAL, getDefaultServerName);

data/src/agent/Core/ConfigChange.cpp

@@ -54,7 +54,6 @@ struct ConfigChangeRequest {
 	vector<Controller::ConfigChangeRequest *> forController;
 	ServerKit::ConfigChangeRequest forApiServerKit;
 	ApiServer::ConfigChangeRequest forApiServer;
-	AdminPanelConnector::ConfigChangeRequest forAdminPanelConnector;
 
 	ConfigChangeRequest()
 		: counter(0)
@@ -146,18 +145,6 @@ asyncPrepareConfigChangeForApiServer(const Json::Value &updates, ConfigChangeReq
 	asyncPrepareConfigChangeCompletedOne(req);
 }
 
-static void
-asyncPrepareConfigChangeForAdminPanelConnectorDone(const vector<ConfigKit::Error> &errors,
-	AdminPanelConnector::ConfigChangeRequest &_, ConfigChangeRequest *req)
-{
-	vector<ConfigKit::Error> translatedErrors = coreSchema->adminPanelConnector.translator.reverseTranslate(errors);
-	boost::lock_guard<boost::mutex> l(workingObjects->configSyncher);
-	P_DEBUG("asyncPrepareConfigChangeForAdminPanelConnectorDone: counter "
-		<< req->counter << " -> " << (req->counter - 1));
-	req->errors.insert(req->errors.begin(), translatedErrors.begin(), translatedErrors.end());
-	asyncPrepareConfigChangeCompletedOne(req);
-}
-
 //
 //
 
@@ -212,15 +199,6 @@ asyncPrepareConfigChange(const Json::Value &updates, ConfigChangeRequest *req,
 			asyncPrepareConfigChangeForApiServer, updates, req));
 	}
 
-	if (wo->adminPanelConnector != NULL) {
-		req->counter++;
-		wo->adminPanelConnector->asyncPrepareConfigChange(
-			coreSchema->adminPanelConnector.translator.translate(updates),
-			req->forAdminPanelConnector,
-			boost::bind(asyncPrepareConfigChangeForAdminPanelConnectorDone,
-				boost::placeholders::_1, boost::placeholders::_2, req));
-	}
-
 	/***************/
 	/***************/
 
@@ -268,16 +246,6 @@ asyncCommitConfigChangeForApiServer(ConfigChangeRequest *req) {
 	asyncCommitConfigChangeCompletedOne(req);
 }
 
-static void
-asyncCommitConfigChangeForAdminPanelConnectorDone(AdminPanelConnector::ConfigChangeRequest &_,
-	ConfigChangeRequest *req)
-{
-	boost::lock_guard<boost::mutex> l(workingObjects->configSyncher);
-	P_DEBUG("asyncCommitConfigChangeForAdminPanelConnectorDone: counter "
-		<< req->counter << " -> " << (req->counter - 1));
-	asyncCommitConfigChangeCompletedOne(req);
-}
-
 //
 //
 
@@ -321,14 +289,6 @@ asyncCommitConfigChange(ConfigChangeRequest *req, const CommitConfigChangeCallba
 			asyncCommitConfigChangeForApiServer, req));
 	}
 
-	if (wo->adminPanelConnector != NULL) {
-		req->counter++;
-		wo->adminPanelConnector->asyncCommitConfigChange(
-			req->forAdminPanelConnector,
-			boost::bind(asyncCommitConfigChangeForAdminPanelConnectorDone,
-				boost::placeholders::_1, req));
-	}
-
 	/***************/
 	/***************/
 
@@ -361,7 +321,7 @@ manipulateLoggingKitConfig(const ConfigKit::Store &coreConfig,
 	const Json::Value &loggingKitConfig)
 {
 	Json::Value result = loggingKitConfig;
-	result["buffer_logs"] = !coreConfig["admin_panel_url"].isNull();
+	result["buffer_logs"] = false;
 	return result;
 }
 

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

@@ -23,10 +23,15 @@
  *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  *  THE SOFTWARE.
  */
-#include "DataStructures/LString.h"
+#include <DataStructures/LString.h>
 #include <Core/Controller.h>
 #include <Core/SpawningKit/ErrorRenderer.h>
 
+#if defined(__GLIBCXX__) || defined(__APPLE__)
+	#include <cxxabi.h>
+	#define CXX_ABI_API_AVAILABLE
+#endif
+
 /*************************************************************************
  *
  * Implements Core::Controller methods pertaining selecting an application
@@ -173,30 +178,62 @@ Controller::maybeSend100Continue(Client *client, Request *req) {
 	}
 }
 
+void
+Controller::handleSessionInitiationError(Client *client, Request *req, const std::exception &e) {
+	// TODO: only retry the session initiation if error is recoverable
+	if (req->sessionCheckoutTry < MAX_SESSION_CHECKOUT_TRY) {
+		SKC_DEBUG(client, "Error initiating session (" << e.what() << "); retrying (attempt " << int(req->sessionCheckoutTry) << ")");
+		refRequest(req, __FILE__, __LINE__);
+		getContext()->libev->runLater(boost::bind(checkoutSessionLater, req));
+	} else {
+		SKC_ERROR(client, "Error initiating session (" << e.what() << "); giving up after too many retries");
+		endRequestAsGatewayTimeout(&client, &req);
+	}
+}
+
+int
+Controller::getSessionSocketConnectIoWatchConditions() const {
+	return EV_WRITE;
+}
+
+double
+Controller::getSessionSocketEffectiveConnectTimeout(Request *req) const {
+	return req->connectTimeout;
+}
+
 void
 Controller::initiateSession(Client *client, Request *req) {
 	TRACE_POINT();
 	req->sessionCheckoutTry++;
 	try {
-		req->session->initiate(false);
-	} catch (const SystemException &e2) {
-		if (req->sessionCheckoutTry < MAX_SESSION_CHECKOUT_TRY) {
-			SKC_DEBUG(client, "Error checking out session (" << e2.what() <<
-				"); retrying (attempt " << req->sessionCheckoutTry << ")");
-			refRequest(req, __FILE__, __LINE__);
-			getContext()->libev->runLater(boost::bind(checkoutSessionLater, req));
-		} else {
-			string message = "could not initiate a session (";
-			message.append(e2.what());
-			message.append(")");
-			disconnectWithError(&client, message);
+		if (!req->session->initiate()) {
+			SKC_DEBUG(client, "Session socket connection in progress");
+
+			req->connectedWatcher.data = req;
+			req->connectedWatcherTimout.data = req;
+
+			ev_io_init(&req->connectedWatcher, onSessionSocketConnected, req->session->fd(), getSessionSocketConnectIoWatchConditions());
+			ev_timer_init(&req->connectedWatcherTimout, onSessionSocketConnectTimeout, getSessionSocketEffectiveConnectTimeout(req), 0);
+
+			ev_io_start(getLoop(), &req->connectedWatcher);
+			ev_timer_start(getLoop(), &req->connectedWatcherTimout);
+
+			return;
 		}
+	} catch (const oxt::tracable_exception &e) {
+		UPDATE_TRACE_POINT();
+		handleSessionInitiationError(client, req, e);
 		return;
 	}
 
 	UPDATE_TRACE_POINT();
+	SKC_DEBUG(client, "Session socket immediately connected");
+	finishInitiatingSession(client, req);
+}
 
-	UPDATE_TRACE_POINT();
+void
+Controller::finishInitiatingSession(Client *client, Request *req) {
+	TRACE_POINT();
 	SKC_DEBUG(client, "Session initiated: fd=" << req->session->fd());
 	req->appSink.reinitialize(req->session->fd());
 	req->appSource.reinitialize(req->session->fd());
@@ -206,6 +243,55 @@ Controller::initiateSession(Client *client, Request *req) {
 	sendHeaderToApp(client, req);
 }
 
+void
+Controller::onSessionSocketConnected(EV_P_ ev_io *io, int revents) {
+	Request *req = static_cast<Request *>(io->data);
+	Client *client = static_cast<Client *>(req->client);
+	Controller *self = static_cast<Controller *>(Controller::getServerFromClient(client));
+
+	TRACE_POINT();
+
+    ev_io_stop(self->getLoop(), io);
+	if (req->connectedWatcherTimout.active) {
+		ev_timer_stop(self->getLoop(), &req->connectedWatcherTimout);
+	}
+
+	if (revents & EV_WRITE) {
+		// Socket connect finished
+		int connectError = 0;
+		socklen_t connectErrorLen = sizeof(connectError);
+		if (-1 == getsockopt(req->session->fd(), SOL_SOCKET, SO_ERROR, &connectError, &connectErrorLen)) {
+			int err = errno;
+			SystemException e("Cannot check socket status", err);
+			self->handleSessionInitiationError(client, req, e);
+			return;
+		} else if (connectError != 0) {
+			// connectError uses the same error codes as errno
+			SystemException e("Cannot connect socket", connectError);
+			self->handleSessionInitiationError(client, req, e);
+			return;
+		}
+
+		self->finishInitiatingSession(client, req);
+	} else {
+		// Something went very wrong
+		RuntimeException e("Unknown error occurred while waiting for socket connect to finish");
+		self->handleSessionInitiationError(client, req, e);
+	}
+}
+
+void
+Controller::onSessionSocketConnectTimeout(EV_P_ ev_timer *io, int flag) {
+	Request *req = static_cast<Request *>(io->data);
+	Client *client = static_cast<Client *>(req->client);
+	Controller *self = static_cast<Controller *>(Controller::getServerFromClient(client));
+
+	TRACE_POINT();
+	ev_io_stop(self->getLoop(), &req->connectedWatcher);
+	SystemException e("Waiting on socket connect timed out", ETIMEDOUT);
+	self->handleSessionInitiationError(client, req, e);
+}
+
 void
 Controller::checkoutSessionLater(Request *req) {
 	Client *client = static_cast<Client *>(req->client);

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

@@ -27,7 +27,6 @@
 #define _PASSENGER_REQUEST_HANDLER_CLIENT_H_
 
 #include <ev++.h>
-#include <ostream>
 #include <ServerKit/HttpClient.h>
 #include <Core/Controller/Request.h>
 

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

@@ -118,7 +118,7 @@ parseControllerBenchmarkMode(const StaticString &mode) {
  *   old_routing                                         boolean            -          default(false),read_only
  *   request_freelist_limit                              unsigned integer   -          default(1024)
  *   response_buffer_high_watermark                      unsigned integer   -          default(134217728)
- *   server_software                                     string             -          default("Phusion_Passenger/6.0.25")
+ *   server_software                                     string             -          default("Phusion_Passenger/6.0.27")
  *   show_version_in_header                              boolean            -          default(true)
  *   start_reading_after_accept                          boolean            -          default(true)
  *   stat_throttle_rate                                  unsigned integer   -          default(10)