swee 0.0.1

data/lib/swee/support.rb

@@ -0,0 +1,79 @@
+class Object
+  def try(*a, &b)
+    try!(*a, &b) if a.empty? || respond_to?(a.first)
+  end
+
+  def try!(*a, &b)
+    if a.empty? && block_given?
+      if b.arity.zero?
+        instance_eval(&b)
+      else
+        yield self
+      end
+    else
+      public_send(*a, &b)
+    end
+  end
+
+  def blank?
+    respond_to?(:empty?) ? !!empty? : !self
+  end
+  def present?
+    !blank?
+  end
+
+  def presence
+    self if present?
+  end
+end
+
+class NilClass
+  def try(*args)
+    nil
+  end
+
+  def try!(*args)
+    nil
+  end
+
+  def blank?
+    true
+  end
+end
+
+class FalseClass
+  def blank?
+    true
+  end
+end
+
+class TrueClass
+  def blank?
+    false
+  end
+end
+
+class Array
+  alias_method :blank?, :empty?
+end
+
+class Hash
+  alias_method :blank?, :empty?
+end
+
+class String
+  BLANK_RE = /\A[[:space:]]*\z/
+  def blank?
+    BLANK_RE === self
+  end
+
+  def html_safe
+    self.gsub /[&"'><]/, { '&' => '&amp;',  '>' => '&gt;',   '<' => '&lt;', '"' => '&quot;', "'" => '&#39;' }
+  end
+end
+
+class Numeric
+  def blank?
+    false
+  end
+end

data/lib/swee/swee_logger.rb

@@ -0,0 +1,59 @@
+require "fiber"
+
+class Swee::SweeLogger
+  def initialize
+    @logs = Array.new
+    @msg = Array.new
+    init_fiber
+  end
+
+  def init_fiber
+    @fb = Fiber.new { loop_log }
+  end
+
+  def loop_log
+    loop do
+      each_log
+      Fiber.yield
+    end
+  end
+
+  def each_log
+    while !@msg.empty?
+      _msg = @msg.shift
+      @logs.each { |_log| _log.debug _msg }
+    end
+  end
+
+  def get_binding
+    binding
+  end
+
+  def roll!
+    each_log
+    # Fiber 存在跨线程问题 暂时不用Fiber处理
+    # init_fiber if !@fb.alive?
+    # @fb.resume
+  end
+
+  def addlog log
+    @logs << log
+  end
+
+  def get_io
+    @logs.select { |log| log.io? }.first
+  end
+
+  def get_file
+    @logs.select { |log| log.file? }.first
+  end
+
+  def logs
+    @logs
+  end
+
+  def <<(msg)
+    @msg << msg
+    roll!
+  end
+end

data/lib/swee/thin/headers.rb

@@ -0,0 +1,40 @@
+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)
+      downcase_key = key.downcase
+      if !@sent.has_key?(downcase_key) || ALLOWED_DUPLICATES.include?(downcase_key)
+        @sent[downcase_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.downcase]
+    end
+    
+    def to_s
+      @out.join
+    end
+  end
+end

data/lib/swee/thin/request.rb

@@ -0,0 +1,162 @@
+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
+    REQUEST_METHOD    = 'REQUEST_METHOD'.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
+    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     = ''
+      @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 an +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)
+
+        # 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[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/lib/swee/thin/response.rb

@@ -0,0 +1,177 @@
+module Thin
+
+  module VERSION #:nodoc:
+    MAJOR    = 1
+    MINOR    = 6
+    TINY     = 3
+    
+    STRING   = [MAJOR, MINOR, TINY].join('.')
+    
+    CODENAME = "Protein Powder".freeze
+    
+    RACK     = [1, 0].freeze # Rack protocol version
+  end
+
+  NAME    = 'thin'.freeze
+  SERVER  = "#{NAME} #{VERSION::STRING} codename #{VERSION::CODENAME}".freeze  
+
+  HTTP_STATUS_CODES = {  
+    100  => 'Continue', 
+    101  => 'Switching Protocols', 
+    200  => 'OK', 
+    201  => 'Created', 
+    202  => 'Accepted', 
+    203  => 'Non-Authoritative Information', 
+    204  => 'No Content', 
+    205  => 'Reset Content', 
+    206  => 'Partial Content', 
+    300  => 'Multiple Choices', 
+    301  => 'Moved Permanently', 
+    302  => 'Moved Temporarily', 
+    303  => 'See Other', 
+    304  => 'Not Modified', 
+    305  => 'Use Proxy', 
+    400  => 'Bad Request', 
+    401  => 'Unauthorized', 
+    402  => 'Payment Required', 
+    403  => 'Forbidden', 
+    404  => 'Not Found', 
+    405  => 'Method Not Allowed', 
+    406  => 'Not Acceptable', 
+    407  => 'Proxy Authentication Required', 
+    408  => 'Request Time-out', 
+    409  => 'Conflict', 
+    410  => 'Gone', 
+    411  => 'Length Required', 
+    412  => 'Precondition Failed', 
+    413  => 'Request Entity Too Large', 
+    414  => 'Request-URI Too Large', 
+    415  => 'Unsupported Media Type',
+    422  => 'Unprocessable Entity',   
+    500  => 'Internal Server Error', 
+    501  => 'Not Implemented', 
+    502  => 'Bad Gateway', 
+    503  => 'Service Unavailable', 
+    504  => 'Gateway Time-out', 
+    505  => 'HTTP Version not supported'
+  }
+
+  # 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
+
+    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
+
+    # 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?(Integer)
+            vs = vs.to_s
+          end
+          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
+
+      unless @skip_body
+        if @body.is_a?(String)
+          yield @body
+        else
+          @body.each { |chunk| yield chunk }
+        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