gross 1.7.2

data/lib/thin/runner.rb

@@ -0,0 +1,238 @@
+require 'logger'
+require 'optparse'
+require 'yaml'
+require 'erb'
+
+module Thin
+  # CLI runner.
+  # Parse options and send command to the correct Controller.
+  class Runner
+    COMMANDS            = %w(start stop restart config)
+    LINUX_ONLY_COMMANDS = %w(install)
+
+    # Commands that wont load options from the config file
+    CONFIGLESS_COMMANDS = %w(config install)
+
+    # Parsed options
+    attr_accessor :options
+
+    # Name of the command to be runned.
+    attr_accessor :command
+
+    # Arguments to be passed to the command.
+    attr_accessor :arguments
+
+    # Return all available commands
+    def self.commands
+      commands  = COMMANDS
+      commands += LINUX_ONLY_COMMANDS if Thin.linux?
+      commands
+    end
+
+    def initialize(argv)
+      @argv = argv
+
+      # Default options values
+      @options = {
+        :chdir                => Dir.pwd,
+        :environment          => ENV['RACK_ENV'] || 'development',
+        :address              => '0.0.0.0',
+        :port                 => Server::DEFAULT_PORT,
+        :timeout              => Server::DEFAULT_TIMEOUT,
+        :log                  => File.join(Dir.pwd, 'log/thin.log'),
+        :pid                  => 'tmp/pids/thin.pid',
+        :max_conns            => Server::DEFAULT_MAXIMUM_CONNECTIONS,
+        :max_persistent_conns => Server::DEFAULT_MAXIMUM_PERSISTENT_CONNECTIONS,
+        :require              => [],
+        :wait                 => Controllers::Cluster::DEFAULT_WAIT_TIME,
+        :threadpool_size      => 20
+      }
+
+      parse!
+    end
+
+    def parser
+      # NOTE: If you add an option here make sure the key in the +options+ hash is the
+      # same as the name of the command line option.
+      # +option+ keys are used to build the command line to launch other processes,
+      # see <tt>lib/thin/command.rb</tt>.
+      @parser ||= OptionParser.new do |opts|
+        opts.banner = "Usage: thin [options] #{self.class.commands.join('|')}"
+
+        opts.separator ""
+        opts.separator "Server options:"
+
+        opts.on("-a", "--address HOST", "bind to HOST address " +
+                                        "(default: #{@options[:address]})")             { |host| @options[:address] = host }
+        opts.on("-p", "--port PORT", "use PORT (default: #{@options[:port]})")          { |port| @options[:port] = port.to_i }
+        opts.on("-S", "--socket FILE", "bind to unix domain socket")                    { |file| @options[:socket] = file }
+        opts.on("-y", "--swiftiply [KEY]", "Run using swiftiply")                       { |key| @options[:swiftiply] = key }
+        opts.on("-A", "--adapter NAME", "Rack adapter to use (default: autodetect)",
+                                        "(#{Rack::ADAPTERS.map{|(a,b)|a}.join(', ')})") { |name| @options[:adapter] = name }
+        opts.on("-R", "--rackup FILE", "Load a Rack config file instead of " +
+                                       "Rack adapter")                                  { |file| @options[:rackup] = file }
+        opts.on("-c", "--chdir DIR", "Change to dir before starting")                   { |dir| @options[:chdir] = File.expand_path(dir) }
+        opts.on(      "--stats PATH", "Mount the Stats adapter under PATH")             { |path| @options[:stats] = path }
+
+        opts.separator ""
+        opts.separator "SSL options:"
+
+        opts.on(      "--ssl", "Enables SSL")                                           { @options[:ssl] = true }
+        opts.on(      "--ssl-key-file PATH", "Path to private key")                     { |path| @options[:ssl_key_file] = path }
+        opts.on(      "--ssl-cert-file PATH", "Path to certificate")                    { |path| @options[:ssl_cert_file] = path }
+        opts.on(      "--ssl-disable-verify", "Disables (optional) client cert requests") { @options[:ssl_disable_verify] = true }
+        opts.on(      "--ssl-version VERSION", "TLSv1, TLSv1_1, TLSv1_2")               { |version| @options[:ssl_version] = version }
+        opts.on(      "--ssl-cipher-list STRING", "Example: HIGH:!ADH:!RC4:-MEDIUM:-LOW:-EXP:-CAMELLIA") { |cipher| @options[:ssl_cipher_list] = cipher }
+
+        opts.separator ""
+        opts.separator "Adapter options:"
+        opts.on("-e", "--environment ENV", "Framework environment " +
+                                           "(default: #{@options[:environment]})")      { |env| @options[:environment] = env }
+        opts.on(      "--prefix PATH", "Mount the app under PATH (start with /)")       { |path| @options[:prefix] = path }
+
+        unless Thin.win? # Daemonizing not supported on Windows
+          opts.separator ""
+          opts.separator "Daemon options:"
+
+          opts.on("-d", "--daemonize", "Run daemonized in the background")              { @options[:daemonize] = true }
+          opts.on("-l", "--log FILE", "File to redirect output " +
+                                      "(default: #{@options[:log]})")                   { |file| @options[:log] = file }
+          opts.on("-P", "--pid FILE", "File to store PID " +
+                                      "(default: #{@options[:pid]})")                   { |file| @options[:pid] = file }
+          opts.on("-u", "--user NAME", "User to run daemon as (use with -g)")           { |user| @options[:user] = user }
+          opts.on("-g", "--group NAME", "Group to run daemon as (use with -u)")         { |group| @options[:group] = group }
+          opts.on(      "--tag NAME", "Additional text to display in process listing")  { |tag| @options[:tag] = tag }
+
+          opts.separator ""
+          opts.separator "Cluster options:"
+
+          opts.on("-s", "--servers NUM", "Number of servers to start")                  { |num| @options[:servers] = num.to_i }
+          opts.on("-o", "--only NUM", "Send command to only one server of the cluster") { |only| @options[:only] = only.to_i }
+          opts.on("-C", "--config FILE", "Load options from config file")               { |file| @options[:config] = file }
+          opts.on(      "--all [DIR]", "Send command to each config files in DIR")      { |dir| @options[:all] = dir } if Thin.linux?
+          opts.on("-O", "--onebyone", "Restart the cluster one by one (only works with restart command)") { @options[:onebyone] = true }
+          opts.on("-w", "--wait NUM", "Maximum wait time for server to be started in seconds (use with -O)") { |time| @options[:wait] = time.to_i }
+        end
+
+        opts.separator ""
+        opts.separator "Tuning options:"
+
+        opts.on("-b", "--backend CLASS", "Backend to use, full classname")              { |name| @options[:backend] = name }
+        opts.on("-t", "--timeout SEC", "Request or command timeout in sec " +
+                                       "(default: #{@options[:timeout]})")              { |sec| @options[:timeout] = sec.to_i }
+        opts.on("-f", "--force", "Force the execution of the command")                  { @options[:force] = true }
+        opts.on(      "--max-conns NUM", "Maximum number of open file descriptors " +
+                                         "(default: #{@options[:max_conns]})",
+                                         "Might require sudo to set higher than 1024")  { |num| @options[:max_conns] = num.to_i } unless Thin.win?
+        opts.on(      "--max-persistent-conns NUM",
+                                       "Maximum number of persistent connections",
+                                       "(default: #{@options[:max_persistent_conns]})") { |num| @options[:max_persistent_conns] = num.to_i }
+        opts.on(      "--threaded", "Call the Rack application in threads " +
+                                    "[experimental]")                                   { @options[:threaded] = true }
+        opts.on(      "--threadpool-size NUM", "Sets the size of the EventMachine threadpool.",
+                                       "(default: #{@options[:threadpool_size]})") { |num| @options[:threadpool_size] = num.to_i }
+        opts.on(      "--no-epoll", "Disable the use of epoll")                         { @options[:no_epoll] = true } if Thin.linux?
+
+        opts.separator ""
+        opts.separator "Common options:"
+
+        opts.on_tail("-r", "--require FILE", "require the library")                     { |file| @options[:require] << file }
+        opts.on_tail("-q", "--quiet", "Silence all logging")                            { @options[:quiet] = true }
+        opts.on_tail("-D", "--debug", "Enable debug logging")                           { @options[:debug] = true }
+        opts.on_tail("-V", "--trace", "Set tracing on (log raw request/response)")      { @options[:trace] = true }
+        opts.on_tail("-h", "--help", "Show this message")                               { puts opts; exit }
+        opts.on_tail('-v', '--version', "Show version")                                 { puts Thin::SERVER; exit }
+      end
+    end
+
+    # Parse the options.
+    def parse!
+      parser.parse! @argv
+      @command   = @argv.shift
+      @arguments = @argv
+    end
+
+    # Parse the current shell arguments and run the command.
+    # Exits on error.
+    def run!
+      if self.class.commands.include?(@command)
+        run_command
+      elsif @command.nil?
+        puts "Command required"
+        puts @parser
+        exit 1
+      else
+        abort "Unknown command: #{@command}. Use one of #{self.class.commands.join(', ')}"
+      end
+    end
+
+    # Send the command to the controller: single instance or cluster.
+    def run_command
+      load_options_from_config_file! unless CONFIGLESS_COMMANDS.include?(@command)
+
+      # PROGRAM_NAME is relative to the current directory, so make sure
+      # we store and expand it before changing directory.
+      Command.script = File.expand_path($PROGRAM_NAME)
+
+      # Change the current directory ASAP so that all relative paths are
+      # relative to this one.
+      Dir.chdir(@options[:chdir]) unless CONFIGLESS_COMMANDS.include?(@command)
+
+      @options[:require].each { |r| ruby_require r }
+
+      # Setup the logger
+      if @options[:quiet]
+        Logging.silent = true
+      else
+        Logging.level = Logger::DEBUG if @options[:debug]
+      end
+
+      if @options[:trace]
+        # Trace raw requests/responses
+        Logging.trace_logger = Logging.logger
+      end
+
+      controller = case
+      when cluster? then Controllers::Cluster.new(@options)
+      when service? then Controllers::Service.new(@options)
+      else               Controllers::Controller.new(@options)
+      end
+
+      if controller.respond_to?(@command)
+        begin
+          controller.send(@command, *@arguments)
+        rescue RunnerError => e
+          abort e.message
+        end
+      else
+        abort "Invalid options for command: #{@command}"
+      end
+    end
+
+    # +true+ if we're controlling a cluster.
+    def cluster?
+      @options[:only] || @options[:servers] || @options[:config]
+    end
+
+    # +true+ if we're acting a as system service.
+    def service?
+      @options.has_key?(:all) || @command == 'install'
+    end
+
+    private
+      def load_options_from_config_file!
+        if file = @options.delete(:config)
+          YAML.load(ERB.new(File.read(file)).result).each { |key, value| @options[key.to_sym] = value }
+        end
+      end
+
+      def ruby_require(file)
+        if File.extname(file) == '.ru'
+          warn 'WARNING: Use the -R option to load a Rack config file'
+          @options[:rackup] = file
+        else
+          require file
+        end
+      end
+  end
+end

