liebre 0.1.3

data/lib/liebre/config.rb

@@ -0,0 +1,48 @@
+require "yaml"
+
+module Liebre
+  class Config
+
+    CONFIG_PATH = File.expand_path("config/liebre.yml")
+    CONNECTION_PATH = File.expand_path("config/rabbitmq.yml")
+    DEFAULT_LOGGER = Logger.new STDOUT
+    DEFAULT_RPC_TIMEOUT = 5
+    
+    class << self
+      attr_accessor :env
+      attr_writer :config_path, :connection_path, :logger
+      
+      def config_path
+        @config_path || CONFIG_PATH
+      end
+      
+      def connection_path
+        @connection_path || CONNECTION_PATH
+      end
+      
+      def logger
+        @logger || DEFAULT_LOGGER
+      end
+      
+    end
+    
+    def consumers
+      config.fetch 'consumers', {}
+    end
+    
+    def publishers
+      config.fetch 'publishers', {}
+    end
+    
+    def rpc_request_timeout
+      config.fetch 'rpc_request_timeout', DEFAULT_RPC_TIMEOUT
+    end
+
+    private
+
+    def config
+      @config ||= YAML.load_file self.class.config_path
+    end
+
+  end
+end

data/lib/liebre/connection_manager.rb

@@ -0,0 +1,64 @@
+require "yaml"
+require "bunny"
+
+module Liebre
+  class ConnectionManager
+
+    def initialize path = Liebre::Config.connection_path
+      @path = path
+      @connections = {}
+    end
+
+    def start
+      initialize_connections
+      connections.each do |_, bunny|
+        bunny.start
+      end
+    end
+    
+    def ensure_started
+      all_open = !@connections.empty? and @connections.all? do |_, bunny|
+        bunny.open?
+      end
+      restart unless all_open
+    end
+
+    def restart
+      stop
+      start
+    end
+
+    def get connection_name
+      connections[connection_name.to_sym]
+    end
+
+    def stop
+      connections.each do |_, bunny|
+        if bunny and bunny.open?
+          bunny.close
+        end
+      end
+      connections.clear
+    end
+
+    private
+    
+    def initialize_connections
+      config.each do |name, conf|
+        @connections[name.to_sym] = connection_for(conf)
+      end
+    end
+
+    def connection_for config
+      Bunny.new(config)
+    end
+
+    def config
+      result = YAML.load_file(path)
+      Liebre.env ? result.fetch(Liebre.env) : result
+    end
+
+    attr_reader :path, :connections
+
+  end
+end

data/lib/liebre/publisher.rb

@@ -0,0 +1,88 @@
+module Liebre
+  class Publisher
+    
+    def initialize publisher_name
+      @publisher_name = publisher_name
+    end
+    
+    def enqueue message, options = {}
+      with_connection do
+        exchange.publish message, options
+      end
+    end
+    
+    def enqueue_and_wait message, options = {}
+      result = nil
+      with_connection do
+        begin
+          correlation_id = options[:correlation_id] ||= generate_uuid
+          reply_queue = reply_queue correlation_id
+          options[:reply_to] = reply_queue.name
+          exchange.publish message, options
+          Timeout::timeout(Liebre.config.rpc_request_timeout) do
+            reply_queue.subscribe(:block => true) do |delivery_info, meta, payload|
+              if meta[:correlation_id] == correlation_id
+                result = payload
+                channel.consumers[delivery_info.consumer_tag].cancel
+              end
+            end
+          end
+        rescue Timeout::Error
+          #do nothing
+        ensure
+          reply_queue.delete
+        end
+      end
+      result
+    end
+    
+    alias_method :rpc, :enqueue_and_wait
+    
+    private
+    
+    def with_connection
+      connection_manager.ensure_started
+      yield
+    end
+    
+    def reply_queue correlation_id
+      queue_name = "#{publisher_name}_callback_#{correlation_id}"
+      channel.queue queue_name, :exclusive => true
+    end
+    
+    def exchange
+      Liebre::Common::Utils.create_exchange channel, exchange_config
+    end
+    
+    def channel
+      @channel ||= connection_manager.get(connection_name).create_channel
+    end
+    
+    def publishers
+      Liebre.config.publishers
+    end
+
+    def exchange_config
+      config.fetch("exchange")
+    end
+    
+    def config
+      publishers.fetch publisher_name
+    end
+      
+    def connection_name
+      config.fetch('connection_name', 'default').to_sym
+    end
+
+    def connection_manager
+      @connection_manager ||= ConnectionManager.new
+    end
+    
+    def generate_uuid
+      SecureRandom.uuid
+    end
+    
+    attr_reader :publisher_name
+
+  end
+end

data/lib/liebre/runner.rb

