thin 1.8.2 → 2.0.0.pre

data/lib/rack/adapter/rails.rb

@@ -1,178 +0,0 @@
-require 'cgi'
-
-# Adapter to run a Rails app with any supported Rack handler.
-# By default it will try to load the Rails application in the
-# current directory in the development environment.
-#
-# Options:
-#  root: Root directory of the Rails app
-#  environment: Rails environment to run in (development [default], production or test)
-#  prefix: Set the relative URL root.
-#
-# Based on http://fuzed.rubyforge.org/ Rails adapter
-module Rack
-  module Adapter
-    class Rails
-      FILE_METHODS = %w(GET HEAD).freeze
-
-      def initialize(options = {})
-        @root   = options[:root]        || Dir.pwd
-        @env    = options[:environment] || 'development'
-        @prefix = options[:prefix]
-
-        load_application
-
-        @rails_app = self.class.rack_based? ? ActionController::Dispatcher.new : CgiApp.new
-        @file_app  = Rack::File.new(::File.join(RAILS_ROOT, "public"))
-      end
-
-      def load_application
-        ENV['RAILS_ENV'] = @env
-
-        require "#{@root}/config/environment"
-        require 'dispatcher'
-
-        if @prefix
-          if ActionController::Base.respond_to?(:relative_url_root=)
-            ActionController::Base.relative_url_root = @prefix # Rails 2.1.1
-          else
-            ActionController::AbstractRequest.relative_url_root = @prefix
-          end
-        end
-      end
-
-      def file_exist?(path)
-        full_path = ::File.join(@file_app.root, Utils.unescape(path))
-        ::File.file?(full_path) && ::File.readable_real?(full_path)
-      end
-
-      def call(env)
-        path        = env['PATH_INFO'].chomp('/')
-        method      = env['REQUEST_METHOD']
-        cached_path = (path.empty? ? 'index' : path) + ActionController::Base.page_cache_extension
-
-        if FILE_METHODS.include?(method)
-          if file_exist?(path)              # Serve the file if it's there
-            return @file_app.call(env)
-          elsif file_exist?(cached_path)    # Serve the page cache if it's there
-            env['PATH_INFO'] = cached_path
-            return @file_app.call(env)
-          end
-        end
-
-        # No static file, let Rails handle it
-        @rails_app.call(env)
-      end
-
-      def self.rack_based?
-        rails_version = ::Rails::VERSION
-        return false if rails_version::MAJOR < 2
-        return false if rails_version::MAJOR == 2 && rails_version::MINOR < 2
-        return false if rails_version::MAJOR == 2 && rails_version::MINOR == 2 && rails_version::TINY < 3
-        true # >= 2.2.3
-      end
-
-      protected
-        # For Rails pre Rack (2.3)
-        class CgiApp
-          def call(env)
-            request         = Request.new(env)
-            response        = Response.new
-            session_options = ActionController::CgiRequest::DEFAULT_SESSION_OPTIONS
-            cgi             = CGIWrapper.new(request, response)
-
-            Dispatcher.dispatch(cgi, session_options, response)
-
-            response.finish
-          end
-        end
-
-        class CGIWrapper < ::CGI
-          def initialize(request, response, *args)
-            @request  = request
-            @response = response
-            @args     = *args
-            @input    = request.body
-
-            super *args
-          end
-
-          def header(options = 'text/html')
-            if options.is_a?(String)
-              @response['Content-Type']     = options unless @response['Content-Type']
-            else
-              @response['Content-Length']   = options.delete('Content-Length').to_s if options['Content-Length']
-
-              @response['Content-Type']     = options.delete('type') || "text/html"
-              @response['Content-Type']    += '; charset=' + options.delete('charset') if options['charset']
-
-              @response['Content-Language'] = options.delete('language') if options['language']
-              @response['Expires']          = options.delete('expires') if options['expires']
-
-              @response.status              = options.delete('Status') if options['Status']
-
-              # Convert 'cookie' header to 'Set-Cookie' headers.
-              # Because Set-Cookie header can appear more the once in the response body,
-              # we store it in a line break seperated string that will be translated to
-              # multiple Set-Cookie header by the handler.
-              if cookie = options.delete('cookie')
-                cookies = []
-
-                case cookie
-                  when Array then cookie.each { |c| cookies << c.to_s }
-                  when Hash  then cookie.each { |_, c| cookies << c.to_s }
-                  else            cookies << cookie.to_s
-                end
-
-                @output_cookies.each { |c| cookies << c.to_s } if @output_cookies
-
-                @response['Set-Cookie'] = [@response['Set-Cookie'], cookies].compact
-                # See http://groups.google.com/group/rack-devel/browse_thread/thread/e8759b91a82c5a10/a8dbd4574fe97d69?#a8dbd4574fe97d69
-                if Thin.ruby_18?
-                  @response['Set-Cookie'].flatten!
-                else
-                  @response['Set-Cookie'] = @response['Set-Cookie'].join("\n")
-                end
-              end
-
-              options.each { |k, v| @response[k] = v }
-            end
-
-            ''
-          end
-
-          def params
-            @params ||= @request.params
-          end
-
-          def cookies
-            @request.cookies
-          end
-
-          def query_string
-            @request.query_string
-          end
-
-          # Used to wrap the normal args variable used inside CGI.
-          def args
-            @args
-          end
-
-          # Used to wrap the normal env_table variable used inside CGI.
-          def env_table
-            @request.env
-          end
-
-          # Used to wrap the normal stdinput variable used inside CGI.
-          def stdinput
-            @input
-          end
-
-          def stdoutput
-            STDERR.puts 'stdoutput should not be used.'
-            @response.body
-          end
-      end
-    end
-  end
-end

