thin 1.3.1 → 1.4.0

data/spec/backends/swiftiply_client_spec.rb

@@ -1,66 +0,0 @@
-require '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

@@ -1,33 +0,0 @@
-require '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

@@ -1,37 +0,0 @@
-require '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

@@ -1,25 +0,0 @@
-require '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

@@ -1,9 +0,0 @@
---- 
-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

@@ -1,9 +0,0 @@
---- 
-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

@@ -1,107 +0,0 @@
-require 'spec_helper'
-
-describe Connection do
-  before do
-    @connection = Connection.new(mock('EM', :null_object => true))
-    @connection.post_init
-    @connection.backend = mock("backend", :ssl? => false)
-    @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

@@ -1,267 +0,0 @@
-require '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
-
-describe Cluster, "rolling restart" do
-  before do
-    @cluster = Cluster.new(:chdir => '/rails_app',
-                           :address => '0.0.0.0',
-                           :port => 3000, 
-                           :servers => 2,
-                           :timeout => 10,
-                           :log => 'thin.log',
-                           :pid => 'thin.pid',
-                           :onebyone => true,
-                           :wait => 30
-                          )
-  end
-  
-  it "should restart servers one by one" do
-    Command.should_receive(:run).with(:stop, options_for_port(3000))
-    Command.should_receive(:run).with(:start, options_for_port(3000))
-    @cluster.should_receive(:wait_until_server_started).with(3000)
-    
-    Command.should_receive(:run).with(:stop, options_for_port(3001))
-    Command.should_receive(:run).with(:start, options_for_port(3001))
-    @cluster.should_receive(:wait_until_server_started).with(3001)
-    
-    @cluster.restart
-  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