passenger 3.0.8 → 3.0.9

data/ext/nginx/Configuration.c

@@ -57,6 +57,11 @@ static ngx_path_init_t  ngx_http_proxy_temp_path = {
 };
 
 
+static int
+ngx_str_equals(ngx_str_t *str, const char *value) {
+    return ngx_memn2cmp(str->data, (u_char *) value, str->len, strlen(value)) == 0;
+}
+
 void *
 passenger_create_main_conf(ngx_conf_t *cf)
 {
@@ -92,6 +97,10 @@ passenger_create_main_conf(ngx_conf_t *cf)
     conf->union_station_gateway_port = (ngx_uint_t) NGX_CONF_UNSET;
     conf->union_station_gateway_cert.data = NULL;
     conf->union_station_gateway_cert.len = 0;
+    conf->union_station_proxy_address.data = NULL;
+    conf->union_station_proxy_address.len = 0;
+    conf->union_station_proxy_type.data = NULL;
+    conf->union_station_proxy_type.len = 0;
     
     conf->prestart_uris = ngx_array_create(cf->pool, 1, sizeof(ngx_str_t));
     if (conf->prestart_uris == NULL) {
@@ -234,6 +243,18 @@ passenger_init_main_conf(ngx_conf_t *cf, void *conf_pointer)
         conf->union_station_gateway_cert.data = (u_char *) "";
     }
     
+    if (conf->union_station_proxy_address.len == 0) {
+        conf->union_station_proxy_address.data = (u_char *) "";
+    }
+    
+    if (conf->union_station_proxy_type.len == 0) {
+        conf->union_station_proxy_type.data = (u_char *) "";
+        
+    } else if (!ngx_str_equals(&conf->union_station_proxy_type, "http")
+            && !ngx_str_equals(&conf->union_station_proxy_type, "socks5")) {
+        return "union_station_proxy_type may only be 'http' or 'socks5'.";
+    }
+    
     return NGX_CONF_OK;
 }
 
@@ -1145,6 +1166,20 @@ const ngx_command_t passenger_commands[] = {
       offsetof(passenger_main_conf_t, union_station_gateway_cert),
       NULL },
 
+    { ngx_string("union_station_proxy_address"),
+      NGX_HTTP_MAIN_CONF | NGX_CONF_TAKE1,
+      ngx_conf_set_str_slot,
+      NGX_HTTP_MAIN_CONF_OFFSET,
+      offsetof(passenger_main_conf_t, union_station_proxy_address),
+      NULL },
+
+    { ngx_string("union_station_proxy_type"),
+      NGX_HTTP_MAIN_CONF | NGX_CONF_TAKE1,
+      ngx_conf_set_str_slot,
+      NGX_HTTP_MAIN_CONF_OFFSET,
+      offsetof(passenger_main_conf_t, union_station_proxy_type),
+      NULL },
+
     { ngx_string("union_station_filter"),
       NGX_HTTP_MAIN_CONF | NGX_HTTP_SRV_CONF | NGX_HTTP_LOC_CONF | NGX_HTTP_LIF_CONF | NGX_CONF_TAKE1,
       union_station_filter,

data/ext/nginx/Configuration.h

@@ -80,6 +80,8 @@ typedef struct {
     ngx_str_t    union_station_gateway_address;
     ngx_uint_t   union_station_gateway_port;
     ngx_str_t    union_station_gateway_cert;
+    ngx_str_t    union_station_proxy_address;
+    ngx_str_t    union_station_proxy_type;
     ngx_array_t *prestart_uris;
 } passenger_main_conf_t;
 

data/ext/nginx/ContentHandler.c

@@ -336,6 +336,7 @@ create_request(ngx_http_request_t *r)
     ngx_table_elt_t               *header;
     ngx_http_script_code_pt        code;
     ngx_http_script_engine_t       e, le;
+    ngx_http_core_srv_conf_t      *cscf;
     passenger_loc_conf_t          *slcf;
     passenger_main_conf_t         *main_conf;
     passenger_context_t           *context;
@@ -344,6 +345,7 @@ create_request(ngx_http_request_t *r)
         ngx_http_ssl_srv_conf_t   *ssl_conf;
     #endif
     
+    cscf = ngx_http_get_module_srv_conf(r, ngx_http_core_module);
     slcf = ngx_http_get_module_loc_conf(r, ngx_http_passenger_module);
     main_conf = &passenger_main_conf;
     context = ngx_http_get_module_ctx(r, ngx_http_passenger_module);
@@ -415,11 +417,15 @@ create_request(ngx_http_request_t *r)
     }
     
     /* SERVER_NAME; must be equal to HTTP_HOST without the port part */
