liebre 0.1.21 → 0.2.1

data/lib/liebre/publisher.rb

@@ -1,113 +0,0 @@
-module Liebre
-  class Publisher
-    
-    def initialize publisher_name
-      @publisher_name = publisher_name
-    end
-    
-    def enqueue message, options = {}
-      with_connection do
-        exchange = exchange_for default_channel
-        logger.debug "Liebre# Publishing '#{message}' with '#{options}' to exchange: #{exchange.name}"
-        exchange.publish message, options
-      end
-    end
-    
-    def enqueue_and_wait message, options = {}
-      result = nil
-      with_rpc_channel do |channel|
-        correlation_id = options[:correlation_id] ||= generate_uuid
-        reply_queue = reply_queue channel, correlation_id
-        options[:reply_to] = reply_queue.name
-        reply_queue.subscribe(:block => false) do |delivery_info, meta, payload|
-          if meta[:correlation_id] == correlation_id
-            result = payload
-            logger.debug "Liebre# Received response '#{result}'"
-            channel.consumers[delivery_info.consumer_tag].cancel
-          end
-        end
-        exchange = exchange_for channel
-        logger.debug "Liebre# Publishing '#{message}' with '#{options}' to exchange: #{exchange.name}"
-        exchange.publish message, options
-        begin
-          Timeout.timeout(Liebre.config.rpc_request_timeout) do
-            sleep 0.01 while result.nil?
-          end
-        rescue Timeout::Error
-          #do nothing
-        end
-      end
-      result
-    end
-    
-    alias_method :rpc, :enqueue_and_wait
-    
-    private
-    
-    def with_connection
-      connection_manager.ensure_started
-      begin
-        yield
-      rescue Bunny::Exception => e
-        logger.warn("#{self.class.name}: #{e.class} found restarting connection - #{e.message}")
-        connection_manager.restart
-        retry
-      end
-    end
-    
-    def with_rpc_channel
-      with_connection do
-        Common::Utils.mutex_sync do
-          channel = connection_manager.get(connection_name).create_channel
-          channel.prefetch 1
-          yield(channel)
-          channel.close
-        end
-      end
-    end
-    
-    def default_channel
-      @default_channel ||= connection_manager.channel_for(connection_name)
-    end
-    
-    def reply_queue channel, correlation_id
-      queue_name = "#{publisher_name}_callback_#{correlation_id}"
-      channel.queue queue_name, :exclusive => true, :auto_delete => true
-    end
-    
-    def exchange_for channel 
-      Liebre::Common::Utils.create_exchange channel, exchange_config
-    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.instance
-    end
-    
-    def generate_uuid
-      SecureRandom.uuid
-    end
-        
-    def logger
-      Liebre::Config.logger
-    end
-    
-    attr_reader :publisher_name
-
-  end
-end

data/lib/liebre/runner/consumers.rb

@@ -1,46 +0,0 @@
-module Liebre
-  class Runner
-    class Consumers
-
-      def initialize connection_manager
-        @connection_manager = connection_manager
-        @threads = []
-      end
-    
-      def consumer_names
-        consumers.keys
-      end
-
-      def start_all
-        consumer_names.each do |name|
-          start(name)
-        end
-      end
-      
-      def stop
-        threads.each do |starter| 
-          starter.stop
-        end
-      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.start
-          threads << starter
-        end
-      end
-
-      private
-
-      def consumers
-        Liebre.config.consumers
-      end
-
-      attr_reader :connection_manager, :threads
-
-    end
-  end
-end

data/lib/liebre/runner/starter.rb

@@ -1,44 +0,0 @@
-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 start
-       @consumer = consumer_class.new(connection, config).start
-      end
-      
-      def stop
-        @consumer.cancel
-      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

