thin 0.5.3-x86-mswin32-60

data/lib/thin/headers.rb

@@ -0,0 +1,37 @@
+module Thin
+  # Acts like a Hash, but allows duplicated keys
+  class Headers
+    HEADER_FORMAT      = "%s: %s\r\n".freeze
+    ALLOWED_DUPLICATES = %w(Set-Cookie Set-Cookie2 Warning WWW-Authenticate).freeze
+    
+    def initialize
+      @sent = {}
+      @items = []
+    end
+
+    def []=(key, value)
+      if @sent.has_key?(key) && !ALLOWED_DUPLICATES.include?(key)
+        # If we don't allow duplicate for that field
+        # we overwrite the one that is already there
+        @items.assoc(key)[1] = value
+      else
+        @sent[key] = true
+        @items << [key, value]
+      end
+    end
+    
+    def [](key)
+      if item = @items.assoc(key)
+        item[1]
+      end
+    end
+    
+    def size
+      @items.size
+    end
+    
+    def to_s
+      @items.inject('') { |out, (name, value)| out << HEADER_FORMAT % [name, value] }
+    end
+  end
+end

data/lib/thin/logging.rb

@@ -0,0 +1,23 @@
+module Thin
+  # To be included into classes to allow some basic logging
+  # that can be silented (+silent+) or made more verbose ($DEBUG=true).
+  module Logging
+    # Don't output any message if +true+.
+    attr_accessor :silent
+    
+    protected
+      # Log a message to the console
+      def log(msg)
+        puts msg unless @silent
+      end
+      
+      # Log a message to the console if tracing is activated
+      def trace(msg=nil)
+        puts msg || yield if $DEBUG && !@silent
+      end
+      
+      def log_error(e)
+        trace { "#{e}\n\t" + e.backtrace.join("\n\t") }
+      end
+  end
+end

data/lib/thin/request.rb

@@ -0,0 +1,72 @@
+require 'thin_parser'
+
+module Thin
+  # Raised when an incoming request is not valid
+  # 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
+
+    SERVER_SOFTWARE   = 'SERVER_SOFTWARE'.freeze
+    REMOTE_ADDR       = 'REMOTE_ADDR'.freeze
+    FORWARDED_FOR     = 'HTTP_X_FORWARDED_FOR'.freeze
+
+    CONTENT_LENGTH    = 'CONTENT_LENGTH'.freeze
+
+    RACK_INPUT        = 'rack.input'.freeze
+    RACK_VERSION      = 'rack.version'.freeze
+    RACK_ERRORS       = 'rack.errors'.freeze
+    RACK_MULTITHREAD  = 'rack.multithread'.freeze
+    RACK_MULTIPROCESS = 'rack.multiprocess'.freeze
+    RACK_RUN_ONCE     = 'rack.run_once'.freeze
+    
+    attr_reader :env, :data, :body
+    
+    def initialize
+      @parser   = HttpParser.new
+      @data     = ''
+      @nparsed  = 0
+      @body     = StringIO.new
+      @env      = {
+        SERVER_SOFTWARE   => SERVER,
+        
+        # Rack stuff
+        RACK_INPUT        => @body,
+        
+        RACK_VERSION      => [0, 2],
+        RACK_ERRORS       => STDERR,
+        
+        RACK_MULTITHREAD  => false,
+        RACK_MULTIPROCESS => false,
+        RACK_RUN_ONCE     => false
+      }
+    end
+    
+    def parse(data)
+      @data << data
+			
+			if @parser.finished?                    # Header finished, can only be some more body
+        body << data
+			elsif @data.size > MAX_HEADER           # Oho! very big header, must be a mean person
+			  raise InvalidRequest, MAX_HEADER_MSG
+			else                                    # Parse more header using the super parser
+			  @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 # Request is fully parsed
+		  end
+			
+			false # Not finished, need more data
+    end
+    
+    def content_length
+      @env[CONTENT_LENGTH].to_i
+    end
+  end  
+end

data/lib/thin/response.rb

