m2r 0.0.3 → 1.0.0

data/.document

@@ -1,5 +0,0 @@
-README.rdoc
-lib/**/*.rb
-bin/*
-features/**/*.feature
-LICENSE

data/.gitignore

@@ -1,21 +0,0 @@
-## MAC OS
-.DS_Store
-
-## TEXTMATE
-*.tmproj
-tmtags
-
-## EMACS
-*~
-\#*
-.\#*
-
-## VIM
-*.swp
-
-## PROJECT::GENERAL
-coverage
-rdoc
-pkg
-
-## PROJECT::SPECIFIC

data/ISSUES

@@ -1,62 +0,0 @@
-On Ruby 1.9.2, ffi-rzmq crashes on even moderately high loads with the following stack. At this point, the only fix is to switch over to JRuby. I suspect that this crash has a lot to do with MRI's global interpreter lock (GIL). There's also a note about weird behavior on the ffi-rzmq github page, which counsels people to use JRuby, which doesn't have a GIL.
-
-.rvm/gems/ruby-1.9.2-p0/gems/ffi-rzmq-0.5.0/lib/ffi-rzmq/message.rb:80: [BUG] cfp consistency error - call0
-ruby 1.9.2p0 (2010-08-18 revision 29036) [x86_64-darwin10.4.0]
-
--- control frame ----------
-c:0014 p:---- s:0048 b:0048 l:000047 d:000047 CFUNC  :(null)
-c:0013 p:---- s:0046 b:0046 l:000045 d:000045 CFUNC  :new
-c:0012 p:0044 s:0040 b:0040 l:000039 d:000039 METHOD .rvm/gems/ruby-1.9.2-p0/gems/ffi-rzmq-0.5.0/lib/ffi-rzmq/message.rb:80
-c:0011 p:---- s:0035 b:0035 l:000034 d:000034 FINISH
-c:0010 p:---- s:0033 b:0033 l:000032 d:000032 CFUNC  :new
-c:0009 p:0017 s:0030 b:0030 l:000029 d:000029 METHOD .rvm/gems/ruby-1.9.2-p0/gems/ffi-rzmq-0.5.0/lib/ffi-rzmq/socket.rb:293
-c:0008 p:0022 s:0024 b:0023 l:000022 d:000022 METHOD /m2r/lib/connection.rb:42
-c:0007 p:0021 s:0020 b:0020 l:000010 d:000019 BLOCK  /m2r/lib/handler.rb:43
-c:0006 p:---- s:0016 b:0016 l:000015 d:000015 FINISH
-c:0005 p:---- s:0014 b:0014 l:000013 d:000013 CFUNC  :loop
-c:0004 p:0011 s:0011 b:0011 l:000010 d:000010 METHOD /m2r/lib/handler.rb:39
-c:0003 p:0112 s:0008 b:0008 l:001598 d:000a68 EVAL   example/http_0mq.rb:33
-c:0002 p:---- s:0004 b:0004 l:000003 d:000003 FINISH
-c:0001 p:0000 s:0002 b:0002 l:001598 d:001598 TOP   
----------------------------
--- Ruby level backtrace information ----------------------------------------
-example/http_0mq.rb:33:in `<main>'
-/m2r/lib/handler.rb:39:in `listen'
-/m2r/lib/handler.rb:39:in `loop'
-/m2r/lib/handler.rb:43:in `block in listen'
-/m2r/lib/connection.rb:42:in `recv'
-.rvm/gems/ruby-1.9.2-p0/gems/ffi-rzmq-0.5.0/lib/ffi-rzmq/socket.rb:293:in `recv_string'
-.rvm/gems/ruby-1.9.2-p0/gems/ffi-rzmq-0.5.0/lib/ffi-rzmq/socket.rb:293:in `new'
-.rvm/gems/ruby-1.9.2-p0/gems/ffi-rzmq-0.5.0/lib/ffi-rzmq/message.rb:80:in `initialize'
-.rvm/gems/ruby-1.9.2-p0/gems/ffi-rzmq-0.5.0/lib/ffi-rzmq/message.rb:80:in `new'
-.rvm/gems/ruby-1.9.2-p0/gems/ffi-rzmq-0.5.0/lib/ffi-rzmq/message.rb:80: [BUG] Segmentation fault
-ruby 1.9.2p0 (2010-08-18 revision 29036) [x86_64-darwin10.4.0]
-
--- control frame ----------
-c:0014 p:---- s:0048 b:0048 l:000047 d:000047 CFUNC  :(null)
-c:0013 p:---- s:0046 b:0046 l:000045 d:000045 CFUNC  :new
-c:0012 p:0044 s:0040 b:0040 l:000039 d:000039 METHOD .rvm/gems/ruby-1.9.2-p0/gems/ffi-rzmq-0.5.0/lib/ffi-rzmq/message.rb:80
-c:0011 p:---- s:0035 b:0035 l:000034 d:000034 FINISH
-c:0010 p:---- s:0033 b:0033 l:000032 d:000032 CFUNC  :new
-c:0009 p:0017 s:0030 b:0030 l:000029 d:000029 METHOD .rvm/gems/ruby-1.9.2-p0/gems/ffi-rzmq-0.5.0/lib/ffi-rzmq/socket.rb:293
-c:0008 p:0022 s:0024 b:0023 l:000022 d:000022 METHOD /m2r/lib/connection.rb:42
-c:0007 p:0021 s:0020 b:0020 l:000010 d:000019 BLOCK  /m2r/lib/handler.rb:43
-c:0006 p:---- s:0016 b:0016 l:000015 d:000015 FINISH
-c:0005 p:---- s:0014 b:0014 l:000013 d:000013 CFUNC  :loop
-c:0004 p:0011 s:0011 b:0011 l:000010 d:000010 METHOD /m2r/lib/handler.rb:39
-c:0003 p:0112 s:0008 b:0008 l:001598 d:000a68 EVAL   example/http_0mq.rb:33
-c:0002 p:---- s:0004 b:0004 l:000003 d:000003 FINISH
-c:0001 p:0000 s:0002 b:0002 l:001598 d:001598 TOP   
----------------------------
--- Ruby level backtrace information ----------------------------------------
-example/http_0mq.rb:33:in `<main>'
-/m2r/lib/handler.rb:39:in `listen'
-/m2r/lib/handler.rb:39:in `loop'
-/m2r/lib/handler.rb:43:in `block in listen'
-/m2r/lib/connection.rb:42:in `recv'
-.rvm/gems/ruby-1.9.2-p0/gems/ffi-rzmq-0.5.0/lib/ffi-rzmq/socket.rb:293:in `recv_string'
-.rvm/gems/ruby-1.9.2-p0/gems/ffi-rzmq-0.5.0/lib/ffi-rzmq/socket.rb:293:in `new'
-.rvm/gems/ruby-1.9.2-p0/gems/ffi-rzmq-0.5.0/lib/ffi-rzmq/message.rb:80:in `initialize'
-.rvm/gems/ruby-1.9.2-p0/gems/ffi-rzmq-0.5.0/lib/ffi-rzmq/message.rb:80:in `new'
-
-

