passenger 5.0.9 → 5.0.10

data/ext/common/ServerKit/Server.h

@@ -491,63 +491,6 @@ private:
 	}
 
 protected:
-	/***** Protected API *****/
-
-	/** Get a thread-safe reference to the client. As long as the client
-	 * has a reference, it will never be added to the freelist.
-	 */
-	ClientRefType getClientRef(Client *client, const char *file, unsigned int line) {
-		return ClientRefType(client, file, line);
-	}
-
-	/**
-	 * Returns a pointer to the BaseServer that created the given Client object.
-	 * Unlike the void pointer that Client::getServerBaseClassPointer() returns,
-	 * this method's typed return value allows safe recasting of the result pointer.
-	 */
-	static const BaseServer *getConstServerFromClient(const Client *client) {
-		return static_cast<BaseServer *>(client->getServerBaseClassPointer());
-	}
-
-	static BaseServer *getServerFromClient(Client *client) {
-		return static_cast<BaseServer *>(client->getServerBaseClassPointer());
-	}
-
-	/** Increase client reference count. */
-	void refClient(Client *client, const char *file, unsigned int line) {
-		int oldRefcount = client->refcount.fetch_add(1, boost::memory_order_relaxed);
-		SKC_TRACE_WITH_POS(client, 3, file, line,
-			"Refcount increased; it is now " << (oldRefcount + 1));
-	}
-
-	/** Decrease client reference count. Adds client to the
-	 * freelist if reference count drops to 0.
-	 */
-	void unrefClient(Client *client, const char *file, unsigned int line) {
-		int oldRefcount = client->refcount.fetch_sub(1, boost::memory_order_release);
-		assert(oldRefcount >= 1);
-
-		SKC_TRACE_WITH_POS(client, 3, file, line,
-			"Refcount decreased; it is now " << (oldRefcount - 1));
-		if (oldRefcount == 1) {
-			boost::atomic_thread_fence(boost::memory_order_acquire);
-
-			if (ctx->libev->onEventLoopThread()) {
-				assert(client->getConnState() != Client::IN_FREELIST);
-				/* As long as the client is still in the ACTIVE state, it has at least
-				 * one reference, namely from the Server itself. Therefore it's impossible
-				 * to get to a zero reference count without having disconnected a client. */
-				P_ASSERT_EQ(client->getConnState(), Client::DISCONNECTED);
-				clientReachedZeroRefcount(client);
-			} else {
-				// Let the event loop handle the client reaching the 0 refcount.
-				SKC_TRACE(client, 3, "Passing client object to event loop thread");
-				passClientToEventLoopThread(client);
-			}
-		}
-	}
-
-
 	/***** Hooks *****/
 
 	virtual void onClientObjectCreated(Client *client) {
@@ -864,6 +807,40 @@ public:
 		return NULL;
 	}
 
+	/** Increase client reference count. */
+	void refClient(Client *client, const char *file, unsigned int line) {
+		int oldRefcount = client->refcount.fetch_add(1, boost::memory_order_relaxed);
+		SKC_TRACE_WITH_POS(client, 3, file, line,
+			"Refcount increased; it is now " << (oldRefcount + 1));
+	}
+
+	/** Decrease client reference count. Adds client to the
+	 * freelist if reference count drops to 0.
+	 */
+	void unrefClient(Client *client, const char *file, unsigned int line) {
+		int oldRefcount = client->refcount.fetch_sub(1, boost::memory_order_release);
+		assert(oldRefcount >= 1);
+
+		SKC_TRACE_WITH_POS(client, 3, file, line,
+			"Refcount decreased; it is now " << (oldRefcount - 1));
+		if (oldRefcount == 1) {
+			boost::atomic_thread_fence(boost::memory_order_acquire);
+
+			if (ctx->libev->onEventLoopThread()) {
+				assert(client->getConnState() != Client::IN_FREELIST);
+				/* As long as the client is still in the ACTIVE state, it has at least
+				 * one reference, namely from the Server itself. Therefore it's impossible
+				 * to get to a zero reference count without having disconnected a client. */
+				P_ASSERT_EQ(client->getConnState(), Client::DISCONNECTED);
+				clientReachedZeroRefcount(client);
+			} else {
+				// Let the event loop handle the client reaching the 0 refcount.
+				SKC_TRACE(client, 3, "Passing client object to event loop thread");
+				passClientToEventLoopThread(client);
+			}
+		}
+	}
+
 	bool disconnect(int fd) {
 		assert(serverState != FINISHED_SHUTDOWN);
 		Client *client = lookupClient(fd);
@@ -1024,6 +1001,29 @@ public:
 	}
 
 
