passenger 4.0.30 → 4.0.31

data/lib/phusion_passenger/utils/unseekable_socket.rb

@@ -21,7 +21,7 @@
 #  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 #  THE SOFTWARE.
 
-require 'phusion_passenger/utils'   # So that we can know whether #writev is supported.
+PhusionPassenger.require_passenger_lib 'utils'   # So that we can know whether #writev is supported.
 
 module PhusionPassenger
 module Utils

data/resources/templates/apache2/config_snippets.txt.erb

@@ -6,8 +6,7 @@ Please edit your Apache configuration file, and add these lines:
    <b>PassengerRoot <%= @passenger_root %></b>
    <b>PassengerDefaultRuby <%= @ruby %></b>
 
-After you restart Apache, you are ready to deploy any number of Ruby on Rails
-applications on Apache, without any further Ruby on Rails-specific
-configuration!
+After you restart Apache, you are ready to deploy any number of web
+applications on Apache, with a minimum amount of configuration!
 
 <b>Press ENTER to continue.</b>

data/resources/templates/apache2/deployment_example.txt.erb

@@ -1,6 +1,6 @@
-<banner>Deploying a Ruby on Rails application: an example</banner>
+<banner>Deploying a web application: an example</banner>
 
-Suppose you have a Rails application in <b>/somewhere</b>. Add a virtual host to your
+Suppose you have a web application in <b>/somewhere</b>. Add a virtual host to your
 Apache configuration file and set its DocumentRoot to <b>/somewhere/public</b>:
 <b>
    <VirtualHost *:80>

data/resources/templates/apache2/notify_apache_module_installed.txt.erb

@@ -0,0 +1,3 @@
+<green>The <%= PROGRAM_NAME %> Apache module is correctly installed :-)</green>
+
+Press Enter to learn how to deploy a web app on Apache.

data/resources/templates/nginx/config_snippets.txt.erb

@@ -11,7 +11,7 @@ and set the <b>passenger_root</b> and <b>passenger_ruby</b> configuration option
       ...
   }</b>
 
-After you (re)start Nginx, you are ready to deploy any number of Ruby on Rails
+After you (re)start Nginx, you are ready to deploy any number of web
 applications on Nginx.
 
 <b>Press ENTER to continue.</b>

data/resources/templates/nginx/deployment_example.txt.erb

@@ -1,6 +1,6 @@
-<banner>Deploying a Ruby on Rails application: an example</banner>
+<banner>Deploying a web application: an example</banner>
 
-Suppose you have a Ruby on Rails application in <b>/somewhere</b>. Add a <b>server</b> block
+Suppose you have a web application in <b>/somewhere</b>. Add a <b>server</b> block
 to your Nginx configuration file, set its <b>root</b> to <b>/somewhere/public</b>, and set
 <b>'passenger_enabled on'</b>, like this:
 <b>

data/resources/templates/nginx/nginx_module_sources_not_available.txt.erb

@@ -1,6 +1,12 @@
-<red>Nginx module sources not available</red>
+<red>The necessary source files for compiling Nginx are not installed.</red>
+<% if PhusionPassenger.native_packaging_method == "deb" %>
+Please install them with:
 
-You didn't install the Phusion Passenger Nginx module sources. If you're on
-Debian or Ubuntu, please run <b>sudo apt-get install ruby-passenger-dev</b>
-first. If you're not on Debian/Ubuntu, or if you cannot run apt-get, please
-install Phusion Passenger from source: https://www.phusionpassenger.com/
+  <b>sudo apt-get install <%= DEB_DEV_PACKAGE %></b>
+<% elsif PhusionPassenger.native_packaging_method == "rpm" %>
+Please install them with:
+
+  <b>sudo yum install <%= RPM_DEV_PACKAGE %></b>
+<% else %>
+Please ask your operating system vendor how to solve this problem.
+<% end %>

data/rpm/Vagrantfile