@@ -0,0 +1,59 @@
+module Liebre
+  class Runner
+    
+    autoload :Consumers, 'liebre/runner/consumers'
+    autoload :Starter,   'liebre/runner/starter'
+    
+    RETRY_INTERVAL = 5
+
+    def initialize retry_interval = RETRY_INTERVAL
+      @retry_interval = retry_interval
+    end
+
+    def start
+      setup_shutdown
+      conn_manager.restart
+      start_consumers
+      sleep
+    rescue StandardError => e
+      log_and_wait(e)
+      retry
+    end
+
+  private
+
+    def setup_shutdown
+      Signal.trap("TERM") { do_shutdown; exit }
+    end
+
+    def do_shutdown
+      Thread.start do
+        logger.info("Closing AMQP connection...")
+        conn_manager.stop
+        logger.info("AMQP connection closed")
+      end.join
+    end
+
+    def start_consumers
+      consumers = Consumers.new(conn_manager)
+      consumers.start_all
+    end
+
+    def log_and_wait e
+      logger.warn(e)
+      sleep(retry_interval)
+      logger.warn("Retrying connection")
+    end
+
+    def logger
+      Liebre.logger
+    end
+
+    def conn_manager
+      @conn_manager ||= ConnectionManager.new
+    end
+
+    attr_reader :retry_interval
+
+  end
+end

data/lib/liebre/runner/consumers.rb

@@ -0,0 +1,36 @@
+module Liebre
+  class Runner
+    class Consumers
+
+      def initialize connection_manager
+        @connection_manager = connection_manager
+      end
+    
+      def consumer_names
+        consumers.keys
+      end
+
+      def start_all
+        consumer_names.each { |name| start(name) }
+      end
+
+      def start name
+        params = consumers.fetch(name)
+        num_threads = params.fetch("num_threads", 1)
+        num_threads.times do
+          starter = Starter.new(connection_manager, params)
+          starter.call
+        end
+      end
+
+      private
+
+      def consumers
+        Liebre.config.consumers
+      end
+
+      attr_reader :connection_manager
+
+    end
+  end
+end

data/lib/liebre/runner/starter.rb

@@ -0,0 +1,40 @@
+module Liebre
+  class Runner
+    class Starter
+      
+      autoload :Consumer,  'liebre/runner/starter/consumer'
+      autoload :Resources, 'liebre/runner/starter/resources'
+      autoload :RPC,       'liebre/runner/starter/rpc'
+
+      def initialize connection_manager, config
+        @connection_manager = connection_manager
+        @config = config
+      end
+
+      def call
+        consumer_class.new(connection, config).call
+      end
+
+      private
+      
+      def consumer_class
+        is_rpc? ? RPC : Consumer
+      end
+    
+      def is_rpc?
+        config.fetch("rpc", false)
+      end
+      
+      def connection
+        connection_manager.get connection_name
+      end
+      
+      def connection_name
+        config.fetch('connection_name', 'default').to_sym
+      end
+
+      attr_reader :connection_manager, :config
+
+    end
+  end
+end

data/lib/liebre/runner/starter/consumer.rb

@@ -0,0 +1,91 @@
+module Liebre
+  class Runner
+    class Starter
+      class Consumer
+        
+        autoload :Handler,   "liebre/runner/starter/consumer/handler"
+
+        def initialize connection, config
+          @connection = connection
+          @config = config
+        end
+
+        def call
+          initialize_error_queue
+          initialize_queue
+        end
+        
+        private
+        
+        def initialize_queue
+          queue.subscribe(:manual_ack => true) do |info, meta, payload|
+            begin
+              logger.debug "Received message for #{klass.name}: #{payload} - #{meta}"
+              consumer = klass.new(payload, meta)
+              response = consumer.call
+              handler.respond response, info
+            rescue => e
+              logger.error e.inspect
+              logger.error e.backtrace.join("\n")
+              handler.respond :error, info
+            end
+          end
+        end
+        
+        def initialize_error_queue
+          Resources.new(connection, error_config).queue
+        end
+        
+        def klass
+          @klass ||= Kernel.const_get config.fetch("class_name")
+        end
+        
+        def handler
+          @handler ||= Handler.new(channel)
+        end
+        
+        def channel
+          resources.channel
+        end
+
+        def exchange
+          resources.exchange
+        end
+
+        def queue
+          resources.queue
+        end
+
+        def resources
+          @resources ||= Resources.new(connection, parse_config)
+        end
+        
+        def parse_config
+          result = clone_hash config
+          result['queue']['opts']['arguments'] ||= {}
+          result['queue']['opts']['arguments']['x-dead-letter-exchange'] = result['exchange']['name'] + "-error"
+          result
+        end
+        
+        def error_config
+          result = clone_hash config
+          result['exchange']['name'] += "-error"
+          result['queue']['name'] += "-error"
+          result['queue']['opts']['exclusive'] = true
+          result
+        end
+        
+        def logger
+          Liebre::Config.logger
+        end
+        
+        def clone_hash hash
+          Marshal.load(Marshal.dump(hash))
+        end
+
+        attr_reader :connection, :config
+        
+      end
+    end
+  end
+end

data/lib/liebre/runner/starter/consumer/handler.rb

@@ -0,0 +1,35 @@
+module Liebre
+  class Runner
+    class Starter
+      class Consumer
+        class Handler
+
+          def initialize channel
+            @channel = channel
+          end
+          
+          def respond action, meta
+            send(action, meta.delivery_tag)
+          end
+
+          private
+          
+          def ack delivery_tag
+            channel.acknowledge delivery_tag
+          end
+          
+          def reject delivery_tag
+            channel.reject delivery_tag, true
+          end
+          
+          def error delivery_tag
+            channel.reject delivery_tag, false            
+          end
+
+          attr_reader :channel
+        
+        end
+      end
+    end
+  end
+end