thin 1.2.3-x86-mswin32

data/lib/thin/stats.rb

@@ -0,0 +1,52 @@
+require 'erb'
+
+module Thin
+  module Stats
+    # Rack adapter to log stats about a Rack application.
+    class Adapter
+      include ERB::Util
+      
+      def initialize(app, path='/stats')
+        @app  = app
+        @path = path
+
+        @template = ERB.new(File.read(File.dirname(__FILE__) + '/stats.html.erb'))
+        
+        @requests          = 0
+        @requests_finished = 0
+        @start_time        = Time.now
+      end
+      
+      def call(env)
+        if env['PATH_INFO'].index(@path) == 0
+          serve(env)
+        else
+          log(env) { @app.call(env) }
+        end
+      end
+      
+      def log(env)
+        @requests += 1
+        @last_request = Rack::Request.new(env)
+        request_started_at = Time.now
+        
+        response = yield
+        
+        @requests_finished += 1
+        @last_request_time = Time.now - request_started_at
+        
+        response
+      end
+      
+      def serve(env)
+        body = @template.result(binding)
+        
+        [
+          200,
+          { 'Content-Type' => 'text/html' },
+          [body]
+        ]
+      end
+    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,32 @@
+module Thin  
+  # Raised when a feature is not supported on the
+  # current platform.
+  class PlatformNotSupported < RuntimeError; end
+  
+  module VERSION #:nodoc:
+    MAJOR    = 1
+    MINOR    = 2
+    TINY     = 3
+    
+    STRING   = [MAJOR, MINOR, TINY].join('.')
+    
+    CODENAME = "Flaming Astroboy".freeze
+    
+    RACK     = [1, 0].freeze # Rack protocol version
+  end
+  
+  NAME    = 'thin'.freeze
+  SERVER  = "#{NAME} #{VERSION::STRING} codename #{VERSION::CODENAME}".freeze  
+  
+  def self.win?
+    RUBY_PLATFORM =~ /mswin|mingw/
+  end
+  
+  def self.linux?
+    RUBY_PLATFORM =~ /linux/
+  end
+  
+  def self.ruby_18?
+    RUBY_VERSION =~ /^1\.8/
+  end
+end

data/spec/backends/swiftiply_client_spec.rb

@@ -0,0 +1,66 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Backends::SwiftiplyClient do
+  before do
+    @backend = Backends::SwiftiplyClient.new('0.0.0.0', 3333)
+    @backend.server = mock('server', :null_object => true)
+  end
+  
+  it "should connect" do
+    EventMachine.run do
+      @backend.connect
+      EventMachine.stop
+    end
+  end
+  
+  it "should disconnect" do
+    EventMachine.run do
+      @backend.connect
+      @backend.disconnect
+      EventMachine.stop
+    end
+  end
+end
+
+describe SwiftiplyConnection do
+  before do
+    @connection = SwiftiplyConnection.new(nil)
+    @connection.backend = Backends::SwiftiplyClient.new('0.0.0.0', 3333)
+    @connection.backend.server = mock('server', :null_object => true)
+  end
+  
+  it do
+    @connection.should be_persistent
+  end
+  
+  it "should send handshake on connection_completed" do
+    @connection.should_receive(:send_data).with('swiftclient000000000d0500')
+    @connection.connection_completed
+  end
+  
+  it "should reconnect on unbind" do
+    @connection.backend.stub!(:running?).and_return(true)
+    @connection.stub!(:rand).and_return(0) # Make sure we don't wait
+    
+    @connection.should_receive(:reconnect).with('0.0.0.0', 3333)
+    
+    EventMachine.run do
+      @connection.unbind
+      EventMachine.add_timer(0) { EventMachine.stop }      
+    end
+  end
+  
+  it "should not reconnect when not running" do
+    @connection.backend.stub!(:running?).and_return(false)
+    EventMachine.should_not_receive(:add_timer)
+    @connection.unbind
+  end
+  
+  it "should have a host_ip" do
+    @connection.send(:host_ip).should == [0, 0, 0, 0]
+  end
+  
+  it "should generate swiftiply_handshake based on key" do
+    @connection.send(:swiftiply_handshake, 'key').should == 'swiftclient000000000d0503key'
+  end
+end

data/spec/backends/tcp_server_spec.rb