data/lib/thin/server.rb

@@ -0,0 +1,290 @@
+module Thin
+  # The utterly famous Thin HTTP server.
+  # It listens for incoming requests through a given +backend+
+  # and forwards all requests to +app+.
+  #
+  # == TCP server
+  # Create a new TCP server bound to <tt>host:port</tt> by specifiying +host+
+  # and +port+ as the first 2 arguments.
+  #
+  #   Thin::Server.start('0.0.0.0', 3000, app)
+  #
+  # == UNIX domain server
+  # Create a new UNIX domain socket bound to +socket+ file by specifiying a filename
+  # as the first argument. Eg.: /tmp/thin.sock. If the first argument contains a <tt>/</tt>
+  # it will be assumed to be a UNIX socket. 
+  #
+  #   Thin::Server.start('/tmp/thin.sock', app)
+  #
+  # == Using a custom backend
+  # You can implement your own way to connect the server to its client by creating your
+  # own Backend class and passing it as the :backend option.
+  #
+  #   Thin::Server.start('galaxy://faraway', 1345, app, :backend => Thin::Backends::MyFancyBackend)
+  #
+  # == Rack application (+app+)
+  # All requests will be processed through +app+, which must be a valid Rack adapter.
+  # A valid Rack adapter (application) must respond to <tt>call(env#Hash)</tt> and
+  # return an array of <tt>[status, headers, body]</tt>.
+  #
+  # == Building an app in place
+  # If a block is passed, a <tt>Rack::Builder</tt> instance
+  # will be passed to build the +app+. So you can do cool stuff like this:
+  # 
+  #   Thin::Server.start('0.0.0.0', 3000) do
+  #     use Rack::CommonLogger
+  #     use Rack::ShowExceptions
+  #     map "/lobster" do
+  #       use Rack::Lint
+  #       run Rack::Lobster.new
+  #     end
+  #   end
+  #
+  # == Controlling with signals
+  # * INT and TERM: Force shutdown (see Server#stop!)
+  # * TERM & QUIT calls +stop+ to shutdown gracefully.
+  # * HUP calls +restart+ to ... surprise, restart!
+  # * USR1 reopen log files.
+  # Signals are processed at one second intervals.
+  # Disable signals by passing <tt>:signals => false</tt>.
+  # 
+  class Server
+    include Logging
+    include Daemonizable
+    extend  Forwardable
+    
+    # Default values
+    DEFAULT_TIMEOUT                        = 30 #sec
+    DEFAULT_HOST                           = '0.0.0.0'
+    DEFAULT_PORT                           = 3000
+    DEFAULT_MAXIMUM_CONNECTIONS            = 1024
+    DEFAULT_MAXIMUM_PERSISTENT_CONNECTIONS = 100
+        
+    # Application (Rack adapter) called with the request that produces the response.
+    attr_accessor :app
+
+    # A tag that will show in the process listing
+    attr_accessor :tag
+
+    # Backend handling the connections to the clients.
+    attr_accessor :backend
+    
+    # Maximum number of seconds for incoming data to arrive before the connection
+    # is dropped.
+    def_delegators :backend, :timeout, :timeout=
+    
+    # Maximum number of file or socket descriptors that the server may open.
+    def_delegators :backend, :maximum_connections, :maximum_connections=
+    
+    # Maximum number of connections that can be persistent at the same time.
+    # Most browsers never close the connection so most of the time they are closed
+    # when the timeout occurs. If we don't control the number of persistent connections,
+    # it would be very easy to overflow the server for a DoS attack.
+    def_delegators :backend, :maximum_persistent_connections, :maximum_persistent_connections=
+    
+    # Allow using threads in the backend.
+    def_delegators :backend, :threaded?, :threaded=, :threadpool_size, :threadpool_size=
+    
+    # Allow using SSL in the backend.
+    def_delegators :backend, :ssl?, :ssl=, :ssl_options=
+    
+    # Address and port on which the server is listening for connections.
+    def_delegators :backend, :host, :port
+    
+    # UNIX domain socket on which the server is listening for connections.
+    def_delegator :backend, :socket
+    
+    # Disable the use of epoll under Linux
+    def_delegators :backend, :no_epoll, :no_epoll=
+    
+    def initialize(*args, &block)
+      host, port, options = DEFAULT_HOST, DEFAULT_PORT, {}
+      
+      # Guess each parameter by its type so they can be
+      # received in any order.
+      args.each do |arg|
+        case arg
+        when 0.class, /^\d+$/ then port    = arg.to_i
+        when String           then host    = arg
+        when Hash             then options = arg
+        else
+          @app = arg if arg.respond_to?(:call)
+        end
+      end
+      
+      # Set tag if needed
+      self.tag = options[:tag]
+
+      # Try to intelligently select which backend to use.
+      @backend = select_backend(host, port, options)
+      
+      load_cgi_multipart_eof_fix
+      
+      @backend.server = self
+      
+      # Set defaults
+      @backend.maximum_connections            = DEFAULT_MAXIMUM_CONNECTIONS
+      @backend.maximum_persistent_connections = DEFAULT_MAXIMUM_PERSISTENT_CONNECTIONS
+      @backend.timeout                        = options[:timeout] || DEFAULT_TIMEOUT
+      
+      # Allow using Rack builder as a block
+      @app = Rack::Builder.new(&block).to_app if block
+      
+      # If in debug mode, wrap in logger adapter
+      @app = Rack::CommonLogger.new(@app) if Logging.debug?
+      
+      @setup_signals = options[:signals] != false
+    end
+    
+    # Lil' shortcut to turn this:
+    # 
+    #   Server.new(...).start
+    # 
+    # into this:
+    # 
+    #   Server.start(...)
+    # 
+    def self.start(*args, &block)
+      new(*args, &block).start!
+    end
+        
+    # Start the server and listen for connections.
+    def start
+      raise ArgumentError, 'app required' unless @app
+      
+      log_info  "Thin web server (v#{VERSION::STRING} codename #{VERSION::CODENAME})"
+      log_debug "Debugging ON"
+      trace     "Tracing ON"
+      
+      log_info "Maximum connections set to #{@backend.maximum_connections}"
+      log_info "Listening on #{@backend}, CTRL+C to stop"
+
+      @backend.start { setup_signals if @setup_signals }
+    end
+    alias :start! :start
+    
+    # == Gracefull shutdown
+    # Stops the server after processing all current connections.
+    # As soon as this method is called, the server stops accepting
+    # new requests and waits for all current connections to finish.
+    # Calling twice is the equivalent of calling <tt>stop!</tt>.
+    def stop
+      if running?
+        @backend.stop
+        unless @backend.empty?
+          log_info "Waiting for #{@backend.size} connection(s) to finish, "\
+                   "can take up to #{timeout} sec, CTRL+C to stop now"
+        end
+      else
+        stop!
+      end
+    end
+    
+    # == Force shutdown
+    # Stops the server closing all current connections right away.
+    # This doesn't wait for connection to finish their work and send data.
+    # All current requests will be dropped.
+    def stop!
+      if @backend.started_reactor?
+        log_info "Stopping ..."
+      else
+        log_info "Stopping Thin ..."
+        log_info "Thin was started inside an existing EventMachine.run block."
+        log_info "Call `EventMachine.stop` to stop the reactor and quit the process."
+      end
+
+      @backend.stop!
+    end
+    
+    # == Reopen log file.
+    # Reopen the log file and redirect STDOUT and STDERR to it.
+    def reopen_log
+      return unless log_file
+      file = File.expand_path(log_file)
+      log_info "Reopening log file: #{file}"
+      Daemonize.redirect_io(file)
+    end
+    
+    # == Configure the server
+    # The process might need to have superuser privilege to configure
+    # server with optimal options.
+    def config
+      @backend.config
+    end
+    
+    # Name of the server and type of backend used.
+    # This is also the name of the process in which Thin is running as a daemon.
+    def name
+      "thin server (#{@backend})" + (tag ? " [#{tag}]" : "")
+    end
+    alias :to_s :name
+    
+    # Return +true+ if the server is running and ready to receive requests.
+    # Note that the server might still be running and return +false+ when
+    # shuting down and waiting for active connections to complete.
+    def running?
+      @backend.running?
+    end
+    
+    protected
+      def setup_signals
+        # Queue up signals so they are processed in non-trap context
+        # using a EM timer.
+        @signal_queue ||= []
+
+        %w( INT TERM ).each do |signal|
+          trap(signal) { @signal_queue.push signal }
+        end
+        # *nix only signals
+        %w( QUIT HUP USR1 ).each do |signal|
+          trap(signal) { @signal_queue.push signal }
+        end unless Thin.win?
+
+        # Signals are processed at one second intervals.
+        @signal_timer ||= EM.add_periodic_timer(1) { handle_signals }
+      end
+
+      def handle_signals
+        case @signal_queue.shift
+        when 'INT'
+          stop!
+        when 'TERM', 'QUIT'
+          stop
+        when 'HUP'
+          restart
+        when 'USR1'
+          reopen_log
+        end
+        EM.next_tick { handle_signals } unless @signal_queue.empty?
+      end
+      
+      def select_backend(host, port, options)
+        case
+        when options.has_key?(:backend)
+          raise ArgumentError, ":backend must be a class" unless options[:backend].is_a?(Class)
+          options[:backend].new(host, port, options)
+        when options.has_key?(:swiftiply)
+          Backends::SwiftiplyClient.new(host, port, options)
+        when host.include?('/')
+          Backends::UnixServer.new(host)
+        else
+          Backends::TcpServer.new(host, port)
+        end
+      end
+      
+      # Taken from Mongrel cgi_multipart_eof_fix
+      # Ruby 1.8.5 has a security bug in cgi.rb, we need to patch it.
+      def load_cgi_multipart_eof_fix
+        version = RUBY_VERSION.split('.').map { |i| i.to_i }
+        
+        if version[0] <= 1 && version[1] <= 8 && version[2] <= 5 && RUBY_PLATFORM !~ /java/
+          begin
+            require 'cgi_multipart_eof_fix'
+          rescue LoadError
+            log_error "Ruby 1.8.5 is not secure please install cgi_multipart_eof_fix:"
+            log_error "gem install cgi_multipart_eof_fix"
+          end
+        end
+      end
+  end
+end