queuel 0.0.1 → 0.1.0

data/lib/queuel/base/queue.rb

@@ -0,0 +1,59 @@
+module Queuel
+  module Base
+    class Queue
+      extend Introspect
+
+      def initialize(client, queue_name)
+        self.client = client
+        self.name = queue_name
+      end
+
+      def peek(options = {})
+        raise NotImplementedError, "must implement #peek"
+      end
+
+      def push(message)
+        raise NotImplementedError, "must implement #push"
+      end
+
+      def pop(options = {}, &block)
+        bare_message = pop_bare_message(options)
+        unless bare_message.nil?
+          build_new_message(bare_message).tap { |message|
+            if block_given? && message.present?
+              message.delete if yield(message)
+            end
+          }
+        end
+      end
+
+      def receive(options = {}, &block)
+        poller_klass.new(self, block, options, thread_count).poll
+      end
+
+      private
+      attr_accessor :client
+      attr_accessor :name
+
+      def thread_count
+        Queuel.receiver_threads || 1
+      end
+
+      def pop_bare_message(options = {})
+        raise NotImplementedError, "must implement bare Message getter"
+      end
+
+      def build_new_message(bare_message)
+        message_klass.new(bare_message)
+      end
+
+      def message_klass
+        self.class.const_with_nesting("Message")
+      end
+
+      def poller_klass
+        self.class.const_with_nesting("Poller")
+      end
+    end
+  end
+end

data/lib/queuel/client.rb

@@ -1,14 +1,18 @@
 module Queuel
+  NoQueueGivenError = Class.new StandardError
   class Client
-    extend Forwardable
-    def_delegators :queue_connection, :push, :pop, :receive
-
     def initialize(engine, credentials, init_queue = nil)
       self.engine = engine
       self.credentials = credentials
       self.given_queue = init_queue
     end
 
+    [:push, :pop, :receive].each do |operation|
+      define_method(operation) do |*args, &block|
+        with_queue { queue_connection.public_send(operation, *args, &block) }
+      end
+    end
+
     def with(change_queue = nil)
       self.clone.tap { |client| client.given_queue = change_queue }
     end
@@ -23,6 +27,14 @@ module Queuel
 
     private
 
+    def with_queue
+      if queue.nil? || queue.to_s.strip.empty?
+        raise NoQueueGivenError, "Must select a queue with #with or set a default_queue"
+      else
+        yield
+      end
+    end
+
     def queue_connection
       engine_client.queue queue
     end

data/lib/queuel/configurator.rb

@@ -0,0 +1,65 @@
+require "mono_logger"
+module Queuel
+  class Configurator
+    InvalidConfigurationError = Class.new StandardError
+    private
+    attr_accessor :option_values
+
+    def self.option_values
+      @option_values ||= {}
+    end
+
+    def self.define_param_accessors(param_name)
+      define_method param_name do |*values|
+        value = values.first
+        value ? self.send("#{param_name}=", value) : retrieve(param_name)
+      end
+      define_method "#{param_name}=" do |value|
+        validate!(param_name, value) &&
+          instance_variable_set("@#{param_name}", value)
+      end
+    end
+
+    def validate(param_name, value)
+      validator = self.class.option_values[param_name].fetch(:validate) { {} }[:validator] || ->(val) { true }
+      validator.call value
+    end
+
+    def validate!(param_name, value)
+      message = self.class.option_values[param_name].fetch(:validate) { {} }[:message]
+      message ||= "#{value} is not a valid value for #{param_name}"
+      validate(param_name, value) || raise(InvalidConfigurationError, message)
+    end
+
+    def retrieve(param)
+      if instance_variable_defined?("@#{param}")
+        instance_variable_get("@#{param}")
+      else
+        self.class.option_values[param][:default]
+      end
+    end
+
+    def self.param(param_name, options = {})
+      attr_accessor param_name
+      self.option_values[param_name] = options
+      define_param_accessors param_name
+      public param_name
+      public "#{param_name}="
+    end
+
+    public
+
+    param :credentials
+    param :engine
+    param :default_queue
+    param :receiver_threads, default: 1
+    param :logger, default: MonoLogger.new(STDOUT), validate: {
+      message: "Logger must respond to #{%w[info warn debug level level]}",
+      validator: ->(logger) {
+        %w[info warn debug level].all? { |msg| logger.respond_to? msg } &&
+          logger.respond_to?(:level)
+      }
+    }
+    param :log_level, default: MonoLogger::ERROR
+  end
+end

data/lib/queuel/introspect.rb

@@ -0,0 +1,11 @@
+module Queuel
+  module Introspect
+    def module_names
+      self.to_s.split("::")[0..-2].join("::")
+    end
+
+    def const_with_nesting(other_name)
+      Object.module_eval("#{module_names}::#{other_name}", __FILE__, __LINE__)
+    end
+  end
+end

data/lib/queuel/iron_mq/engine.rb

@@ -1,40 +1,34 @@
+require "forwardable"
 module Queuel
   module IronMq
-    class Engine
-      IronMqMissingError = Class.new(StandardError)
-
-      def initialize(credentials = {})
-        self.credentials = credentials
-        self.memoized_queues = {}
-      end
+    class Engine < Base::Engine
+      extend Forwardable
+      def_delegators :Queuel, :logger
 
-      def queue(which_queue)
-        memoized_queues[which_queue.to_s] ||= Queue.new(client, which_queue)
-      end
+      IronMqMissingError = Class.new(StandardError)
 
       private
-      attr_accessor :credentials
-      attr_accessor :memoized_queues
-
-      def client
-        @client ||= client_proper.new credentials
-      end
 
       def try_typhoeus
         require 'typhoeus'
+        true
       rescue LoadError
