thin 1.8.0 → 2.0.0.pre

data/lib/thin/backends/swiftiply_client.rb

@@ -1,56 +0,0 @@
-module Thin
-  module Backends
-    # Backend to act as a Swiftiply client (http://swiftiply.swiftcore.org).
-    class SwiftiplyClient < Base
-      attr_accessor :key
-
-      attr_accessor :host, :port
-
-      def initialize(host, port, options = {})
-        @host = host
-        @port = port.to_i
-        @key  = options[:swiftiply].to_s
-        super()
-      end
-
-      # Connect the server
-      def connect
-        EventMachine.connect(@host, @port, SwiftiplyConnection, &method(:initialize_connection))
-      end
-
-      # Stops the server
-      def disconnect
-        EventMachine.stop
-      end
-
-      def to_s
-        "#{@host}:#{@port} swiftiply"
-      end
-    end
-  end
-
-  class SwiftiplyConnection < Connection
-    def connection_completed
-      send_data swiftiply_handshake(@backend.key)
-    end
-
-    def persistent?
-      true
-    end
-
-    def unbind
-      super
-      EventMachine.add_timer(rand(2)) { reconnect(@backend.host, @backend.port) } if @backend.running?
-    end
-
-    protected
-      def swiftiply_handshake(key)
-        'swiftclient' << host_ip.collect { |x| sprintf('%02x', x.to_i) }.join << sprintf('%04x', @backend.port) << sprintf('%02x', key.length) << key
-      end
-
-      # For some reason Swiftiply request the current host
-      def host_ip
-        Socket.gethostbyname(@backend.host)[3].unpack('CCCC') rescue [0, 0, 0, 0]
-      end
-  end
-end

data/lib/thin/backends/tcp_server.rb

@@ -1,34 +0,0 @@
-module Thin
-  module Backends
-    # Backend to act as a TCP socket server.
-    class TcpServer < Base
-      # Address and port on which the server is listening for connections.
-      attr_accessor :host, :port
-
-      def initialize(host, port)
-        @host = host
-        @port = port
-        super()
-      end
-
-      # Connect the server
-      def connect
-        @signature = EventMachine.start_server(@host, @port, Connection, &method(:initialize_connection))
-        binary_name = EventMachine.get_sockname( @signature )
-        port_name = Socket.unpack_sockaddr_in( binary_name )
-        @port = port_name[0]
-        @host = port_name[1]
-        @signature
-      end
-
-      # Stops the server
-      def disconnect
-        EventMachine.stop_server(@signature)
-      end
-
-      def to_s
-        "#{@host}:#{@port}"
-      end
-    end
-  end
-end

data/lib/thin/backends/unix_server.rb

@@ -1,56 +0,0 @@
-module Thin
-  module Backends
-    # Backend to act as a UNIX domain socket server.
-    class UnixServer < Base
-      # UNIX domain socket on which the server is listening for connections.
-      attr_accessor :socket
-      
-      def initialize(socket)
-        raise PlatformNotSupported, 'UNIX domain sockets not available on Windows' if Thin.win?
-        @socket = socket
-        super()
-      end
-      
-      # Connect the server
-      def connect
-        at_exit { remove_socket_file } # In case it crashes
-        old_umask = File.umask(0)
-        begin
-          EventMachine.start_unix_domain_server(@socket, UnixConnection, &method(:initialize_connection))
-          # HACK EventMachine.start_unix_domain_server doesn't return the connection signature
-          #      so we have to go in the internal stuff to find it.
-        @signature = EventMachine.instance_eval{@acceptors.keys.first}
-        ensure
-          File.umask(old_umask)
-        end
-      end
-      
-      # Stops the server
-      def disconnect
-        EventMachine.stop_server(@signature)
-      end
-      
-      # Free up resources used by the backend.
-      def close
-        remove_socket_file
-      end
-      
-      def to_s
-        @socket
-      end
-      
-      protected
-        def remove_socket_file
-          File.delete(@socket) if @socket && File.exist?(@socket)
-        end
-    end    
-  end
-
-  # Connection through a UNIX domain socket.
-  class UnixConnection < Connection
-    protected
-      def socket_address        
-        '127.0.0.1' # Unix domain sockets can only be local
-      end
-  end
-end

data/lib/thin/command.rb