data/VERSION

@@ -1 +0,0 @@
-0.0.3

data/benchmarks/jruby

@@ -1,60 +0,0 @@
-Machine: 2.66GHZ Core 2 Duo
-RAM: 4GB
-
-w/ 1 worker running on JRuby 1.5.1 64-bit hotspot
---------------------------------------------------------------------------------------------------
-httperf --server=localhost --num-conns 10 --num-calls 10000 --port 6767 --uri "/handlertest"
-httperf --client=0/1 --server=localhost --port=6767 --uri=/handlertest --send-buffer=4096 --recv-buffer=16384 --num-conns=10 --num-calls=10000
-httperf: warning: open file limit > FD_SETSIZE; limiting max. # of open files to FD_SETSIZE
-Maximum connect burst length: 1
-
-Total: connections 10 requests 100000 replies 100000 test-duration 278.142 s
-
-Connection rate: 0.0 conn/s (27814.2 ms/conn, <=1 concurrent connections)
-Connection time [ms]: min 23196.2 avg 27814.2 max 36479.8 median 25946.5 stddev 3871.1
-Connection time [ms]: connect 1.1
-Connection length [replies/conn]: 10000.000
-
-Request rate: 359.5 req/s (2.8 ms/req)
-Request size [B]: 73.0
-
-Reply rate [replies/s]: min 165.0 avg 359.1 max 473.6 stddev 61.9 (55 samples)
-Reply time [ms]: response 2.8 transfer 0.0
-Reply size [B]: header 40.0 content 290.0 footer 0.0 (total 330.0)
-Reply status: 1xx=0 2xx=100000 3xx=0 4xx=0 5xx=0
-
-CPU time [s]: user 25.18 system 109.49 (user 9.1% system 39.4% total 48.4%)
-Net I/O: 141.5 KB/s (1.2*10^6 bps)
-
-Errors: total 0 client-timo 0 socket-timo 0 connrefused 0 connreset 0
-Errors: fd-unavail 0 addrunavail 0 ftab-full 0 other 0
-
-
-w/ 3 workers running on Jruby 1.5.1 64-bit hotspot
-----------------------------------------------------------------------------------------------------
-httperf --server=localhost --num-conns 10 --num-calls 10000 --port 6767 --uri "/handlertest"
-httperf --client=0/1 --server=localhost --port=6767 --uri=/handlertest --send-buffer=4096 --recv-buffer=16384 --num-conns=10 --num-calls=10000
-httperf: warning: open file limit > FD_SETSIZE; limiting max. # of open files to FD_SETSIZE
-Maximum connect burst length: 1
-
-Total: connections 10 requests 100000 replies 100000 test-duration 311.645 s
-
-Connection rate: 0.0 conn/s (31164.5 ms/conn, <=1 concurrent connections)
-Connection time [ms]: min 26030.3 avg 31164.5 max 40239.7 median 28590.5 stddev 4521.9
-Connection time [ms]: connect 0.5
-Connection length [replies/conn]: 10000.000
-
-Request rate: 320.9 req/s (3.1 ms/req)
-Request size [B]: 73.0
-
-Reply rate [replies/s]: min 152.2 avg 320.6 max 409.4 stddev 56.1 (62 samples)
-Reply time [ms]: response 3.1 transfer 0.0
-Reply size [B]: header 40.0 content 290.0 footer 0.0 (total 330.0)
-Reply status: 1xx=0 2xx=100000 3xx=0 4xx=0 5xx=0
-
-CPU time [s]: user 30.40 system 134.12 (user 9.8% system 43.0% total 52.8%)
-Net I/O: 126.3 KB/s (1.0*10^6 bps)
-
-Errors: total 0 client-timo 0 socket-timo 0 connrefused 0 connreset 0
-Errors: fd-unavail 0 addrunavail 0 ftab-full 0 other 0
-

