thin 1.2.6-x86-mingw32

data/lib/thin/headers.rb

@@ -0,0 +1,39 @@
+module Thin
+  # Store HTTP header name-value pairs direcly to a string
+  # and allow duplicated entries on some names.
+  class Headers
+    HEADER_FORMAT      = "%s: %s\r\n".freeze
+    ALLOWED_DUPLICATES = %w(Set-Cookie Set-Cookie2 Warning WWW-Authenticate).freeze
+    
+    def initialize
+      @sent = {}
+      @out = []
+    end
+    
+    # Add <tt>key: value</tt> pair to the headers.
+    # Ignore if already sent and no duplicates are allowed
+    # for this +key+.
+    def []=(key, value)
+      if !@sent.has_key?(key) || ALLOWED_DUPLICATES.include?(key)
+        @sent[key] = true
+        value = case value
+                when Time
+                  value.httpdate
+                when NilClass
+                  return
+                else
+                  value.to_s
+                end
+        @out << HEADER_FORMAT % [key, value]
+      end
+    end
+    
+    def has_key?(key)
+      @sent[key]
+    end
+    
+    def to_s
+      @out.join
+    end
+  end
+end

data/lib/thin/logging.rb

@@ -0,0 +1,54 @@
+module Thin
+  # To be included in classes to allow some basic logging
+  # that can be silenced (<tt>Logging.silent=</tt>) or made
+  # more verbose.
+  # <tt>Logging.debug=</tt>: log all error backtrace and messages
+  #                          logged with +debug+.
+  # <tt>Logging.trace=</tt>: log all raw request and response and
+  #                          messages logged with +trace+.
+  module Logging
+    class << self
+      attr_writer :trace, :debug, :silent
+      
+      def trace?;  !@silent && @trace  end
+      def debug?;  !@silent && @debug  end
+      def silent?;  @silent            end
+    end
+    
+    # Global silencer methods
+    def silent
+      Logging.silent?
+    end
+    def silent=(value)
+      Logging.silent = value
+    end
+    
+    # Log a message to the console
+    def log(msg)
+      puts msg unless Logging.silent?
+    end
+    module_function :log
+    public :log
+    
+    # Log a message to the console if tracing is activated
+    def trace(msg=nil)
+      log msg || yield if Logging.trace?
+    end
+    module_function :trace
+    public :trace
+    
+    # Log a message to the console if debugging is activated
+    def debug(msg=nil)
+      log msg || yield if Logging.debug?
+    end
+    module_function :debug
+    public :debug
+    
+    # Log an error backtrace if debugging is activated
+    def log_error(e=$!)
+      debug "#{e}\n\t" + e.backtrace.join("\n\t")
+    end
+    module_function :log_error
+    public :log_error
+  end
+end

data/lib/thin/request.rb