@@ -0,0 +1,33 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Backends::TcpServer do
+  before do
+    @backend = Backends::TcpServer.new('0.0.0.0', 3333)
+  end
+  
+  it "should not use epoll" do
+    @backend.no_epoll = true
+    EventMachine.should_not_receive(:epoll)
+    @backend.config
+  end
+  
+  it "should use epoll" do
+    EventMachine.should_receive(:epoll)
+    @backend.config
+  end
+  
+  it "should connect" do
+    EventMachine.run do
+      @backend.connect
+      EventMachine.stop
+    end
+  end
+  
+  it "should disconnect" do
+    EventMachine.run do
+      @backend.connect
+      @backend.disconnect
+      EventMachine.stop
+    end
+  end
+end

data/spec/backends/unix_server_spec.rb

@@ -0,0 +1,37 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Backends::UnixServer do
+  before do
+    @backend = Backends::UnixServer.new('/tmp/thin-test.sock')
+  end
+  
+  it "should connect" do
+    EventMachine.run do
+      @backend.connect
+      EventMachine.stop
+    end
+  end
+  
+  it "should disconnect" do
+    EventMachine.run do
+      @backend.connect
+      @backend.disconnect
+      EventMachine.stop
+    end
+  end
+  
+  it "should remove socket file on close" do
+    @backend.close
+    File.exist?('/tmp/thin-test.sock').should be_false
+  end
+end
+
+describe UnixConnection do
+  before do
+    @connection = UnixConnection.new(nil)
+  end
+  
+  it "should return 127.0.0.1 as remote_address" do
+    @connection.remote_address.should == '127.0.0.1'
+  end
+end

data/spec/command_spec.rb

@@ -0,0 +1,25 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe Command do
+  before do
+    Command.script = 'thin'
+    @command = Command.new(:start, :port => 3000, :daemonize => true, :log => 'hi.log',
+                           :require => %w(rubygems thin), :no_epoll => true)
+  end
+  
+  it 'should shellify command' do
+    out = @command.shellify
+    out.should include('--port=3000', '--daemonize', '--log="hi.log"', 'thin start --')
+    out.should_not include('--pid')
+  end
+  
+  it 'should shellify Array argument to multiple parameters' do
+    out = @command.shellify
+    out.should include('--require="rubygems"', '--require="thin"')
+  end
+
+  it 'should convert _ to - in option name' do
+    out = @command.shellify
+    out.should include('--no-epoll')
+  end
+end

data/spec/configs/cluster.yml

@@ -0,0 +1,9 @@
+--- 
+pid: tmp/pids/thin.pid
+log: log/thin.log
+timeout: 60
+port: 5000
+chdir: spec/rails_app
+environment: production
+servers: 3
+address: 127.0.0.1

data/spec/configs/single.yml

@@ -0,0 +1,9 @@
+--- 
+pid: tmp/pids/thin.pid
+log: log/thin.log
+timeout: 60
+port: 6000
+chdir: spec/rails_app
+environment: production
+daemonize: true
+address: 127.0.0.1

data/spec/connection_spec.rb

@@ -0,0 +1,106 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe Connection do
+  before do
+    @connection = Connection.new(mock('EM', :null_object => true))
+    @connection.post_init
+    @connection.app = proc do |env|
+      [200, {}, ['']]
+    end
+  end
+  
+  it "should parse on receive_data" do
+    @connection.request.should_receive(:parse).with('GET')
+    @connection.receive_data('GET')
+  end
+
+  it "should close connection on InvalidRequest error in receive_data" do
+    @connection.request.stub!(:parse).and_raise(InvalidRequest)
+    @connection.should_receive(:close_connection)
+    @connection.receive_data('')
+  end
+  
+  it "should process when parsing complete" do
+    @connection.request.should_receive(:parse).and_return(true)
+    @connection.should_receive(:process)
+    @connection.receive_data('GET')
+  end
+  
+  it "should process" do
+    @connection.process
+  end
+  
+  it "should rescue error in process" do
+    @connection.app.should_receive(:call).and_raise(StandardError)
+    @connection.process
+  end
+  
+  it "should rescue Timeout error in process" do
+    @connection.app.should_receive(:call).and_raise(Timeout::Error.new("timeout error not rescued"))
+    @connection.process
+  end
+  
+  it "should not return HTTP_X_FORWARDED_FOR as remote_address" do
+    @connection.request.env['HTTP_X_FORWARDED_FOR'] = '1.2.3.4'
+    @connection.stub!(:socket_address).and_return("127.0.0.1")
+    @connection.remote_address.should == "127.0.0.1"
+  end
+  
+  it "should return nil on error retreiving remote_address" do
+    @connection.stub!(:get_peername).and_raise(RuntimeError)
+    @connection.remote_address.should be_nil
+  end
+  
+  it "should return nil on nil get_peername" do
+    @connection.stub!(:get_peername).and_return(nil)
+    @connection.remote_address.should be_nil
+  end
+  
+  it "should return nil on empty get_peername" do
+    @connection.stub!(:get_peername).and_return('')
+    @connection.remote_address.should be_nil
+  end
+  
+  it "should return remote_address" do
+    @connection.stub!(:get_peername).and_return(Socket.pack_sockaddr_in(3000, '127.0.0.1'))
+    @connection.remote_address.should == '127.0.0.1'
+  end
+  
+  it "should not be persistent" do
+    @connection.should_not be_persistent
+  end
+
+  it "should be persistent when response is and allowed" do
+    @connection.response.stub!(:persistent?).and_return(true)
+    @connection.can_persist!
+    @connection.should be_persistent
+  end
+
+  it "should not be persistent when response is but not allowed" do
+    @connection.response.persistent!
+    @connection.should_not be_persistent
+  end
+  
+  it "should set request env as rack.multithread" do
+    EventMachine.should_receive(:defer)
+    
+    @connection.threaded = true
+    @connection.process
+    
+    @connection.request.env["rack.multithread"].should == true
+  end
+  
+  it "should set as threaded when app.deferred? is true" do
+    @connection.app.should_receive(:deferred?).and_return(true)
+    @connection.should be_threaded
+  end
+  
+  it "should not set as threaded when app.deferred? is false" do
+    @connection.app.should_receive(:deferred?).and_return(false)
+    @connection.should_not be_threaded
+  end
+
+  it "should not set as threaded when app do not respond to deferred?" do
+    @connection.should_not be_threaded
+  end
+end