@@ -0,0 +1,48 @@
+module Thin
+  # A response sent to the client.
+  class Response
+    CONTENT_LENGTH = 'Content-Length'.freeze
+    CONNECTION     = 'Connection'.freeze
+    CLOSE          = 'close'.freeze
+    
+    attr_accessor :status
+    attr_reader   :headers, :body
+    
+    def initialize
+      @headers = Headers.new
+      @body    = StringIO.new
+      @status  = 200
+    end
+    
+    def headers_output
+      @headers[CONTENT_LENGTH] = @body.size
+      @headers[CONNECTION] = CLOSE
+      @headers.to_s
+    end
+    
+    def head
+      "HTTP/1.1 #{@status} #{HTTP_STATUS_CODES[@status.to_i]}\r\n#{headers_output}\r\n"
+    end
+    
+    def headers=(key_value_pairs)
+      key_value_pairs.each do |k, vs|
+        vs.each { |v| @headers[k] = v.chomp }
+      end
+    end
+    
+    def body=(stream)
+      stream.each do |part|
+        @body << part
+      end
+    end
+    
+    def close
+      @body.close
+    end
+    
+    def to_s
+      @body.rewind
+      head + @body.read
+    end
+  end
+end

data/lib/thin/server.rb

@@ -0,0 +1,80 @@
+module Thin
+  # Raise when we require the server to stop
+  class StopServer < Exception; end
+  
+  # The Thin HTTP server used to served request.
+  # It listen for incoming request on a given port
+  # 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
+    include Daemonizable
+    
+    # Addresse and port on which the server is listening for connections.
+    attr_accessor :port, :host
+    
+    # App called with the request that produce the response.
+    attr_accessor :app
+    
+    # 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=nil)
+      @host       = host
+      @port       = port.to_i
+      @app        = app
+      @timeout    = 60 # sec
+    end
+    
+    # Starts the handlers.
+    def start
+      raise ArgumentError, "app required" unless @app
+      
+      log   ">> Thin web server (v#{VERSION::STRING} codename #{VERSION::CODENAME})"
+      trace ">> Tracing ON"
+    end
+    
+    # Start the server and listen for connections
+    def start!
+      start
+      listen!
+    end
+    
+    # Start listening for connections
+    def listen!
+      trap('INT')  { stop }
+			trap('TERM') { stop! }
+      
+      # See http://rubyeventmachine.com/pub/rdoc/files/EPOLL.html
+      EventMachine.epoll
+
+			EventMachine.run do
+				begin
+				  log ">> Listening on #{@host}:#{@port}, CTRL+C to stop"
+					EventMachine.start_server(@host, @port, Connection) do |connection|
+					  connection.comm_inactivity_timeout = @timeout
+					  connection.app                     = @app
+					  connection.silent                  = @silent
+					end
+				rescue StopServer
+					EventMachine.stop_event_loop
+				end
+			end
+    end
+    
+    
+    def stop
+      EventMachine.stop_event_loop
+    rescue
+      warn "Error stopping : #{$!}"
+    end
+    
+    def stop!
+      raise StopServer
+    end
+  end
+end

data/lib/thin/statuses.rb

@@ -0,0 +1,43 @@
+module Thin
+  # Every standard HTTP code mapped to the appropriate message.
+  # Stolent from Mongrel.
+  HTTP_STATUS_CODES = {  
+    100  => 'Continue', 
+    101  => 'Switching Protocols', 
+    200  => 'OK', 
+    201  => 'Created', 
+    202  => 'Accepted', 
+    203  => 'Non-Authoritative Information', 
+    204  => 'No Content', 
+    205  => 'Reset Content', 
+    206  => 'Partial Content', 
+    300  => 'Multiple Choices', 
+    301  => 'Moved Permanently', 
+    302  => 'Moved Temporarily', 
+    303  => 'See Other', 
+    304  => 'Not Modified', 
+    305  => 'Use Proxy', 
+    400  => 'Bad Request', 
+    401  => 'Unauthorized', 
+    402  => 'Payment Required', 
+    403  => 'Forbidden', 
+    404  => 'Not Found', 
+    405  => 'Method Not Allowed', 
+    406  => 'Not Acceptable', 
+    407  => 'Proxy Authentication Required', 
+    408  => 'Request Time-out', 
+    409  => 'Conflict', 
+    410  => 'Gone', 
+    411  => 'Length Required', 
+    412  => 'Precondition Failed', 
+    413  => 'Request Entity Too Large', 
+    414  => 'Request-URI Too Large', 
+    415  => 'Unsupported Media Type', 
+    500  => 'Internal Server Error', 
+    501  => 'Not Implemented', 
+    502  => 'Bad Gateway', 
+    503  => 'Service Unavailable', 
+    504  => 'Gateway Time-out', 
+    505  => 'HTTP Version not supported'
+  }
+end