@@ -0,0 +1,157 @@
+require "#{Thin::ROOT}/thin_parser"
+require 'tempfile'
+
+module Thin
+  # Raised when an incoming request is not valid
+  # and the server can not process it.
+  class InvalidRequest < IOError; end
+
+  # A request sent by the client to the server.
+  class Request
+    # Maximum request body size before it is moved out of memory
+    # and into a tempfile for reading.
+    MAX_BODY          = 1024 * (80 + 32)
+    BODY_TMPFILE      = 'thin-body'.freeze
+    MAX_HEADER        = 1024 * (80 + 32)
+    
+    INITIAL_BODY      = ''
+    # Force external_encoding of request's body to ASCII_8BIT
+    INITIAL_BODY.encode!(Encoding::ASCII_8BIT) if INITIAL_BODY.respond_to?(:encode!)
+    
+    # Freeze some HTTP header names & values
+    SERVER_SOFTWARE   = 'SERVER_SOFTWARE'.freeze
+    SERVER_NAME       = 'SERVER_NAME'.freeze
+    LOCALHOST         = 'localhost'.freeze
+    HTTP_VERSION      = 'HTTP_VERSION'.freeze
+    HTTP_1_0          = 'HTTP/1.0'.freeze
+    REMOTE_ADDR       = 'REMOTE_ADDR'.freeze
+    CONTENT_LENGTH    = 'CONTENT_LENGTH'.freeze
+    CONNECTION        = 'HTTP_CONNECTION'.freeze
+    KEEP_ALIVE_REGEXP = /\bkeep-alive\b/i.freeze
+    CLOSE_REGEXP      = /\bclose\b/i.freeze
+    
+    # Freeze some Rack header names
+    RACK_INPUT        = 'rack.input'.freeze
+    RACK_VERSION      = 'rack.version'.freeze
+    RACK_ERRORS       = 'rack.errors'.freeze
+    RACK_MULTITHREAD  = 'rack.multithread'.freeze
+    RACK_MULTIPROCESS = 'rack.multiprocess'.freeze
+    RACK_RUN_ONCE     = 'rack.run_once'.freeze
+    ASYNC_CALLBACK    = 'async.callback'.freeze
+    ASYNC_CLOSE       = 'async.close'.freeze
+
+    # CGI-like request environment variables
+    attr_reader :env
+
+    # Unparsed data of the request
+    attr_reader :data
+
+    # Request body
+    attr_reader :body
+
+    def initialize
+      @parser   = Thin::HttpParser.new
+      @data     = ''
+      @nparsed  = 0
+      @body     = StringIO.new(INITIAL_BODY.dup)
+      @env      = {
+        SERVER_SOFTWARE   => SERVER,
+        SERVER_NAME       => LOCALHOST,
+
+        # Rack stuff
+        RACK_INPUT        => @body,
+
+        RACK_VERSION      => VERSION::RACK,
+        RACK_ERRORS       => STDERR,
+
+        RACK_MULTITHREAD  => false,
+        RACK_MULTIPROCESS => false,
+        RACK_RUN_ONCE     => false
+      }
+    end
+
+    # Parse a chunk of data into the request environment
+    # Raises a +InvalidRequest+ if invalid.
+    # Returns +true+ if the parsing is complete.
+    def parse(data)
+      if @parser.finished?  # Header finished, can only be some more body
+        body << data
+      else                  # Parse more header using the super parser
+        @data << data
+        raise InvalidRequest, 'Header longer than allowed' if @data.size > MAX_HEADER
+
+        @nparsed = @parser.execute(@env, @data, @nparsed)
+
+        # Transfert to a tempfile if body is very big
+        move_body_to_tempfile if @parser.finished? && content_length > MAX_BODY
+      end
+
+
+      if finished?   # Check if header and body are complete
+        @data = nil
+        @body.rewind
+        true         # Request is fully parsed
+      else
+        false        # Not finished, need more data
+      end
+    end
+
+    # +true+ if headers and body are finished parsing
+    def finished?
+      @parser.finished? && @body.size >= content_length
+    end
+
+    # Expected size of the body
+    def content_length
+      @env[CONTENT_LENGTH].to_i
+    end
+
+    # Returns +true+ if the client expect the connection to be persistent.
+    def persistent?
+      # Clients and servers SHOULD NOT assume that a persistent connection
+      # is maintained for HTTP versions less than 1.1 unless it is explicitly
+      # signaled. (http://www.w3.org/Protocols/rfc2616/rfc2616-sec8.html)
+      if @env[HTTP_VERSION] == HTTP_1_0
+        @env[CONNECTION] =~ KEEP_ALIVE_REGEXP
+
+      # HTTP/1.1 client intends to maintain a persistent connection unless
+      # a Connection header including the connection-token "close" was sent
+      # in the request
+      else
+        @env[CONNECTION].nil? || @env[CONNECTION] !~ CLOSE_REGEXP
+      end
+    end
+
+    def remote_address=(address)
+      @env[REMOTE_ADDR] = address
+    end
+
+    def threaded=(value)
+      @env[RACK_MULTITHREAD] = value
+    end
+    
+    def async_callback=(callback)
+      @env[ASYNC_CALLBACK] = callback
+      @env[ASYNC_CLOSE] = EventMachine::DefaultDeferrable.new
+    end
+    
+    def async_close
+      @async_close ||= @env[ASYNC_CLOSE]
+    end
+
+    # Close any resource used by the request
+    def close
+      @body.delete if @body.class == Tempfile
+    end
+
+    private
+      def move_body_to_tempfile
+        current_body = @body
+        current_body.rewind
+        @body = Tempfile.new(BODY_TMPFILE)
+        @body.binmode
+        @body << current_body.read
+        @env[RACK_INPUT] = @body
+      end
+  end
+end

