thin 1.0.0 → 1.2.1

data/ext/thin_parser/parser.rl

@@ -83,7 +83,7 @@
 /** Data **/
 %% write data;
 
-int http_parser_init(http_parser *parser)  {
+int thin_http_parser_init(http_parser *parser)  {
   int cs = 0;
   %% write init;
   parser->cs = cs;
@@ -99,7 +99,7 @@ int http_parser_init(http_parser *parser)  {
 
 
 /** exec **/
-size_t http_parser_execute(http_parser *parser, const char *buffer, size_t len, size_t off)  {
+size_t thin_http_parser_execute(http_parser *parser, const char *buffer, size_t len, size_t off)  {
   const char *p, *pe;
   int cs = parser->cs;
 
@@ -126,34 +126,32 @@ size_t http_parser_execute(http_parser *parser, const char *buffer, size_t len,
 
   if(parser->body_start) {
     /* final \r\n combo encountered so stop right here */
-    %%write eof;
     parser->nread++;
   }
 
   return(parser->nread);
 }
 
-int http_parser_finish(http_parser *parser)
+int thin_http_parser_finish(http_parser *parser)
 {
   int cs = parser->cs;
 
-  %%write eof;
 
   parser->cs = cs;
 
-  if (http_parser_has_error(parser) ) {
+  if (thin_http_parser_has_error(parser) ) {
     return -1;
-  } else if (http_parser_is_finished(parser) ) {
+  } else if (thin_http_parser_is_finished(parser) ) {
     return 1;
   } else {
     return 0;
   }
 }
 
-int http_parser_has_error(http_parser *parser) {
+int thin_http_parser_has_error(http_parser *parser) {
   return parser->cs == http_parser_error;
 }
 
-int http_parser_is_finished(http_parser *parser) {
+int thin_http_parser_is_finished(http_parser *parser) {
   return parser->cs == http_parser_first_final;
 }

data/ext/thin_parser/thin.c

@@ -72,7 +72,7 @@ DEF_MAX_LENGTH(QUERY_STRING, (1024 * 10));
 DEF_MAX_LENGTH(HEADER, (1024 * (80 + 32)));
 
 
-void http_field(void *data, const char *field, size_t flen, const char *value, size_t vlen)
+static void http_field(void *data, const char *field, size_t flen, const char *value, size_t vlen)
 {
   char *ch, *end;
   VALUE req = (VALUE)data;
@@ -86,7 +86,7 @@ void http_field(void *data, const char *field, size_t flen, const char *value, s
   f = rb_str_dup(global_http_prefix);
   f = rb_str_buf_cat(f, field, flen); 
 
-  for(ch = RSTRING_PTR(f), end = ch + RSTRING_LEN(f); ch < end; ch++) {
+  for(ch = RSTRING_PTR(f) + RSTRING_LEN(global_http_prefix), end = RSTRING_PTR(f) + RSTRING_LEN(f); ch < end; ch++) {
     if(*ch == '-') {
       *ch = '_';
     } else {
@@ -97,7 +97,7 @@ void http_field(void *data, const char *field, size_t flen, const char *value, s
   rb_hash_aset(req, f, v);
 }
 
-void request_method(void *data, const char *at, size_t length)
+static void request_method(void *data, const char *at, size_t length)
 {
   VALUE req = (VALUE)data;
   VALUE val = Qnil;
@@ -106,7 +106,7 @@ void request_method(void *data, const char *at, size_t length)
   rb_hash_aset(req, global_request_method, val);
 }
 
-void request_uri(void *data, const char *at, size_t length)
+static void request_uri(void *data, const char *at, size_t length)
 {
   VALUE req = (VALUE)data;
   VALUE val = Qnil;
@@ -117,7 +117,7 @@ void request_uri(void *data, const char *at, size_t length)
   rb_hash_aset(req, global_request_uri, val);
 }
 
-void fragment(void *data, const char *at, size_t length)
+static void fragment(void *data, const char *at, size_t length)
 {
   VALUE req = (VALUE)data;
   VALUE val = Qnil;
@@ -128,7 +128,7 @@ void fragment(void *data, const char *at, size_t length)
   rb_hash_aset(req, global_fragment, val);
 }
 
-void request_path(void *data, const char *at, size_t length)
+static void request_path(void *data, const char *at, size_t length)
 {
   VALUE req = (VALUE)data;
   VALUE val = Qnil;
@@ -140,7 +140,7 @@ void request_path(void *data, const char *at, size_t length)
   rb_hash_aset(req, global_path_info, val);
 }
 
-void query_string(void *data, const char *at, size_t length)
+static void query_string(void *data, const char *at, size_t length)
 {
   VALUE req = (VALUE)data;
   VALUE val = Qnil;
@@ -151,7 +151,7 @@ void query_string(void *data, const char *at, size_t length)
   rb_hash_aset(req, global_query_string, val);
 }
 
-void http_version(void *data, const char *at, size_t length)
+static void http_version(void *data, const char *at, size_t length)
 {
   VALUE req = (VALUE)data;
   VALUE val = rb_str_new(at, length);
@@ -161,7 +161,7 @@ void http_version(void *data, const char *at, size_t length)
 /** Finalizes the request header to have a bunch of stuff that's
   needed. */
 
-void header_done(void *data, const char *at, size_t length)
+static void header_done(void *data, const char *at, size_t length)
 {
   VALUE req = (VALUE)data;
   VALUE temp = Qnil;
@@ -215,7 +215,7 @@ void header_done(void *data, const char *at, size_t length)
 }
 
 
-void HttpParser_free(void *data) {
+void Thin_HttpParser_free(void *data) {
   TRACE();
 
   if(data) {
@@ -224,7 +224,7 @@ void HttpParser_free(void *data) {
 }
 
 
-VALUE HttpParser_alloc(VALUE klass)
+VALUE Thin_HttpParser_alloc(VALUE klass)
 {
   VALUE obj;
   http_parser *hp = ALLOC_N(http_parser, 1);
@@ -237,9 +237,9 @@ VALUE HttpParser_alloc(VALUE klass)
   hp->query_string = query_string;
   hp->http_version = http_version;
   hp->header_done = header_done;
-  http_parser_init(hp);
+  thin_http_parser_init(hp);
 
-  obj = Data_Wrap_Struct(klass, NULL, HttpParser_free, hp);
+  obj = Data_Wrap_Struct(klass, NULL, Thin_HttpParser_free, hp);
 
   return obj;
 }
@@ -251,11 +251,11 @@ VALUE HttpParser_alloc(VALUE klass)
  *
  * Creates a new parser.
  */
-VALUE HttpParser_init(VALUE self)
+VALUE Thin_HttpParser_init(VALUE self)
 {
   http_parser *http = NULL;
   DATA_GET(self, http_parser, http);
-  http_parser_init(http);
+  thin_http_parser_init(http);
 
   return self;
 }
@@ -268,11 +268,11 @@ VALUE HttpParser_init(VALUE self)
  * Resets the parser to it's initial state so that you can reuse it
  * rather than making new ones.
  */
-VALUE HttpParser_reset(VALUE self)
+VALUE Thin_HttpParser_reset(VALUE self)
 {
   http_parser *http = NULL;
   DATA_GET(self, http_parser, http);
-  http_parser_init(http);
+  thin_http_parser_init(http);
 
   return Qnil;
 }
@@ -285,13 +285,13 @@ VALUE HttpParser_reset(VALUE self)
  * Finishes a parser early which could put in a "good" or bad state.
  * You should call reset after finish it or bad things will happen.
  */
-VALUE HttpParser_finish(VALUE self)
+VALUE Thin_HttpParser_finish(VALUE self)
 {
   http_parser *http = NULL;
   DATA_GET(self, http_parser, http);
-  http_parser_finish(http);
+  thin_http_parser_finish(http);
 
-  return http_parser_is_finished(http) ? Qtrue : Qfalse;
+  return thin_http_parser_is_finished(http) ? Qtrue : Qfalse;
 }
 
 
@@ -312,7 +312,7 @@ VALUE HttpParser_finish(VALUE self)
  * the parsing from that position.  It needs all of the original data as well 
  * so you have to append to the data buffer as you read.
  */
-VALUE HttpParser_execute(VALUE self, VALUE req_hash, VALUE data, VALUE start)
+VALUE Thin_HttpParser_execute(VALUE self, VALUE req_hash, VALUE data, VALUE start)
 {
   http_parser *http = NULL;
   int from = 0;
@@ -329,11 +329,11 @@ VALUE HttpParser_execute(VALUE self, VALUE req_hash, VALUE data, VALUE start)
     rb_raise(eHttpParserError, "Requested start is after data buffer end.");
   } else {
     http->data = (void *)req_hash;
-    http_parser_execute(http, dptr, dlen, from);
+    thin_http_parser_execute(http, dptr, dlen, from);
 
     VALIDATE_MAX_LENGTH(http_parser_nread(http), HEADER);
 
-    if(http_parser_has_error(http)) {
+    if(thin_http_parser_has_error(http)) {
       rb_raise(eHttpParserError, "Invalid HTTP format, parsing fails.");
     } else {
       return INT2FIX(http_parser_nread(http));
@@ -349,12 +349,12 @@ VALUE HttpParser_execute(VALUE self, VALUE req_hash, VALUE data, VALUE start)
  *
  * Tells you whether the parser is in an error state.
  */
-VALUE HttpParser_has_error(VALUE self)
+VALUE Thin_HttpParser_has_error(VALUE self)
 {
   http_parser *http = NULL;
   DATA_GET(self, http_parser, http);
 
-  return http_parser_has_error(http) ? Qtrue : Qfalse;
+  return thin_http_parser_has_error(http) ? Qtrue : Qfalse;
 }
 
 
@@ -364,12 +364,12 @@ VALUE HttpParser_has_error(VALUE self)
  *
  * Tells you whether the parser is finished or not and in a good state.
  */
-VALUE HttpParser_is_finished(VALUE self)
+VALUE Thin_HttpParser_is_finished(VALUE self)
 {
   http_parser *http = NULL;
   DATA_GET(self, http_parser, http);
 
-  return http_parser_is_finished(http) ? Qtrue : Qfalse;
+  return thin_http_parser_is_finished(http) ? Qtrue : Qfalse;
 }
 
 
@@ -380,7 +380,7 @@ VALUE HttpParser_is_finished(VALUE self)
  * Returns the amount of data processed so far during this processing cycle.  It is
  * set to 0 on initialize or reset calls and is incremented each time execute is called.
  */
-VALUE HttpParser_nread(VALUE self)
+VALUE Thin_HttpParser_nread(VALUE self)
 {
   http_parser *http = NULL;
   DATA_GET(self, http_parser, http);
@@ -422,12 +422,12 @@ void Init_thin_parser()
   eHttpParserError = rb_define_class_under(mThin, "InvalidRequest", rb_eIOError);
 
   cHttpParser = rb_define_class_under(mThin, "HttpParser", rb_cObject);
-  rb_define_alloc_func(cHttpParser, HttpParser_alloc);
-  rb_define_method(cHttpParser, "initialize", HttpParser_init,0);
-  rb_define_method(cHttpParser, "reset", HttpParser_reset,0);
-  rb_define_method(cHttpParser, "finish", HttpParser_finish,0);
-  rb_define_method(cHttpParser, "execute", HttpParser_execute,3);
-  rb_define_method(cHttpParser, "error?", HttpParser_has_error,0);
-  rb_define_method(cHttpParser, "finished?", HttpParser_is_finished,0);
-  rb_define_method(cHttpParser, "nread", HttpParser_nread,0);
+  rb_define_alloc_func(cHttpParser, Thin_HttpParser_alloc);
+  rb_define_method(cHttpParser, "initialize", Thin_HttpParser_init,0);
+  rb_define_method(cHttpParser, "reset", Thin_HttpParser_reset,0);
+  rb_define_method(cHttpParser, "finish", Thin_HttpParser_finish,0);
+  rb_define_method(cHttpParser, "execute", Thin_HttpParser_execute,3);
+  rb_define_method(cHttpParser, "error?", Thin_HttpParser_has_error,0);
+  rb_define_method(cHttpParser, "finished?", Thin_HttpParser_is_finished,0);
+  rb_define_method(cHttpParser, "nread", Thin_HttpParser_nread,0);
 }

data/lib/rack/adapter/rails.rb

@@ -22,7 +22,13 @@ module Rack
         
         load_application
         
-        @file_server = Rack::File.new(::File.join(RAILS_ROOT, "public"))
+        @rails_app = if ActionController::Dispatcher.instance_methods.include?(:call)
+          ActionController::Dispatcher.new
+        else
+          CgiApp.new
+        end
+        
+        @file_app = Rack::File.new(::File.join(RAILS_ROOT, "public"))
       end
       
       def load_application
@@ -31,31 +37,20 @@ module Rack
         require "#{@root}/config/environment"
         require 'dispatcher'
         
-        ActionController::AbstractRequest.relative_url_root = @prefix if @prefix 
+        if @prefix
+          if ActionController::Base.respond_to?(:relative_url_root=)
+            ActionController::Base.relative_url_root = @prefix # Rails 2.1.1
+          else
+            ActionController::AbstractRequest.relative_url_root = @prefix
+          end
+        end
       end
       
-      # TODO refactor this in File#can_serve?(path) ??
       def file_exist?(path)
-        full_path = ::File.join(@file_server.root, Utils.unescape(path))
+        full_path = ::File.join(@file_app.root, Utils.unescape(path))
         ::File.file?(full_path) && ::File.readable_real?(full_path)
       end
       
-      def serve_file(env)
-        @file_server.call(env)
-      end
-      
-      def serve_rails(env)
-        request         = Request.new(env)
-        response        = Response.new
-        
-        session_options = ActionController::CgiRequest::DEFAULT_SESSION_OPTIONS
-        cgi             = CGIWrapper.new(request, response)
-    
-        Dispatcher.dispatch(cgi, session_options, response)
-
-        response.finish
-      end
-      
       def call(env)
         path        = env['PATH_INFO'].chomp('/')
         method      = env['REQUEST_METHOD']
@@ -63,18 +58,31 @@ module Rack
         
         if FILE_METHODS.include?(method)
           if file_exist?(path)              # Serve the file if it's there
-            return serve_file(env)
+            return @file_app.call(env)
           elsif file_exist?(cached_path)    # Serve the page cache if it's there
             env['PATH_INFO'] = cached_path
-            return serve_file(env)
+            return @file_app.call(env)
           end
         end
         
         # No static file, let Rails handle it
-        serve_rails(env)
+        @rails_app.call(env)
       end
     
       protected
+        # For Rails pre Rack (2.3)
+        class CgiApp
+          def call(env)
+            request         = Request.new(env)
+            response        = Response.new
+            session_options = ActionController::CgiRequest::DEFAULT_SESSION_OPTIONS
+            cgi             = CGIWrapper.new(request, response)
+
+            Dispatcher.dispatch(cgi, session_options, response)
+
+            response.finish
+          end
+        end
         
         class CGIWrapper < ::CGI
           def initialize(request, response, *args)

data/lib/thin.rb

@@ -4,8 +4,10 @@ require 'fileutils'
 require 'timeout'
 require 'stringio'
 require 'time'
+require 'forwardable'
 
 require 'rubygems'
+require 'openssl'
 require 'eventmachine'
 
 require 'thin/version'
@@ -41,9 +43,6 @@ require 'rack'
 require 'rack/adapter/loader'
 
 module Rack
-  module Handler
-    autoload :Thin, 'rack/handler/thin'
-  end
   module Adapter
     autoload :Rails, 'rack/adapter/rails'
   end

data/lib/thin/command.rb

@@ -34,12 +34,13 @@ module Thin
     # Turn into a runnable shell command
     def shellify
       shellified_options = @options.inject([]) do |args, (name, value)|
+        option_name = name.to_s.tr("_", "-")
         case value
         when NilClass,
-             TrueClass then args << "--#{name}"
+             TrueClass then args << "--#{option_name}"
         when FalseClass
-        when Array     then value.each { |v| args << "--#{name}=#{v.inspect}" }
-        else                args << "--#{name.to_s.tr('_', '-')}=#{value.inspect}"
+        when Array     then value.each { |v| args << "--#{option_name}=#{v.inspect}" }
+        else                args << "--#{option_name}=#{value.inspect}"
         end
         args
       end

data/lib/thin/connection.rb

@@ -10,7 +10,10 @@ module Thin
     CHUNKED_REGEXP    = /\bchunked\b/i.freeze
 
     include Logging
-
+    
+    # This is a template async response. N.B. Can't use string for body on 1.9
+    AsyncResponse = [-1, {}, []].freeze
+    
     # Rack application (adapter) served by this connection.
     attr_accessor :app
 
@@ -59,8 +62,20 @@ module Thin
       # Add client info to the request env
       @request.remote_address = remote_address
 
-      # Process the request calling the Rack adapter
-      @app.call(@request.env)
+      # Connection may be closed unless the App#call response was a [-1, ...]
+      # It should be noted that connection objects will linger until this 
+      # callback is no longer referenced, so be tidy!
+      @request.async_callback = method(:post_process)
+      
+      # When we're under a non-async framework like rails, we can still spawn
+      # off async responses using the callback info, so there's little point
+      # in removing this.
+      response = AsyncResponse
+      catch(:async) do
+        # Process the request calling the Rack adapter
+        response = @app.call(@request.env)
+      end
+      response
     rescue Exception
       handle_error
       terminate_request
@@ -69,13 +84,18 @@ module Thin
 
     def post_process(result)
       return unless result
+      result = result.to_a
+      
+      # Status code -1 indicates that we're going to respond later (async).
+      return if result.first == AsyncResponse.first
 
       # Set the Content-Length header if possible
       set_content_length(result) if need_content_length?(result)
-
-      @response.status, @response.headers, @response.body = result
+      
+      @response.status, @response.headers, @response.body = *result
 
       log "!! Rack application returned nil body. Probably you wanted it to be an empty string?" if @response.body.nil?
+
       # Make the response persistent if requested by the client
       @response.persistent! if @request.persistent?
 
@@ -85,13 +105,17 @@ module Thin
         send_data chunk
       end
 
-      # If no more request on that same connection, we close it.
-      close_connection_after_writing unless persistent?
-
     rescue Exception
       handle_error
     ensure
-      terminate_request
+      # If the body is being deferred, then terminate afterward.
+      if @response.body.respond_to?(:callback) && @response.body.respond_to?(:errback)
+        @response.body.callback { terminate_request }
+        @response.body.errback  { terminate_request }
+      else
+        # Don't terminate the response if we're going async.
+        terminate_request unless result && result.first == AsyncResponse.first
+      end
     end
 
     # Logs catched exception and closes the connection.
@@ -101,22 +125,33 @@ module Thin
       close_connection rescue nil
     end
 
+    def close_request_response
+      @request.async_close.succeed
+      @request.close  rescue nil
+      @response.close rescue nil
+    end
+
     # Does request and response cleanup (closes open IO streams and
     # deletes created temporary files).
     # Re-initializes response and request if client supports persistent
     # connection.
     def terminate_request
-      @request.close  rescue nil
-      @response.close rescue nil
-
-      # Prepare the connection for another request if the client
-      # supports HTTP pipelining (persistent connection).
-      post_init if persistent?
+      unless persistent?
+        close_connection_after_writing rescue nil
+        close_request_response
+      else
+        close_request_response
+        # Prepare the connection for another request if the client
+        # supports HTTP pipelining (persistent connection).
+        post_init
+      end
     end
 
     # Called when the connection is unbinded from the socket
     # and can no longer be used to process requests.
     def unbind
+      @request.async_close.succeed if @request.async_close
+      @response.body.fail if @response.body.respond_to?(:fail)
       @backend.connection_finished(self)
     end
 
@@ -161,6 +196,7 @@ module Thin
     private
       def need_content_length?(result)
         status, headers, body = result
+        return false if status == -1
         return false if headers.has_key?(CONTENT_LENGTH)
         return false if (100..199).include?(status) || status == 204 || status == 304
         return false if headers.has_key?(TRANSFER_ENCODING) && headers[TRANSFER_ENCODING] =~ CHUNKED_REGEXP