rack-rabbit 0.5.0

data/lib/rack-rabbit/adapter/bunny.rb

@@ -0,0 +1,87 @@
+begin
+  require 'bunny'
+rescue LoadError
+  abort "missing 'bunny' gem"
+end
+
+module RackRabbit
+  class Adapter
+    class Bunny < RackRabbit::Adapter
+
+      attr_accessor :connection, :channel
+
+      def connect
+        return if connected?
+        @connection = ::Bunny.new(connection_options)
+        connection.start
+        @channel = connection.create_channel
+        channel.prefetch(1)
+      end
+
+      def disconnect
+        channel.close unless channel.nil?
+        connection.close unless connection.nil?
+      end
+
+      def connected?
+        !@connection.nil?
+      end
+
+      def subscribe(options = {}, &block)
+        queue    = get_queue(options.delete(:queue)) || channel.queue("", :exclusive => true)
+        exchange = get_exchange(options.delete(:exchange), options.delete(:exchange_type))
+        if exchange
+          queue.bind(exchange, :routing_key => options.delete(:routing_key))
+        end
+        queue.subscribe(options) do |delivery_info, properties, payload|
+          yield Message.new(delivery_info.delivery_tag, properties, payload, self)
+        end
+      end
+
+      def publish(payload, properties)
+        exchange = get_exchange(properties.delete(:exchange), properties.delete(:exchange_type))
+        exchange ||= channel.default_exchange
+        exchange.publish(payload || "", properties)
+      end
+
+      def with_reply_queue(&block)
+        yield channel.queue("", :exclusive => true, :auto_delete => true)
+      end
+
+      def ack(delivery_tag)
+        channel.acknowledge(delivery_tag, false)
+      end
+
+      def reject(delivery_tag)
+        channel.reject(delivery_tag, false)
+      end
+
+      #========================================================================
+      # PRIVATE IMPLEMENTATION
+      #========================================================================
+
+      private
+
+      def get_exchange(ex = :default, type = :direct)
+        case ex
+        when ::Bunny::Exchange then ex
+        when Symbol, String    then channel.send(type || :direct, ex) unless ex.to_s.downcase.to_sym == :default
+        else
+          nil
+        end
+      end
+
+      def get_queue(q)
+        case q
+        when ::Bunny::Queue then q
+        when Symbol, String then channel.queue(q)
+        else
+          nil
+        end
+      end
+
+      #------------------------------------------------------------------------
+
+    end # class Bunny
+  end # module Adapter
+end # module RackRabbit

data/lib/rack-rabbit/adapter/mock.rb

@@ -0,0 +1,92 @@
+module RackRabbit
+  class Adapter
+    class Mock < RackRabbit::Adapter
+
+      attr_accessor :connection
+
+      def startup
+        @started = true
+      end
+
+      def shutdown
+        @started = false
+      end
+
+      def started?
+        !!@started
+      end
+
+      def connect
+        @connected = true
+      end
+
+      def disconnect
+        @connected = false
+      end
+
+      def connected?
+        !!@connected
+      end
+
+      def subscribe(options = {}, &block)
+        @subscribe_options = options
+        while !queue.empty?
+          message = queue.shift
+          yield message
+          subscribed_messages << message
+        end
+      end
+
+      def publish(body, properties)
+        published_messages << properties.merge(:body => body)
+      end
+
+      def with_reply_queue(&block)
+        yield OpenStruct.new :name => "reply.queue"
+      end
+
+      def ack(delivery_tag)
+        acked_messages << delivery_tag
+      end
+
+      def reject(delivery_tag)
+        rejected_messages << delivery_tag 
+      end
+
+      #========================================================================
+      # TEST HELPER METHODS
+      #========================================================================
+
+      def acked_messages
+        @acked_messages ||= []
+      end
+
+      def rejected_messages
+        @rejected_messages ||= []
+      end
+
+      def published_messages
+        @published_messages ||= []
+      end
+
+      def subscribed_messages
+        @subscribed_messages ||= []
+      end
+
+      def queue
+        @queue ||= []
+      end
+
+      def prime(message)
+        queue << message
+      end
+
+      def subscribe_options
+        @subscribe_options
+      end
+
+    end
+
+  end
+end
+

data/lib/rack-rabbit/client.rb