data/spec/controllers/cluster_spec.rb

@@ -0,0 +1,235 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+include Controllers
+
+describe Cluster, "with host and port" do
+  before do
+    @cluster = Cluster.new(:chdir => '/rails_app',
+                           :address => '0.0.0.0',
+                           :port => 3000, 
+                           :servers => 3,
+                           :timeout => 10,
+                           :log => 'thin.log',
+                           :pid => 'thin.pid'
+                          )
+  end
+    
+  it 'should include port number in file names' do
+    @cluster.send(:include_server_number, 'thin.log', 3000).should == 'thin.3000.log'
+    @cluster.send(:include_server_number, 'thin.pid', 3000).should == 'thin.3000.pid'
+  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 start on each port' do
+    Command.should_receive(:run).with(:start, options_for_port(3000))
+    Command.should_receive(:run).with(:start, options_for_port(3001))
+    Command.should_receive(:run).with(:start, options_for_port(3002))
+
+    @cluster.start
+  end
+
+  it 'should stop on each port' do
+    Command.should_receive(:run).with(:stop, options_for_port(3000))
+    Command.should_receive(:run).with(:stop, options_for_port(3001))
+    Command.should_receive(:run).with(:stop, options_for_port(3002))
+
+    @cluster.stop
+  end
+  
+  private
+    def options_for_port(port)
+      { :daemonize => true, :log => "thin.#{port}.log", :timeout => 10, :address => "0.0.0.0", :port => port, :pid => "thin.#{port}.pid", :chdir => "/rails_app" }
+    end
+end
+
+describe Cluster, "with UNIX socket" do
+  before do
+    @cluster = Cluster.new(:chdir => '/rails_app',
+                           :socket => '/tmp/thin.sock',
+                           :address => '0.0.0.0',
+                           :port => 3000,
+                           :servers => 3,
+                           :timeout => 10,
+                           :log => 'thin.log',
+                           :pid => 'thin.pid'
+                          )
+  end
+  
+  it 'should include socket number in file names' do
+    @cluster.send(:include_server_number, 'thin.sock', 0).should == 'thin.0.sock'
+    @cluster.send(:include_server_number, 'thin', 0).should == 'thin.0'
+  end
+  
+  it "should exclude :address and :port options" do
+    @cluster.options.should_not have_key(:address)
+    @cluster.options.should_not have_key(:port)
+  end
+  
+  it 'should call each server' do
+    calls = []
+    @cluster.send(:with_each_server) do |n|
+      calls << n
+    end
+    calls.should == [0, 1, 2]
+  end
+  
+  it 'should start each server' do
+    Command.should_receive(:run).with(:start, options_for_socket(0))
+    Command.should_receive(:run).with(:start, options_for_socket(1))
+    Command.should_receive(:run).with(:start, options_for_socket(2))
+
+    @cluster.start
+  end
+
+  it 'should stop each server' do
+    Command.should_receive(:run).with(:stop, options_for_socket(0))
+    Command.should_receive(:run).with(:stop, options_for_socket(1))
+    Command.should_receive(:run).with(:stop, options_for_socket(2))
+
+    @cluster.stop
+  end
+  
+  
+  private
+    def options_for_socket(number)
+      { :daemonize => true, :log => "thin.#{number}.log", :timeout => 10, :socket => "/tmp/thin.#{number}.sock", :pid => "thin.#{number}.pid", :chdir => "/rails_app" }
+    end
+end
+
+describe Cluster, "controlling only one server" do
+  before do
+    @cluster = Cluster.new(:chdir => '/rails_app',
+                           :address => '0.0.0.0',
+                           :port => 3000, 
+                           :servers => 3,
+                           :timeout => 10,
+                           :log => 'thin.log',
+                           :pid => 'thin.pid',
+                           :only => 3001
+                          )
+  end
+  
+  it 'should call only specified server' do
+    calls = []
+    @cluster.send(:with_each_server) do |n|
+      calls << n
+    end
+    calls.should == [3001]
+  end
+  
+  it "should start only specified server" do
+    Command.should_receive(:run).with(:start, options_for_port(3001))
+
+    @cluster.start
+  end
+  
+  private
+    def options_for_port(port)
+      { :daemonize => true, :log => "thin.#{port}.log", :timeout => 10, :address => "0.0.0.0", :port => port, :pid => "thin.#{port}.pid", :chdir => "/rails_app" }
+    end
+end
+
+describe Cluster, "controlling only one server with UNIX socket" do
+  before do
+    @cluster = Cluster.new(:chdir => '/rails_app',
+                           :socket => '/tmp/thin.sock',
+                           :address => '0.0.0.0',
+                           :port => 3000,
+                           :servers => 3,
+                           :timeout => 10,
+                           :log => 'thin.log',
+                           :pid => 'thin.pid',
+                           :only => 1
+                          )
+  end
+  
+  it 'should call only specified server' do
+    calls = []
+    @cluster.send(:with_each_server) do |n|
+      calls << n
+    end
+    calls.should == [1]
+  end
+end
+
+describe Cluster, "controlling only one server, by sequence number" do
+  before do
+    @cluster = Cluster.new(:chdir => '/rails_app',
+                           :address => '0.0.0.0',
+                           :port => 3000, 
+                           :servers => 3,
+                           :timeout => 10,
+                           :log => 'thin.log',
+                           :pid => 'thin.pid',
+                           :only => 1
+                          )
+  end
+  
+  it 'should call only specified server' do
+    calls = []
+    @cluster.send(:with_each_server) do |n|
+      calls << n
+    end
+    calls.should == [3001]
+  end
+  
+  it "should start only specified server" do
+    Command.should_receive(:run).with(:start, options_for_port(3001))
+
+    @cluster.start
+  end
+  
+  private
+    def options_for_port(port)
+      { :daemonize => true, :log => "thin.#{port}.log", :timeout => 10, :address => "0.0.0.0", :port => port, :pid => "thin.#{port}.pid", :chdir => "/rails_app" }
+    end
+end
+
+describe Cluster, "with Swiftiply" do
+  before do
+    @cluster = Cluster.new(:chdir => '/rails_app',
+                           :address => '0.0.0.0',
+                           :port => 3000, 
+                           :servers => 3,
+                           :timeout => 10,
+                           :log => 'thin.log',
+                           :pid => 'thin.pid',
+                           :swiftiply => true
+                          )
+  end
+  
+  it 'should call each server' do
+    calls = []
+    @cluster.send(:with_each_server) do |n|
+      calls << n
+    end
+    calls.should == [0, 1, 2]
+  end
+  
+  it 'should start each server' do
+    Command.should_receive(:run).with(:start, options_for_swiftiply(0))
+    Command.should_receive(:run).with(:start, options_for_swiftiply(1))
+    Command.should_receive(:run).with(:start, options_for_swiftiply(2))
+
+    @cluster.start
+  end
+
+  it 'should stop each server' do
+    Command.should_receive(:run).with(:stop, options_for_swiftiply(0))
+    Command.should_receive(:run).with(:stop, options_for_swiftiply(1))
+    Command.should_receive(:run).with(:stop, options_for_swiftiply(2))
+
+    @cluster.stop
+  end
+  
+  private
+    def options_for_swiftiply(number)
+      { :address => '0.0.0.0', :port => 3000, :daemonize => true, :log => "thin.#{number}.log", :timeout => 10, :pid => "thin.#{number}.pid", :chdir => "/rails_app", :swiftiply => true }
+    end
+end