thin 1.2.6-x86-mingw32

data/spec/server/tcp_spec.rb

@@ -0,0 +1,57 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Server, 'on TCP socket' do
+  before do
+    start_server do |env|
+      body = env.inspect + env['rack.input'].read
+      [200, { 'Content-Type' => 'text/html' }, body]
+    end
+  end
+  
+  it 'should GET from Net::HTTP' do
+    get('/?cthis').should include('cthis')
+  end
+  
+  it 'should GET from TCPSocket' do
+    status, headers, body = parse_response(send_data("GET /?this HTTP/1.0\r\nConnection: close\r\n\r\n"))
+    status.should == 200
+    headers['Content-Type'].should == 'text/html'
+    headers['Connection'].should == 'close'
+    body.should include('this')
+  end
+  
+  it "should add the Content-Length to the response when not present" do
+    status, headers, body = parse_response(send_data("GET / HTTP/1.0\r\nConnection: close\r\n\r\n"))
+    headers.should have_key('Content-Length')
+  end
+  
+  it 'should set the Content-Length to equal the body size in bytes' do
+    status, headers, body = parse_response(send_data("GET / HTTP/1.0\r\nConnection: close\r\n\r\n"))
+    headers['Content-Length'].should == (body.respond_to?(:bytesize) ? body.bytesize : body.size).to_s
+  end
+  
+  it 'should return empty string on incomplete headers' do
+    send_data("GET /?this HTTP/1.1\r\nHost:").should be_empty
+  end
+  
+  it 'should return empty string on incorrect Content-Length' do
+    send_data("POST / HTTP/1.1\r\nContent-Length: 300\r\nConnection: close\r\n\r\naye").should be_empty
+  end
+  
+  it 'should POST from Net::HTTP' do
+    post('/', :arg => 'pirate').should include('arg=pirate')
+  end
+  
+  it 'should handle big POST' do
+    big = 'X' * (20 * 1024)
+    post('/', :big => big).should include(big)
+  end
+  
+  it "should retreive remote address" do
+    get('/').should include('"REMOTE_ADDR"=>"127.0.0.1"')
+  end
+  
+  after do
+    stop_server
+  end
+end

data/spec/server/threaded_spec.rb

@@ -0,0 +1,27 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Server, 'with threads' do
+  before do
+    @requests = 0
+    start_server DEFAULT_TEST_ADDRESS, DEFAULT_TEST_PORT, :threaded => true do |env|
+      sleep env['PATH_INFO'].delete('/').to_i
+      @requests += 1
+      [200, { 'Content-Type' => 'text/html' }, 'hi']
+    end
+  end
+  
+  it "should process request" do
+    get('/').should_not be_empty
+  end
+  
+  it "should process requests when blocked" do
+    slow_request = Thread.new { get('/3') }
+    get('/').should_not be_empty
+    @requests.should == 1
+    slow_request.kill
+  end
+  
+  after do
+    stop_server
+  end
+end

data/spec/server/unix_socket_spec.rb

@@ -0,0 +1,26 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Server, "on UNIX domain socket" do
+  before do
+    start_server('/tmp/thin_test.sock') do |env|
+      [200, { 'Content-Type' => 'text/html' }, [env.inspect]]
+    end
+  end
+  
+  it "should accept GET request" do
+    get("/?this").should include('this')
+  end
+  
+  it "should retreive remote address" do    
+    get('/').should include('"REMOTE_ADDR"=>"127.0.0.1"')
+  end
+  
+  it "should remove socket file after server stops" do
+    @server.stop!
+    File.exist?('/tmp/thin_test.sock').should be_false
+  end
+  
+  after do
+    stop_server
+  end
+end

data/spec/server_spec.rb

