passenger 5.0.1 → 5.0.2

data/ext/common/agents/HelperAgent/Main.cpp

@@ -527,6 +527,8 @@ initializeNonPrivilegedWorkingObjects() {
 		two.serverKitContext->secureModePassword = wo->password;
 		two.serverKitContext->defaultFileBufferedChannelConfig.bufferDir =
 			options.get("data_buffer_dir");
+		two.serverKitContext->defaultFileBufferedChannelConfig.threshold =
+			options.getUint("file_buffer_threshold");
 
 		UPDATE_TRACE_POINT();
 		two.requestHandler = new RequestHandler(two.serverKitContext, agentsOptions, i + 1);
@@ -979,6 +981,7 @@ setAgentsOptionsDefaults() {
 	options.setDefault("sticky_sessions_cookie_name", DEFAULT_STICKY_SESSIONS_COOKIE_NAME);
 	options.setDefaultBool("turbocaching", true);
 	options.setDefault("data_buffer_dir", getSystemTempDir());
+	options.setDefaultUint("file_buffer_threshold", DEFAULT_FILE_BUFFERED_CHANNEL_THRESHOLD);
 	options.setDefaultInt("response_buffer_high_watermark", DEFAULT_RESPONSE_BUFFER_HIGH_WATERMARK);
 	options.setDefaultBool("selfchecks", false);
 	options.setDefaultBool("server_graceful_exit", true);
@@ -1068,6 +1071,18 @@ sanityCheckOptions() {
 			ok = false;
 		#endif
 	}
+	if (options.has("max_request_time")) {
+		if (options.getInt("max_request_time", false, 0) < 1) {
+			fprintf(stderr, "ERROR: the value passed to --max-request-time must be at least 1.\n");
+			ok = false;
+		}
+		#ifndef PASSENGER_IS_ENTERPRISE
+			fprintf(stderr, "ERROR: the --max-request-time option is only supported in "
+				PROGRAM_NAME " Enterprise.\nYou are currently using the open source "
+				PROGRAM_NAME ". Buy " PROGRAM_NAME " Enterprise here: https://www.phusionpassenger.com/enterprise\n");
+			ok = false;
+		#endif
+	}
 	if (RequestHandler::parseBenchmarkMode(options.get("benchmark_mode", false))
 		== RequestHandler::BM_UNKNOWN)
 	{

data/ext/common/agents/HelperAgent/OptionParser.h

@@ -125,7 +125,9 @@ serverUsage() {
 	printf("      --min-instances N     Minimum number of application processes. Default: 1\n");
 	printf("\n");
 	printf("Request handling options (optional):\n");
-	printf("      --sticky-sessions    Enable sticky sessions\n");
+	printf("      --max-request-time    Abort requests that take too much time (Enterprise\n");
+	printf("                            only)\n");
+	printf("      --sticky-sessions     Enable sticky sessions\n");
 	printf("      --sticky-sessions-cookie-name NAME\n");
 	printf("                            Cookie name to use for sticky sessions.\n");
 	printf("                            Default: " DEFAULT_STICKY_SESSIONS_COOKIE_NAME "\n");
@@ -273,6 +275,9 @@ parseServerOption(int argc, const char *argv[], int &i, VariantMap &options) {
 	} else if (p.isFlag(argv[i], '\0', "--disable-friendly-error-pages")) {
 		options.setBool("friendly_error_pages", false);
 		i++;
+	} else if (p.isValueFlag(argc, i, argv[i], '\0', "--max-request-time")) {
+		options.setInt("max_request_time", atoi(argv[i + 1]));
+		i += 2;
 	} else if (p.isFlag(argv[i], '\0', "--sticky-sessions")) {
 		options.setBool("sticky_sessions", true);
 		i++;

data/ext/common/agents/HelperAgent/RequestHandler.h

@@ -450,6 +450,9 @@ public:
 			}
 		}
 
+		doc["app_source_state"] = req->appSource.inspectAsJson();
+		doc["app_sink_state"] = req->appSink.inspectAsJson();
+
 		return doc;
 	}
 };

data/lib/phusion_passenger.rb

@@ -30,7 +30,7 @@ module PhusionPassenger
 
   PACKAGE_NAME = 'passenger'
   # Run 'rake ext/common/Constants.h' after changing this number.
-  VERSION_STRING = '5.0.1'
+  VERSION_STRING = '5.0.2'
 
   PREFERRED_NGINX_VERSION = '1.6.2'
   NGINX_SHA256_CHECKSUM = 'b5608c2959d3e7ad09b20fc8f9e5bd4bc87b3bc8ba5936a513c04ed8f1391a18'

data/lib/phusion_passenger/common_library.rb

@@ -100,8 +100,11 @@ class CommonLibraryBuilder
     return link_objects.join(' ')
   end
 
-  def enable_optimizations!
+  def enable_optimizations!(lto = false)
     @default_optimization_level = "-O"
+    if lto
+      @default_optimization_level << " -flto"
+    end
   end
 
   def define_tasks(extra_compiler_flags = nil)
@@ -132,7 +135,7 @@ private
       file(object_file => dependencies_for(options)) do
         case options[:optimize]
         when :light
-          optimize = "-O1"
+          optimize = "-O"
         when true, :heavy
           optimize = "-O2"
         when :very_heavy
@@ -142,14 +145,19 @@ private
         else
           raise "Unknown optimization level #{options[:optimize]}"
         end
-        if options[:strict_aliasing] == false
+        if options[:strict_aliasing] == false # and not nil
           optimize = "#{optimize} -fno-strict-aliasing"
+          # Disable link-time optimization so that we can no-strict-aliasing
+          # works: http://stackoverflow.com/a/25765338/20816
+          optimize.sub!(/-flto/, "")
         end
         ensure_directory_exists(File.dirname(object_file))
+        # We put 'optimize' at the end of the command string so that it overrides
+        # the default optimization level embedded in 'cflags'.
         if source_file =~ /\.c$/
-          compile_c(source_file, "#{optimize} #{cflags} -o #{object_file}".strip)
+          compile_c(source_file, "#{cflags} #{optimize} -o #{object_file}".strip)
         else
-          compile_cxx(source_file, "#{optimize} #{cxxflags} -o #{object_file}".strip)
+          compile_cxx(source_file, "#{cxxflags} #{optimize} -o #{object_file}".strip)
         end
       end
     end

data/lib/phusion_passenger/config/restart_app_command.rb

@@ -158,12 +158,16 @@ module PhusionPassenger
       def select_app_group_name_interactively
         colors = PhusionPassenger::Utils::AnsiColors.new
 
+        choices = query_group_names
+        if choices.size == 1
+          # No running apps
+          abort_app_not_found "#{PROGRAM_NAME} is currently not serving any applications."
+        end
+
         puts "Please select the application to restart."
         puts colors.ansi_colorize("<gray>Tip: re-run this command with --help to learn how to automate it.</gray>")
         puts colors.ansi_colorize("<dgray>If the menu doesn't display correctly, press '!'</dgray>")
         puts
-
-        choices = query_group_names
         menu = PhusionPassenger::Utils::TerminalChoiceMenu.new(choices, :single_choice)
         begin
           index, name = menu.query
@@ -205,7 +209,7 @@ module PhusionPassenger
             :method => restart_method)
           response = @instance.http_request("agents.s/server_admin", request)
           if response.code.to_i / 100 == 2