data/lib/thin/response.rb

@@ -0,0 +1,101 @@
+module Thin
+  # A response sent to the client.
+  class Response
+    CONNECTION     = 'Connection'.freeze
+    CLOSE          = 'close'.freeze
+    KEEP_ALIVE     = 'keep-alive'.freeze
+    SERVER         = 'Server'.freeze
+    CONTENT_LENGTH = 'Content-Length'.freeze
+
+    # Status code
+    attr_accessor :status
+
+    # Response body, must respond to +each+.
+    attr_accessor :body
+
+    # Headers key-value hash
+    attr_reader   :headers
+
+    def initialize
+      @headers    = Headers.new
+      @status     = 200
+      @persistent = false
+    end
+
+    # String representation of the headers
+    # to be sent in the response.
+    def headers_output
+      # Set default headers
+      @headers[CONNECTION] = persistent? ? KEEP_ALIVE : CLOSE
+      @headers[SERVER]     = Thin::SERVER
+
+      @headers.to_s
+    end
+
+    # Top header of the response,
+    # containing the status code and response headers.
+    def head
+      "HTTP/1.1 #{@status} #{HTTP_STATUS_CODES[@status.to_i]}\r\n#{headers_output}\r\n"
+    end
+
+    if Thin.ruby_18?
+
+      # Ruby 1.8 implementation.
+      # Respects Rack specs.
+      #
+      # See http://rack.rubyforge.org/doc/files/SPEC.html
+      def headers=(key_value_pairs)
+        key_value_pairs.each do |k, vs|
+          vs.each { |v| @headers[k] = v.chomp } if vs
+        end if key_value_pairs
+      end
+
+    else
+
+      # Ruby 1.9 doesn't have a String#each anymore.
+      # Rack spec doesn't take care of that yet, for now we just use
+      # +each+ but fallback to +each_line+ on strings.
+      # I wish we could remove that condition.
+      # To be reviewed when a new Rack spec comes out.
+      def headers=(key_value_pairs)
+        key_value_pairs.each do |k, vs|
+          next unless vs
+          if vs.is_a?(String)
+            vs.each_line { |v| @headers[k] = v.chomp }
+          else
+            vs.each { |v| @headers[k] = v.chomp }
+          end
+        end if key_value_pairs
+      end
+
+    end
+
+    # Close any resource used by the response
+    def close
+      @body.close if @body.respond_to?(:close)
+    end
+
+    # Yields each chunk of the response.
+    # To control the size of each chunk
+    # define your own +each+ method on +body+.
+    def each
+      yield head
+      if @body.is_a?(String)
+        yield @body
+      else
+        @body.each { |chunk| yield chunk }
+      end
+    end
+
+    # Tell the client the connection should stay open
+    def persistent!
+      @persistent = true
+    end
+
+    # Persistent connection must be requested as keep-alive
+    # from the server and have a Content-Length.
+    def persistent?
+      @persistent && @headers.has_key?(CONTENT_LENGTH)
+    end
+  end
+end

data/lib/thin/runner.rb

@@ -0,0 +1,212 @@
+require 'optparse'
+require 'yaml'
+
+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          => 'development',
+        :address              => '0.0.0.0',
+        :port                 => Server::DEFAULT_PORT,
+        :timeout              => Server::DEFAULT_TIMEOUT,
+        :log                  => '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
+      }
+      
+      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 "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 then 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(      "--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("-D", "--debug", "Set debbuging on")                               { @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 }
+      Logging.debug = @options[:debug]
+      Logging.trace = @options[:trace]
+      
+      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_file(file).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