data/example/rack_handler.rb

@@ -1,69 +0,0 @@
-require 'rubygems'
-require 'rack'
-require 'stringio'
-# require 'ruby-debug'
-# Debugger.start
-# gem install ruby-debug19 -- --with-ruby-include=$HOME/.rvm/src/ruby-1.9.2-head
-
-$: << ::File.expand_path(::File.dirname(__FILE__) + '/../lib')
-require 'connection'
-
-$sender_id = "70D107AB-19F5-44AE-A2D0-2326A167D8D7"
-
-module Rack
-  module Handler
-    class Mongrel2
-      def self.run(app, receive = "tcp://127.0.0.1:9997", send = "tcp://127.0.0.1:9996")
-        conn = ::Mongrel2::Connection.new($sender_id, receive, send)
-        @running = true
-        trap("SIGINT") do
-          @running = false
-        end
-        
-        while @running
-          puts "WAITING FOR REQUEST"
-
-          req = conn.recv # Caution: Abort traps on SIGINT :/
-          if req.disconnect?
-            puts "DICONNECT"
-            next
-          end
-          
-          script_name = ENV["RACK_RELATIVE_URL_ROOT"] ||
-            # PATTERN is like:  /test/(.*.json) or /handlertest
-            req.headers["PATTERN"].split('(', 2).first.gsub(/\/$/, '')
-          
-          env = {
-            "rack.version" => Rack::VERSION,
-            "rack.url_scheme" => "http",
-            "rack.input" => StringIO.new(req.body),
-            "rack.errors" => $stderr,
-            "rack.multithread" => true,
-            "rack.multiprocess" => true,
-            "rack.run_once" => false,
-            
-            "mongrel2.pattern" => req.headers["PATTERN"],
-            
-            "REQUEST_METHOD" => req.headers["METHOD"],
-            "SCRIPT_NAME" => script_name,
-            "PATH_INFO" => req.headers["PATH"].gsub(script_name, ''),
-            "QUERY_STRING" => req.headers["QUERY"]
-          }
-          
-          env["SERVER_NAME"], env["SERVER_PORT"] = req.headers["host"].split(':', 2)
-          req.headers.each do |key, val|
-            unless key =~ /content_(type|length)/i
-              key = "HTTP_#{key.upcase}"
-            end
-            env[key] = val
-          end
-          
-          status, headers, rack_response = app.call(env)
-          body = ""
-          rack_response.each{|b| body << b}
-          conn.reply_http(req, body, status, headers)
-        end
-      end
-    end
-  end
-end

