mega-fast-sys 0.0.1

data/thin-2.0.1/lib/thin/logging.rb

@@ -0,0 +1,174 @@
+require 'logger'
+
+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.trace=</tt>:  log all raw request and response and
+  #                           messages logged with +trace+.
+  # <tt>Logging.silent=</tt>: silence all log all log messages
+  #                           altogether.
+  module Logging
+    # Simple formatter which only displays the message.
+    # Taken from ActiveSupport
+    class SimpleFormatter < Logger::Formatter
+      def call(severity, timestamp, progname, msg)
+        "#{timestamp} #{String === msg ? msg : msg.inspect}\n"
+      end
+    end
+
+    @trace_logger = nil
+
+    class << self
+      attr_reader :logger
+      attr_reader :trace_logger
+
+      def trace=(enabled)
+        if enabled
+          @trace_logger ||= Logger.new(STDOUT)
+        else
+          @trace_logger = nil
+        end
+      end
+
+      def trace?
+        !@trace_logger.nil?
+      end
+
+      def silent=(shh)
+        if shh
+          @logger = nil
+        else
+          @logger ||= Logger.new(STDOUT)
+        end
+      end
+
+      def silent?
+        !@logger.nil?
+      end
+
+      def level
+        @logger ? @logger.level : nil # or 'silent'
+      end
+
+      def level=(value)
+        # If logging has been silenced, then re-enable logging
+        @logger = Logger.new(STDOUT) if @logger.nil?
+        @logger.level = value
+      end
+
+      # Allow user to specify a custom logger to use.
+      # This object must respond to:
+      # +level+, +level=+ and +debug+, +info+, +warn+, +error+, +fatal+
+      def logger=(custom_logger)
+        [ :level   ,
+          :level=  ,
+          :debug   ,
+          :info    ,
+          :warn    ,
+          :error   ,
+          :fatal   ,
+          :unknown ,
+        ].each do |method|
+          if not custom_logger.respond_to?(method)
+            raise ArgumentError, "logger must respond to #{method}"
+          end
+        end
+
+        @logger = custom_logger
+      end
+
+      def trace_logger=(custom_tracer)
+        [ :level   ,
+          :level=  ,
+          :debug   ,
+          :info    ,
+          :warn    ,
+          :error   ,
+          :fatal   ,
+          :unknown ,
+        ].each do |method|
+          if not custom_tracer.respond_to?(method)
+            raise ArgumentError, "trace logger must respond to #{method}"
+          end
+        end
+
+        @trace_logger = custom_tracer
+      end
+
+      def log_msg(msg, level=Logger::INFO)
+        return unless @logger
+        @logger.add(level, msg)
+      end
+
+      def trace_msg(msg)
+        return unless @trace_logger
+        @trace_logger.info(msg)
+      end
+
+      # Provided for backwards compatibility.
+      # Callers should be using the +level+ (on the +Logging+ module
+      # or on the instance) to figure out what the log level is.
+      def debug?
+        self.level == Logger::DEBUG
+      end
+      def debug=(val)
+        self.level = (val ? Logger::DEBUG : Logger::INFO)
+      end
+
+    end # module methods
+
+    # Default logger to stdout.
+    self.logger           = Logger.new(STDOUT)
+    self.logger.level     = Logger::INFO
+    self.logger.formatter = Logging::SimpleFormatter.new
+
+    def silent
+      Logging.silent?
+    end
+
+    def silent=(value)
+      Logging.silent = value
+    end
+
+    # Log a message if tracing is activated
+    def trace(msg=nil)
+      Logging.trace_msg(msg) if msg
+    end
+    module_function :trace
+    public :trace
+
+    # Log a message at DEBUG level
+    def log_debug(msg=nil)
+      Logging.log_msg(msg || yield, Logger::DEBUG)
+    end
+    module_function :log_debug
+    public :log_debug
+
+    # Log a message at INFO level
+    def log_info(msg)
+      Logging.log_msg(msg || yield, Logger::INFO)
+    end
+    module_function :log_info
+    public :log_info
+
+    # Log a message at ERROR level (and maybe a backtrace)
+    def log_error(msg, e=nil)
+      log_msg = msg
+      if e
+        log_msg += ": #{e}\n\t" + e.backtrace.join("\n\t") + "\n"
+      end
+      Logging.log_msg(log_msg, Logger::ERROR)
+    end
+    module_function :log_error
+    public :log_error
+
+    # For backwards compatibility
+    def log msg
+      STDERR.puts('#log has been deprecated, please use the ' \
+                  'log_level function instead (e.g. - log_info).')
+      log_info(msg)
+    end
+
+  end
+end

