thin 1.8.0 → 2.0.0.pre

data/lib/rack/adapter/loader.rb

@@ -1,75 +0,0 @@
-module Rack
-  class AdapterNotFound < RuntimeError; end
-  
-  # Mapping used to guess which adapter to use in <tt>Adapter.for</tt>.
-  # Framework <name> => <file unique to this framework> in order they will
-  # be tested.
-  # +nil+ for value to never guess.
-  # NOTE: If a framework has a file that is not unique, make sure to place
-  # it at the end.
-  ADAPTERS = [
-    [:rack,    'config.ru'],
-    [:rails,   'config/environment.rb'],
-    [:ramaze,  'start.rb'],
-    [:merb,    'config/init.rb'],
-    [:file,    nil]
-  ]
-  
-  module Adapter
-    # Guess which adapter to use based on the directory structure
-    # or file content.
-    # Returns a symbol representing the name of the adapter to use
-    # to load the application under <tt>dir/</tt>.
-    def self.guess(dir)
-      ADAPTERS.each do |adapter, file|
-        return adapter if file && ::File.exist?(::File.join(dir, file))
-      end
-      raise AdapterNotFound, "No adapter found for #{dir}"
-    end
-    
-    # Load a Rack application from a Rack config file (.ru).
-    def self.load(config)
-      rackup_code = ::File.read(config)
-      eval("Rack::Builder.new {( #{rackup_code}\n )}.to_app", TOPLEVEL_BINDING, config)
-    end
-    
-    # Loads an adapter identified by +name+ using +options+ hash.
-    def self.for(name, options={})
-      ENV['RACK_ENV'] = options[:environment]
-      
-      case name.to_sym
-      when :rack
-        return load(::File.join(options[:chdir], "config.ru"))
-        
-      when :rails
-        return Rails.new(options.merge(:root => options[:chdir]))
-      
-      when :ramaze
-        require "#{options[:chdir]}/start"
-        
-        Ramaze.trait[:essentials].delete Ramaze::Adapter
-        Ramaze.start :force => true
-        
-        return Ramaze::Adapter::Base
-        
-      when :merb
-        require 'merb-core'
-        
-        Merb::Config.setup(:merb_root   => options[:chdir],
-                           :environment => options[:environment])
-        Merb.environment = Merb::Config[:environment]
-        Merb.root = Merb::Config[:merb_root]
-        Merb::BootLoader.run
-        
-        return Merb::Rack::Application.new
-        
-      when :file
-        return Rack::File.new(options[:chdir])
-        
-      else
-        raise AdapterNotFound, "Adapter not found: #{name}"
-        
-      end
-    end
-  end
-end

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