rack-rabbit 0.5.0

data/lib/rack-rabbit/signals.rb

@@ -0,0 +1,62 @@
+module RackRabbit
+  class Signals
+
+    # The RackRabbit server process has a single primary thread, but it doesn't
+    # actually need to do any work once it has spun up the worker processes. I
+    # need it to hibernate until one (or more) signal event's occurs.
+    #
+    # Originally I tried to use the standard Thread::Queue, it uses a Mutex to
+    # perform a blocking pop on the Queue. However Ruby (2.x) won't let the last
+    # active thread hibernate (it's overly aggressive at deadlock prevention)
+    #
+    # So, instead of using a Mutex based Queue, I can use a blocking select
+    # on an IO pipe, then when the signal handler pushes into the Queue
+    # it can also write to the pipe in order to "awaken" the primary thread.
+    #
+    # FYI: this is the same underlying idea that is used by the Unicorn master
+    #      process, I've just encapsulated it in a Signals class
+    #
+
+    def initialize
+      @reader, @writer = IO.pipe
+      @queue = []
+    end
+
+    def close
+      @reader.close
+      @writer.close
+      @reader = @writer = nil
+    end
+
+    def closed?
+      @reader.nil?
+    end
+
+    def push(item)
+      raise RuntimeError, "closed" if closed?
+      @queue << item
+      awaken
+    end
+
+    def pop(options = {})
+      raise RuntimeError, "closed" if closed?
+      if @queue.empty? && (:timeout == hibernate(options[:timeout]))
+        :timeout
+      else
+        @queue.shift
+      end
+    end
+
+  private
+
+    def awaken
+      @writer.write '.'
+    end
+
+    def hibernate(seconds = nil)
+      return :timeout unless IO.select([@reader], nil, nil, seconds)
+      @reader.readchar 
+    end
+
+  end
+end

data/lib/rack-rabbit/subscriber.rb

@@ -0,0 +1,77 @@
+require 'rack-rabbit/adapter'
+require 'rack-rabbit/handler'
+
+module RackRabbit
+  class Subscriber
+
+    #--------------------------------------------------------------------------
+
+    attr_reader :config,  # configuration options provided by the Server
+                :logger,  # convenience for config.logger
+                :rabbit,  # rabbitMQ adapter constructed by this class
+                :handler, # actually does the work of handling the RACK request/response
+                :lock     # mutex to synchronize with Worker#shutdown for graceful QUIT handling
+
+    #--------------------------------------------------------------------------
+
+    def initialize(rabbit, handler, lock, config)
+      @rabbit  = rabbit
+      @handler = handler
+      @lock    = lock
+      @config  = config
+      @logger  = config.logger
+    end
+
+    #--------------------------------------------------------------------------
+
+    def subscribe
+      rabbit.startup
+      rabbit.connect
+      rabbit.subscribe(:queue         => config.queue,
+                       :exchange      => config.exchange,
+                       :exchange_type => config.exchange_type,
+                       :routing_key   => config.routing_key,
+                       :ack           => config.ack) do |message|
+        lock.synchronize do
+          start = Time.now
+          response = handle(message)
+          finish = Time.now
+          logger.info "\"#{message.method} #{message.path}\" [#{response.status}] - #{"%.4f" % (finish - start)}"
+        end
+      end
+    end
+
+    def unsubscribe
+      rabbit.disconnect
+      rabbit.shutdown
+    end
+
+    #==========================================================================
+    # PRIVATE IMPLEMENTATION
+    #==========================================================================
+
+    private
+
+    def handle(message)
+
+      response = handler.handle(message) # does all the Rack related work
+
+      if message.should_reply?
+        rabbit.publish(response.body, message.get_reply_properties(response, config))
+      end
+
+      if config.ack && !message.acknowledged? && !message.rejected?
+        if response.succeeded?
+          message.ack
+        else
+          message.reject
+        end
+      end
+
+      response
+    end
+
+    #--------------------------------------------------------------------------
+
+  end # class Subscriber
+end # module RackRabbit

data/lib/rack-rabbit/worker.rb