data/lib/thin/version.rb

@@ -0,0 +1,11 @@
+module Thin
+  module VERSION #:nodoc:
+    MAJOR    = 0
+    MINOR    = 5
+    TINY     = 3
+
+    STRING   = [MAJOR, MINOR, TINY].join('.')
+    
+    CODENAME = 'Purple Yogurt'
+  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

data/spec/daemonizing_spec.rb

@@ -0,0 +1,93 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe 'Daemonizing' do
+  before do
+    @server = Server.new('0.0.0.0', 3000, nil)
+    @server.log_file = File.dirname(__FILE__) + '/../log/daemonizing_test.log'
+    @server.pid_file = 'test.pid'
+    @pid = nil
+  end
+  
+  it 'should have a pid file' do
+    @server.should respond_to(:pid_file)
+    @server.should respond_to(:pid_file=)
+  end
+  
+  it 'should create a pid file' do
+    @pid = fork do
+      @server.daemonize
+      sleep 1
+    end
+    
+    Process.wait(@pid)
+    File.exist?(@server.pid_file).should be_true
+    @pid = @server.pid
+
+    proc { sleep 0.1 while File.exist?(@server.pid_file) }.should take_less_then(2)
+  end
+  
+  it 'should redirect stdio to a log file' do
+    @pid = fork do
+      @server.log_file = 'daemon_test.log'
+      @server.daemonize
+
+      puts "simple puts"
+      STDERR.puts "STDERR.puts"
+      STDOUT.puts "STDOUT.puts"
+    end
+    Process.wait(@pid)
+    # Wait for the file to close and magical stuff to happen
+    proc { sleep 0.1 until File.exist?('daemon_test.log') }.should take_less_then(3)
+    sleep 0.5
+
+    log = File.read('daemon_test.log')
+    log.should include('simple puts', 'STDERR.puts', 'STDOUT.puts')
+    
+    File.delete 'daemon_test.log'
+  end
+  
+  it 'should change privilege' do
+    @pid = fork do
+      @server.daemonize
+      @server.change_privilege('root', 'admin')
+    end
+    Process.wait(@pid)
+    $?.should be_a_success
+  end
+  
+  it 'should kill process in pid file' do
+    @pid = fork do
+      @server.daemonize
+      loop { sleep 1 }
+    end
+  
+    proc { sleep 0.1 until File.exist?(@server.pid_file) }.should take_less_then(3)
+  
+    silence_stream STDOUT do
+      Server.kill(@server.pid_file, 1)
+    end
+  
+    File.exist?(@server.pid_file).should_not be_true
+  end
+  
+  it 'should send kill signal if timeout' do
+    @pid = fork do
+      @server.should_receive(:stop) # pretend we cannot handle the INT signal
+      @server.daemonize
+      sleep 5
+    end
+  
+    proc { sleep 0.1 until File.exist?(@server.pid_file) }.should take_less_then(10)
+  
+    silence_stream STDOUT do
+      Server.kill(@server.pid_file, 1)
+    end
+  
+    File.exist?(@server.pid_file).should be_false
+    Process.running?(@pid).should be_false
+  end
+  
+  after do
+    Process.kill(9, @pid.to_i) if @pid && Process.running?(@pid.to_i)
+  end
+end