@@ -0,0 +1,100 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe Server do
+  before do
+    @server = Server.new('0.0.0.0', 3000)
+  end
+  
+  it "should set maximum_connections size" do
+    @server.maximum_connections = 100
+    @server.config
+    @server.maximum_connections.should == 100
+  end
+
+  it "should set lower maximum_connections size when too large" do
+    # root users under Linux will not have a limitation on maximum
+    # connections, so we cannot really run this test under that
+    # condition.
+    pending("only for non-root users") if Process.euid == 0
+    @server.maximum_connections = 100_000
+    @server.config
+    @server.maximum_connections.should < 100_000
+  end
+  
+  it "should default to non-threaded" do
+    @server.should_not be_threaded
+  end
+  
+  it "should set backend to threaded" do
+    @server.threaded = true
+    @server.backend.should be_threaded
+  end
+end
+
+describe Server, "initialization" do
+  it "should set host and port" do
+    server = Server.new('192.168.1.1', 8080)
+
+    server.host.should == '192.168.1.1'
+    server.port.should == 8080
+  end
+
+  it "should set socket" do
+    server = Server.new('/tmp/thin.sock')
+
+    server.socket.should == '/tmp/thin.sock'
+  end
+  
+  it "should set host, port and app" do
+    app = proc {}
+    server = Server.new('192.168.1.1', 8080, app)
+    
+    server.host.should_not be_nil
+    server.app.should == app
+  end
+
+  it "should set socket and app" do
+    app = proc {}
+    server = Server.new('/tmp/thin.sock', app)
+    
+    server.socket.should_not be_nil
+    server.app.should == app
+  end
+
+  it "should set socket, nil and app" do
+    app = proc {}
+    server = Server.new('/tmp/thin.sock', nil, app)
+    
+    server.socket.should_not be_nil
+    server.app.should == app
+  end
+  
+  it "should set host, port and backend" do
+    server = Server.new('192.168.1.1', 8080, :backend => Thin::Backends::SwiftiplyClient)
+    
+    server.host.should_not be_nil
+    server.backend.should be_kind_of(Thin::Backends::SwiftiplyClient)
+  end  
+
+  it "should set host, port, app and backend" do
+    app = proc {}
+    server = Server.new('192.168.1.1', 8080, app, :backend => Thin::Backends::SwiftiplyClient)
+    
+    server.host.should_not be_nil
+    server.app.should == app
+    server.backend.should be_kind_of(Thin::Backends::SwiftiplyClient)
+  end
+  
+  it "should set port as string" do
+    app = proc {}
+    server = Server.new('192.168.1.1', '8080')
+    
+    server.host.should == '192.168.1.1'
+    server.port.should == 8080
+  end
+  
+  it "should not register signals w/ :signals => false" do
+    Server.should_not_receive(:setup_signals)
+    Server.new(:signals => false)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,219 @@
+require 'rubygems'
+require 'thin'
+require 'spec'
+require 'benchmark'
+require 'timeout'
+require 'fileutils'
+require 'net/http'
+require 'socket'
+
+include Thin
+
+FileUtils.mkdir_p File.dirname(__FILE__) + '/../log'
+Command.script = File.dirname(__FILE__) + '/../bin/thin'
+Logging.silent = true
+
+unless Object.const_defined?(:SWIFTIPLY_PATH)
+  SWIFTIPLY_PATH       = `which swiftiply`.chomp
+  DEFAULT_TEST_ADDRESS = '0.0.0.0'
+  DEFAULT_TEST_PORT    = 3333
+end
+
+module Matchers
+  class BeFasterThen
+    def initialize(max_time)
+      require 'benchmark_unit'
+      @max_time = max_time
+    end
+
+    # Base on benchmark_unit/assertions#compare_benchmarks
+    def matches?(proc)
+      @time, multiplier = 0, 1
+      
+      while (@time < 0.01) do
+        @time = Benchmark::Unit.measure do 
+          multiplier.times &proc
+        end
+        multiplier *= 10
+      end
+      
+      multiplier /= 10
+      
+      iterations = (Benchmark::Unit::CLOCK_TARGET / @time).to_i * multiplier
+      iterations = 1 if iterations < 1
+      
+      total = Benchmark::Unit.measure do 
+        iterations.times &proc
+      end
+      
+      @time = total / iterations
+      
+      @time < @max_time
+    end
+    
+    def failure_message(less_more=:less)
+      "took <#{@time.inspect} RubySeconds>, should take #{less_more} than #{@max_time} RubySeconds."
+    end
+
+    def negative_failure_message
+      failure_message :more
+    end
+  end
+  
+  class ValidateWithLint
+    def matches?(request)
+      @request = request
+      Rack::Lint.new(proc{[200, {'Content-Type' => 'text/html', 'Content-Length' => '0'}, []]}).call(@request.env)
+      true
+    rescue Rack::Lint::LintError => e
+      @message = e.message
+      false
+    end
+    
+    def failure_message(negation=nil)
+      "should#{negation} validate with Rack Lint: #{@message}"
+    end
+
+    def negative_failure_message
+      failure_message ' not'
+    end
+  end
+
+  class TakeLessThen
+    def initialize(time)
+      @time = time
+    end
+    
+    def matches?(proc)
+      Timeout.timeout(@time) { proc.call }
+      true
+    rescue Timeout::Error
+      false 
+    end
+    
+    def failure_message(negation=nil)
+      "should#{negation} take less then #{@time} sec to run"
+    end
+
+    def negative_failure_message
+      failure_message ' not'
+    end
+  end
+
+  # Actual matchers that are exposed.
+
+  def be_faster_then(time)
+    BeFasterThen.new(time)
+  end
+  
+  def validate_with_lint
+    ValidateWithLint.new
+  end
+
+  def take_less_then(time)
+    TakeLessThen.new(time)
+  end  
+end
+
+module Helpers
+  # Silences any stream for the duration of the block.
+  #
+  #   silence_stream(STDOUT) do
+  #     puts 'This will never be seen'
+  #   end
+  #
+  #   puts 'But this will'
+  #
+  # (Taken from ActiveSupport)
+  def silence_stream(stream)
+    old_stream = stream.dup
+    stream.reopen(RUBY_PLATFORM =~ /mswin/ ? 'NUL:' : '/dev/null')
+    stream.sync = true
+    yield
+  ensure
+    stream.reopen(old_stream)
+  end
+  
+  # Create and parse a request
+  def R(raw, convert_line_feed=false)
+    raw.gsub!("\n", "\r\n") if convert_line_feed
+    request = Thin::Request.new
+    request.parse(raw)
+    request
+  end
+  
+  def start_server(address=DEFAULT_TEST_ADDRESS, port=DEFAULT_TEST_PORT, options={}, &app)
+    @server = Thin::Server.new(address, port, options, app)
+    @server.threaded = options[:threaded]
+    @server.timeout = 3
+    
+    @thread = Thread.new { @server.start }
+    if options[:wait_for_socket]
+      wait_for_socket(address, port)
+    else
+      # If we can't ping the address fallback to just wait for the server to run
+      sleep 1 until @server.running?
+    end
+  end
+  
+  def stop_server
+    @server.stop!
+    @thread.kill
+    raise "Reactor still running, wtf?" if EventMachine.reactor_running?
+  end
+  
+  def wait_for_socket(address=DEFAULT_TEST_ADDRESS, port=DEFAULT_TEST_PORT, timeout=5)
+    Timeout.timeout(timeout) do
+      loop do
+        begin
+          if address.include?('/')
+            UNIXSocket.new(address).close
+          else
+            TCPSocket.new(address, port).close
+          end
+          return true
+        rescue
+        end
+      end
+    end
+  end
+    
+  def send_data(data)
+    if @server.backend.class == Backends::UnixServer
+      socket = UNIXSocket.new(@server.socket)
+    else
+      socket = TCPSocket.new(@server.host, @server.port)
+    end
+    socket.write data
+    out = socket.read
+    socket.close
+    out
+  end
+  
+  def parse_response(response)
+    raw_headers, body = response.split("\r\n\r\n", 2)
+    raw_status, raw_headers = raw_headers.split("\r\n", 2)
+
+    status  = raw_status.match(%r{\AHTTP/1.1\s+(\d+)\b}).captures.first.to_i
+    headers = Hash[ *raw_headers.split("\r\n").map { |h| h.split(/:\s+/, 2) }.flatten ]
+
+    [ status, headers, body ]
+  end
+  
+  def get(url)
+    if @server.backend.class == Backends::UnixServer
+      send_data("GET #{url} HTTP/1.1\r\nConnection: close\r\n\r\n")
+    else
+      Net::HTTP.get(URI.parse("http://#{@server.host}:#{@server.port}" + url))
+    end
+  end
+  
+  def post(url, params={})
+    Net::HTTP.post_form(URI.parse("http://#{@server.host}:#{@server.port}" + url), params).body
+  end
+end
+
+Spec::Runner.configure do |config|
+  config.include Matchers
+  config.include Helpers
+end

data/tasks/announce.rake

@@ -0,0 +1,22 @@
+require 'erb'
+
+MSG_TEMPLATE = File.dirname(__FILE__) + '/email.erb'
+SEND_TO      = %w(thin-ruby@googlegroups.com ruby-talk@ruby-lang.org)
+
+desc 'Generate a template for the new version annoucement'
+task :ann do
+  msg = ERB.new(File.read(MSG_TEMPLATE)).result(binding)
+    
+  body = <<END_OF_MESSAGE
+To: #{SEND_TO.join(', ')}
+Subject: [ANN] Thin #{Thin::VERSION::STRING} #{Thin::VERSION::CODENAME} release
+
+#{msg}
+END_OF_MESSAGE
+
+  fork { `echo "#{body}" | mate` }
+end
+
+def changelog
+  File.read('CHANGELOG').split("==")[1].split("\n")[1..-1].join("\n")
+end