-            return REXML::Document.new(response.body)
+            response.body
           else
             STDERR.puts "*** An error occured while communicating with the #{PROGRAM_NAME} server:"
             STDERR.puts response.body
@@ -228,7 +232,7 @@ module PhusionPassenger
         request.basic_auth("ro_admin", obtain_read_only_admin_password(@instance))
         response = @instance.http_request("agents.s/server_admin", request)
         if response.code.to_i / 100 == 2
-          return REXML::Document.new(response.body)
+          REXML::Document.new(response.body)
         else
           STDERR.puts "*** An error occured while querying the #{PROGRAM_NAME} server:"
           STDERR.puts response.body

data/lib/phusion_passenger/constants.rb

@@ -72,6 +72,7 @@ module PhusionPassenger
     MESSAGE_SERVER_MAX_PASSWORD_SIZE = 100
     POOL_HELPER_THREAD_STACK_SIZE = 1024 * 256
     DEFAULT_MBUF_CHUNK_SIZE = 16 * 32
+    DEFAULT_FILE_BUFFERED_CHANNEL_THRESHOLD = 1024 * 128
     SERVER_KIT_MAX_SERVER_ENDPOINTS = 4
 
     # Time limits

data/lib/phusion_passenger/standalone/command.rb

@@ -37,7 +37,7 @@ module PhusionPassenger
 
       def parse_options
         load_and_merge_global_options(@options)