data/lib/connection.rb

@@ -1,158 +0,0 @@
-# On OSX:
-# sudo port install zmq
-# sudo gem install zmq
-# RUBY_ENGINE = 'ruby'
-require 'rubygems'
-gem 'ffi-rzmq'
-gem 'json'
-require 'ffi-rzmq'
-require 'json'
-
-$: << File.dirname(__FILE__)
-require 'request'
-
-CTX = ZMQ::Context.new(1)
-
-module Mongrel2
-  # A Connection object manages the connection between your handler
-  # and a Mongrel2 server (or servers).  It can receive raw requests
-  # or JSON encoded requests whether from HTTP or MSG request types,
-  # and it can send individual responses or batch responses either
-  # raw or as JSON.  It also has a way to encode HTTP responses
-  # for simplicity since that'll be fairly common.
-  class Connection
-  
-    def initialize(sender_id, sub_addr, pub_addr)
-      @sender_id = sender_id
-
-      @reqs = CTX.socket(ZMQ::UPSTREAM)
-      @reqs.connect(sub_addr)
-
-      @resp = CTX.socket(ZMQ::PUB)
-      @resp.connect(pub_addr)
-      @resp.setsockopt(ZMQ::IDENTITY, sender_id)
-
-      @sub_addr = sub_addr
-      @pub_addr = pub_addr
-    end
-  
-    # Receives a raw Request object that you
-    # can then work with.
-    def recv
-      Request.parse(@reqs.recv_string(0))
-    end
-
-    # Same as regular recv, but assumes the body is JSON and 
-    # creates a new attribute named req.data with the decoded
-    # payload.  This will throw an error if it is not JSON.
-    # 
-    # Normally Request just does this if the METHOD is 'JSON'
-    # but you can use this to force it for say HTTP requests.
-    def recv_json
-      self.recv.tap do |req|
-        req.data ||= JSON.parse(req.body)
-      end
-    end
-     
-    # Raw send to the given connection ID, mostly used 
-    # internally.
-    def send_resp(uuid, conn_id, msg)
-      header = "%s %d:%s," % [uuid, conn_id.size, conn_id]
-      string = header + ' ' + msg
-      #puts "DEBUG: #{string.inspect}"
-      @resp.send_string(string, 0)
-    end
-    
-    # Does a reply based on the given Request object and message.
-    # This is easier since the req object contains all the info
-    # needed to do the proper reply addressing.
-    def reply(req, msg)
-      self.send_resp(req.sender, req.conn_id, msg)
-    end
-
-    # Same as reply, but tries to convert data to JSON first.
-    def reply_json(req, data)
-      self.send_resp(req.sender, req.conn_id, JSON.generate(data))
-    end
-
-    # Basic HTTP response mechanism which will take your body,
-    # any headers you've made, and encode them so that the 
-    # browser gets them.
-    def reply_http(req, body, code=200, headers={})
-      self.reply(req, http_response(body, code, headers))
-    end
-
-    # This lets you send a single message to many currently
-    # connected clients.  There's a MAX_IDENTS that you should
-    # not exceed, so chunk your targets as needed.  Each target
-    # will receive the message once by Mongrel2, but you don't have
-    # to loop which cuts down on reply volume.
-    def deliver(uuid, idents, data)
-      self.send_resp(uuid, idents.join(' '), data)
-    end
-
-    # Same as deliver, but converts to JSON first.
-    def deliver_json(uuid, idents, data)
-      self.deliver(uuid, idents, JSON.generate(data))
-    end
-    
-    # Same as deliver, but builds an HTTP response, which means, yes,
-    # you can reply to multiple connected clients waiting for an HTTP 
-    # response from one handler.  Kinda cool.
-    def deliver_http(uuid, idents, body, code=200, headers={})
-      self.deliver(uuid, idents, http_response(body, code, headers))
-    end
-    
-    private
-    def http_response(body, code, headers)
-      headers['Content-Length'] = body.size
-      headers_s = headers.map{|k, v| "%s: %s" % [k,v]}.join("\r\n")
-
-      "HTTP/1.1 #{code} #{StatusMessage[code.to_i]}\r\n#{headers_s}\r\n\r\n#{body}"
-    end
-    
-    # From WEBrick: thanks dawg.
-    StatusMessage = {
-      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 => 'Found',
-      303 => 'See Other',
-      304 => 'Not Modified',
-      305 => 'Use Proxy',
-      307 => 'Temporary Redirect',
-      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 Timeout',
-      409 => 'Conflict',
-      410 => 'Gone',
-      411 => 'Length Required',
-      412 => 'Precondition Failed',
-      413 => 'Request Entity Too Large',
-      414 => 'Request-URI Too Large',
-      415 => 'Unsupported Media Type',
-      416 => 'Request Range Not Satisfiable',
-      417 => 'Expectation Failed',
-      500 => 'Internal Server Error',
-      501 => 'Not Implemented',
-      502 => 'Bad Gateway',
-      503 => 'Service Unavailable',
-      504 => 'Gateway Timeout',
-      505 => 'HTTP Version Not Supported'
-    }
-  end # class Connection
-end # mod Mongrel2