-    tmp = memchr(r->headers_in.host->value.data, ':', r->headers_in.host->value.len);
-    if (tmp == NULL) {
-        server_name_len = r->headers_in.host->value.len;
+    if (r->headers_in.host != NULL) {
+        tmp = memchr(r->headers_in.host->value.data, ':', r->headers_in.host->value.len);
+        if (tmp == NULL) {
+            server_name_len = r->headers_in.host->value.len;
+        } else {
+            server_name_len = (int) ((const u_char *) tmp - r->headers_in.host->value.data);
+        }
     } else {
-        server_name_len = (int) ((const u_char *) tmp - r->headers_in.host->value.data);
+        server_name_len = cscf->server_name.len;
     }
     len += sizeof("SERVER_NAME") + server_name_len + 1;
     
@@ -650,8 +656,13 @@ create_request(ngx_http_request_t *r)
     
     /* SERVER_NAME */
     b->last = ngx_copy(b->last, "SERVER_NAME", sizeof("SERVER_NAME"));
-    b->last = ngx_copy(b->last, r->headers_in.host->value.data,
-                       server_name_len);
+    if (r->headers_in.host != NULL) {
+        b->last = ngx_copy(b->last, r->headers_in.host->value.data,
+                           server_name_len);
+    } else {
+        b->last = ngx_copy(b->last, cscf->server_name.data,
+                           server_name_len);
+    }
     b->last = ngx_copy(b->last, "", 1);
     
     /* Various other HTTP headers. */

data/ext/nginx/ngx_http_passenger_module.c

@@ -239,6 +239,8 @@ start_helper_server(ngx_cycle_t *cycle) {
     char   *analytics_log_permissions;
     char   *union_station_gateway_address;
     char   *union_station_gateway_cert;
+    char   *union_station_proxy_address;
+    char   *union_station_proxy_type;
     char   *error_message = NULL;
     
     core_conf = (ngx_core_conf_t *) ngx_get_conf(cycle->conf_ctx, ngx_core_module);
@@ -256,6 +258,8 @@ start_helper_server(ngx_cycle_t *cycle) {
     analytics_log_permissions = ngx_str_null_terminate(&passenger_main_conf.analytics_log_permissions);
     union_station_gateway_address = ngx_str_null_terminate(&passenger_main_conf.union_station_gateway_address);
     union_station_gateway_cert = ngx_str_null_terminate(&passenger_main_conf.union_station_gateway_cert);
+    union_station_proxy_address = ngx_str_null_terminate(&passenger_main_conf.union_station_proxy_address);
+    union_station_proxy_type = ngx_str_null_terminate(&passenger_main_conf.union_station_proxy_type);
     
     prestart_uris = (ngx_str_t *) passenger_main_conf.prestart_uris->elts;
     prestart_uris_ary = calloc(sizeof(char *), passenger_main_conf.prestart_uris->nelts);
@@ -284,6 +288,8 @@ start_helper_server(ngx_cycle_t *cycle) {
         union_station_gateway_address,
         passenger_main_conf.union_station_gateway_port,
         union_station_gateway_cert,
+        union_station_proxy_address,
+        union_station_proxy_type,
         (const char **) prestart_uris_ary, passenger_main_conf.prestart_uris->nelts,
         starting_helper_server_after_fork,
         cycle,
@@ -355,6 +361,8 @@ cleanup:
     free(analytics_log_permissions);
     free(union_station_gateway_address);
     free(union_station_gateway_cert);
+    free(union_station_proxy_address);
+    free(union_station_proxy_type);
     free(error_message);
     if (prestart_uris_ary != NULL) {
         for (i = 0; i < passenger_main_conf.prestart_uris->nelts; i++) {

data/lib/phusion_passenger.rb

@@ -25,9 +25,9 @@ module PhusionPassenger
 	###### Version numbers ######
 	
 	# Phusion Passenger version number. Don't forget to edit ext/common/Constants.h too.
-	VERSION_STRING = '3.0.8'
+	VERSION_STRING = '3.0.9'
 	
-	PREFERRED_NGINX_VERSION = '1.0.5'
+	PREFERRED_NGINX_VERSION = '1.0.6'
 	PREFERRED_PCRE_VERSION  = '8.12'
 	STANDALONE_INTERFACE_VERSION  = 1
 	

data/lib/phusion_passenger/analytics_logger.rb

@@ -24,7 +24,7 @@
 require 'thread'
 require 'phusion_passenger/utils'
 require 'phusion_passenger/debug_logging'
-require 'phusion_passenger/message_client'
+require 'phusion_passenger/message_channel'
 
 module PhusionPassenger
 
@@ -38,24 +38,33 @@ class AnalyticsLogger
 	class Log
 		attr_reader :txn_id
 		
-		def initialize(shared_data = nil, txn_id = nil)
-			if shared_data
-				@shared_data = shared_data
+		def initialize(connection = nil, txn_id = nil)
+			if connection
+				@connection = connection
 				@txn_id = txn_id
-				shared_data.ref
+				connection.ref
 			end
 		end
 		
 		def null?
-			return !@shared_data
+			return !@connection
 		end
 		
 		def message(text)
-			@shared_data.synchronize do
-				@shared_data.client.write("log", @txn_id,
-					AnalyticsLogger.timestamp_string)
-				@shared_data.client.write_scalar(text)
-			end if @shared_data
+			@connection.synchronize do
+				return if !@connection.connected?
+				begin
+					@connection.channel.write("log", @txn_id,
+						AnalyticsLogger.timestamp_string)
+					@connection.channel.write_scalar(text)
+				rescue SystemCallError, IOError => e
+					@connection.disconnect
+					DebugLogging.warn("Error communicating with the logging agent: #{e.message}")
+				rescue Exception => e
+					@connection.disconnect
+					raise e
+				end
+			end if @connection
 		end
 		
 		def begin_measure(name, extra_info = nil)
@@ -107,30 +116,39 @@ class AnalyticsLogger
 		end
 		
 		def close(flush_to_disk = false)
-			@shared_data.synchronize do
-				# We need an ACK here. See abstract_request_handler.rb finalize_request.
-				@shared_data.client.write("closeTransaction", @txn_id,
-					AnalyticsLogger.timestamp_string, true)
-				result = @shared_data.client.read
-				if result != ["ok"]
-					raise "Expected logging server to respond with 'ok', but got #{result.inspect} instead"
-				end
-				if flush_to_disk
-					@shared_data.client.write("flush")
-					result = @shared_data.client.read
+			@connection.synchronize do
+				begin
+					# We need an ACK here. See abstract_request_handler.rb finalize_request.
+					@connection.channel.write("closeTransaction", @txn_id,
+						AnalyticsLogger.timestamp_string, true)
+					result = @connection.channel.read
 					if result != ["ok"]
-						raise "Invalid logging server response #{result.inspect} to the 'flush' command"
+						raise "Expected logging agent to respond with 'ok', but got #{result.inspect} instead"
+					end
+					if flush_to_disk
+						@connection.channel.write("flush")
+						result = @connection.channel.read
+						if result != ["ok"]
+							raise "Invalid logging agent response #{result.inspect} to the 'flush' command"
+						end
 					end
+				rescue SystemCallError, IOError => e
+					@connection.disconnect
+					DebugLogging.warn("Error communicating with the logging agent: #{e.message}")
+				rescue Exception => e
+					@connection.disconnect
+					raise e
+				ensure
+					@connection.unref
+					@connection = nil
 				end
-				@shared_data.unref
-				@shared_data = nil
-			end if @shared_data
+			end if @connection
 		end
 		
 		def closed?
-			if @shared_data
-				@shared_data.synchronize do
-					return !@shared_data.client.connected?
+			if @connection
+				@connection.synchronize do
+					return !@connection.connected?
 				end
 			else
 				return nil
@@ -170,10 +188,10 @@ class AnalyticsLogger
 		@random_dev = File.open("/dev/urandom")
 		
 		# This mutex protects the following instance variables, but
-		# not the contents of @shared_data.
+		# not the contents of @connection.
 		@mutex = Mutex.new
 		
-		@shared_data = SharedData.new
+		@connection = Connection.new(nil)
 		if @server_address && local_socket_address?(@server_address)
 			@max_connect_tries = 10
 		else
@@ -185,20 +203,20 @@ class AnalyticsLogger
 	
 	def clear_connection
 		@mutex.synchronize do
-			@shared_data.synchronize do
+			@connection.synchronize do
 				@random_dev = File.open("/dev/urandom") if @random_dev.closed?
-				@shared_data.unref
-				@shared_data = SharedData.new
+				@connection.unref
+				@connection = Connection.new(nil)
 			end
 		end
 	end
 	
 	def close
 		@mutex.synchronize do
-			@shared_data.synchronize do
+			@connection.synchronize do
 				@random_dev.close
-				@shared_data.unref
-				@shared_data = nil
+				@connection.unref
+				@connection = nil
 			end
 		end
 	end
@@ -212,44 +230,53 @@ class AnalyticsLogger
 		
 		txn_id = (AnalyticsLogger.current_time.to_i / 60).to_s(36)
 		txn_id << "-#{random_token(11)}"
+		
 		Lock.new(@mutex).synchronize do |lock|
-		Lock.new(@shared_data.mutex).synchronize do |shared_data_lock|
-			try_count = 0
-			if current_time >= @next_reconnect_time
-				while try_count < @max_connect_tries
+			if current_time < @next_reconnect_time
+				return Log.new
+			end
+			
+			Lock.new(@connection.mutex).synchronize do |connection_lock|
+				if !@connection.connected?
 					begin
-						connect if !connected?
-						@shared_data.client.write("openTransaction",
-							txn_id, group_name, "", category,
-							AnalyticsLogger.timestamp_string,
-							union_station_key,
-							true,
-							true)
-						result = @shared_data.client.read
-						if result != ["ok"]
-							raise "Expected logging server to respond with 'ok', but got #{result.inspect} instead"
-						end
-						return Log.new(@shared_data, txn_id)
-					rescue Errno::ENOENT, *NETWORK_ERRORS
-						try_count += 1
-						disconnect(true)
-						shared_data_lock.reset(@shared_data.mutex, false)
-						lock.unlock
-						sleep RETRY_SLEEP if try_count < @max_connect_tries
-						lock.lock
-						shared_data_lock.lock
+						connect
+						connection_lock.reset(@connection.mutex)
+					rescue SystemCallError, IOError
+						@connection.disconnect
+						DebugLogging.warn("Cannot connect to the logging agent at #{@server_address}; " +
+							"retrying in #{@reconnect_timeout} second(s).")
+						@next_reconnect_time = current_time + @reconnect_timeout
+						return Log.new
 					rescue Exception => e
-						disconnect
+						@connection.disconnect
 						raise e
 					end
 				end
-				# Failed to connect.
-				DebugLogging.warn("Cannot connect to the logging agent (#{@server_address}); " +
-					"retrying in #{@reconnect_timeout} second(s).")
-				@next_reconnect_time = current_time + @reconnect_timeout
+				
+				begin
+					@connection.channel.write("openTransaction",
+						txn_id, group_name, "", category,
+						AnalyticsLogger.timestamp_string,
+						union_station_key,
+						true,
+						true)
+					result = @connection.channel.read
+					if result != ["ok"]
+						raise "Expected logging server to respond with 'ok', but got #{result.inspect} instead"
+					end
+					return Log.new(@connection, txn_id)
+				rescue SystemCallError, IOError
+					@connection.disconnect
+					DebugLogging.warn("The logging agent at #{@server_address}" <<
+						" closed the connection; will reconnect in " <<
+						"#{@reconnect_timeout} second(s).")
+					@next_reconnect_time = current_time + @reconnect_timeout
+					return Log.new
+				rescue Exception => e
+					@connection.disconnect
+					raise e
+				end
 			end
-			return Log.new
-		end
 		end
 	end
 	
@@ -261,38 +288,46 @@ class AnalyticsLogger
 		end
 		
 		Lock.new(@mutex).synchronize do |lock|
-		Lock.new(@shared_data.mutex).synchronize do |shared_data_lock|
-			try_count = 0
-			if current_time >= @next_reconnect_time
-				while try_count < @max_connect_tries
+			if current_time < @next_reconnect_time
+				return Log.new
+			end
+			
+			Lock.new(@connection.mutex).synchronize do |connection_lock|
+				if !@connection.connected?
 					begin
-						connect if !connected?
-						@shared_data.client.write("openTransaction",
-							txn_id, group_name, "", category,
-							AnalyticsLogger.timestamp_string,
-							union_station_key,
-							true)
-						return Log.new(@shared_data, txn_id)
-					rescue Errno::ENOENT, *NETWORK_ERRORS
-						try_count += 1
-						disconnect(true)
-						shared_data_lock.reset(@shared_data.mutex, false)
-						lock.unlock
-						sleep RETRY_SLEEP if try_count < @max_connect_tries
-						lock.lock
-						shared_data_lock.lock
+						connect
+						connection_lock.reset(@connection.mutex)
+					rescue SystemCallError, IOError
+						@connection.disconnect
+						DebugLogging.warn("Cannot connect to the logging agent at #{@server_address}; " +
+							"retrying in #{@reconnect_timeout} second(s).")
+						@next_reconnect_time = current_time + @reconnect_timeout
+						return Log.new
 					rescue Exception => e
-						disconnect
+						@connection.disconnect
 						raise e
 					end
 				end
-				# Failed to connect.
-				DebugLogging.warn("Cannot connect to the logging agent (#{@server_address}); " +
-					"retrying in #{@reconnect_timeout} second(s).")
-				@next_reconnect_time = current_time + @reconnect_timeout
+				
+				begin
+					@connection.channel.write("openTransaction",
+						txn_id, group_name, "", category,
+						AnalyticsLogger.timestamp_string,
+						union_station_key,
+						true)
+					return Log.new(@connection, txn_id)
+				rescue SystemCallError, IOError
+					@connection.disconnect
+					DebugLogging.warn("The logging agent at #{@server_address}" <<
+						" closed the connection; will reconnect in " <<
+						"#{@reconnect_timeout} second(s).")
+					@next_reconnect_time = current_time + @reconnect_timeout
+					return Log.new
+				rescue Exception => e
+					@connection.disconnect
+					raise e
+				end
 			end
-			return Log.new
-		end
 		end
 	end
 
@@ -337,18 +372,23 @@ private
 		end
 	end
 	
-	class SharedData
+	class Connection
 		attr_reader :mutex
-		attr_accessor :client
+		attr_accessor :channel
 		
-		def initialize
+		def initialize(io)
 			@mutex = Mutex.new
 			@refcount = 1
+			@channel = MessageChannel.new(io) if io
+		end
+		
+		def connected?
+			return !!@channel
 		end
 		
-		def disconnect(check_error_response = false)
-			# TODO: implement check_error_response support
-			@client.close if @client
+		def disconnect
+			@channel.close if @channel
+			@channel = nil
 		end
 		
 		def ref
@@ -369,29 +409,46 @@ private
 		end
 	end
 	
-	def connected?
-		return @shared_data.client && @shared_data.client.connected?
-	end
-	
 	def connect
-		@shared_data.client = MessageClient.new(@username, @password, @server_address)
-		@shared_data.client.write("init", @node_name)
-		args = @shared_data.client.read
+		socket  = connect_to_server(@server_address)
+		channel = MessageChannel.new(socket)
+		
+		result = channel.read
+		if result.nil?
+			raise EOFError
+		elsif result.size != 2 || result[0] != "version"
+			raise IOError, "The logging agent didn't sent a valid version identifier"
+		elsif result[1] != "1"
+			raise IOError, "Unsupported logging agent protocol version #{result[1]}"
+		end
+		
+		channel.write_scalar(@username)
+		channel.write_scalar(@password)
+		
+		result = channel.read
+		if result.nil?
+			raise EOFError
+		elsif result[0] != "ok"
+			raise SecurityError, result[0]
+		end
+		
+		channel.write("init", @node_name)
+		args = channel.read
 		if !args
-			raise Errno::ECONNREFUSED, "Cannot connect to logging server"
+			raise Errno::ECONNREFUSED, "Cannot connect to logging agent"
 		elsif args.size != 1
-			raise IOError, "Logging server returned an invalid reply for the 'init' command"
+			raise IOError, "Logging agent returned an invalid reply for the 'init' command"
 		elsif args[0] == "server shutting down"
-			raise Errno::ECONNREFUSED, "Cannot connect to logging server"
+			raise Errno::ECONNREFUSED, "Cannot connect to logging agent"
 		elsif args[0] != "ok"
-			raise IOError, "Logging server returned an invalid reply for the 'init' command"
+			raise IOError, "Logging agent returned an invalid reply for the 'init' command"
 		end
-	end
-	
-	def disconnect(check_error_response = false)
-		@shared_data.disconnect(check_error_response)
-		@shared_data.unref
-		@shared_data = SharedData.new
+		
+		@connection.unref
+		@connection = Connection.new(socket)
+	rescue Exception => e
+		socket.close if socket && !socket.closed?
+		raise e
 	end
 	
 	def random_token(length)