@@ -0,0 +1,84 @@
+require 'rack-rabbit/signals'
+require 'rack-rabbit/subscriber'
+require 'rack-rabbit/handler'
+require 'rack-rabbit/adapter'
+
+module RackRabbit
+  class Worker
+
+    #--------------------------------------------------------------------------
+
+    attr_reader :config,     # provided by the Server
+                :logger,     # convenience for config.logger
+                :signals,    # blocking Q for signal handling
+                :lock,       # mutex to synchronise with Subscriber#subscribe for graceful QUIT handling
+                :rabbit,     # interface to rabbit MQ
+                :subscriber, # actually does the work of subscribing to the rabbit queue
+                :handler     # actually does the work of handling the rack request/response
+
+    #--------------------------------------------------------------------------
+
+    def initialize(config, app)
+      @config     = config
+      @logger     = config.logger
+      @signals    = Signals.new
+      @lock       = Mutex.new
+      @rabbit     = Adapter.load(config.rabbit)
+      @handler    = Handler.new(app, config)
+      @subscriber = Subscriber.new(rabbit, handler, lock, config)
+    end
+
+    #--------------------------------------------------------------------------
+
+    def run
+
+      logger.info "STARTED a new worker with PID #{Process.pid}"
+
+      trap_signals
+
+      subscriber.subscribe
+
+      while true
+        sig = signals.pop   # BLOCKS until there is a signal
+        case sig
+        when :INT  then shutdown(:INT)
+        when :QUIT then shutdown(:QUIT)
+        when :TERM then shutdown(:TERM)
+        else
+          raise RuntimeError, "unknown signal #{sig}"
+        end
+      end
+
+    ensure
+      subscriber.unsubscribe
+
+    end
+
+    #--------------------------------------------------------------------------
+
+    def shutdown(sig)
+      lock.lock if sig == :QUIT # graceful shutdown should wait for any pending message handler to finish
+      logger.info "#{RackRabbit.friendly_signal(sig)} worker #{Process.pid}"
+      exit
+    end
+
+    #--------------------------------------------------------------------------
+
+    def trap_signals  # overwrite the handlers inherited from the server process
+
+      [:QUIT, :TERM, :INT].each do |sig|
+        trap(sig) do
+          signals.push(sig)
+        end
+      end
+
+      trap(:CHLD, :DEFAULT)
+      trap(:TTIN, nil)
+      trap(:TTOU, nil)
+
+    end
+
+    #--------------------------------------------------------------------------
+
+  end
+end

data/rack-rabbit.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+LIB = File.expand_path("lib", File.dirname(__FILE__))
+$LOAD_PATH.unshift LIB unless $LOAD_PATH.include?(LIB)
+
+require 'rack-rabbit'
+
+Gem::Specification.new do |s|
+
+  s.name     = "rack-rabbit"
+  s.version  = RackRabbit::VERSION
+  s.platform = Gem::Platform::RUBY
+  s.authors  = ["Jake Gordon"]
+  s.email    = ["jake@codeincomplete.com"]
+  s.homepage = "https://github.com/jakesgordon/rack-rabbit"
+  s.summary  = RackRabbit::SUMMARY
+
+  s.has_rdoc         = false
+  s.extra_rdoc_files = ["README.md"]
+  s.rdoc_options     = ["--charset=UTF-8"]
+  s.files            = `git ls-files `.split("\n")
+  s.test_files       = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables      = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths    = ["lib"]
+  s.licenses         = ["MIT"]
+
+end

data/test/apps/config.ru

@@ -0,0 +1,7 @@
+class DefaultApp
+  def self.call(env)
+    [ 200, {}, [ "Hello World" ] ]
+  end
+end
+
+run DefaultApp

data/test/apps/custom.conf

@@ -0,0 +1,27 @@
+
+rack_file "custom.ru"
+
+rabbit :host => "10.10.10.10",
+       :port => "1234",
+       :adapter => "amqp"
+
+queue "myqueue"
+exchange "myexchange"
+exchange_type "topic"
+routing_key "myroute"
+app_id "myapp"
+workers 7
+min_workers 3
+max_workers 42
+ack true
+preload_app true
+daemonize true
+logfile "myapp.log"
+pidfile "myapp.pid"
+log_level :fatal
+
+class ::MyLogger < Logger
+end
+
+logger MyLogger.new($stderr)
+

data/test/apps/custom.ru

@@ -0,0 +1,7 @@
+class CustomApp
+  def self.call(env)
+    [ 200, {}, [ "Custom App" ] ]
+  end
+end
+
+run CustomApp