@@ -1,53 +0,0 @@
-require 'open3'
-
-module Thin
-  # Run a command through the +thin+ command-line script.
-  class Command
-    include Logging
-    
-    class << self
-      # Path to the +thin+ script used to control the servers.
-      # Leave this to default to use the one in the path.
-      attr_accessor :script
-    end
-    
-    def initialize(name, options={})
-      @name    = name
-      @options = options
-    end
-    
-    def self.run(*args)
-      new(*args).run
-    end
-    
-    # Send the command to the +thin+ script
-    def run
-      shell_cmd = shellify
-      trace shell_cmd
-      trap('INT') {} # Ignore INT signal to pass CTRL+C to subprocess
-      Open3.popen3(shell_cmd) do |stdin, stdout, stderr|
-        log_info stdout.gets until stdout.eof?
-        log_info stderr.gets until stderr.eof?
-      end
-    end
-    
-    # Turn into a runnable shell command
-    def shellify
-      shellified_options = @options.inject([]) do |args, (name, value)|
-        option_name = name.to_s.tr("_", "-")
-        case value
-        when NilClass,
-             TrueClass then args << "--#{option_name}"
-        when FalseClass
-        when Array     then value.each { |v| args << "--#{option_name}=#{v.inspect}" }
-        else                args << "--#{option_name}=#{value.inspect}"
-        end
-        args
-      end
-      
-      raise ArgumentError, "Path to thin script can't be found, set Command.script" unless self.class.script
-      
-      "#{self.class.script} #{@name} #{shellified_options.compact.join(' ')}"
-    end
-  end
-end

data/lib/thin/controllers/cluster.rb