-        @parsed_options = {}
+        @parsed_options = self.class.create_default_options
         @parser = self.class.create_option_parser(@parsed_options)
         begin
           @original_argv = @argv.dup

data/lib/phusion_passenger/standalone/start_command.rb

@@ -94,6 +94,9 @@ module PhusionPassenger
       ################# Configuration loading, option parsing and initialization ###################
 
       def self.create_option_parser(options)
+        # Clear @parsed_options so that #remerge_all_options works.
+        options.clear
+
         # If you add or change an option, make sure to update the following places too:
         # lib/phusion_passenger/standalone/start_command/builtin_engine.rb, #build_daemon_controller_options
         # resources/templates/config/standalone.erb
@@ -245,6 +248,10 @@ module PhusionPassenger
 
           opts.separator ""
           opts.separator "Request handling options:"
+          opts.on("--max-request-time SECONDS", "Abort requests that take too much time#{nl}" +
+            "(Enterprise only)") do |val|
+            options[:max_request_time] = val
+          end
           opts.on("--sticky-sessions", "Enable sticky sessions") do
             options[:sticky_sessions] = true
           end
@@ -311,6 +318,7 @@ module PhusionPassenger
             if value !~ /=.+/
               abort "*** ERROR: invalid --ctl format: #{value}"
             end