+        logger.warn "Typhoeus not found..."
+        logger.warn "Typhoeus is recommended for IronMQ"
         false
       end
 
-      def client_proper
+      def client_klass
         if defined?(::IronMQ::Client)
           try_typhoeus
           ::IronMQ::Client
         else
           begin
+            logger.info "Loading IronMQ..."
             require 'iron_mq'
             ::IronMQ::Client
           rescue LoadError
+            logger.error "Couldn't find iron_mq gem"
             raise(IronMqMissingError)
           end
         end

data/lib/queuel/iron_mq/message.rb

@@ -1,43 +1,22 @@
 require 'forwardable'
 module Queuel
   module IronMq
-    class Message
+    class Message < Base::Message
       extend Forwardable
-      def_delegators :message_object, :delete
 
-      def self.new_from_iron_mq_object(message_object)
-        allocate.tap { |instance|
-          instance.send :initialize_from_iron_mq_object, message_object
-        }
-      end
-
-      def initialize_from_iron_mq_object(message_object)
-        self.message_object = message_object
-      end
-      private :initialize_from_iron_mq_object
-
-      def initialize(id, body, queue = nil)
-        self.id = id
-        self.body = body
-        self.queue = queue
+      def body
+        @body || message_object && message_object.body
       end
 
-      def body
-        @body || message_object && message_object.msg
+      def delete
+        message_object.delete
       end
 
       [:id, :queue].each do |delegate|
         define_method(delegate) do
           instance_variable_get("@#{delegate}") || message_object && message_object.public_send(delegate)
         end
-
-        private
-        attr_writer delegate
       end
-
-      private
-      attr_accessor :message_object
-      attr_writer :body
     end
   end
 end

data/lib/queuel/iron_mq/poller.rb

@@ -1,123 +1,20 @@
-require 'timeout'
 module Queuel
   module IronMq
-    class Poller
-      def initialize(queue, options, block)
-        self.queue = queue
-        self.options = options || {}
-        self.block = block
-        self.tries = 0
-        self.continue_looping = true
-      end
-
-      def poll
-        choose_looper do |msg|
-          if msg.nil?
-            tried
-            quit_looping! if break_if_nil? || maxed_tried?
-            sleep(sleep_time)
-          else
-            reset_tries
-            block.call msg
-            msg.delete
-          end
-          !msg.nil?
-        end
-      end
-
-      protected
-      attr_accessor :tries
-
+    class Poller < Base::Poller
+      # Public: poll
       private
-      attr_accessor :queue
-      attr_accessor :args
-      attr_accessor :options
-      attr_accessor :block
-      attr_accessor :continue_looping
-
-      def choose_looper(&loop_block)
-        timeout? ? timeout_looper(loop_block) : looper(loop_block)
-      end
-
-      def timeout_looper(loop_block)
-        Timeout.timeout(timeout) { looper(loop_block) }
-      rescue Timeout::Error
-        false
-      end
-
-      def looper(loop_block)
-        while continue_looping? do
-          loop_block.call(pop_new_message)
-        end
-      end
-
-      def continue_looping?
-        !!continue_looping
-      end
-
-      def quit_looping!
-        self.continue_looping = false
-      end
-
-      def timeout
-        options[:poll_timeout].to_i
-      end
-
-      def timeout?
-        timeout > 0
-      end
-
-      def pop_new_message
-        queue.pop built_options
-      end
-
-      def start_sleep_time
-        0.1
-      end
-
-      def sleep_time
-        tries < 30 ? (start_sleep_time * tries) : 3
-      end
-
-      def reset_tries
-        self.tries = 0
-      end
-
-      def maxed_tried?
-        tries >= max_fails if max_fails_given?
-      end
-
-      def max_fails_given?
-        max_fails > 0
-      end
-
-      def max_fails
-        options[:max_consecutive_fails].to_i
-      end
-
-      def tried
-        self.tries += 1
-      end
-
-      def break_if_nil?
-        !!options.fetch(:break_if_nil, false)
-      end
-
-      def option_keys
-        %w[break_if_nil poll_timeout max_consecutive_fails]
-      end
-
-      def my_options
-        options.select { |key,_| option_keys.include? key.to_s }
-      end
 
       def built_options
-        options.merge default_args # intentional direction, force defaults
+        options.merge default_options # intentional direction, force defaults
       end
 
-      def default_args
+      def default_options
         { n: 1 }
       end
+
+      def peek_options
+        { n: self.workers }
+      end
     end
   end
 end

data/lib/queuel/iron_mq/queue.rb

@@ -1,36 +1,25 @@
 require 'queuel/iron_mq/poller'
+require 'queuel/base/queue'
+require 'forwardable'
 module Queuel
   module IronMq
-    class Queue
-      def initialize(client, queue_name)
-        self.client = client
-        self.name = queue_name
-      end
-
-      # For IronMQ it should just be (message)
-      def push(*args)
-        queue_connection.post *args
-      end
+    class Queue < Base::Queue
+      extend Forwardable
+      def_delegators :queue_connection, :peek
 
-      def pop(*args, &block)
-        bare_message = queue_connection.get(*args)
-        unless bare_message.nil?
-          Message.new_from_iron_mq_object(bare_message).tap { |message|
-            if block_given? && !message.nil?
-              yield message
-              message.delete
-            end
-          }
-        end
+      def peek(options = {})
+        Array(queue_connection.peek(options))
       end
 
-      def receive(options = {}, &block)
-        Poller.new(self, options, block).poll
+      # For IronMQ it should just be (message)
+      def push(message)
+        queue_connection.post message
       end
 
       private
-      attr_accessor :client
-      attr_accessor :name
+      def pop_bare_message(options = {})
+        queue_connection.get options
+      end
 
       def queue_connection
         @queue_connection ||= client.queue(name)