@@ -19,6 +19,7 @@ Vagrant.configure(VAGRANTFILE_API_VERSION) do |config|
   end
 
   pkg_cmd = %Q{
+    echo "exclude = kernel*" >> /etc/yum.conf
     rpm -Uvh http://mirror.overthewire.com.au/pub/epel/6/i386/epel-release-6-8.noarch.rpm &&
     yum update -y &&
     yum install -y @development-tools fedora-packager git sudo nano &&

data/test/cxx/ApplicationPool2/PoolTest.cpp

@@ -162,7 +162,7 @@ namespace tut {
 			ProcessPtr process = currentSession->getProcess();
 			currentSession.reset();
 			EVENTUALLY(5,
-				result = process->utilization() == 0;
+				result = process->busyness() == 0;
 			);
 			return body;
 		}
@@ -233,8 +233,8 @@ namespace tut {
 		// Close the session so that the process is now idle.
 		ProcessPtr process = currentSession->getProcess();
 		currentSession.reset();
-		ensure_equals(process->utilization(), 0);
-		ensure(!process->atFullCapacity());
+		ensure_equals(process->busyness(), 0);
+		ensure(!process->isTotallyBusy());
 		
 		// Verify test assertion.
 		ScopedLock l(pool->syncher);
@@ -262,7 +262,7 @@ namespace tut {
 		ProcessPtr process = session1->getProcess();
 		currentSession.reset();
 		ensure_equals(process->sessions, 1);
-		ensure(process->atFullCapacity());
+		ensure(process->isTotallyBusy());
 		
 		// Now call asyncGet() again.
 		pool->asyncGet(options, callback);
@@ -577,7 +577,7 @@ namespace tut {
 		debug->messages->send("Proceed with spawn loop iteration 1");
 		ensureMinProcesses(1);
 
-		ensure_equals(pool->restartGroupsByAppRoot("stub/rack"), 1u);
+		ensure(pool->restartGroupByName("stub/rack#default"));
 		debug->debugger->recv("About to end restarting");
 		ensure(pool->detachSuperGroupByName("stub/rack"));
 		ensure_equals(pool->getSuperGroupCount(), 0u);
@@ -620,6 +620,38 @@ namespace tut {
 		ensure(pool->detachSuperGroupByName("stub/rack"));
 		ensure_equals(pool->getSuperGroupCount(), 0u);
 	}
+
+	TEST_METHOD(17) {
+		// Test that restartGroupByName() spawns more processes to ensure
+		// that minProcesses and other constraints are met.
+		ensureMinProcesses(1);
+		ensure(pool->restartGroupByName("stub/rack#default"));
+		EVENTUALLY(5,
+			result = pool->getProcessCount() == 1;
+		);
+	}
+
+	TEST_METHOD(18) {
+		// Test getting from an app for which minProcesses is set to 0,
+		// and restart.txt already existed.
+		TempDirCopy dir("stub/wsgi", "tmp.wsgi");
+		Options options = createOptions();
+		options.appRoot = "tmp.wsgi";
+		options.appType = "wsgi";
+		options.spawnMethod = "direct";
+		options.minProcesses = 0;
+		initPoolDebugging();
+		debug->spawning = false;
+
+		touchFile("tmp.wsgi/tmp/restart.txt", 1);
+		pool->asyncGet(options, callback, false);
+		debug->debugger->recv("About to end restarting");
+		debug->messages->send("Finish restarting");
+		EVENTUALLY(5,
+			result = number == 1;
+		);
+		ensure_equals(pool->getProcessCount(), 1u);
+	}
 	
 	
 	/*********** Test asyncGet() behavior on multiple SuperGroups,
@@ -675,7 +707,6 @@ namespace tut {
 		EVENTUALLY(5,
 			result = number == 1;
 		);
-		SessionPtr session1 = currentSession;
 		ProcessPtr process1 = currentSession->getProcess();
 		GroupPtr group1 = process1->getGroup();
 		SuperGroupPtr superGroup1 = group1->getSuperGroup();
@@ -699,51 +730,210 @@ namespace tut {
 		ensure_equals(pool->getProcessCount(), 2u);
 		ensure_equals(superGroup1->getProcessCount(), 0u);
 	}
-	
+
 	TEST_METHOD(22) {
-		// Suppose the pool is full, and one tries to asyncGet() from a nonexistant group,
-		// and the process that is selected for killing is the sole process in its group.
-		// If there were waiters in the group then those waiters will be satisfied after
-		// capacity has become free.
+		// Suppose the pool is at full capacity, and one tries to asyncGet() from an
+		// existant group that does not have any processes. It should kill a process
+		// from another group, and the request should succeed.
 		Options options = createOptions();
-		pool->setMax(2);
-		
-		// Get from /foo and retain its session.
+		SessionPtr session;
+		pid_t pid1, pid2;
+		pool->setMax(1);
+
+		// Create a group /foo.
 		options.appRoot = "/foo";
 		SystemTime::force(1);
-		SessionPtr session1 = pool->get(options, &ticket);
-		GroupPtr fooGroup = session1->getGroup();
+		session = pool->get(options, &ticket);
+		pid1 = session->getPid();
+		session.reset();
 
-		// Get from /bar and retain its session.
+		// Create a group /bar.
 		options.appRoot = "/bar";
 		SystemTime::force(2);
-		SessionPtr session2 = pool->get(options, &ticket);
+		session = pool->get(options, &ticket);
+		pid2 = session->getPid();
+		session.reset();
+
+		// Sleep for a short while to give Pool a chance to shutdown
+		// the first process.
+		usleep(300000);
+		ensure_equals("(1)", pool->getProcessCount(), 1u);
 
-		// Request another get(). /foo will now have 1 waiter in its waitlist.
+		// Get from /foo.
 		options.appRoot = "/foo";
-		pool->asyncGet(options, callback);
+		SystemTime::force(3);
+		session = pool->get(options, &ticket);
+		ensure("(2)", session->getPid() != pid1);
+		ensure("(3)", session->getPid() != pid2);
+		ensure_equals("(4)", pool->getProcessCount(), 1u);
+	}
+
+	TEST_METHOD(23) {
+		// Suppose the pool is at full capacity, and one tries to asyncGet() from an
+		// existant group that does not have any processes, and that happens to need
+		// restarting. It should kill a process from another group and the request
+		// should succeed.
+		Options options1 = createOptions();
+		Options options2 = createOptions();
+		TempDirCopy dir("stub/wsgi", "tmp.wsgi");
+		SessionPtr session;
+		pid_t pid1, pid2;
+		pool->setMax(1);
+
+		// Create a group tmp.wsgi.
+		options1.appRoot = "tmp.wsgi";
+		options1.appType = "wsgi";
+		options1.spawnMethod = "direct";
+		SystemTime::force(1);
+		session = pool->get(options1, &ticket);
+		pid1 = session->getPid();
+		session.reset();
+
+		// Create a group bar.
+		options2.appRoot = "bar";
+		SystemTime::force(2);
+		session = pool->get(options2, &ticket);
+		pid2 = session->getPid();
+		session.reset();
+
+		// Sleep for a short while to give Pool a chance to shutdown
+		// the first process.
+		usleep(300000);
+		ensure_equals("(1)", pool->getProcessCount(), 1u);
+
+		// Get from tmp.wsgi.
+		SystemTime::force(3);
+		touchFile("tmp.wsgi/tmp/restart.txt", 4);
+		session = pool->get(options1, &ticket);
+		ensure("(2)", session->getPid() != pid1);
+		ensure("(3)", session->getPid() != pid2);
+		ensure_equals("(4)", pool->getProcessCount(), 1u);
+	}
+
+	TEST_METHOD(24) {
+		// Suppose the pool is at full capacity, with two groups:
+		// - one that is spawning a process.
+		// - one with no processes.
+		// When one tries to asyncGet() from the second group, there should
+		// be no process to kill, but when the first group is done spawning
+		// it should throw away that process immediately to allow the second
+		// group to spawn.
+		Options options1 = createOptions();
+		Options options2 = createOptions();
+		initPoolDebugging();
+		debug->restarting = false;
+		pool->setMax(1);
+
+		// Create a group foo.
+		options1.appRoot = "foo";
+		options1.noop = true;
+		SystemTime::force(1);
+		pool->get(options1, &ticket);
+
+		// Create a group bar, but don't let it finish spawning.
+		options2.appRoot = "bar";
+		options2.noop = true;
+		SystemTime::force(2);
+		GroupPtr barGroup = pool->get(options2, &ticket)->getGroup();
 		{
 			LockGuard l(pool->syncher);
-			ensure("(1)", session1->getProcess()->isAlive());
-			ensure_equals("(3)", fooGroup->getWaitlist.size(), 1u);
+			ensure_equals("(1)", barGroup->spawn(), SR_OK);
 		}
+		debug->debugger->recv("Begin spawn loop iteration 1");
 
-		// This kill the process for /foo.
+		// Now get from foo again and let the request be queued.
+		options1.noop = false;
 		SystemTime::force(3);
-		options.appRoot = "/baz";
-		SessionPtr session3 = pool->get(options, &ticket);
-		{
+		pool->asyncGet(options1, callback);
+
+		// Nothing should happen while bar is spawning.
+		SHOULD_NEVER_HAPPEN(100,
+			result = number > 0;
+		);
+		ensure_equals("(2)", pool->getProcessCount(), 0u);
+
+		// Now let bar finish spawning. Eventually there should
+		// only be one process: the one for foo.
+		debug->messages->send("Proceed with spawn loop iteration 1");
+		debug->debugger->recv("Spawn loop done");
+		debug->messages->send("Proceed with spawn loop iteration 2");
+		debug->debugger->recv("Spawn loop done");
+		EVENTUALLY(5,
 			LockGuard l(pool->syncher);
-			ensure("(4)", session1->getProcess()->enabled == Process::DETACHED);
-			ensure_equals("(6)", fooGroup->getWaitlist.size(), 1u);
-			ensure_equals("(7)", pool->getWaitlist.size(), 0u);
-		}
+			vector<ProcessPtr> processes = pool->getProcesses(false);
+			if (processes.size() == 1) {
+				GroupPtr group = processes[0]->getGroup();
+				result = group->name == "foo#default";
+			} else {
+				result = false;
+			}
+		);
+	}
 
-		// Make process /bar available for killing.
-		session2.reset();
+	TEST_METHOD(25) {
+		// Suppose the pool is at full capacity, with two groups:
+		// - one that is spawning a process, and has a queued request.
+		// - one with no processes.
+		// When one tries to asyncGet() from the second group, there should
+		// be no process to kill, but when the first group is done spawning
+		// it should throw away that process immediately to allow the second
+		// group to spawn.
+		Options options1 = createOptions();
+		Options options2 = createOptions();
+		initPoolDebugging();
+		debug->restarting = false;
+		pool->setMax(1);
+
+		// Create a group foo.
+		options1.appRoot = "foo";
+		options1.noop = true;
+		SystemTime::force(1);
+		pool->get(options1, &ticket);
+
+		// Create a group bar with a queued request, but don't let it finish spawning.
+		options2.appRoot = "bar";
+		SystemTime::force(2);
+		pool->asyncGet(options2, callback);
+		debug->debugger->recv("Begin spawn loop iteration 1");
+
+		// Now get from foo again and let the request be queued.
+		options1.noop = false;
+		SystemTime::force(3);
+		pool->asyncGet(options1, callback);
+
+		// Nothing should happen while bar is spawning.
+		SHOULD_NEVER_HAPPEN(100,
+			result = number > 0;
+		);
+		ensure_equals("(1)", pool->getProcessCount(), 0u);
+
+		// Now let bar finish spawning. The request for bar should be served.
+		debug->messages->send("Proceed with spawn loop iteration 1");
+		debug->debugger->recv("Spawn loop done");
 		EVENTUALLY(5,
 			result = number == 1;
 		);
+		ensure_equals(currentSession->getGroup()->name, "bar#default");
+
+		// When that request is done, the process for bar should be killed,
+		// and a process for foo should be spawned.
+		currentSession.reset();
+		debug->messages->send("Proceed with spawn loop iteration 2");
+		debug->debugger->recv("Spawn loop done");
+		EVENTUALLY(5,
+			LockGuard l(pool->syncher);
+			vector<ProcessPtr> processes = pool->getProcesses(false);
+			if (processes.size() == 1) {
+				GroupPtr group = processes[0]->getGroup();
+				result = group->name == "foo#default";
+			} else {
+				result = false;
+			}
+		);
+
+		EVENTUALLY(5,
+			result = number == 2;
+		);
 	}
 	
 	
@@ -1286,14 +1476,14 @@ namespace tut {
 		pool->setMax(1);
 
 		// Send normal request.
-		ensure_equals(sendRequest(options, "/"), "hello <b>world</b>");
+		ensure_equals(sendRequest(options, "/"), "front page");
 
 		// Modify application; it shouldn't have effect yet.
 		writeFile("tmp.wsgi/passenger_wsgi.py",
 			"def application(env, start_response):\n"
 			"	start_response('200 OK', [('Content-Type', 'text/html')])\n"
 			"	return ['restarted']\n");
-		ensure_equals(sendRequest(options, "/"), "hello <b>world</b>");
+		ensure_equals(sendRequest(options, "/"), "front page");
 
 		// Create restart.txt and send request again. The change should now be activated.
 		touchFile("tmp.wsgi/tmp/restart.txt", 1);
@@ -1412,7 +1602,6 @@ namespace tut {
 		Options options1 = createOptions();
 		Options options2 = createOptions();
 		options2.appRoot = "stub/wsgi";
-		options2.allowTrashingNonIdleProcesses = false;
 
 		retainSessions = true;
 		pool->setMax(2);

data/test/cxx/ApplicationPool2/ProcessTest.cpp

@@ -53,8 +53,8 @@ namespace tut {
 			errorPipe[0], sockets, 0, 0);
 		process->dummy = true;
 		process->requiresShutdown = false;
-		ensure_equals(process->utilization(), 0);
-		ensure(!process->atFullCapacity());
+		ensure_equals(process->busyness(), 0);
+		ensure(!process->isTotallyBusy());
 	}
 	
 	TEST_METHOD(2) {
@@ -74,8 +74,8 @@ namespace tut {
 	}
 	
 	TEST_METHOD(3) {
-		// newSession() checks out the socket with the smallest utilization number
-		// and sessionClosed() restores the session utilization statistics.
+		// newSession() checks out the socket with the smallest busyness number
+		// and sessionClosed() restores the session busyness statistics.
 		ProcessPtr process = boost::make_shared<Process>(bg.safe,
 			123, "", "", adminSocket[0],
 			errorPipe[0], sockets, 0, 0);
@@ -128,12 +128,12 @@ namespace tut {
 		process->requiresShutdown = false;
 		vector<SessionPtr> sessions;
 		for (int i = 0; i < 9; i++) {
-			ensure(!process->atFullCapacity());
+			ensure(!process->isTotallyBusy());
 			SessionPtr session = process->newSession();
 			ensure(session != NULL);
 			sessions.push_back(session);
 		}
-		ensure(process->atFullCapacity());
+		ensure(process->isTotallyBusy());
 		ensure(process->newSession() == NULL);
 	}
 }