data/lib/fiber_handler.rb

@@ -1,43 +0,0 @@
-module Mongrel2
-  class FiberHandler < Handler
-    def initialize(*args)
-      raise "This handler is just around for testing. don't use it, it'll suck."
-    end
-
-    def fiber_handle
-      @fiber ||= Fiber.new do |request|
-        loop do
-          on_request(request)
-
-          # run on_disconnect if the server disconnects
-          if request.disconnect?
-            on_disconnect
-            request = Fiber.yield
-            next
-          end
-            
-          # get the response from on_request
-          response = process(request) 
-
-          # run the response through a filter
-          response = after_process(response, request)
-
-          # send it back to the server on the PUB socket
-          @connection.reply_http(request, response)
-
-          after_reply(request, response)
-          request = Fiber.yield
-        end
-      end
-    end
-
-    def listen
-      loop do
-        on_wait
-        request = @connection.recv
-        fiber_handle.resume(request)
-      end
-    end
-
-  end
-end

data/lib/handler.rb

@@ -1,66 +0,0 @@
-module Mongrel2
-  class Handler
-    attr_accessor :connection
-    def initialize(sender_uuid, subscribe_address, publish_address) 
-      @connection = Mongrel2::Connection.new(sender_uuid,
-                      subscribe_address, publish_address)
-    end
-
-    # Callback for when the handler is waiting for a request
-    def on_wait(*args)
-    end
-
-    # Callback when a request is received (for debug)
-    def on_request(request, *args)
-    end
-
-    # Override this to return a custom response 
-    def process(request, *args) 
-      puts "PROCESS REQUEST: #{request}"
-      #raise NoHandlerDefined, "define process_request in your subclass"
-      return request.inspect
-    end
-
-    # Callback for when the server disconnects
-    def on_disconnect(request, *args)
-    end
-
-    # Callback after process_request is done 
-    def after_process(response, request, *args)
-      return response
-    end
-    
-    # Callback after the server gets the response
-    def after_reply(request, response, *args)
-    end
-  
-    # the body of the main recv loop
-    def listen
-      loop do
-        on_wait
-
-        # get the request from Mongrel2 on the UPSTREAM socket
-        request = @connection.recv
-        # run the on_request hook
-        on_request(request)
-
-        # run on_disconnect if the server disconnects
-        if request.disconnect?
-          on_disconnect
-          next
-        end
-          
-        # get the response from on_request
-        response = process(request) 
-
-        # run the response through a filter
-        response = after_process(response, request)
-
-        # send it back to the server on the PUB socket
-        @connection.reply_http(request, response)
-
-        after_reply(request, response)
-      end
-    end
-  end
-end