+            options[:ctls] ||= []
             options[:ctls] << value
           end
           opts.on("--binaries-url-root URL", String,

data/lib/phusion_passenger/standalone/start_command/builtin_engine.rb

@@ -139,6 +139,7 @@ module PhusionPassenger
           add_param(command, :min_instances, "--min-instances")
           add_enterprise_param(command, :concurrency_model, "--concurrency-model")
           add_enterprise_param(command, :thread_count, "--app-thread-count")
+          add_enterprise_param(command, :max_request_time, "--max-request-time")
           add_enterprise_flag_param(command, :rolling_restarts, "--rolling-restarts")
           add_enterprise_flag_param(command, :resist_deployment_errors, "--resist-deployment-errors")
           add_enterprise_flag_param(command, :debugger, "--debugger")

data/test/cxx/ServerKit/FileBufferedChannelTest.cpp

@@ -24,6 +24,7 @@ namespace tut {
 		int toConsume;
 		bool endConsume;
 		unsigned int counter;
+		unsigned int buffersFlushed;
 		string log;
 
 		ServerKit_FileBufferedChannelTest()
@@ -32,19 +33,21 @@ namespace tut {
 			  channel(&context),
 			  toConsume(CONSUME_FULLY),
 			  endConsume(false),
-			  counter(0)
+			  counter(0),
+			  buffersFlushed(0)
 		{
 			initializeLibeio();
 			channel.setDataCallback(dataCallback);
+			channel.setBuffersFlushedCallback(buffersFlushedCallback);
 			channel.setHooks(this);
 			Hooks::impl = NULL;
 			Hooks::userData = NULL;
 		}
 
 		~ServerKit_FileBufferedChannelTest() {
+			bg.stop(); // Prevent any runLater callbacks from running.
 			channel.deinitialize(); // Cancel any event loop next tick callbacks.
 			setLogLevel(DEFAULT_LOG_LEVEL);
-			bg.stop();
 			shutdownLibeio();
 		}
 
@@ -76,6 +79,13 @@ namespace tut {
 			}
 		}
 
+		static void buffersFlushedCallback(FileBufferedChannel *channel) {
+			ServerKit_FileBufferedChannelTest *self = (ServerKit_FileBufferedChannelTest *)
+				channel->getHooks();
+			boost::lock_guard<boost::mutex> l(self->syncher);
+			self->buffersFlushed++;
+		}
+
 		void feedChannel(const string &data) {
 			bg.safe->runLater(boost::bind(&ServerKit_FileBufferedChannelTest::_feedChannel,
 				this, data));
@@ -550,6 +560,144 @@ namespace tut {
 	}
 
 	TEST_METHOD(33) {
+		set_test_name("Suppose that a data chunk from disk is being passed to the callback. "
+			"If the callback consumes the chunk immediately and is willing to accept "
+			"further data, then the FileBufferedChannel will repeat this process with the "
+			"next chunk from disk");
+
+		// Setup a FileBufferedChannel in the in-file mode.
+		toConsume = -1;
+		context.defaultFileBufferedChannelConfig.threshold = 1;
+		startLoop();
+		feedChannel("hello");
+		feedChannel("world!");
+		EVENTUALLY(5,
+			result = getChannelMode() == FileBufferedChannel::IN_FILE_MODE;
+		);
+		EVENTUALLY(5,
+			result = getChannelWriterState() == FileBufferedChannel::WS_INACTIVE;
+		);
+		ensure_equals(getChannelBytesBuffered(), 0u);
+
+		// Consume the initial "hello" so that the FileBufferedChannel starts
+		// reading "world" from disk. When "world" is read, we first consume
+		// "world" only, then "!" too.
+		context.defaultFileBufferedChannelConfig.maxDiskChunkReadSize = sizeof("world") - 1;
+		toConsume = CONSUME_FULLY;
+		channelConsumed(sizeof("hello") - 1, false);
+		EVENTUALLY(5,
+			LOCK();
+			result = log ==
+				"Data: hello\n"
+				"Data: world\n"
+				"Data: !\n";
+		);
+	}
+
+	TEST_METHOD(34) {
+		set_test_name("Suppose that a data chunk from disk is being passed to the callback. "
+			"If the callback consumes the chunk asynchronously, and is willing "
+			"to accept further data, then the FileBufferedChannel will repeat this process "
+			"with the next chunk from disk after the channel has become idle");
+
+		// Setup a FileBufferedChannel in the in-file mode.
+		toConsume = -1;
+		context.defaultFileBufferedChannelConfig.threshold = 1;
+		startLoop();
+		feedChannel("hello");
+		feedChannel("world!");
+		EVENTUALLY(5,
+			result = getChannelMode() == FileBufferedChannel::IN_FILE_MODE;
+		);
+		EVENTUALLY(5,
+			result = getChannelWriterState() == FileBufferedChannel::WS_INACTIVE;
+		);
+		ensure_equals(getChannelBytesBuffered(), 0u);
+
+		// Consume the initial "hello" so that the FileBufferedChannel starts
+		// reading "world" from disk.
+		context.defaultFileBufferedChannelConfig.maxDiskChunkReadSize = sizeof("world") - 1;
+		channelConsumed(sizeof("hello") - 1, false);
+		EVENTUALLY(5,
+			LOCK();
+			result = log ==
+				"Data: hello\n";
+		);
+		// We haven't consumed "world" yet, so the FileBufferedChannel should
+		// be waiting for it to become idle.
+		EVENTUALLY(5,
+			result = getChannelReaderState() == FileBufferedChannel::RS_WAITING_FOR_CHANNEL_IDLE;
+		);
+
+		// Now consume "world".
+		channelConsumed(sizeof("world") - 1, false);
+		EVENTUALLY(5,
+			LOCK();
+			result = log ==
+				"Data: hello\n"
+				"Data: world\n";
+		);
+		// We haven't consumed "!" yet, so the FileBufferedChannel should
+		// be waiting for it to become idle.
+		EVENTUALLY(5,
+			result = getChannelReaderState() == FileBufferedChannel::RS_WAITING_FOR_CHANNEL_IDLE;
+		);
+
+		// Now consume "!".
+		channelConsumed(sizeof("!") - 1, false);
+		EVENTUALLY(5,
+			LOCK();
+			result = log ==
+				"Data: hello\n"
+				"Data: world\n"
+				"Data: !\n";
+		);
+	}
+
+	TEST_METHOD(35) {
+		set_test_name("Suppose that a data chunk from disk is being passed to the callback. "
+			"If the callback consumes the chunk immediately, but is not willing "
+			"to accept further data, then the FileBufferedChannel will terminate");
+
+		// Setup a FileBufferedChannel in the in-file mode.
+		toConsume = -1;
+		context.defaultFileBufferedChannelConfig.threshold = 1;
+		startLoop();
+		feedChannel("hello");
+		feedChannel("world!");
+		EVENTUALLY(5,
+			result = getChannelMode() == FileBufferedChannel::IN_FILE_MODE;
+		);
+		EVENTUALLY(5,
+			result = getChannelWriterState() == FileBufferedChannel::WS_INACTIVE;
+		);
+		ensure_equals(getChannelBytesBuffered(), 0u);
+
+		// Consume the initial "hello" so that the FileBufferedChannel starts
+		// reading "world" from disk. When it is read, we will consume it fully
+		// while ending the channel.
+		context.defaultFileBufferedChannelConfig.maxDiskChunkReadSize = sizeof("world") - 1;
+		toConsume = CONSUME_FULLY;
+		endConsume = true;
+		channelConsumed(sizeof("hello") - 1, false);
+		EVENTUALLY(5,
+			LOCK();
+			result = log ==
+				"Data: hello\n"
+				"Data: world\n";
+		);
+		EVENTUALLY(5,
+			result = getChannelReaderState() == FileBufferedChannel::RS_TERMINATED;
+		);
+		SHOULD_NEVER_HAPPEN(100,
+			LOCK();
+			result = log !=
+				"Data: hello\n"
+				"Data: world\n";
+		);
+	}
+
+	TEST_METHOD(36) {
 		set_test_name("If there is no unread data on disk, it passes the next "
 			"in-memory buffer to the callback");
 
@@ -596,7 +744,7 @@ namespace tut {
 		);
 	}
 
-	TEST_METHOD(34) {
+	TEST_METHOD(37) {
 		set_test_name("Upon feeding EOF, the EOF is passed to the callback after "
 			"all on-disk and in-memory data is passed");
 
@@ -658,7 +806,7 @@ namespace tut {
 		);
 	}
 
-	TEST_METHOD(35) {
+	TEST_METHOD(38) {
 		set_test_name("Upon feeding an error, it switches to the error mode immediately "
 			"and it doesn't call the callback");
 
@@ -737,6 +885,33 @@ namespace tut {
 		);
 	}
 
+	TEST_METHOD(41) {
+		set_test_name("It calls the buffersFlushedCallback if the switching happens while "
+			"there are buffers in memory that haven't been written to disk yet");
+
+		toConsume = -1;
+		context.defaultFileBufferedChannelConfig.threshold = 1;
+		context.defaultFileBufferedChannelConfig.delayInFileModeSwitching = 1000;
+		startLoop();
+
+		feedChannel("hello");
+		feedChannel("world!");
+		EVENTUALLY(5,
+			result = getChannelMode() == FileBufferedChannel::IN_FILE_MODE;
+		);
+		ensure_equals(getChannelBytesBuffered(), 11u);
+
+		channelConsumed(sizeof("hello") - 1, false);
+		channelConsumed(sizeof("world!") - 1, false);
+		EVENTUALLY(5,
+			result = getChannelMode() == FileBufferedChannel::IN_MEMORY_MODE;
+		);
+		EVENTUALLY(5,
+			LOCK();
+			result = buffersFlushed == 1;
+		);
+	}
+
 
 	/***** When stopped *****/