@@ -1,178 +0,0 @@
-require 'socket'
-
-module Thin
-  # An exception class to handle the event that server didn't start on time
-  class RestartTimeout < RuntimeError; end
-  
-  module Controllers
-    # Control a set of servers.
-    # * Generate start and stop commands and run them.
-    # * Inject the port or socket number in the pid and log filenames.
-    # Servers are started throught the +thin+ command-line script.
-    class Cluster < Controller
-      # Cluster only options that should not be passed in the command sent
-      # to the indiviual servers.
-      CLUSTER_OPTIONS = [:servers, :only, :onebyone, :wait]
-      
-      # Maximum wait time for the server to be restarted
-      DEFAULT_WAIT_TIME = 30    # seconds
-      
-      # Create a new cluster of servers launched using +options+.
-      def initialize(options)
-        super
-        # Cluster can only contain daemonized servers
-        @options.merge!(:daemonize => true)
-      end
-      
-      def first_port; @options[:port]     end
-      def address;    @options[:address]  end
-      def socket;     @options[:socket]   end
-      def pid_file;   @options[:pid]      end
-      def log_file;   @options[:log]      end
-      def size;       @options[:servers]  end
-      def only;       @options[:only]     end
-      def onebyone;   @options[:onebyone] end
-      def wait;       @options[:wait]     end
-      
-      def swiftiply?
-        @options.has_key?(:swiftiply)
-      end
-    
-      # Start the servers
-      def start
-        with_each_server { |n| start_server n }
-      end
-    
-      # Start a single server
-      def start_server(number)
-        log_info "Starting server on #{server_id(number)} ... "
-      
-        run :start, number
-      end
-  
-      # Stop the servers
-      def stop
-        with_each_server { |n| stop_server n }
-      end
-    
-      # Stop a single server
-      def stop_server(number)
-        log_info "Stopping server on #{server_id(number)} ... "
-      
-        run :stop, number
-      end
-    
-      # Stop and start the servers.
-      def restart
-        unless onebyone
-          # Let's do a normal restart by defaults
-          stop
-          sleep 0.1 # Let's breath a bit shall we ?
-          start
-        else
-          with_each_server do |n| 
-            stop_server(n)
-            sleep 0.1 # Let's breath a bit shall we ?
-            start_server(n)
-            wait_until_server_started(n)
-          end
-        end
-      end
-      
-      def test_socket(number)
-        if socket
-          UNIXSocket.new(socket_for(number))
-        else
-          TCPSocket.new(address, number)
-        end
-      rescue
-        nil
-      end
-      
-      # Make sure the server is running before moving on to the next one.
-      def wait_until_server_started(number)
-        log_info "Waiting for server to start ..."
-        STDOUT.flush # Need this to make sure user got the message
-        
-        tries = 0
-        loop do
-          if test_socket = test_socket(number)
-            test_socket.close
-            break
-          elsif tries < wait
-            sleep 1
-            tries += 1
-          else
-            raise RestartTimeout, "The server didn't start in time. Please look at server's log file " +
-                                  "for more information, or set the value of 'wait' in your config " +
-                                  "file to be higher (defaults: 30)."
-          end
-        end
-      end
-    
-      def server_id(number)
-        if socket
-          socket_for(number)
-        elsif swiftiply?
-          [address, first_port, number].join(':')
-        else
-          [address, number].join(':')
-        end
-      end
-    
-      def log_file_for(number)
-        include_server_number log_file, number
-      end
-    
-      def pid_file_for(number)
-        include_server_number pid_file, number
-      end
-    
-      def socket_for(number)
-        include_server_number socket, number
-      end
-    
-      def pid_for(number)
-        File.read(pid_file_for(number)).chomp.to_i
-      end
-      
-      private
-        # Send the command to the +thin+ script
-        def run(cmd, number)
-          cmd_options = @options.reject { |option, value| CLUSTER_OPTIONS.include?(option) }
-          cmd_options.merge!(:pid => pid_file_for(number), :log => log_file_for(number))
-          if socket
-            cmd_options.merge!(:socket => socket_for(number))
-          elsif swiftiply?
-            cmd_options.merge!(:port => first_port)
-          else
-            cmd_options.merge!(:port => number)
-          end
-          Command.run(cmd, cmd_options)
-        end
-      
-        def with_each_server
-          if only
-            if first_port && only < 80
-              # interpret +only+ as a sequence number
-              yield first_port + only
-            else
-              # interpret +only+ as an absolute port number
-              yield only
-            end
-          elsif socket || swiftiply?
-            size.times { |n| yield n }
-          else
-            size.times { |n| yield first_port + n }
-          end
-        end
-      
-        # Add the server port or number in the filename
-        # so each instance get its own file
-        def include_server_number(path, number)
-          ext = File.extname(path)
-          path.gsub(/#{ext}$/, ".#{number}#{ext}")
-        end
-    end
-  end
-end

data/lib/thin/controllers/controller.rb

@@ -1,189 +0,0 @@
-require 'yaml'
-
-module Thin
-  # Error raised that will abort the process and print not backtrace.
-  class RunnerError < RuntimeError; end
-  
-  # Raised when a mandatory option is missing to run a command.
-  class OptionRequired < RunnerError
-    def initialize(option)
-      super("#{option} option required")
-    end
-  end
-  
-  # Raised when an option is not valid.
-  class InvalidOption < RunnerError; end
-  
-  # Build and control Thin servers.
-  # Hey Controller pattern is not only for web apps yo!
-  module Controllers  
-    # Controls one Thin server.
-    # Allow to start, stop, restart and configure a single thin server.
-    class Controller
-      include Logging
-    
-      # Command line options passed to the thin script
-      attr_accessor :options
-    
-      def initialize(options)
-        @options = options
-        
-        if @options[:socket]
-          @options.delete(:address)
-          @options.delete(:port)
-        end
-      end
-    
-      def start
-        # Constantize backend class
-        @options[:backend] = eval(@options[:backend], TOPLEVEL_BINDING) if @options[:backend]
-
-        server = Server.new(@options[:socket] || @options[:address], # Server detects kind of socket
-                            @options[:port],                         # Port ignored on UNIX socket
-                            @options)
-        
-        # Set options
-        server.pid_file                       = @options[:pid]
-        server.log_file                       = @options[:log]
-        server.timeout                        = @options[:timeout]
-        server.maximum_connections            = @options[:max_conns]
-        server.maximum_persistent_connections = @options[:max_persistent_conns]
-        server.threaded                       = @options[:threaded]
-        server.no_epoll                       = @options[:no_epoll] if server.backend.respond_to?(:no_epoll=)
-        server.threadpool_size                = @options[:threadpool_size] if server.threaded?
-
-        # ssl support
-        if @options[:ssl]
-          server.ssl = true
-          server.ssl_options = { :private_key_file => @options[:ssl_key_file], :cert_chain_file => @options[:ssl_cert_file], :verify_peer => !@options[:ssl_disable_verify], :ssl_version => @options[:ssl_version], :cipher_list => @options[:ssl_cipher_list]}
-        end
-
-        # Detach the process, after this line the current process returns
-        server.daemonize if @options[:daemonize]
-
-        # +config+ must be called before changing privileges since it might require superuser power.
-        server.config
-        
-        server.change_privilege @options[:user], @options[:group] if @options[:user] && @options[:group]
-
-        # If a Rack config file is specified we eval it inside a Rack::Builder block to create
-        # a Rack adapter from it. Or else we guess which adapter to use and load it.
-        if @options[:rackup]
-          server.app = load_rackup_config
-        else
-          server.app = load_adapter
-        end
-
-        # If a prefix is required, wrap in Rack URL mapper
-        server.app = Rack::URLMap.new(@options[:prefix] => server.app) if @options[:prefix]
-
-        # If a stats URL is specified, wrap in Stats adapter
-        server.app = Stats::Adapter.new(server.app, @options[:stats]) if @options[:stats]
-
-        # Register restart procedure which just start another process with same options,
-        # so that's why this is done here.
-        server.on_restart { Command.run(:start, @options) }
-
-        server.start
-      end
-    
-      def stop
-        raise OptionRequired, :pid unless @options[:pid]
-      
-        tail_log(@options[:log]) do
-          if Server.kill(@options[:pid], @options[:force] ? 0 : (@options[:timeout] || 60))
-            wait_for_file :deletion, @options[:pid]
-          end
-        end
-      end
-    
-      def restart
-        raise OptionRequired, :pid unless @options[:pid]
-        
-        tail_log(@options[:log]) do
-          if Server.restart(@options[:pid])
-            wait_for_file :creation, @options[:pid]
-          end
-        end
-      end
-    
-      def config
-        config_file = @options.delete(:config) || raise(OptionRequired, :config)
-
-        # Stringify keys
-        @options.keys.each { |o| @options[o.to_s] = @options.delete(o) }
-
-        File.open(config_file, 'w') { |f| f << @options.to_yaml }
-        log_info "Wrote configuration to #{config_file}"
-      end
-      
-      protected
-        # Wait for a pid file to either be created or deleted.
-        def wait_for_file(state, file)
-          Timeout.timeout(@options[:timeout] || 30) do
-            case state
-            when :creation then sleep 0.1 until File.exist?(file)
-            when :deletion then sleep 0.1 while File.exist?(file)
-            end
-          end
-        end
-        
-        # Tail the log file of server +number+ during the execution of the block.        
-        def tail_log(log_file)
-          if log_file
-            tail_thread = tail(log_file)
-            yield
-            tail_thread.kill
-          else
-            yield
-          end
-        end
-        
-        # Acts like GNU tail command. Taken from Rails.
-        def tail(file)
-          cursor = File.exist?(file) ? File.size(file) : 0
-          last_checked = Time.now
-          tail_thread = Thread.new do
-            Thread.pass until File.exist?(file)
-            File.open(file, 'r') do |f|
-              loop do
-                f.seek cursor
-                if f.mtime > last_checked
-                  last_checked = f.mtime
-                  contents = f.read
-                  cursor += contents.length
-                  print contents
-                  STDOUT.flush
-                end
-                sleep 0.1
-              end
-            end
-          end
-          sleep 1 if File.exist?(file) # HACK Give the thread a little time to open the file
-          tail_thread
-        end
-
-      private
-        def load_adapter
-          adapter = @options[:adapter] || Rack::Adapter.guess(@options[:chdir])
-          log_info "Using #{adapter} adapter"
-          Rack::Adapter.for(adapter, @options)
-        rescue Rack::AdapterNotFound => e
-          raise InvalidOption, e.message
-        end
-        
-        def load_rackup_config
-          ENV['RACK_ENV'] = @options[:environment]
-          case @options[:rackup]
-          when /\.rb$/
-            Kernel.load(@options[:rackup])
-            Object.const_get(File.basename(@options[:rackup], '.rb').capitalize.to_sym)
-          when /\.ru$/
-            Rack::Adapter.load(@options[:rackup])
-          else
-            raise "Invalid rackup file.  please specify either a .ru or .rb file"
-          end
-        end
-    end
-  end
-end