passenger 5.2.3 → 5.3.0

data/src/agent/Core/ApplicationPool/Pool/AnalyticsCollection.cpp

@@ -105,47 +105,6 @@ Pool::updateProcessMetrics(const ProcessList &processes,
 	}
 }
 
-void
-Pool::prepareUnionStationProcessStateLogs(vector<UnionStationLogEntry> &logEntries,
-	const GroupPtr &group) const
-{
-	const UnionStation::ContextPtr &unionStationContext = getUnionStationContext();
-	if (group->options.analytics && unionStationContext != NULL) {
-		logEntries.push_back(UnionStationLogEntry());
-		UnionStationLogEntry &entry = logEntries.back();
-		stringstream stream;
-
-		stream << "Group: <group>";
-		group->inspectXml(stream, false);
-		stream << "</group>";
-
-		entry.groupName = group->options.getAppGroupName();
-		entry.category  = "processes";
-		entry.key       = group->options.unionStationKey;
-		entry.data      = stream.str();
-	}
-}
-
-void
-Pool::prepareUnionStationSystemMetricsLogs(vector<UnionStationLogEntry> &logEntries,
-	const GroupPtr &group) const
-{
-	const UnionStation::ContextPtr &unionStationContext = getUnionStationContext();
-	if (group->options.analytics && unionStationContext != NULL) {
-		logEntries.push_back(UnionStationLogEntry());
-		UnionStationLogEntry &entry = logEntries.back();
-		stringstream stream;
-
-		stream << "System metrics: ";
-		systemMetrics.toXml(stream);
-
-		entry.groupName = group->options.getAppGroupName();
-		entry.category  = "system_metrics";
-		entry.key       = group->options.unionStationKey;
-		entry.data      = stream.str();
-	}
-}
-
 void
 Pool::realCollectAnalytics() {
 	TRACE_POINT();
@@ -177,7 +136,7 @@ Pool::realCollectAnalytics() {
 	}
 
 	// Collect process metrics and system and store them in the
-	// data structures. Later, we log them to Union Station.
+	// data structures.
 	ProcessMetricMap processMetrics;
 	try {
 		UPDATE_TRACE_POINT();
@@ -198,7 +157,6 @@ Pool::realCollectAnalytics() {
 
 	{
 		UPDATE_TRACE_POINT();
-		vector<UnionStationLogEntry> logEntries;
 		vector<ProcessPtr> processesToDetach;
 		boost::container::vector<Callback> actions;
 		ScopedLock l(syncher);
@@ -210,8 +168,6 @@ Pool::realCollectAnalytics() {
 			updateProcessMetrics(group->enabledProcesses, processMetrics, processesToDetach);
 			updateProcessMetrics(group->disablingProcesses, processMetrics, processesToDetach);
 			updateProcessMetrics(group->disabledProcesses, processMetrics, processesToDetach);
-			prepareUnionStationProcessStateLogs(logEntries, group);
-			prepareUnionStationSystemMetricsLogs(logEntries, group);
 			g_it.next();
 		}
 
@@ -223,21 +179,6 @@ Pool::realCollectAnalytics() {
 		processesToDetach.clear();
 
 		l.unlock();
-		UPDATE_TRACE_POINT();
-		if (!logEntries.empty()) {
-			const UnionStation::ContextPtr &unionStationContext = getUnionStationContext();
-			P_DEBUG("Sending process and system metrics to Union Station");
-			while (!logEntries.empty()) {
-				UnionStationLogEntry &entry = logEntries.back();
-				UnionStation::TransactionPtr transaction =
-					unionStationContext->newTransaction(
-						entry.groupName,
-						entry.category,
-						entry.key);
-				transaction->message(entry.data);
-				logEntries.pop_back();
-			}
-		}
 
 		UPDATE_TRACE_POINT();
 		runAllActions(actions);

data/src/agent/Core/ApplicationPool/Pool/GeneralUtils.cpp

@@ -80,12 +80,14 @@ bool
 Pool::runHookScripts(const char *name,
 	const boost::function<void (HookScriptOptions &)> &setup) const
 {
-	if (!agentConfig.isNull()) {
+	ScopedLock l(context->agentConfigSyncher);
+	if (!context->agentConfig.isNull()) {
 		string hookName = string("hook_") + name;
-		string spec = agentConfig.get(hookName, Json::Value()).asString();
+		string spec = context->agentConfig.get(hookName, Json::Value()).asString();
 		if (!spec.empty()) {
 			HookScriptOptions options;
-			options.agentConfig = agentConfig;
+			options.agentConfig = context->agentConfig;
+			l.unlock();
 			options.name = name;
 			options.spec = spec;
 			setup(options);
@@ -219,22 +221,17 @@ Pool::syncGetCallback(const AbstractSessionPtr &session, const ExceptionPtr &e,
 
 Context *
 Pool::getContext() {
-	return &context;
+	return context;
 }
 
-const SpawningKit::ConfigPtr &
-Pool::getSpawningKitConfig() const {
-	return context.getSpawningKitConfig();
-}
-
-const UnionStation::ContextPtr &
-Pool::getUnionStationContext() const {
-	return getSpawningKitConfig()->unionStationContext;
+SpawningKit::Context *
+Pool::getSpawningKitContext() const {
+	return context->getSpawningKitContext();
 }
 
 const RandomGeneratorPtr &
 Pool::getRandomGenerator() const {
-	return getSpawningKitConfig()->randomGenerator;
+	return context->getRandomGenerator();
 }
 
 

data/src/agent/Core/ApplicationPool/Pool/InitializationAndShutdown.cpp

@@ -38,15 +38,10 @@ using namespace std;
 using namespace boost;
 
 
-Pool::Pool(const SpawningKit::FactoryPtr &spawningKitFactory,
-	const Json::Value &agentConfig)
-	: abortLongRunningConnectionsCallback(NULL)
+Pool::Pool(Context *_context)
+	: context(_context),
+	  abortLongRunningConnectionsCallback(NULL)
 {
-	context.setSpawningKitFactory(spawningKitFactory);
-	context.finalize();
-
-	this->agentConfig = agentConfig;
-
 	try {
 		systemMetricsCollector.collect(systemMetrics);
 	} catch (const RuntimeException &e) {

data/src/agent/Core/ApplicationPool/Pool/Miscellaneous.cpp

@@ -41,7 +41,7 @@ using namespace boost;
 // 'lockNow == false' may only be used during unit tests. Normally we
 // should never call the callback while holding the lock.
 void
-Pool::asyncGet(const Options &options, const GetCallback &callback, bool lockNow, UnionStation::StopwatchLog **stopwatchLog) {
+Pool::asyncGet(const Options &options, const GetCallback &callback, bool lockNow) {
 	DynamicScopedLock lock(syncher, lockNow);
 
 	assert(lifeStatus == ALIVE || lifeStatus == PREPARED_FOR_SHUTDOWN);
@@ -50,32 +50,6 @@ Pool::asyncGet(const Options &options, const GetCallback &callback, bool lockNow
 	boost::container::vector<Callback> actions;
 
 	Group *existingGroup = findMatchingGroup(options);
-	if (stopwatchLog != NULL) {
-		// Log some essentials stats about what this request is facing in its upcoming journey through the queue:
-		// 1) position in the queue upon entry, and 2) whether spawning activity is occurring (which takes cycles
-		// but also indicates the server has headroom to handle the load).
-		Json::Value data;
-		if (!existingGroup) {
-			data["message"] = "spawning.."; // the first of this group, so keep it simple (also: we don't know maxQ yet)
-		} else {
-			char queueMaxStr[10];
-			int queueMax = existingGroup->options.maxRequestQueueSize;
-			if (queueMax > 0) {
-				snprintf(queueMaxStr, sizeof(queueMaxStr), "%d", queueMax);
-			}
-			char message[50];
-			snprintf(message, sizeof(message), "queue: %zu / %s, spawning: %s", existingGroup->getWaitlist.size(),
-					(queueMax == 0 ? "inf" : queueMaxStr),
-					(existingGroup->processesBeingSpawned == 0 ? "no" : "yes"));
-			data["message"] = message;
-		}
-		Json::Value json;
-		json["data"] = data;
-		json["data_type"] = "generic";
-		json["name"] = "Await available process";
-
-		*stopwatchLog = new UnionStation::StopwatchLog(options.transaction, "Pool::asyncGet", stringifyJson(json).c_str());
-	}
 
 	if (OXT_LIKELY(existingGroup != NULL)) {
 		/* Best case: the app group is already in the pool. Let's use it. */
@@ -119,7 +93,7 @@ Pool::asyncGet(const Options &options, const GetCallback &callback, bool lockNow
 			 */
 			P_DEBUG("Could not free a process; putting request to top-level getWaitlist");
 			getWaitlist.push_back(GetWaiter(
-				options.copyAndPersist().detachFromUnionStationTransaction(),
+				options.copyAndPersist(),
 				callback));
 		} else {
 			/* Now that a process has been trashed we can create
@@ -250,12 +224,6 @@ Pool::isSpawning(bool lock) const {
 	return false;
 }
 
-void
-Pool::setAgentConfig(const Json::Value &agentConfig) {
-	LockGuard l(syncher);
-	this->agentConfig = agentConfig;
-}
-
 bool
 Pool::authorizeByApiKey(const ApiKey &key, bool lock) const {
 	return key.isSuper() || findGroupByApiKey(key.toStaticString(), lock) != NULL;

data/src/agent/Core/ApplicationPool/Pool/StateInspection.cpp

@@ -108,7 +108,7 @@ Pool::inspectProcessList(const InspectOptions &options, stringstream &result,
 		}
 
 		const Socket *socket;
-		if (options.verbose && (socket = process->getSockets().findSocketWithName("http")) != NULL) {
+		if (options.verbose && (socket = process->getSockets().findFirstSocketWithProtocol("http")) != NULL) {
 			result << "    URL     : http://" << replaceString(socket->address, "tcp://", "") << endl;
 			result << "    Password: " << group->getApiKey().toStaticString() << endl;
 		}

data/src/agent/Core/ApplicationPool/Process.cpp

@@ -33,20 +33,25 @@ namespace ApplicationPool2 {
 using namespace std;
 using namespace boost;
 
-SpawningKit::PipeWatcherPtr Process::makePipeWatcher(const SpawningKit::ConfigPtr &config, FileDescriptor socket, const char *channel, pid_t pid, const BasicGroupInfo *groupInfo) {
-	StaticString appLogFile;
-	HashedStaticString appGroupName;
-	if (groupInfo->group != NULL) {
-		appLogFile = groupInfo->group->options.appLogFile;
-		appGroupName = groupInfo->group->options.getAppGroupName();
+
+string
+Process::getAppGroupName(const BasicGroupInfo *info) const {
+	if (info->group != NULL) {
+		return info->group->options.getAppGroupName().toString();
+	} else {
+		return string();
 	}
-	SpawningKit::PipeWatcherPtr watcher = boost::make_shared<SpawningKit::PipeWatcher>(
-		config, socket, channel, pid, appGroupName, appLogFile
-	);
-	watcher->initialize();
-	watcher->start();
-	return watcher;
 }
 
+string
+Process::getAppLogFile(const BasicGroupInfo *info) const {
+	if (info->group != NULL) {
+		return info->group->options.appLogFile.toString();
+	} else {
+		return string();
+	}
+}
+
+
 } // namespace ApplicationPool2
 } // namespace Passenger

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

@@ -65,16 +65,14 @@ typedef boost::container::vector<ProcessPtr> ProcessList;
 
 /**
  * Represents an application process, as spawned by a SpawningKit::Spawner. Every
- * Process has a PID, an admin socket and a list of sockets on which it listens for
- * connections. A Process object is contained inside a Group.
+ * Process has a PID, a stdin pipe, an output pipe and a list of sockets on which
+ * it listens for connections. A Process object is contained inside a Group.
  *
- * The admin socket, an anonymous Unix domain socket, is mapped to the process's
- * STDIN and STDOUT and has two functions.
+ * The stdin pipe is mapped to the process's STDIN and is used for garbage
+ * collection: closing the STDIN part causes the process to gracefully terminate itself.
  *
- *  1. It acts as the main communication channel with the process. Commands are
- *     sent to and responses are received from it.
- *  2. It's used for garbage collection: closing the STDIN part causes the process
- *     to gracefully terminate itself.
+ * The output pipe is mapped to the process' STDOUT and STDERR. All data coming
+ * from those pipes will be printed.
  *
  * Except for the otherwise documented parts, this class is not thread-safe,
  * so only use within the Pool lock.
@@ -102,7 +100,7 @@ typedef boost::container::vector<ProcessPtr> ProcessList;
  */
 class Process {
 public:
-	static const unsigned int MAX_SESSION_SOCKETS = 3;
+	static const unsigned int MAX_SOCKETS_ACCEPTING_HTTP_REQUESTS = 3;
 
 private:
 	/*************************************************************
@@ -121,21 +119,20 @@ private:
 	int concurrency;
 
 	/**
-	 * A subset of 'sockets': all sockets that speak the
-	 * "session" or "http_session" protocol.
+	 * A subset of 'sockets': all sockets that accept HTTP requests
+	 * from the Passenger Core controller.
 	 */
-	unsigned int sessionSocketCount;
-	Socket *sessionSockets[MAX_SESSION_SOCKETS];
+	unsigned int socketsAcceptingHttpRequestsCount;
+	Socket *socketsAcceptingHttpRequests[MAX_SOCKETS_ACCEPTING_HTTP_REQUESTS];
 
-	/** Admin socket. See Process class description. */
-	FileDescriptor adminSocket;
+	/** Input pipe. See Process class description. */
+	FileDescriptor inputPipe;
 
 	/**
-	 * Pipe on which this process outputs errors. Mapped to the process's STDERR.
-	 * Only Processes spawned by DirectSpawner have this set.
-	 * SmartSpawner-spawned Processes use the same STDERR as their parent preloader processes.
+	 * Pipe on which this process outputs stdout and stderr data. Mapped to the
+	 * process's STDOUT and STDERR.
 	 */
-	FileDescriptor errorPipe;
+	FileDescriptor outputPipe;
 
 	/**
 	 * The code revision of the application, inferred through various means.
@@ -201,9 +198,9 @@ private:
 		};
 
 		struct SocketStringOffsets {
-			String name;
 			String address;
 			String protocol;
+			String description;
 		};
 
 		vector<SocketStringOffsets> socketStringOffsets;
@@ -211,15 +208,33 @@ private:
 	};
 
 	void appendJsonFieldToBuffer(std::string &buffer, const Json::Value &json,
-		const char *key, InitializationLog::String &str) const
+		const char *key, InitializationLog::String &str, bool required = true) const
 	{
-		StaticString value = getJsonStaticStringField(json, key);
+		StaticString value;
+		if (required) {
+			value = getJsonStaticStringField(json, key);
+		} else {
+			value = getJsonStaticStringField(json, Json::StaticString(key),
+				StaticString());
+		}
 		str.offset = buffer.size();
 		str.size   = value.size();
 		buffer.append(value.data(), value.size());
 		buffer.append(1, '\0');
 	}
 
+	void initializeSocketsAndStringFields(const SpawningKit::Result &result) {
+		Json::Value doc, sockets(Json::arrayValue);
+		vector<SpawningKit::Result::Socket>::const_iterator it, end = result.sockets.end();
+
+		for (it = result.sockets.begin(); it != end; it++) {
+			sockets.append(it->inspectAsJson());
+		}
+
+		doc["sockets"] = sockets;
+		initializeSocketsAndStringFields(doc);
+	}
+
 	void initializeSocketsAndStringFields(const Json::Value &json) {
 		InitializationLog log;
 		string buffer;
@@ -238,9 +253,10 @@ private:
 			const Json::Value &socket = *it;
 			InitializationLog::SocketStringOffsets offsets;
 
-			appendJsonFieldToBuffer(buffer, socket, "name", offsets.name);
 			appendJsonFieldToBuffer(buffer, socket, "address", offsets.address);
 			appendJsonFieldToBuffer(buffer, socket, "protocol", offsets.protocol);
+			appendJsonFieldToBuffer(buffer, socket, "description", offsets.description,
+				false);
 
 			log.socketStringOffsets.push_back(offsets);
 		}
@@ -267,13 +283,14 @@ private:
 			const Json::Value &socket = *it;
 			this->sockets.add(
 				info.pid,
-				StaticString(base + log.socketStringOffsets[i].name.offset,
-					log.socketStringOffsets[i].name.size),
 				StaticString(base + log.socketStringOffsets[i].address.offset,
 					log.socketStringOffsets[i].address.size),
 				StaticString(base + log.socketStringOffsets[i].protocol.offset,
 					log.socketStringOffsets[i].protocol.size),
-				getJsonIntField(socket, "concurrency")
+				StaticString(base + log.socketStringOffsets[i].description.offset,
+					log.socketStringOffsets[i].description.size),
+				getJsonIntField(socket, "concurrency"),
+				getJsonBoolField(socket, "accept_http_requests")
 			);
 		}
 
@@ -283,44 +300,51 @@ private:
 		}
 	}
 
-	void indexSessionSockets() {
+	void indexSocketsAcceptingHttpRequests() {
 		SocketList::iterator it;
 
 		concurrency = 0;
-		memset(sessionSockets, 0, sizeof(sessionSockets));
+		memset(socketsAcceptingHttpRequests, 0, sizeof(socketsAcceptingHttpRequests));
 
 		for (it = sockets.begin(); it != sockets.end(); it++) {
 			Socket *socket = &(*it);
-			if (socket->protocol == "session" || socket->protocol == "http_session") {
-				if (sessionSocketCount == MAX_SESSION_SOCKETS) {
-					throw RuntimeException("The process has too many session sockets. "
-						"A maximum of " + toString(MAX_SESSION_SOCKETS) + " is allowed");
-				}
-				sessionSockets[sessionSocketCount] = socket;
-				sessionSocketCount++;
-
-				if (concurrency != -1) {
-					if (socket->concurrency == 0) {
-						// If one of the sockets has a concurrency of
-						// 0 (unlimited) then we mark this entire Process
-						// as having a concurrency of 0.
-						concurrency = -1;
-					} else {
-						concurrency += socket->concurrency;
-					}
+			if (!socket->acceptHttpRequests) {
+				continue;
+			}
+			if (socketsAcceptingHttpRequestsCount == MAX_SOCKETS_ACCEPTING_HTTP_REQUESTS) {
+				throw RuntimeException("The process has too many sockets that accept HTTP requests. "
+					"A maximum of " + toString(MAX_SOCKETS_ACCEPTING_HTTP_REQUESTS) + " is allowed");
+			}
+
+			socketsAcceptingHttpRequests[socketsAcceptingHttpRequestsCount] = socket;
+			socketsAcceptingHttpRequestsCount++;
+
+			if (concurrency >= 0) {
+				if (socket->concurrency < 0) {
+					// If one of the sockets has a concurrency of
+					// < 0 (unknown) then we mark this entire Process
+					// as having a concurrency of -1 (unknown).
+					concurrency = -1;
+				} else if (socket->concurrency == 0) {
+					// If one of the sockets has a concurrency of
+					// 0 (unlimited) then we mark this entire Process
+					// as having a concurrency of 0.
+					concurrency = -999;
+				} else {
+					concurrency += socket->concurrency;
 				}
 			}
 		}
 
-		if (concurrency == -1) {
+		if (concurrency == -999) {
 			concurrency = 0;
 		}
 	}
 
 	void destroySelf() const {
 		this->~Process();
-		LockGuard l(getContext()->getMmSyncher());
-		getContext()->getProcessObjectPool().free(const_cast<Process *>(this));
+		LockGuard l(getContext()->memoryManagementSyncher);
+		getContext()->processObjectPool.free(const_cast<Process *>(this));
 	}
 
 
@@ -353,7 +377,8 @@ private:
 		return result;
 	}
 
-	SpawningKit::PipeWatcherPtr makePipeWatcher(const SpawningKit::ConfigPtr &config, FileDescriptor socket, const char *channel, pid_t pid, const BasicGroupInfo *groupInfo);
+	string getAppGroupName(const BasicGroupInfo *info) const;
+	string getAppLogFile(const BasicGroupInfo *info) const;
 
 public:
 	/*************************************************************
@@ -427,13 +452,13 @@ public:
 	ProcessMetrics metrics;
 
 
-	Process(const BasicGroupInfo *groupInfo, const Json::Value &json)
-		: info(this, groupInfo, json),
-		  sessionSocketCount(0),
-		  spawnerCreationTime(getJsonUint64Field(json, "spawner_creation_time")),
-		  spawnStartTime(getJsonUint64Field(json, "spawn_start_time")),
+	Process(const BasicGroupInfo *groupInfo, const Json::Value &args)
+		: info(this, groupInfo, args),
+		  socketsAcceptingHttpRequestsCount(0),
+		  spawnerCreationTime(getJsonUint64Field(args, "spawner_creation_time")),
+		  spawnStartTime(getJsonUint64Field(args, "spawn_start_time")),
 		  spawnEndTime(SystemTime::getUsec()),
-		  dummy(json["type"] == "dummy"),
+		  dummy(args["type"] == "dummy"),
 		  requiresShutdown(false),
 		  refcount(1),
 		  index(-1),
@@ -447,21 +472,46 @@ public:
 		  longRunningConnectionsAborted(false),
 		  shutdownStartTime(0)
 	{
-		initializeSocketsAndStringFields(json);
-		indexSessionSockets();
-
-		const SpawningKit::Result *skResult = dynamic_cast<const SpawningKit::Result *>(&json);
-		if (skResult != NULL) {
-			adminSocket = skResult->adminSocket;
-			errorPipe = skResult->errorPipe;
-
-			if (adminSocket != -1) {
-				SpawningKit::PipeWatcherPtr watcher = makePipeWatcher(getContext()->getSpawningKitConfig(), adminSocket, "stdout", info.pid, groupInfo);
-			}
-
-			if (errorPipe != -1) {
-				SpawningKit::PipeWatcherPtr watcher = makePipeWatcher(getContext()->getSpawningKitConfig(), errorPipe, "stderr", info.pid, groupInfo);
+		initializeSocketsAndStringFields(args);
+		indexSocketsAcceptingHttpRequests();
+	}
+
+	Process(const BasicGroupInfo *groupInfo, const SpawningKit::Result &skResult,
+		const Json::Value &args)
+		: info(this, groupInfo, skResult),
+		  socketsAcceptingHttpRequestsCount(0),
+		  spawnerCreationTime(getJsonUint64Field(args, "spawner_creation_time")),
+		  spawnStartTime(skResult.spawnStartTime),
+		  spawnEndTime(skResult.spawnEndTime),
+		  dummy(skResult.dummy),
+		  requiresShutdown(false),
+		  refcount(1),
+		  index(-1),
+		  lastUsed(spawnEndTime),
+		  sessions(0),
+		  processed(0),
+		  lifeStatus(ALIVE),
+		  enabled(ENABLED),
+		  oobwStatus(OOBW_NOT_ACTIVE),
+		  m_osProcessExists(true),
+		  longRunningConnectionsAborted(false),
+		  shutdownStartTime(0)
+	{
+		initializeSocketsAndStringFields(skResult);
+		indexSocketsAcceptingHttpRequests();
+
+		inputPipe = skResult.stdinFd;
+		outputPipe = skResult.stdoutAndErrFd;
+
+		if (outputPipe != -1) {
+			SpawningKit::PipeWatcherPtr watcher = boost::make_shared<SpawningKit::PipeWatcher>(
+				outputPipe, "output", getAppGroupName(groupInfo),
+				getAppLogFile(groupInfo), skResult.pid);
+			if (!args["log_file"].isNull()) {
+				watcher->setLogFile(args["log_file"].asString());
 			}
+			watcher->initialize();
+			watcher->start();
 		}
 	}
 
@@ -479,8 +529,8 @@ public:
 	void forceMaxConcurrency(int value) {
 		assert(value >= 0);
 		concurrency = value;
-		for (unsigned i = 0; i < sessionSocketCount; i++) {
-			sessionSockets[i]->concurrency = concurrency;
+		for (unsigned i = 0; i < socketsAcceptingHttpRequestsCount; i++) {
+			socketsAcceptingHttpRequests[i]->concurrency = concurrency;
 		}
 	}
 
@@ -553,8 +603,8 @@ public:
 			lifeStatus = SHUTDOWN_TRIGGERED;
 			shutdownStartTime = now;
 		}
-		if (!dummy) {
-			syscalls::shutdown(adminSocket, SHUT_WR);
+		if (inputPipe != -1) {
+			inputPipe.close();
 		}
 	}
 
@@ -644,23 +694,23 @@ public:
 		return sockets;
 	}
 
-	Socket *findSessionSocketWithLowestBusyness() const {
-		if (OXT_UNLIKELY(sessionSocketCount == 0)) {
+	Socket *findSocketsAcceptingHttpRequestsAndWithLowestBusyness() const {
+		if (OXT_UNLIKELY(socketsAcceptingHttpRequestsCount == 0)) {
 			return NULL;
-		} else if (sessionSocketCount == 1) {
-			return sessionSockets[0];
+		} else if (socketsAcceptingHttpRequestsCount == 1) {
+			return socketsAcceptingHttpRequests[0];
 		} else {
-			int leastBusySessionSocketIndex = 0;
-			int lowestBusyness = sessionSockets[0]->busyness();
+			int leastBusySocketIndex = 0;
+			int lowestBusyness = socketsAcceptingHttpRequests[0]->busyness();
 
-			for (unsigned i = 1; i < sessionSocketCount; i++) {
-				if (sessionSockets[i]->busyness() < lowestBusyness) {
-					leastBusySessionSocketIndex = i;
-					lowestBusyness = sessionSockets[i]->busyness();
+			for (unsigned i = 1; i < socketsAcceptingHttpRequestsCount; i++) {
+				if (socketsAcceptingHttpRequests[i]->busyness() < lowestBusyness) {
+					leastBusySocketIndex = i;
+					lowestBusyness = socketsAcceptingHttpRequests[i]->busyness();
 				}
 			}
 
-			return sessionSockets[leastBusySessionSocketIndex];
+			return socketsAcceptingHttpRequests[leastBusySocketIndex];
 		}
 	}
 
@@ -700,15 +750,15 @@ public:
 		/* Different processes within a Group may have different
 		 * 'concurrency' values. We want:
 		 * - the process with the smallest busyness to be be picked for routing.
-		 * - to give processes with concurrency == 0 more priority (in general)
+		 * - to give processes with concurrency == 0 or -1 more priority (in general)
 		 *   over processes with concurrency > 0.
 		 * Therefore, in case of processes 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 processes with concurrency > 0 is usually higher than that of processes
-		 * 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);
@@ -720,7 +770,7 @@ public:
 	 * process.
 	 */
 	bool isTotallyBusy() const {
-		return concurrency != 0 && sessions >= concurrency;
+		return concurrency > 0 && sessions >= concurrency;
 	}
 
 	/**
@@ -745,7 +795,7 @@ public:
 	 * not result in any harmful behavior.
 	 */
 	SessionPtr newSession(unsigned long long now = 0) {
-		Socket *socket = findSessionSocketWithLowestBusyness();
+		Socket *socket = findSocketsAcceptingHttpRequestsAndWithLowestBusyness();
 		if (socket->isTotallyBusy()) {
 			return SessionPtr();
 		} else {
@@ -772,7 +822,7 @@ public:
 
 			~Guard() {
 				if (session != NULL) {
-					context->getSessionObjectPool().free(session);
+					context->sessionObjectPool.free(session);
 				}
 			}
 
@@ -782,8 +832,8 @@ public:
 		};
 
 		Context *context = getContext();
-		LockGuard l(context->getMmSyncher());
-		Session *session = context->getSessionObjectPool().malloc();
+		LockGuard l(context->memoryManagementSyncher);
+		Session *session = context->sessionObjectPool.malloc();
 		Guard guard(context, session);
 		session = new (session) Session(context, &info, socket);
 		guard.clear();
@@ -882,10 +932,13 @@ public:
 			for (it = sockets.begin(); it != sockets.end(); it++) {
 				const Socket &socket = *it;
 				stream << "<socket>";
-				stream << "<name>" << escapeForXml(socket.name) << "</name>";
 				stream << "<address>" << escapeForXml(socket.address) << "</address>";
 				stream << "<protocol>" << escapeForXml(socket.protocol) << "</protocol>";
+				if (!socket.description.empty()) {
+					stream << "<description>" << escapeForXml(socket.description) << "</description>";
+				}
 				stream << "<concurrency>" << socket.concurrency << "</concurrency>";
+				stream << "<accept_http_requests>" << socket.acceptHttpRequests << "</accept_http_requests>";
 				stream << "<sessions>" << socket.sessions << "</sessions>";
 				stream << "</socket>";
 			}