grockit-thin 0.8.2

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,96 @@
+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
+    @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 File.dirname(__FILE__) + '/../lib/thin'
+require 'spec'
+require 'benchmark'
+require 'timeout'
+require 'fileutils'
+require 'benchmark_unit'
+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)
+      @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'}, []]}).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"
+    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

data/tasks/deploy.rake

@@ -0,0 +1,16 @@
+namespace :deploy do
+  task :site => %w(site:upload rdoc:upload)
+  
+  desc 'Deploy on code.macournoyer.com'
+  task :alpha => %w(gem:upload deploy:site)
+  
+  desc 'Deploy on rubyforge'
+  task :public => %w(gem:upload_rubyforge deploy:site)  
+end
+desc 'Deploy on all servers'
+task :deploy => %w(deploy:alpha deploy:public)
+
+def upload(file, to, options={})
+  sh %{ssh macournoyer@macournoyer.com "rm -rf code.macournoyer.com/#{to}"} if options[:replace]
+  sh %{scp -rq #{file} macournoyer@macournoyer.com:code.macournoyer.com/#{to}}
+end

data/tasks/email.erb

@@ -0,0 +1,30 @@
+Hey all,
+
+Thin version <%= Thin::VERSION::STRING %> (codename <%= Thin::VERSION::CODENAME %>) is out!
+
+== What's new?
+
+<%= changelog %>
+
+== Get it!
+ 
+Install Thin from RubyForge:
+
+ gem install thin
+ 
+Or using my mirror:
+
+ gem install thin --source http://code.macournoyer.com
+
+== Contribute
+
+Site:  http://code.macournoyer.com/thin/
+Group: http://groups.google.com/group/thin-ruby/topics
+Bugs:  http://thin.lighthouseapp.com/projects/7212-thin
+Code:  http://github.com/macournoyer/thin
+IRC:   #thin on freenode
+
+Thanks to all the people who contributed to Thin, EventMachine, Rack and Mongrel.
+
+Marc-Andre Cournoyer
+http://macournoyer.com/

data/tasks/ext.rake

@@ -0,0 +1,42 @@
+CLEAN.include %w(**/*.{o,bundle,jar,so,obj,pdb,lib,def,exp,log} ext/*/Makefile ext/*/conftest.dSYM)
+
+def ext_task(name)
+  ext_dir    = "ext/#{name}"
+  ext_bundle = "#{ext_dir}/#{name}.#{Config::CONFIG['DLEXT']}"
+  ext_files  = FileList[
+    "#{ext_dir}/*.c",
+    "#{ext_dir}/*.h",
+    "#{ext_dir}/*.rl",
+    "#{ext_dir}/extconf.rb",
+    "#{ext_dir}/Makefile",
+    "lib"
+  ]
+  
+  task "compile:#{name}" => ["#{ext_dir}/Makefile", ext_bundle]
+  task :compile => "compile:#{name}"
+  
+  file "#{ext_dir}/Makefile" => ["#{ext_dir}/extconf.rb"] do
+    cd(ext_dir) { ruby "extconf.rb" }
+  end
+
+  file ext_bundle => ext_files do
+    cd ext_dir do
+      sh(WIN ? 'nmake' : 'make')
+    end
+    cp ext_bundle, 'lib/'
+  end
+end
+
+desc "Compile the Ragel state machines"
+task :ragel do
+  Dir.chdir 'ext/thin_parser' do
+    target = "parser.c"
+    File.unlink target if File.exist? target
+    sh "ragel parser.rl | rlgen-cd -G2 -o #{target}"
+    raise "Failed to compile Ragel state machine" unless File.exist? target
+  end
+end
+  
+desc "Compile the extensions"
+task :compile
+task :package => :compile