data/test/apps/empty.conf

@@ -0,0 +1 @@
+# empty rack-rabbit configuration file

data/test/apps/error.ru

@@ -0,0 +1,7 @@
+class ErrorApp
+  def self.call(env)
+    raise "wtf"
+  end
+end
+
+run ErrorApp

data/test/apps/mirror.ru

@@ -0,0 +1,19 @@
+require 'json'
+
+class MirrorApp
+  def self.call(env)
+
+    request = Rack::Request.new env
+    result  = {
+      :method => request.request_method,
+      :path   => request.path_info,
+      :params => request.params,
+      :body   => request.body.read
+    }
+
+    [ 200, {}, [ result.to_json ] ]
+
+  end
+end
+
+run MirrorApp

data/test/apps/sinatra.ru

@@ -0,0 +1,37 @@
+require 'sinatra/base'
+
+class MyApp < Sinatra::Base
+
+  set :logging, nil   # skip sinatra logging middleware, use the env['rack.logger'] provided by the rack-rabbit server
+
+  get "/hello" do
+    "Hello World"
+  end
+
+  post "/submit" do
+    "Submitted #{request.body.read}"
+  end
+
+  get "/error" do
+    raise "uh oh"
+  end
+
+  get "/sleep/:seconds" do
+    slumber params[:seconds].to_i
+  end
+
+  post "/sleep/:seconds" do
+    slumber params[:seconds].to_i
+  end
+
+  def slumber(seconds)
+    seconds.times do |i|
+      logger.info "#{request.path_info} - #{i}"
+      sleep(1)
+    end
+    "Slept for #{seconds}"
+  end
+
+end
+
+run MyApp

data/test/apps/sleep.ru

@@ -0,0 +1,21 @@
+class SleepApp
+
+  def self.call(env)
+
+    request = Rack::Request.new env
+    logger  = request.logger
+    path    = request.path_info.to_s
+
+    duration = path.split("/").last.to_i
+    duration.times do |n|
+      logger.info "#{path} - #{n}"
+      sleep(1)
+    end
+
+    [ 200, {}, [ "Slept for: #{duration}" ] ]
+
+  end
+
+end
+
+run SleepApp

data/test/test_case.rb