data/thin-2.0.1/lib/thin/rackup/handler.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative "../server"
+
+module Thin
+  module Rackup
+    class Handler
+      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
+  end
+end

data/thin-2.0.1/lib/thin/request.rb

@@ -0,0 +1,159 @@
+require 'tempfile'
+require_relative './env'
+
+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      = String.new
+    # Force external_encoding of request's body to ASCII_8BIT
+    INITIAL_BODY.encode!(Encoding::ASCII_8BIT) if INITIAL_BODY.respond_to?(:encode!) && defined?(Encoding::ASCII_8BIT)
+
+    # Freeze some HTTP header names & values
+    SERVER_SOFTWARE   = 'SERVER_SOFTWARE'.freeze
+    SERVER_NAME       = 'SERVER_NAME'.freeze
+    REQUEST_METHOD    = 'REQUEST_METHOD'.freeze
+    LOCALHOST         = 'localhost'.freeze
+    REQUEST_HTTP_VERSION      = 'thin.request_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
+    HEAD              = 'HEAD'.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     = String.new
+      @nparsed  = 0
+      @body     = StringIO.new(INITIAL_BODY.dup)
+      @env      = Env.with_defaults({
+        SERVER_SOFTWARE   => SERVER,
+        SERVER_NAME       => LOCALHOST,
+
+        # Rack stuff
+        RACK_INPUT        => @body,
+        RACK_ERRORS       => STDERR,
+      })
+    end
+
+    # Parse a chunk of data into the request environment
+    # Raises an +InvalidRequest+ if invalid.
+    # Returns +true+ if the parsing is complete.
+    def parse(data)
+      if data.size > 0 && finished? # headers and body already fully satisfied. more data is erroneous.
+        raise InvalidRequest, 'Content longer than specified'
+      elsif @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)
+
+        # Transfer 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 expects 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[REQUEST_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
+
+    def head?
+      @env[REQUEST_METHOD] == HEAD
+    end
+
+    # Close any resource used by the request
+    def close
+      @body.close! 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/thin-2.0.1/lib/thin/response.rb

@@ -0,0 +1,144 @@
+module Thin
+  # A response sent to the client.
+  class Response
+    class Stream
+      def initialize(writer)
+        @read_closed = true
+        @write_closed = false
+        @writer = writer
+      end
+
+      def read(length = nil, outbuf = nil)
+        raise ::IOError, 'not opened for reading' if @read_closed
+      end
+
+      def write(chunk)
+        raise ::IOError, 'not opened for writing' if @write_closed
+
+        @writer.call(chunk)
+      end
+
+      alias :<< :write
+
+      def close
+        @read_closed = @write_closed = true
+
+        nil
+      end
+
+      def closed?
+        @read_closed && @write_closed
+      end
+
+      def close_read
+        @read_closed = true
+
+        nil
+      end
+
+      def close_write
+        @write_closed = true
+
+        nil
+      end
+
+      def flush
+        self
+      end
+    end
+
+    CONNECTION     = 'connection'.freeze
+    CLOSE          = 'close'.freeze
+    KEEP_ALIVE     = 'keep-alive'.freeze
+    SERVER         = 'server'.freeze
+    CONTENT_LENGTH = 'content-length'.freeze
+
+    PERSISTENT_STATUSES  = [100, 101].freeze
+
+    #Error Responses
+    ERROR            = [500, {'content-type' => 'text/plain'}, ['Internal server error']].freeze
+    PERSISTENT_ERROR = [500, {'content-type' => 'text/plain', 'connection' => 'keep-alive', 'content-length' => "21"}, ['Internal server error']].freeze
+    BAD_REQUEST      = [400, {'content-type' => 'text/plain'}, ['Bad Request']].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
+      @skip_body  = 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 unless @headers.has_key?(CONNECTION)
+      @headers[SERVER]     = Thin::NAME unless @headers.has_key?(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
+
+    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
+
+    # 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(&block)
+      yield head
+
+      unless @skip_body
+        if @body.is_a?(String)
+          yield @body
+        elsif @body.respond_to?(:each)
+          @body.each { |chunk| yield chunk }
+        else
+          @body.call(Stream.new(block))
+        end
+      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, or the response
+    # status must require that the connection remain open.
+    def persistent?
+      (@persistent && @headers.has_key?(CONTENT_LENGTH)) || PERSISTENT_STATUSES.include?(@status)
+    end
+
+    def skip_body!
+      @skip_body = true
+    end
+  end
+end