thin 0.5.0 → 0.5.2

data/ext/thin_parser/thin.c

@@ -77,7 +77,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(f)->ptr, end = ch + RSTRING(f)->len; ch < end; ch++) {
+  for(ch = RSTRING_PTR(f), end = ch + RSTRING_LEN(f); ch < end; ch++) {
     if(*ch == '-') {
       *ch = '_';
     } else {
@@ -176,12 +176,12 @@ void header_done(void *data, const char *at, size_t length)
   rb_hash_aset(req, global_gateway_interface, global_gateway_interface_value);
   if((temp = rb_hash_aref(req, global_http_host)) != Qnil) {
     /* ruby better close strings off with a '\0' dammit */
-    colon = strchr(RSTRING(temp)->ptr, ':');
+    colon = strchr(RSTRING_PTR(temp), ':');
     if(colon != NULL) {
-      rb_hash_aset(req, global_server_name, rb_str_substr(temp, 0, colon - RSTRING(temp)->ptr));
+      rb_hash_aset(req, global_server_name, rb_str_substr(temp, 0, colon - RSTRING_PTR(temp)));
       rb_hash_aset(req, global_server_port, 
-          rb_str_substr(temp, colon - RSTRING(temp)->ptr+1, 
-            RSTRING(temp)->len));
+          rb_str_substr(temp, colon - RSTRING_PTR(temp)+1, 
+            RSTRING_LEN(temp)));
     } else {
       rb_hash_aset(req, global_server_name, temp);
       rb_hash_aset(req, global_server_port, global_port_80);
@@ -313,8 +313,8 @@ VALUE HttpParser_execute(VALUE self, VALUE req_hash, VALUE data, VALUE start)
   DATA_GET(self, http_parser, http);
 
   from = FIX2INT(start);
-  dptr = RSTRING(data)->ptr;
-  dlen = RSTRING(data)->len;
+  dptr = RSTRING_PTR(data);
+  dlen = RSTRING_LEN(data);
 
   if(from >= dlen) {
     rb_raise(eHttpParserError, "Requested start is after data buffer end.");

data/lib/rack/adapter/rails.rb

@@ -14,8 +14,8 @@ module Rack
   module Adapter 
     class Rails
       def initialize(options={})
-        @root = options[:root] || Dir.pwd
-        @env  = options[:env]  || 'development'
+        @root = options[:root]         || Dir.pwd
+        @env  = options[:environment]  || 'development'
         
         load_application
         
@@ -30,15 +30,16 @@ module Rack
       end
       
       # TODO refactor this in File#can_serve?(path) ??
-      def file?(path)
+      def file_exist?(path)
         full_path = ::File.join(@file_server.root, Utils.unescape(path))
         ::File.file?(full_path) && ::File.readable?(full_path)
       end
       
-      def call(env)
-        # Serve the file if it's there
-        return @file_server.call(env) if file?(env['PATH_INFO'])
-        
+      def serve_file(env)
+        @file_server.call(env)
+      end
+      
+      def serve_rails(env)
         request         = Request.new(env)
         response        = Response.new
         
@@ -49,6 +50,20 @@ module Rack
 
         response.finish
       end
+      
+      def call(env)
+        path        = env['PATH_INFO'].chomp('/')
+        cached_path = (path.empty? ? 'index' : path) + ActionController::Base.page_cache_extension
+        
+        if file_exist?(path)              # Serve the file if it's there
+          serve_file(env)
+        elsif file_exist?(cached_path)    # Serve the page cache if it's there
+          env['PATH_INFO'] = cached_path
+          serve_file(env)
+        else                              # No static file, let Rails handle it
+          serve_rails(env)
+        end
+      end
     
       protected
         
@@ -75,27 +90,28 @@ module Rack
               @response['Expires']          = options.delete('expires') if options['expires']
 
               @response.status              = options.delete('Status') if options['Status']
-        
-              options.each { |k,v| @response[k] = v }
-            
+              
               # Convert 'cookie' header to 'Set-Cookie' headers.
-              # According to http://www.faqs.org/rfcs/rfc2109.html:
-              #   the Set-Cookie response header comprises the token
-              #   Set-Cookie:, followed by a comma-separated list of
-              #   one or more cookies.
-              if cookie = @response.header.delete('Cookie')
-                cookies = case cookie
-                  when Array then cookie.collect { |c| c.to_s }.join(', ')
-                  when Hash  then cookie.collect { |_, c| c.to_s }.join(', ')
-                  else            cookie.to_s
+              # Because Set-Cookie header can appear more the once in the response body, 
+              # we store it in a line break seperated string that will be translated to
+              # multiple Set-Cookie header by the handler.
+              if cookie = options.delete('cookie')
+                cookies = []
+                
+                case cookie
+                  when Array then cookie.each { |c| cookies << c.to_s }
+                  when Hash  then cookie.each { |_, c| cookies << c.to_s }
+                  else            cookies << cookie.to_s
                 end
         
-                cookies << ', ' + @output_cookies.each { |c| c.to_s }.join(', ') if @output_cookies
+                @output_cookies.each { |c| cookies << c.to_s } if @output_cookies
                 
-                @response['Set-Cookie'] = cookies
+                @response['Set-Cookie'] = [@response['Set-Cookie'], cookies].compact.join("\n")
               end
+              
+              options.each { |k,v| @response[k] = v }
             end
-        
+            
             ""
           end
                         

data/lib/thin.rb

@@ -12,8 +12,9 @@ require 'thin/statuses'
 
 module Thin
   NAME    = 'thin'.freeze
-  SERVER  = "#{NAME} #{VERSION::STRING}".freeze  
+  SERVER  = "#{NAME} #{VERSION::STRING} codename #{VERSION::CODENAME}".freeze  
   
+  autoload :Cluster,      'thin/cluster'
   autoload :Connection,   'thin/connection'
   autoload :Daemonizable, 'thin/daemonizing'
   autoload :Logging,      'thin/logging'

data/lib/thin/cluster.rb

@@ -0,0 +1,106 @@
+module Thin
+  # Control a set of servers.
+  # * Generate start and stop commands and run them.
+  # * Inject the port number in the pid and log filenames.
+  # Servers are started throught the +thin+ commandline script.
+  class Cluster
+    include Logging
+    
+    # Path to the +thin+ script used to control the servers.
+    # Leave this to default to use the one in the path.
+    attr_accessor :script
+    
+    # Number of servers in the cluster.
+    attr_accessor :size
+    
+    # Command line options passed to the thin script
+    attr_accessor :options
+    
+    # Create a new cluster of servers launched using +options+.
+    def initialize(options)
+      @options = options.merge(:daemonize => true)
+      @size    = @options.delete(:servers)
+      @script  = 'thin'
+    end
+    
+    def first_port; @options[:port]     end
+    def address;    @options[:address]  end    
+    def pid_file;   File.expand_path File.join(@options[:chdir], @options[:pid]) end
+    def log_file;   File.expand_path File.join(@options[:chdir], @options[:log]) end
+    
+    # Start the servers
+    def start
+      with_each_server { |port| start_on_port port }
+    end
+    
+    # Start the server on a single port
+    def start_on_port(port)
+      log "Starting #{address}:#{port} ... "
+      
+      run :start, @options, port
+    end
+  
+    # Stop the servers
+    def stop
+      with_each_server { |port| stop_on_port port }
+    end
+    
+    # Stop the server running on +port+
+    def stop_on_port(port)
+      log "Stopping #{address}:#{port} ... "
+      
+      run :stop, @options, port
+    end
+    
+    # Stop and start the servers.
+    def restart
+      stop
+      sleep 0.1 # Let's breath a bit shall we ?
+      start
+    end
+    
+    def log_file_for(port)
+      include_port_number log_file, port
+    end
+    
+    def pid_file_for(port)
+      include_port_number pid_file, port
+    end
+    
+    def pid_for(port)
+      File.read(pid_file_for(port)).chomp.to_i
+    end
+    
+    private
+      # Send the command to the +thin+ script
+      def run(cmd, options, port)
+        shell_cmd = shellify(cmd, options.merge(:port => port, :pid => pid_file_for(port), :log => log_file_for(port)))
+        trace shell_cmd
+        ouput = `#{shell_cmd}`.chomp
+        log ouput unless ouput.empty?
+      end
+      
+      # Turn into a runnable shell command
+      def shellify(cmd, options)
+        shellified_options = options.inject([]) do |args, (name, value)|
+          args << case value
+          when NilClass
+          when TrueClass then "--#{name}"
+          else                "--#{name.to_s.tr('_', '-')}=#{value.inspect}"
+          end
+        end
+        "#{@script} #{cmd} #{shellified_options.compact.join(' ')}"
+      end
+      
+      def with_each_server
+        @size.times { |n| yield first_port + n }
+      end
+      
+      # Add the port numbers in the filename
+      # so each instance get its own file
+      def include_port_number(path, port)
+        raise ArgumentError, "filename '#{path}' must include an extension" unless path =~ /\./
+        path.gsub(/\.(.+)$/) { ".#{port}.#{$1}" }
+      end
+  end
+end

data/lib/thin/connection.rb

@@ -12,11 +12,11 @@ module Thin
     end
     
     def receive_data(data)
+      trace { data }
 			process if @request.parse(data)
     rescue InvalidRequest => e
       log "Invalid request"
       log_error e
-      trace { data }
       close_connection
     end
     
@@ -30,9 +30,8 @@ module Thin
       @response.status, @response.headers, @response.body = @app.call(env)
       
       # Send the response
-      send_data @response.head
-      @response.body.rewind
-      send_data @response.body.read
+      trace { @response.to_s }
+      send_data @response.to_s
       
       close_connection_after_writing
       

data/lib/thin/daemonizing.rb

@@ -1,22 +1,5 @@
 require 'etc'
-
-module Kernel
-  unless respond_to? :daemonize # Already part of Ruby 1.9, yeah!
-    # Turns the current script into a daemon process that detaches from the console.
-    # It can be shut down with a TERM signal. Taken from ActiveSupport.
-    def daemonize
-      exit if fork                   # Parent exits, child continues.
-      Process.setsid                 # Become session leader.
-      exit if fork                   # Zap session leader. See [1].
-      Dir.chdir "/"                  # Release old working directory.
-      File.umask 0000                # Ensure sensible umask. Adjust as needed.
-      STDIN.reopen "/dev/null"       # Free file descriptors and
-      STDOUT.reopen "/dev/null", "a" # point them somewhere sensible.
-      STDERR.reopen STDOUT           # STDOUT/ERR should better go to a logfile.
-      trap("TERM") { exit }
-    end
-  end
-end
+require 'daemons'
 
 module Process
   # Returns +true+ the process identied by +pid+ is running.
@@ -51,13 +34,10 @@ module Thin
       raise ArgumentError, 'You must specify a pid_file to deamonize' unless @pid_file
       
       pwd = Dir.pwd # Current directory is changed during daemonization, so store it
-      super         # Calls Kernel#daemonize
-      Dir.chdir pwd
       
-      trap('HUP', 'IGNORE') # Don't die upon logout
-
-      # Redirect output to the logfile
-      [STDOUT, STDERR].each { |f| f.reopen @log_file, 'a' } if @log_file
+      Daemonize.daemonize(File.expand_path(@log_file))
+      
+      Dir.chdir(pwd)
       
       write_pid_file
       at_exit do

data/lib/thin/request.rb

@@ -5,6 +5,7 @@ module Thin
   # and the server can not process it.
   class InvalidRequest < IOError; end
   
+  # A request sent by the client to the server.
   class Request
     MAX_HEADER        = 1024 * (80 + 32)
     MAX_HEADER_MSG    = 'Header longer than allowed'.freeze
@@ -35,7 +36,7 @@ module Thin
         # Rack stuff
         RACK_INPUT        => @body,
         
-        RACK_VERSION      => [0, 1],
+        RACK_VERSION      => [0, 2],
         RACK_ERRORS       => STDERR,
         
         RACK_MULTITHREAD  => false,
@@ -47,18 +48,18 @@ module Thin
     def parse(data)
       @data << data
 			
-			if @parser.finished?  # Header finished, can only be some more body
+			if @parser.finished?                    # Header finished, can only be some more body
         body << data
-			elsif @data.size > MAX_HEADER
+			elsif @data.size > MAX_HEADER           # Oho! very big header, must be a mean person
 			  raise InvalidRequest, MAX_HEADER_MSG
-			else                  # Parse more header
+			else                                    # Parse more header
 			  @nparsed = @parser.execute(@env, @data, @nparsed)
 			end
 			
 			# Check if header and body are complete
 			if @parser.finished? && body.size >= content_length
 		    body.rewind
-		    return true
+		    return true # Request is fully parsed
 		  end
 			
 			false # Not finished, need more data

data/lib/thin/response.rb

@@ -26,9 +26,7 @@ module Thin
     
     def headers=(key_value_pairs)
       key_value_pairs.each do |k, vs|
-        vs.each do |v|
-          @headers[k] = v
-        end
+        vs.each { |v| @headers[k] = v.chomp }
       end
     end
     

data/lib/thin/server.rb

@@ -4,9 +4,9 @@ module Thin
   
   # The Thin HTTP server used to served request.
   # It listen for incoming request on a given port
-  # and forward all request to all the handlers in the order
-  # they were registered.
-  # Based on HTTP 1.1 protocol specs
+  # and forward all request to +app+.
+  #
+  # Based on HTTP 1.1 protocol specs:
   # http://www.w3.org/Protocols/rfc2616/rfc2616.html
   class Server
     include Logging
@@ -18,12 +18,12 @@ module Thin
     # App called with the request that produce the response.
     attr_accessor :app
     
-    # Maximum time for a request to be red and parsed.
+    # Maximum time for incoming data to arrive
     attr_accessor :timeout
     
     # Creates a new server binded to <tt>host:port</tt>
     # that will pass request to +app+.
-    def initialize(host, port, app)
+    def initialize(host, port, app=nil)
       @host       = host
       @port       = port.to_i
       @app        = app
@@ -32,7 +32,9 @@ module Thin
     
     # Starts the handlers.
     def start
-      log   ">> Thin web server (v#{VERSION::STRING})"
+      raise ArgumentError, "app required" unless @app
+      
+      log   ">> Thin web server (v#{VERSION::STRING} codename #{VERSION::CODENAME})"
       trace ">> Tracing ON"
     end
     
@@ -64,6 +66,7 @@ module Thin
 			end
     end
     
+    
     def stop
       EventMachine.stop_event_loop
     rescue

data/lib/thin/version.rb

@@ -1,9 +1,11 @@
 module Thin
   module VERSION #:nodoc:
-    MAJOR = 0
-    MINOR = 5
-    TINY  = 0
+    MAJOR    = 0
+    MINOR    = 5
+    TINY     = 2
 
-    STRING = [MAJOR, MINOR, TINY].join('.')
+    STRING   = [MAJOR, MINOR, TINY].join('.')
+    
+    CODENAME = 'Cheezburger'
   end
 end

data/spec/cluster_spec.rb

@@ -0,0 +1,58 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe Cluster do
+  before do
+    @cluster = Thin::Cluster.new(:chdir => File.dirname(__FILE__) + '/rails_app',
+                                 :address => '0.0.0.0',
+                                 :port => 3000, 
+                                 :servers => 3,
+                                 :timeout => 10,
+                                 :log => 'thin.log',
+                                 :pid => 'thin.pid'
+                                )
+    @cluster.script = File.dirname(__FILE__) + '/../bin/thin'
+    @cluster.silent = true
+  end
+    
+  it 'should include port number in file names' do
+    @cluster.send(:include_port_number, 'thin.log', 3000).should == 'thin.3000.log'
+    @cluster.send(:include_port_number, 'thin.pid', 3000).should == 'thin.3000.pid'
+    proc { @cluster.send(:include_port_number, 'thin', 3000) }.should raise_error(ArgumentError)
+  end
+  
+  it 'should call each server' do
+    calls = []
+    @cluster.send(:with_each_server) do |port|
+      calls << port
+    end
+    calls.should == [3000, 3001, 3002]
+  end
+  
+  it 'should shellify command' do
+    out = @cluster.send(:shellify, :start, :port => 3000, :daemonize => true, :log => 'hi.log', :pid => nil)
+    out.should include('--port=3000', '--daemonize', '--log="hi.log"', 'thin start --')
+    out.should_not include('--pid=')
+  end
+  
+  it 'should absolutize file path' do
+    @cluster.pid_file_for(3000).should == File.expand_path(File.dirname(__FILE__) + "/rails_app/thin.3000.pid")
+  end
+  
+  it 'should start on specified port' do
+    @cluster.should_receive(:`) do |with|
+      with.should include('thin start', '--daemonize', 'thin.3001.log', 'thin.3001.pid', '--port=3001')
+      ''
+    end
+
+    @cluster.start_on_port 3001    
+  end
+
+  it 'should stop on specified port' do
+    @cluster.should_receive(:`) do |with|
+      with.should include('thin stop', '--daemonize', 'thin.3001.log', 'thin.3001.pid', '--port=3001')
+      ''
+    end
+
+    @cluster.stop_on_port 3001
+  end
+end