@@ -0,0 +1,181 @@
+require 'securerandom'
+
+require 'rack-rabbit'
+require 'rack-rabbit/adapter'
+require 'rack-rabbit/message'
+require 'rack-rabbit/response'
+
+module RackRabbit
+  class Client
+
+    #--------------------------------------------------------------------------
+
+    attr_reader :rabbit
+
+    def initialize(options = nil)
+      @rabbit = Adapter.load(DEFAULT_RABBIT.merge(options || {}))
+      connect
+    end
+
+    #--------------------------------------------------------------------------
+
+    def connect
+      rabbit.connect
+    end
+
+    def disconnect
+      rabbit.disconnect
+    end
+
+    #--------------------------------------------------------------------------
+
+    def get(queue, path, options = {})
+      request(queue, path, "", options.merge(:method => :GET))
+    end
+
+    def post(queue, path, body, options = {})
+      request(queue, path, body, options.merge(:method => :POST))
+    end
+
+    def put(queue, path, body, options = {})
+      request(queue, path, body, options.merge(:method => :PUT))
+    end
+
+    def delete(queue, path, options = {})
+      request(queue, path, "", options.merge(:method => :DELETE))
+    end
+
+    #--------------------------------------------------------------------------
+
+    def request(queue, path, body, options = {})
+
+      id        = options[:id] || SecureRandom.uuid    # allow dependency injection for test purposes
+      lock      = Mutex.new
+      condition = ConditionVariable.new
+      method    = options[:method]  || :GET
+      headers   = options[:headers] || {}
+      response  = nil
+
+      rabbit.with_reply_queue do |reply_queue|
+
+        rabbit.subscribe(:queue => reply_queue) do |message|
+          if message.correlation_id == id
+            lock.synchronize do
+              response = Response.new(message.status, message.headers, message.body)
+              condition.signal
+            end
+          end
+        end
+
+        rabbit.publish(body,
+          :correlation_id   => id,
+          :routing_key      => queue,
+          :reply_to         => reply_queue.name,
+          :priority         => options[:priority],
+          :content_type     => options[:content_type]     || default_content_type,
+          :content_encoding => options[:content_encoding] || default_content_encoding,
+          :timestamp        => options[:timestamp]        || default_timestamp,
+          :headers          => headers.merge({
+            RackRabbit::HEADER::METHOD => method.to_s.upcase,
+            RackRabbit::HEADER::PATH   => path
+          })
+        )
+
+      end
+
+      lock.synchronize do
+        condition.wait(lock) unless response
+      end
+
+      response
+
+    end
+
+    #--------------------------------------------------------------------------
+
+    def enqueue(queue, path, body, options = {})
+
+      method  = options[:method]  || :POST
+      headers = options[:headers] || {}
+
+      rabbit.publish(body,
+        :routing_key      => queue,
+        :priority         => options[:priority],
+        :content_type     => options[:content_type]     || default_content_type,
+        :content_encoding => options[:content_encoding] || default_content_encoding,
+        :timestamp        => options[:timestamp]        || default_timestamp,
+        :headers          => headers.merge({
+          RackRabbit::HEADER::METHOD => method.to_s.upcase,
+          RackRabbit::HEADER::PATH   => path
+        })
+      )
+
+      true
+
+    end
+
+    #--------------------------------------------------------------------------
+
+    def publish(exchange, path, body, options = {})
+
+      method  = options[:method]  || :POST
+      headers = options[:headers] || {}
+
+      rabbit.publish(body,
+        :exchange         => exchange,
+        :exchange_type    => options[:exchange_type] || options[:type] || :fanout,
+        :routing_key      => options[:routing_key]   || options[:route],
+        :priority         => options[:priority],
+        :content_type     => options[:content_type]     || default_content_type,
+        :content_encoding => options[:content_encoding] || default_content_encoding,
+        :timestamp        => options[:timestamp]        || default_timestamp,
+        :headers          => headers.merge({
+          RackRabbit::HEADER::METHOD => method.to_s.upcase,
+          RackRabbit::HEADER::PATH   => path
+        })
+      )
+
+      true
+
+    end
+    #--------------------------------------------------------------------------
+
+    def default_content_type
+      'text/plain'
+    end
+
+    def default_content_encoding
+      'utf-8'
+    end
+
+    def default_timestamp
+      Time.now.to_i
+    end
+
+    #--------------------------------------------------------------------------
+
+    def self.define_class_method_for(method_name)
+      define_singleton_method(method_name) do |*params|
+        options  = params.last.is_a?(Hash) ? params.pop : {}
+        client   = Client.new(options.delete(:rabbit))
+        response = client.send(method_name, *params, options)
+        client.disconnect
+        response
+      end
+    end
+
+    define_class_method_for :get
+    define_class_method_for :post
+    define_class_method_for :put
+    define_class_method_for :delete
+    define_class_method_for :request
+    define_class_method_for :enqueue
+    define_class_method_for :publish
+
+    #--------------------------------------------------------------------------
+
+  end
+end
+
+RR = RackRabbit::Client   # much less typing for client applications
+

