thin-fun_embed 0.0.1

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in thin-fun_embed.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,23 @@
+Copyright (c) 2012 Sokolov Yura 'funny-falcon'
+Copyright (c) 2011 Nils Franzén
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,118 @@
+= Thin::FunEmbed
+
+This is minimalistic web server for embedding into EventMachine-enabled application
+based on {idea of Nils Franzén}[http://www.franzens.org/2011/10/writing-minimalistic-web-server-using.html],
+but it uses origin Thin::Request instead of custom wrapper to thin parser.
+
+It is intentionally not full fledge rack server, but you could use +send_status_headers_body+ to return
+rack application's response to client.
+
+It is capable to serve keep-alive requests (but not pipelined).
+
+It is faster than Thin itself cause it allows you to send very custom response, and even for Rack like
+response it doesn't do many checks on your output. But it meens, that you responsible for you response :)
+
+Rack hello world, tested with +ab -k -c 500 -n 50000 127.0.0.1:8080/+ on Core i3@1600Mhz
+
+* with Thin::FunEmbed (see examples/rack_like.rb) ~ 14000 req/sec
+* with `thin -p 8080 -e production start` ~ 6500 req/sec
+
+(But consider, that this is for very dump response. Do not expect big speedup for heavy weight ones')
+
+Also, it doesn't bother with keep-alive timeouts, limits and many other things that Thin do. But it is not
+too hard too look for them in the Thin's sources. And, in any way, it is better to place this "server" behind
+"something like" Nginx, which could use keep-alive connections to upstream since version 1.1 .
+
+== Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'thin-fun_embed'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install thin-fun_embed
+
+== Usage
+
+You should subclass Thin::FunEmbed and override #handle_http_request method. Then you should start it with
+EM.start_server as any other EM::Connection .
+
+Abstract example:
+  require 'thin/fun_embed.rb'
+  class MyServer < Thin::FunEmbed
+    def handle_http_request(env)
+      if rack_like_response?
+        send_status_headers_body(status, headers, body)
+      elsif is_200_ok?
+        send_200_ok(body)
+      elsif is_status_body?
+        send_status_body(status, body)
+      elsif is_raw_string?
+        send_raw_string(full_http_response_string, try_to_keep_alive)
+      end
+    end
+  end
+  
+  host, port = '0.0.0.0', 8080
+  EM.run do
+    EM.start_server host, port, MyServer
+  end
+
+200 ok example:
+  require 'thin/fun_embed.rb'
+
+  class Simple200ok < Thin::FunEmbed
+    def handle_http_request(env)
+      if rand(2) == 1
+        send_200_ok('{"hello":"world"}', 'application/javascript')
+      else
+        send_200_ok('hello world')
+      end
+    end
+  end
+
+  EM.run do
+    EM.start_server '0.0.0.0', 8080, Simple200ok
+  end
+
+Rack like example with correct socket closing:
+  require 'thin/fun_embed.rb'
+
+  class RackLikeServer < Thin::FunEmbed
+    attr_accessor :app
+    def handle_http_request(env)
+      send_rack_response(*app.call(env))
+    end
+  end
+
+  app = proc{|env| [200, {'Content-Length'=>6}, ['hello', "\n"]]}
+
+  host, port = '0.0.0.0', 8080
+  all_conns = {}
+  trap(:INT) do 
+    EM.schedule{ 
+      all_conns.each{|conn, _| conn.close_after_writting}
+      EM.next_tick{ EM.stop }
+    } 
+  end
+
+  EM.run do
+    EM.start_server host, port, RackLikeServer do |conn|
+      conn.app = app
+      all_conns[conn] = true
+      conn.unbind_callback = all_conns.method(:delete)
+    end
+  end
+
+== Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/examples/config.ru

@@ -0,0 +1,2 @@
+app = proc{|env| [200, {'Content-Length'=>'6'}, ['hello', "\n"]]}
+run app

data/examples/rack_like.rb

@@ -0,0 +1,28 @@
+# :stopdoc:
+require 'thin/fun_embed.rb'
+
+class RackLikeServer < Thin::FunEmbed
+  attr_accessor :app
+  def handle_http_request(env)
+    send_rack_response(*app.call(env))
+  end
+end
+
+app = proc{|env| [200, {'Content-Length'=>6}, ['hello', "\n"]]}
+
+host, port = '0.0.0.0', 8080
+all_conns = {}
+trap(:INT) do 
+  EM.schedule{ 
+    all_conns.each{|conn, _| conn.close_after_writting}
+    EM.next_tick{ EM.stop }
+  } 
+end
+
+EM.run do
+  EM.start_server host, port, RackLikeServer do |conn|
+    conn.app = app
+    all_conns[conn] = true
+    conn.unbind_callback = all_conns.method(:delete)
+  end
+end

data/examples/simple_200_ok.rb

@@ -0,0 +1,16 @@
+# :stopdoc:
+require 'thin/fun_embed.rb'
+
+class Simple200ok < Thin::FunEmbed
+  def handle_http_request(env)
+    if false && rand(2) == 1
+      send_200_ok('{"hello":"world"}', 'application/javascript')
+    else
+      send_200_ok('hello world')
+    end
+  end
+end
+
+EM.run do
+  EM.start_server '0.0.0.0', 8080, Simple200ok
+end

data/examples/status_body.rb

@@ -0,0 +1,16 @@
+# :stopdoc:
+require 'thin/fun_embed.rb'
+
+class StatusBody < Thin::FunEmbed
+  def handle_http_request(env)
+    if env[PATH_INFO] =~ /\.js$/
+      send_status_body(200, '{"hello":"world"}', 'application/javascript')
+    else
+      send_status_body(200, 'hello world')
+    end
+  end
+end
+
+EM.run do
+  EM.start_server '0.0.0.0', 8080, StatusBody
+end

data/lib/thin/fun_embed/constants.rb

@@ -0,0 +1,18 @@
+module Thin # :nodoc:
+  class FunEmbed
+    # Usefull constants for analysing Rack environmentc
+    module Constants
+      PATH_INFO = 'PATH_INFO'.freeze
+      REQUEST_METHOD = 'REQUEST_METHOD'.freeze
+      SCRIPT_NAME = 'SCRIPT_NAME'.freeze
+      QUERY_STRING = 'QUERY_STRING'.freeze
+      SERVER_NAME = 'SERVER_NAME'.freeze
+      SERVER_PORT = 'SERVER_PORT'.freeze
+
+      GET = 'GET'.freeze
+      POST = 'POST'.freeze
+      DELETE = 'DELETE'.freeze
+      PUT = 'PUT'.freeze
+    end
+  end
+end

data/lib/thin/fun_embed/version.rb

@@ -0,0 +1,6 @@
+require 'eventmachine'
+module Thin # :nodoc:
+  class FunEmbed < EM::Connection
+    VERSION = "0.0.1"
+  end
+end

data/lib/thin/fun_embed.rb

@@ -0,0 +1,179 @@
+require "eventmachine"
+require "thin_parser"
+require "thin/request"
+require "thin/statuses"
+require "thin/fun_embed/version"
+require "thin/fun_embed/constants"
+
+module Thin # :nodoc:
+  SERVER = "FunEmbed #{FunEmbed::VERSION}".freeze
+  module VERSION # :nodoc:
+    RACK = [1,1].freeze
+  end
+
+  # minimalistic HTTP server for embedding into EventMachine'd applications
+  #
+  # Method #handle_http_request accept fully formed Rack environment and should
+  # call send http status+headers+body using one of #send_200_ok, #send_status_body,
+  # #send_raw_string and #send_rack_response methods or manually. If you send
+  # response manually, then you should call #consider_keep_alive method with your wish:
+  # whether you want to try keep-alive connection or not.
+  #
+  #   require 'thin/fun_embed.rb'
+  #   
+  #   class Simple200ok < Thin::FunEmbed
+  #     def handle_http_request(env)
+  #       if rand(2) == 1
+  #         send_200_ok('{"hello":"world"}', 'application/javascript')
+  #       else
+  #         send_200_ok('hello world')
+  #       end
+  #     end
+  #   end
+  #   
+  #   EM.run do
+  #     EM.start_server '0.0.0.0', 8080, Simple200ok
+  #   end
+  # 
+  class FunEmbed < EM::Connection
+    # :stopdoc:
+    include Constants
+    FULL_KEEP_ALIVE = "Connection: keep-alive\r\n".freeze
+    RN = "\r\n".freeze
+    RNRN = "\r\n\r\n".freeze
+    NL = "\n".freeze
+    CONTENT_LENGTH = "Content-Length".freeze
+    CONTENT_LENGTH_DT = "\r\nContent-Length: ".freeze
+    CONNECTION = 'Connection'.freeze
+    KEEP_ALIVE = 'keep-alive'.freeze
+    CLOSE = 'close'.freeze
+    TEXT_PLAIN = 'text/plain'.freeze
+    HTTP_STATUS_CODES = Thin::HTTP_STATUS_CODES
+    # :startdoc:
+
+    # callback, which called from +#unbind+.
+    # Could be used for monitoring connections.
+    attr_accessor :unbind_callback
+
+    # signals if client may accept keep-alive connection
+    attr :keep_alive
+
+    def post_init
+      @keep_alive = nil
+      @parser = Thin::Request.new
+    end
+
+    def receive_data(data)
+      if @parser.parse(data)
+        @keep_alive = @parser.persistent?
+        handle_http_request(@parser.env)
+      end
+    end
+
+    # main method for override
+    # you ought to put your application logic here
+    def handle_http_request(env)
+      send_200_ok "you should override #handle_http_request"
+    end
+
+    # send simple '200 OK' response with a body
+    def send_200_ok(body = '', type = TEXT_PLAIN, try_keep_alive = true)
+      send_data("HTTP/1.1 200 OK\r\nContent-Type: #{type}\r\n"\
+                "Content-Length: #{body.bytesize}\r\n"\
+                "#{keep_alive ? FULL_KEEP_ALIVE : nil}\r\n")
+      send_data(body)
+      consider_keep_alive(try_keep_alive)
+    end
+
+    # send simple response with status, body and type
+    def send_status_body(status, body = '', type = TEXT_PLAIN, try_keep_alive = true)
+      status = status.to_i
+      if status < 200 || status == 204 || status == 304
+        send_data("HTTP/1.1 #{status} #{HTTP_STATUS_CODES[status]}\r\n"\
+                "#{keep_alive ? FULL_KEEP_ALIVE : nil}\r\n")
+      else
+        send_data("HTTP/1.1 #{status} #{HTTP_STATUS_CODES[status]}\r\n"\
+                "Content-Type: #{type}\r\n"\
+                "Content-Length: #{body.bytesize}\r\n"\
+                "#{keep_alive ? FULL_KEEP_ALIVE : nil}\r\n")
+        send_data(body)
+      end
+      consider_keep_alive(try_keep_alive)
+    end
+
+    # send fully formatted HTTP response
+    def send_raw_string(string, try_keep_alive = true)
+      send_data(string)
+      try_keep_alive &&= @keep_alive &&
+        (cl = string.index(CONTENT_LENGTH_DT)) &&
+        (kai = string.index(FULL_KEEP_ALIVE)) && 
+        kai < (rn = string.index(RNRN)) &&
+        cl < rn
+      consider_keep_alive(try_keep_alive)
+    end
+
+    # send Rack like response (status, headers, body)
+    #
+    # This method tries to implement as much of Rack as it progmatically needed, but not more.
+    # Test it before use
+    def send_rack_response(status, headers, body, try_keep_alive = true)
+      status = status.to_i
+      out = "HTTP/1.1 #{status} #{HTTP_STATUS_CODES[status]}\r\n"
+
+      if String === headers
+        try_keep_alive &&= headers.index(CONTENT_LENGTH_DT) && headers.index(FULL_KEEP_ALIVE)
+        out << headers
+      else
+        content_length = connection = nil
+        headers.each do |k, v|
+          if k == CONTENT_LENGTH
+            content_length = v
+          elsif k == CONNECTION
+            connection = v
+          end
+          if String === v
+            unless v.index(NL)
+              out << "#{k}: #{v}\r\n"
+            else
+              v.each_line{|l| out << "#{k}: #{l}\r\n"}
+            end
+          elsif v.respond_to?(:each)
+            v.each{|l| out << "#{k}: #{l}\r\n"}
+          else
+            unless (v=v.to_s).index(NL)
+              out << "#{k}: #{v}\r\n"
+            else
+              v.each_line{|l| out << "#{k}: #{l}\r\n"}
+            end
+          end
+        end
+
+        try_keep_alive &&= @keep_alive && content_length && (!connection || connection == KEEP_ALIVE)
+        out << FULL_KEEP_ALIVE  if try_keep_alive && !connection
+      end
+      out << RN
+      send_data out
+
+      if String === body
+        send_data(body)
+      else
+        body.each{|s| send_data(s)}
+      end
+
+      consider_keep_alive(try_keep_alive)
+    end
+
+    # call this when you fully send response
+    def consider_keep_alive(try_keep_alive = true)
+      if @keep_alive && try_keep_alive
+        post_init
+      else
+        close_connection_after_writing
+      end
+    end
+
+    def unbind # :nodoc:
+      @unbind_callback && @unbind_callback.call(self)
+    end
+  end
+end

data/thin-fun_embed.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/thin/fun_embed/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Sokolov Yura 'funny-falcon'"]
+  gem.email         = ["funny.falcon@gmail.com"]
+  gem.description   = %q{trim of Thin web server for embedding into eventmachined application}
+  gem.summary       = "Subclass of EM::Connection which uses thin internals to do http request handling.\n"\
+                      "It is intentionally not Rack server, but could be used to build some."
+
+  gem.homepage      = "https://github.com/funny-falcon/thin-fun_embed"
+
+  gem.files         = Dir["examples/*"] + Dir["lib/**/*.rb"] +
+                      %w{Gemfile LICENSE Rakefile README.rdoc thin-fun_embed.gemspec}
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "thin-fun_embed"
+  gem.require_paths = ["lib"]
+  gem.version       = Thin::FunEmbed::VERSION
+
+  gem.add_dependency 'thin', ['>= 1.4']
+end

metadata

@@ -0,0 +1,74 @@
+--- !ruby/object:Gem::Specification
+name: thin-fun_embed
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Sokolov Yura 'funny-falcon'
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-08-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: thin
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '1.4'
+description: trim of Thin web server for embedding into eventmachined application
+email:
+- funny.falcon@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- examples/simple_200_ok.rb
+- examples/rack_like.rb
+- examples/status_body.rb
+- examples/config.ru
+- lib/thin/fun_embed/constants.rb
+- lib/thin/fun_embed/version.rb
+- lib/thin/fun_embed.rb
+- Gemfile
+- LICENSE
+- Rakefile
+- README.rdoc
+- thin-fun_embed.gemspec
+homepage: https://github.com/funny-falcon/thin-fun_embed
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Subclass of EM::Connection which uses thin internals to do http request handling.
+  It is intentionally not Rack server, but could be used to build some.
+test_files: []