@@ -0,0 +1,154 @@
+require 'minitest/autorun'
+require 'mocha/mini_test'
+require 'rack'
+require 'rack/builder'
+require 'ostruct'
+require 'timecop'
+require 'pp'
+
+require 'rack-rabbit'                 # top level module
+
+require 'rack-rabbit/subscriber'      # subscribes to rabbit queue/exchange and passes messages on to a handler
+require 'rack-rabbit/handler'         # converts rabbit messages to rack environments and calls a rack app to handle the request
+require 'rack-rabbit/adapter'         # abstract interface to rabbitMQ
+require 'rack-rabbit/message'         # a rabbitMQ message
+require 'rack-rabbit/response'        # a rack response
+
+require 'rack-rabbit/client'          # client code for making requests
+require 'rack-rabbit/worker'          # worker process
+require 'rack-rabbit/server'          # server process
+require 'rack-rabbit/config'          # server configuration
+require 'rack-rabbit/signals'         # process signal queue
+
+module RackRabbit
+  class TestCase < Minitest::Unit::TestCase
+
+    #--------------------------------------------------------------------------
+
+    EMPTY_CONFIG     = File.expand_path("apps/empty.conf",  File.dirname(__FILE__))
+    CUSTOM_CONFIG    = File.expand_path("apps/custom.conf", File.dirname(__FILE__))
+
+    #--------------------------------------------------------------------------
+
+    DEFAULT_RACK_APP = File.expand_path("apps/config.ru",  File.dirname(__FILE__))
+    CUSTOM_RACK_APP  = File.expand_path("apps/custom.ru",  File.dirname(__FILE__))
+    ERROR_RACK_APP   = File.expand_path("apps/error.ru",   File.dirname(__FILE__))
+    MIRROR_RACK_APP  = File.expand_path("apps/mirror.ru",  File.dirname(__FILE__))
+
+    #--------------------------------------------------------------------------
+
+    APP_ID           = "app.id"
+    DELIVERY_TAG     = "delivery.tag"
+    REPLY_TO         = "reply.queue"
+    CORRELATION_ID   = "correlation.id"
+    QUEUE            = "my.queue"
+    REPLY_QUEUE      = "reply.queue"
+    EXCHANGE         = "my.exchange"
+    ROUTE            = "my.route"
+    BODY             = "body"
+    PATH             = "/foo/bar"
+    QUERY            = "a=b&c=d"
+    URI              = "#{PATH}?#{QUERY}"
+    PRIORITY         = 7
+
+    module CONTENT
+      ASCII                = "iso-8859-1"
+      UTF8                 = "utf-8"
+      PLAIN_TEXT           = "text/plain"
+      PLAIN_TEXT_UTF8      = "text/plain; charset=\"utf-8\""
+      FORM_URLENCODED      = "application/x-www-form-urlencoded"
+      FORM_URLENCODED_UTF8 = "application/x-www-form-urlencoded; charset=\"utf-8\""
+      JSON                 = "application/json"
+      JSON_UTF8            = "application/json; charset=\"utf-8\""
+      JSON_ASCII           = "application/json; charset=\"iso-8859-1\""
+    end
+
+    #--------------------------------------------------------------------------
+
+    NullLogger = Rack::NullLogger.new($stdout)
+
+    #--------------------------------------------------------------------------
+
+    def default_config
+      build_config( :rabbit => nil, :logger => nil )   # special case for select tests that want TRUE defaults (not the :mock adapter or NullLogger needed in 80% of other tests)
+    end
+
+    def build_config(options = {})
+      Config.new({
+        :validate  => false,                   # skip validation for most tests
+        :rack_file => DEFAULT_RACK_APP,        # required - so default to sample app
+        :rabbit    => { :adapter => :mock },   # use RackRabbit::Adapter::Mock to mock out rabbit MQ
+        :logger    => NullLogger               # suppress logging during tests
+      }.merge(options))
+    end
+
+    def build_client(options = {})
+      Client.new({ :adapter => :mock }.merge(options))
+    end
+
+    def build_message(options = {})
+      options[:headers] ||= {}
+      options[:headers][RackRabbit::HEADER::METHOD] ||= options.delete(:method)  # convenience to make calling code a little more compact
+      options[:headers][RackRabbit::HEADER::PATH]   ||= options.delete(:path)    # (ditto)
+      options[:headers][RackRabbit::HEADER::STATUS] ||= options.delete(:status)  # (ditto)
+      Message.new(options[:delivery_tag], OpenStruct.new(options), options[:body], options[:rabbit] || build_rabbit)
+    end
+
+    def build_response(status, body, headers = {})
+      headers ||= {}
+      headers[RackRabbit::HEADER::CONTENT_TYPE]     ||= headers.delete(:content_type)     # convenience to make calling code a little more compact
+      headers[RackRabbit::HEADER::CONTENT_ENCODING] ||= headers.delete(:content_encoding) # (ditto)
+      Response.new(status, headers, body)
+    end
+
+    def build_app(rack_file)
+      Rack::Builder.parse_file(rack_file)[0]
+    end
+
+    def build_handler(options = {})
+      config = options[:config] || build_config(options)
+      app    = options[:app]    || build_app(config.rack_file)
+      Handler.new(app, config)
+    end
+
+    def build_subscriber(options = {})
+      rabbit  = options[:rabbit]  || build_rabbit(options)
+      config  = options[:config]  || build_config(options)
+      handler = options[:handler] || build_handler(options.merge(:config => config))
+      Subscriber.new(rabbit, handler, Mutex.new, handler.config)
+    end
+
+    def build_rabbit(options = {})
+      Adapter.load({ :adapter => :mock }.merge(options))
+    end
+
+    #--------------------------------------------------------------------------
+
+    def assert_raises_argument_error(message = nil, &block)
+      e = assert_raises(ArgumentError, &block)
+      assert_match(/#{message}/, e.message) unless message.nil?
+    end
+
+    #--------------------------------------------------------------------------
+
+    def measure
+      start  = Time.now
+      yield
+      finish = Time.now
+      finish - start
+    end
+
+    #--------------------------------------------------------------------------
+
+    def with_program_name(name)
+      original = $PROGRAM_NAME
+      $PROGRAM_NAME = name
+      yield
+    ensure
+      $PROGRAM_NAME = original
+    end
+
+    #--------------------------------------------------------------------------
+
+  end
+end