data/lib/rack-rabbit/config.rb

@@ -0,0 +1,260 @@
+require 'logger'
+require 'rack'
+
+require 'rack-rabbit'
+
+module RackRabbit
+  class Config
+
+    #--------------------------------------------------------------------------
+
+    def initialize(options = {})
+      @values = {}
+      options.each{|key, value| send(key, value) if respond_to?(key)}
+      reload(options)
+    end
+
+    def reload(options = {})
+      @rack_env = nil
+      instance_eval(File.read(config_file), config_file) if config_file && File.exists?(config_file)
+      validate(options) unless options[:validate] == false
+    end
+
+    #--------------------------------------------------------------------------
+
+    def rabbit(value = :missing)
+      if value == :missing
+        values[:rabbit] ||= {}.merge(DEFAULT_RABBIT)
+      elsif value.is_a?(Hash)
+        rabbit.merge!(value)
+      end
+    end
+
+    def config_file(value = :missing)
+      if value == :missing
+        values[:config_file]
+      else
+        values[:config_file] = filename(value)
+      end
+    end
+
+    def rack_file(value = :missing)
+      if value == :missing
+        values[:rack_file] ||= filename("config.ru", File.dirname(config_file || ""))
+      else
+        values[:rack_file] = filename(value, File.dirname(config_file || ""))
+      end
+    end
+
+    def queue(value = :missing)
+      if value == :missing
+        values[:queue]
+      else
+        values[:queue] = value
+      end
+    end
+
+    def exchange(value = :missing)
+      if value == :missing
+        values[:exchange]
+      else
+        values[:exchange] = value
+      end
+    end
+
+    def exchange_type(value = :missing)
+      if value == :missing
+        values[:exchange_type] ||= :direct
+      else
+        values[:exchange_type] = value.to_s.downcase.to_sym
+      end
+    end
+
+    def routing_key(value = :missing)
+      if value == :missing
+        values[:routing_key]
+      else
+        values[:routing_key] = value
+      end
+    end
+
+    def app_id(value = :missing)
+      if value == :missing
+        values[:app_id] ||= "rr-#{exchange || 'default'}-#{queue || routing_key || 'null'}"
+      else
+        values[:app_id] = value
+      end
+    end
+
+    def workers(value = :missing)
+      if value == :missing
+        values[:workers] ||= 1
+      else
+        values[:workers] = value.to_i
+      end
+    end
+
+    def min_workers(value = :missing)
+      if value == :missing
+        values[:min_workers] ||= 1
+      else
+        values[:min_workers] = value.to_i
+      end
+    end
+
+    def max_workers(value = :missing)
+      if value == :missing
+        values[:max_workers] ||= 32
+      else
+        values[:max_workers] = value.to_i
+      end
+    end
+
+    def ack(value = :missing)
+      if value == :missing
+        values[:ack]
+      else
+        values[:ack] = !!value
+      end
+    end
+
+    def preload_app(value = :missing)
+      if value == :missing
+        values[:preload_app]
+      else
+        values[:preload_app] = !!value
+      end
+    end
+
+    def daemonize(value = :missing)
+      if value == :missing
+        values[:daemonize]
+      else
+        values[:daemonize] = !!value
+      end
+    end
+
+    def log_level(value = :missing)
+      if value == :missing
+        values[:log_level] ||= :info
+      else
+        values[:log_level] = symbolize(value)
+      end
+    end
+
+    def logger(value = :missing)
+      if value == :missing
+        values[:logger] ||= build_default_logger
+      else
+        values[:logger] = value
+      end
+    end
+
+    def logfile(value = :missing)
+      if value == :missing
+        values[:logfile] ||= daemonize ? "/var/log/#{app_id}.log" : nil
+      else
+        values[:logfile] = filename(value)
+      end
+    end
+
+    def pidfile(value = :missing)
+      if value == :missing
+        values[:pidfile] ||= daemonize ? "/var/run/#{app_id}.pid" : nil
+      else
+        values[:pidfile] = filename(value)
+      end
+    end
+
+    def before_fork(server=nil, &block)
+      if block
+        values[:before_fork] = block
+      elsif values[:before_fork].respond_to?(:call)
+        values[:before_fork].call(server)
+      end
+    end
+
+    def after_fork(server=nil, worker=nil, &block)
+      if block
+        values[:after_fork] = block
+      elsif values[:after_fork].respond_to?(:call)
+        values[:after_fork].call(server, worker)
+      end
+    end
+
+    #--------------------------------------------------------------------------
+
+    def rack_env
+      @rack_env ||= {
+        'rack.version'      => Rack::VERSION,
+        'rack.logger'       => logger,
+        'rack.errors'       => $stderr,
+        'rack.multithread'  => false,
+        'rack.multiprocess' => true,
+        'rack.run_once'     => false,
+        'rack.url_scheme'   => 'http',
+        'SERVER_NAME'       => app_id
+      }
+    end
+
+    #--------------------------------------------------------------------------
+
+    private
+
+    attr_reader :values
+
+    def filename(path, relative_to = nil)
+      File.expand_path(path, relative_to)
+    end
+
+    def symbolize(s)
+      s.to_s.downcase.to_sym
+    end
+
+    def validate(options = {})
+
+      raise ArgumentError, "must provide EITHER a :queue OR an :exchange to subscribe to" if queue.nil? && exchange.nil?
+      raise ArgumentError, "missing app_id" if app_id.to_s.empty?
+      raise ArgumentError, "invalid workers" unless workers.is_a?(Fixnum)
+      raise ArgumentError, "invalid min_workers" unless min_workers.is_a?(Fixnum)
+      raise ArgumentError, "invalid max_workers" unless max_workers.is_a?(Fixnum)
+      raise ArgumentError, "invalid workers < min_workers" if workers < min_workers
+      raise ArgumentError, "invalid workers > max_workers" if workers > max_workers
+      raise ArgumentError, "invalid min_workers > max_workers" if min_workers > max_workers
+      raise ArgumentError, "invalid logger" unless [:fatal, :error, :warn, :info, :debug].all?{|method| logger.respond_to?(method)}
+      raise ArgumentError, "missing pidfile - required for daemon" if daemonize && pidfile.to_s.empty?
+      raise ArgumentError, "missing logfile - required for daemon" if daemonize && logfile.to_s.empty?
+
+      unless options[:skip_filesystem_checks]
+        raise ArgumentError, "missing rack config file #{rack_file}" unless File.readable?(rack_file)
+        raise ArgumentError, "pidfile not writable" if pidfile && !File.writable?(File.dirname(pidfile))
+        raise ArgumentError, "logfile not writable" if logfile && !File.writable?(File.dirname(logfile))
+      end
+
+    end
+
+    def build_default_logger
+      logger = Logger.new($stderr)
+      class << logger
+        attr_accessor :master_pid   # track the master_pid (might change if we daemonize) in order to differentiate between "SERVER" vs "worker" in log entry preamble
+      end
+      logger.master_pid = $$
+      logger.formatter = proc do |severity, datetime, progname, msg|
+        "[#{Process.pid}:#{$$ == logger.master_pid ? "SERVER" : "worker"}] #{datetime} #{msg}\n"
+      end
+      logger.level = case log_level.to_s.downcase.to_sym 
+                     when :fatal then Logger::FATAL
+                     when :error then Logger::ERROR
+                     when :warn  then Logger::WARN
+                     when :info  then Logger::INFO
+                     when :debug then Logger::DEBUG
+                     else
+                       Logger::INFO
+                     end
+      logger
+    end
+
+    #--------------------------------------------------------------------------
+
+  end # class Config
+end # module RackRabbit