@@ -1,129 +0,0 @@
-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 start
-          initialize_error_queue
-          initialize_queue
-        end
-        
-        def stop
-          if @consumer
-            @consumer.cancel
-            channel.close
-          end
-        end
-        
-        protected
-        
-        def call_consumer payload, meta
-          consumer = klass.new(payload, meta)
-          consumer.call
-        end
-
-        private
-
-        def initialize_queue
-          @consumer = queue.subscribe(:manual_ack => true) do |info, meta, payload|
-            response = :reject
-            debug_string = ""
-            elapsed_time = nil
-            begin
-              debug_string = "Liebre# Received message for #{klass.name}(#{queue.name}): #{payload} - #{meta}"
-              start_at = Time.now
-              response = call_consumer(payload, meta)
-              elapsed_time = (Time.now - start_at).to_f * 1000
-            rescue StandardError => e
-              response = :error
-              logger.error error_string(e, payload, meta)
-            rescue Exception => e
-              response = :error
-              logger.error error_string(e, payload, meta)
-              handler.respond response, info
-              raise e
-            ensure
-              debug_string += "\nLiebre# Responding with #{response}"
-              log_result debug_string, elapsed_time
-              handler.respond response, info
-            end
-          end
-        end
-        
-        def log_result debug_string, elapsed_time
-          time_string = "\nLiebre# Elapsed time #{elapsed_time} ms"
-          if logger.debug?
-            logger.debug debug_string + time_string
-          else
-            logger.info "Liebre# Received message for #{klass.name}(#{queue.name})" + time_string
-          end
-        end
-        
-        def error_string error, payload, meta
-          "Liebre# Error while processing #{klass.name}(#{queue.name}): #{payload} - #{meta}" + 
-            "\n" + error.inspect + "\n" + error.backtrace.join("\n")
-        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
-        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

@@ -1,35 +0,0 @@
-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

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

@@ -1,45 +0,0 @@
-module Liebre
-  class Runner
-    class Starter
-      class Resources
-        autoload :QueueBuilder, "liebre/runner/starter/resources/queue_builder"
-
-        def initialize connection, config
-          @connection   = connection
-          @config = config
-        end
-
-        def exchange
-          @exchange ||= queue_builder.exchange
-        end
-
-        def queue
-          @queue ||= queue_builder.queue
-        end
-
-        def channel
-          @channel ||= connection.create_channel(nil, pool_size).tap do |channel|
-            channel.prefetch(prefetch_count)
-          end
-        end
-
-        private
-
-        def queue_builder
-          @queue_bilder ||= QueueBuilder.new(channel, config)
-        end
-
-        def prefetch_count
-          config.fetch("prefetch_count", 10)
-        end
-
-        def pool_size
-          config.fetch("pool_size", 1)
-        end
-
-        attr_reader :connection, :config
-
-      end
-    end
-  end
-end

data/lib/liebre/runner/starter/resources/queue_builder.rb

@@ -1,63 +0,0 @@
-module Liebre
-  class Runner
-    class Starter
-      class Resources
-        class QueueBuilder
-
-          def initialize channel, config
-            @channel = channel
-            @config  = config
-          end
-
-          def queue
-            q = channel.queue(queue_name, queue_opts)
-            if routing_keys.any?
-              routing_keys.each do |key|
-                q.bind(exchange, bind_opts.merge(:routing_key => key))
-              end
-            else
-              q.bind(exchange, bind_opts)
-            end
-            q
-          end
-
-          def exchange
-            Liebre::Common::Utils.create_exchange channel, exchange_config
-          end
-
-          private
-
-          def queue_name
-            queue_config.fetch("name")
-          end
-
-          def queue_opts
-            Liebre::Common::Utils.symbolize_keys queue_config.fetch("opts", {})
-          end
-
-          def exchange_config
-            config.fetch("exchange")
-          end
-
-          def queue_config
-            config.fetch("queue")
-          end
-          
-          def routing_keys
-            @routing_keys ||= begin
-              bind_opts[:routing_key] = [*bind_opts[:routing_key]]
-              bind_opts.delete :routing_key
-            end
-          end
-
-          def bind_opts
-            @bind_opts ||= Liebre::Common::Utils.symbolize_keys config.fetch("bind", {})
-          end
-
-          attr_reader :channel, :config
-          
-        end
-      end
-    end
-  end
-end