data/lib/rack/handler/thin.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-require "thin"
-require "thin/server"
-require "thin/logging"
-require "thin/backends/tcp_server"
-
-module Rack
-  module Handler
-    class Thin
-      def self.run(app, **options)
-        environment  = ENV['RACK_ENV'] || 'development'
-        default_host = environment == 'development' ? 'localhost' : '0.0.0.0'
-
-        host = options.delete(:Host) || default_host
-        port = options.delete(:Port) || 8080
-        args = [host, port, app, options]
-
-        server = ::Thin::Server.new(*args)
-        yield server if block_given?
-
-        server.start
-      end
-
-      def self.valid_options
-        environment  = ENV['RACK_ENV'] || 'development'
-        default_host = environment == 'development' ? 'localhost' : '0.0.0.0'
-
-        {
-          "Host=HOST" => "Hostname to listen on (default: #{default_host})",
-          "Port=PORT" => "Port to listen on (default: 8080)",
-        }
-      end
-    end
-
-    register :thin, ::Rack::Handler::Thin
-  end
-end

data/lib/thin/backends/base.rb

@@ -1,169 +0,0 @@
-module Thin
-  module Backends
-    # A Backend connects the server to the client. It handles:
-    # * connection/disconnection to the server
-    # * initialization of the connections
-    # * monitoring of the active connections.
-    #
-    # == Implementing your own backend
-    # You can create your own minimal backend by inheriting this class and
-    # defining the +connect+ and +disconnect+ method.
-    # If your backend is not based on EventMachine you also need to redefine
-    # the +start+, +stop+, <tt>stop!</tt> and +config+ methods.
-    class Base
-      # Server serving the connections throught the backend
-      attr_accessor :server
-      
-      # Maximum time for incoming data to arrive
-      attr_accessor :timeout
-      
-      # Maximum number of file or socket descriptors that the server may open.
-      attr_accessor :maximum_connections
-      
-      # Maximum number of connections that can be persistent
-      attr_accessor :maximum_persistent_connections
-
-      #allows setting of the eventmachine threadpool size
-      attr_reader :threadpool_size
-      def threadpool_size=(size)
-        @threadpool_size = size
-        EventMachine.threadpool_size = size
-      end
-
-      # Allow using threads in the backend.
-      attr_writer :threaded
-      def threaded?; @threaded end
-            
-      # Allow using SSL in the backend.
-      attr_writer :ssl, :ssl_options
-      def ssl?; @ssl end
-      
-      # Number of persistent connections currently opened
-      attr_accessor :persistent_connection_count
-      
-      # Disable the use of epoll under Linux
-      attr_accessor :no_epoll
-      
-      def initialize
-        @connections                    = {}
-        @timeout                        = Server::DEFAULT_TIMEOUT
-        @persistent_connection_count    = 0
-        @maximum_connections            = Server::DEFAULT_MAXIMUM_CONNECTIONS
-        @maximum_persistent_connections = Server::DEFAULT_MAXIMUM_PERSISTENT_CONNECTIONS
-        @no_epoll                       = false
-        @running                        = false
-        @ssl                            = nil
-        @started_reactor                = false
-        @stopping                       = false
-        @threaded                       = nil
-      end
-      
-      # Start the backend and connect it.
-      def start
-        @stopping = false
-        starter   = proc do
-          connect
-          yield if block_given?
-          @running = true
-        end
-        
-        # Allow for early run up of eventmachine.
-        if EventMachine.reactor_running?
-          starter.call
-        else
-          @started_reactor = true
-          EventMachine.run(&starter)
-        end
-      end
-      
-      # Stop of the backend from accepting new connections.
-      def stop
-        @running  = false
-        @stopping = true
-        
-        # Do not accept anymore connection
-        disconnect
-        # Close idle persistent connections
-        @connections.each_value { |connection| connection.close_connection if connection.idle? }
-        stop! if @connections.empty?
-      end
-      
-      # Force stop of the backend NOW, too bad for the current connections.
-      def stop!
-        @running  = false
-        @stopping = false
-        
-        EventMachine.stop if @started_reactor && EventMachine.reactor_running?
-        @connections.each_value { |connection| connection.close_connection }
-        close
-      end
-      
-      # Configure the backend. This method will be called before droping superuser privileges,
-      # so you can do crazy stuff that require godlike powers here.
-      def config
-        # See http://rubyeventmachine.com/pub/rdoc/files/EPOLL.html
-        EventMachine.epoll unless @no_epoll
-        
-        # Set the maximum number of socket descriptors that the server may open.
-        # The process needs to have required privilege to set it higher the 1024 on
-        # some systems.
-        @maximum_connections = EventMachine.set_descriptor_table_size(@maximum_connections) unless Thin.win?
-      end
-      
-      # Free up resources used by the backend.
-      def close
-      end
-      
-      # Returns +true+ if the backend is connected and running.
-      def running?
-        @running
-      end
-
-      def started_reactor?
-        @started_reactor
-      end
-            
-      # Called by a connection when it's unbinded.
-      def connection_finished(connection)
-        @persistent_connection_count -= 1 if connection.can_persist?
-        @connections.delete(connection.__id__)
-        
-        # Finalize gracefull stop if there's no more active connection.
-        stop! if @stopping && @connections.empty?
-      end
-      
-      # Returns +true+ if no active connection.
-      def empty?
-        @connections.empty?
-      end
-      
-      # Number of active connections.
-      def size
-        @connections.size
-      end
-      
-      protected
-        # Initialize a new connection to a client.
-        def initialize_connection(connection)
-          connection.backend                 = self
-          connection.app                     = @server.app
-          connection.comm_inactivity_timeout = @timeout
-          connection.threaded                = @threaded
-          
-          if @ssl
-            connection.start_tls(@ssl_options)
-          end
-
-          # We control the number of persistent connections by keeping
-          # a count of the total one allowed yet.
-          if @persistent_connection_count < @maximum_persistent_connections
-            connection.can_persist!
-            @persistent_connection_count += 1
-          end
-
-          @connections[connection.__id__] = connection
-        end
-      
-    end
-  end
-end

data/lib/thin/backends/swiftiply_client.rb

@@ -1,66 +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
-        begin
-          if defined?(Addrinfo)
-            # ruby 2.0+
-            # TODO: ipv6 support here?
-            Addrinfo.getaddrinfo(@backend.host, @backend.port, :PF_INET, :STREAM).first.ip_address.split('.').map(&:to_i)
-          else
-            Socket.gethostbyname(@backend.host)[3].unpack('CCCC')
-          end
-        rescue
-          [0, 0, 0, 0]
-        end
-      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