+	/***** Miscellaneous *****/
+
+	/** Get a thread-safe reference to the client. As long as the client
+	 * has a reference, it will never be added to the freelist.
+	 */
+	ClientRefType getClientRef(Client *client, const char *file, unsigned int line) {
+		return ClientRefType(client, file, line);
+	}
+
+	/**
+	 * Returns a pointer to the BaseServer that created the given Client object.
+	 * Unlike the void pointer that Client::getServerBaseClassPointer() returns,
+	 * this method's typed return value allows safe recasting of the result pointer.
+	 */
+	static const BaseServer *getConstServerFromClient(const Client *client) {
+		return static_cast<BaseServer *>(client->getServerBaseClassPointer());
+	}
+
+	static BaseServer *getServerFromClient(Client *client) {
+		return static_cast<BaseServer *>(client->getServerBaseClassPointer());
+	}
+
+
 	/***** Friend-public methods and hook implementations *****/
 
 	void _refClient(Client *client, const char *file, unsigned int line) {

data/ext/common/SpawningKit/BackgroundIOCapturer.h

@@ -0,0 +1,160 @@
+/*
+ *  Phusion Passenger - https://www.phusionpassenger.com/
+ *  Copyright (c) 2011-2015 Phusion
+ *
+ *  "Phusion Passenger" is a trademark of Hongli Lai & Ninh Bui.
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in
+ *  all copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ *  THE SOFTWARE.
+ */
+#ifndef _PASSENGER_SPAWNING_KIT_BACKGROUND_IO_CAPTURER_H_
+#define _PASSENGER_SPAWNING_KIT_BACKGROUND_IO_CAPTURER_H_
+
+#include <boost/thread.hpp>
+#include <boost/bind.hpp>
+#include <boost/foreach.hpp>
+#include <oxt/backtrace.hpp>
+#include <oxt/system_calls.hpp>
+#include <string>
+#include <vector>
+#include <cstring>
+
+#include <sys/types.h>
+
+#include <Logging.h>
+#include <FileDescriptor.h>
+#include <StaticString.h>
+#include <Utils.h>
+#include <Utils/StrIntUtils.h>
+
+namespace Passenger {
+namespace SpawningKit {
+
+using namespace std;
+
+
+/**
+ * Given a file descriptor, captures its output in a background thread
+ * and also forwards it immediately to a target file descriptor.
+ * Call stop() to stop the background thread and to obtain the captured
+ * output so far.
+ */
+class BackgroundIOCapturer {
+private:
+	FileDescriptor fd;
+	pid_t pid;
+	const char *channelName;
+	boost::mutex dataSyncher;
+	string data;
+	oxt::thread *thr;
+
+	void capture() {
+		TRACE_POINT();
+		while (!this_thread::interruption_requested()) {
+			char buf[1024 * 8];
+			ssize_t ret;
+
+			UPDATE_TRACE_POINT();
+			ret = syscalls::read(fd, buf, sizeof(buf));
+			int e = errno;
+			this_thread::disable_syscall_interruption dsi;
+			if (ret == 0) {
+				break;
+			} else if (ret == -1) {
+				if (e != EAGAIN && e != EWOULDBLOCK) {
+					P_WARN("Background I/O capturer error: " <<
+						strerror(e) << " (errno=" << e << ")");
+					break;
+				}
+			} else {
+				{
+					boost::lock_guard<boost::mutex> l(dataSyncher);
+					data.append(buf, ret);
+				}
+				UPDATE_TRACE_POINT();
+				if (ret == 1 && buf[0] == '\n') {
+					printAppOutput(pid, channelName, "", 0);
+				} else {
+					vector<StaticString> lines;
+					if (ret > 0 && buf[ret - 1] == '\n') {
+						ret--;
+					}
+					split(StaticString(buf, ret), '\n', lines);
+					foreach (const StaticString line, lines) {
+						printAppOutput(pid, channelName, line.data(), line.size());
+					}
+				}
+			}
+		}
+	}
+
+public:
+	BackgroundIOCapturer(const FileDescriptor &_fd, pid_t _pid, const char *_channelName)
+		: fd(_fd),
+		  pid(_pid),
+		  channelName(_channelName),
+		  thr(NULL)
+		{ }
+
+	~BackgroundIOCapturer() {
+		TRACE_POINT();
+		if (thr != NULL) {
+			this_thread::disable_interruption di;
+			this_thread::disable_syscall_interruption dsi;
+			thr->interrupt_and_join();
+			delete thr;
+			thr = NULL;
+		}
+	}
+
+	const FileDescriptor &getFd() const {
+		return fd;
+	}
+
+	void start() {
+		assert(thr == NULL);
+		thr = new oxt::thread(boost::bind(&BackgroundIOCapturer::capture, this),
+			"Background I/O capturer", 64 * 1024);
+	}
+
+	string stop() {
+		TRACE_POINT();
+		assert(thr != NULL);
+		this_thread::disable_interruption di;
+		this_thread::disable_syscall_interruption dsi;
+		thr->interrupt_and_join();
+		delete thr;
+		thr = NULL;
+		boost::lock_guard<boost::mutex> l(dataSyncher);
+		return data;
+	}
+
+	void appendToBuffer(const StaticString &dataToAdd) {
+		TRACE_POINT();
+		boost::lock_guard<boost::mutex> l(dataSyncher);
+		data.append(dataToAdd.data(), dataToAdd.size());
+	}
+};
+
+typedef boost::shared_ptr<BackgroundIOCapturer> BackgroundIOCapturerPtr;
+
+
+} // namespace SpawningKit
+} // namespace Passenger
+
+#endif /* _PASSENGER_SPAWNING_KIT_BACKGROUND_IO_CAPTURER_H_ */

data/ext/common/SpawningKit/Config.h

@@ -0,0 +1,107 @@
+/*
+ *  Phusion Passenger - https://www.phusionpassenger.com/
+ *  Copyright (c) 2011-2015 Phusion
+ *
+ *  "Phusion Passenger" is a trademark of Hongli Lai & Ninh Bui.
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in
+ *  all copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ *  THE SOFTWARE.
+ */
+#ifndef _PASSENGER_SPAWNING_KIT_CONFIG_H_
+#define _PASSENGER_SPAWNING_KIT_CONFIG_H_
+
+#include <boost/function.hpp>
+#include <boost/make_shared.hpp>
+#include <string>
+#include <cstddef>
+
+#include <ResourceLocator.h>
+#include <RandomGenerator.h>
+#include <Exceptions.h>
+#include <UnionStation/Core.h>
+#include <Utils/VariantMap.h>
+
+namespace Passenger {
+namespace ApplicationPool2 {
+	class Options;
+} // namespace ApplicationPool2
+} // namespace Passenger
+
+namespace Passenger {
+namespace SpawningKit {
+
+using namespace std;
+
+
+struct Config;
+typedef ApplicationPool2::Options Options;
+typedef boost::shared_ptr<Config> ConfigPtr;
+
+typedef void (*ErrorHandler)(const ConfigPtr &config, SpawnException &e, const Options &options);
+typedef boost::function<void (const char *data, unsigned int size)> OutputHandler;
+
+struct Config {
+	// Used by error pages and hooks.
+	ResourceLocator *resourceLocator;
+	const VariantMap *agentsOptions;
+	ErrorHandler errorHandler;
+
+	// Used for Union Station logging.
+	UnionStation::CorePtr unionStationCore;
+
+	// Used by SmartSpawner and DirectSpawner.
+	RandomGeneratorPtr randomGenerator;
+	string instanceDir;
+
+	// Used by DummySpawner and SpawnerFactory.
+	unsigned int concurrency;
+	unsigned int spawnerCreationSleepTime;
+	unsigned int spawnTime;
+
+	// Used by PipeWatcher.
+	OutputHandler outputHandler;
+
+	// Other.
+	void *data;
+
+	Config()
+		: resourceLocator(NULL),
+		  agentsOptions(NULL),
+		  errorHandler(NULL),
+		  concurrency(1),
+		  spawnerCreationSleepTime(0),
+		  spawnTime(0),
+		  data(NULL)
+		{ }
+
+	void finalize() {
+		TRACE_POINT();
+		if (resourceLocator == NULL) {
+			throw RuntimeException("ResourceLocator not initialized");
+		}
+		if (randomGenerator == NULL) {
+			randomGenerator = boost::make_shared<RandomGenerator>();
+		}
+	}
+};
+
+
+} // namespace ApplicationPool2
+} // namespace Passenger
+
+#endif /* _PASSENGER_SPAWNING_KIT_CONFIG_H_ */

data/ext/common/{ApplicationPool2 → SpawningKit}/DirectSpawner.h

@@ -22,17 +22,17 @@
  *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  *  THE SOFTWARE.
  */
-#ifndef _PASSENGER_APPLICATION_POOL2_DIRECT_SPAWNER_H_
-#define _PASSENGER_APPLICATION_POOL2_DIRECT_SPAWNER_H_
+#ifndef _PASSENGER_SPAWNING_KIT_DIRECT_SPAWNER_H_
+#define _PASSENGER_SPAWNING_KIT_DIRECT_SPAWNER_H_
 
-#include <ApplicationPool2/Spawner.h>
+#include <SpawningKit/Spawner.h>
 #include <Constants.h>
 #include <limits.h>  // for PTHREAD_STACK_MIN
 #include <pthread.h>
 
 
 namespace Passenger {
-namespace ApplicationPool2 {
+namespace SpawningKit {
 
 using namespace std;
 using namespace boost;
@@ -121,8 +121,8 @@ private:
 		}
 
 		if (shouldLoadShellEnvvars(options, preparation)) {
-			command.push_back(preparation.shell);
-			command.push_back(preparation.shell);
+			command.push_back(preparation.userSwitching.shell);
+			command.push_back(preparation.userSwitching.shell);
 			command.push_back("-lc");
 			command.push_back("exec \"$@\"");
 			command.push_back("SpawnPreparerShell");
@@ -146,11 +146,11 @@ private:
 	}
 
 public:
-	DirectSpawner(const SpawnerConfigPtr &_config)
+	DirectSpawner(const ConfigPtr &_config)
 		: Spawner(_config)
 		{ }
 
-	virtual SpawnObject spawn(const Options &options) {
+	virtual Result spawn(const Options &options) {
 		TRACE_POINT();
 		this_thread::disable_interruption di;
 		this_thread::disable_syscall_interruption dsi;
@@ -162,7 +162,8 @@ public:
 		vector<string> command = createCommand(options, preparation, args);
 		SocketPair adminSocket = createUnixSocketPair(__FILE__, __LINE__);
 		Pipe errorPipe = createPipe(__FILE__, __LINE__);
-		DebugDirPtr debugDir = boost::make_shared<DebugDir>(preparation.uid, preparation.gid);
+		DebugDirPtr debugDir = boost::make_shared<DebugDir>(preparation.userSwitching.uid,
+			preparation.userSwitching.gid);
 		pid_t pid;
 
 		pid = syscalls::fork();
@@ -231,23 +232,23 @@ public:
 			details.options = &options;
 			details.debugDir = debugDir;
 
-			SpawnObject object;
+			Result result;
 			{
 				this_thread::restore_interruption ri(di);
 				this_thread::restore_syscall_interruption rsi(dsi);
-				object = negotiateSpawn(details);
+				result = negotiateSpawn(details);
 			}
-			detachProcess(object.process->pid);
+			detachProcess(result["pid"].asInt());
 			guard.clear();
 			P_DEBUG("Process spawning done: appRoot=" << options.appRoot <<
-				", pid=" << object.process->pid);
-			return boost::move(object);
+				", pid=" << result["pid"].asInt());
+			return result;
 		}
 	}
 };
 
 
-} // namespace ApplicationPool2
+} // namespace SpawningKit
 } // namespace Passenger
 
-#endif /* _PASSENGER_APPLICATION_POOL2_DIRECT_SPAWNER_H_ */
+#endif /* _PASSENGER_SPAWNING_KIT_DIRECT_SPAWNER_H_ */