rock-queue 0.2.0 → 0.3.0

data/Rakefile

@@ -5,9 +5,9 @@ require 'spec/rake/spectask'
 require 'date'
 $LOAD_PATH.unshift 'lib'
 require 'rock-queue/tasks'
- 
+
 GEM = "rock-queue"
-GEM_VERSION = "0.2.0"
+GEM_VERSION = "0.3.0"
 AUTHOR = "Grzegorz Kazulak"
 EMAIL = "gregorz.kazulak@gmail.com"
 HOMEPAGE = "http://github.com/grzegorzkazulak/rock-queue"
@@ -34,7 +34,7 @@ Rake::GemPackageTask.new(spec) do |pkg|
   pkg.gem_spec = spec
 end
  
-task :default => :test 
+task :default => :spec 
  
 desc "install the gem locally"
 task :install => [:package] do
@@ -56,4 +56,18 @@ task :test do
   Dir['test/*_test.rb'].each do |f|
     require f
   end
-end
+end
+
+desc "Run all examples" 
+Spec::Rake::SpecTask.new('spec') do |t|
+  t.spec_opts  = ["-cfs"]
+  t.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+desc "Run all examples with RCov"
+Spec::Rake::SpecTask.new('spec:rcov') do |t|
+  t.spec_opts  = ["-cfs"]
+  t.rcov = true
+  t.spec_files = FileList['spec/**/*_spec.rb']
+  t.rcov_opts = ['--exclude spec,/home']
+end

data/lib/rock-queue.rb

@@ -2,9 +2,7 @@ $:.unshift File.expand_path(File.dirname(__FILE__))
 require 'logger'
 
 module RockQueue
-
   autoload :Config,                   'rock-queue/config'
-  
   autoload :AbstractNotifier,         'rock-queue/notifiers/abstract_notifier'
   autoload :Notifiers,                'rock-queue/notifiers'
   autoload :EmailNotifier,            'rock-queue/notifiers/email_notifier'
@@ -22,64 +20,67 @@ module RockQueue
   autoload :QueueingServerNotRunning, 'rock-queue/errors'
   autoload :ActiveRecordHelper,       'rock-queue/active_record_helper'
   
-  attr_reader :adapter
+  extend self
 
+  # setup a connection
+  # options: adapter, server, port, log
+  def setup(options)
+    case options[:adapter]
+    when :beanstalkd
+      @adapter = Beanstalkd.new(options)
+    when :resque
+      @adapter = ResqueQueue.new(options)
+    when :delayed_job
+      @adapter = DelayedJob.new(options)
+    else
+      raise ArgumentError
+    end
+    @logger = Logger.new(options[:log].nil? ? STDOUT : options[:log])
+  end
 
-  class Base   
-
-    # Initializes the whole thing and makes the connection to the 
-    # queueing server using selected adapter (passed as lowercased symbol)
-    def initialize(adapter, *options)
-      # Any better way to do this? :-)
-      options = options.first
-      if options.include?(:server) && options.include?(:port)
-        case adapter
-          when :beanstalkd
-            @adapter = Beanstalkd.new(options)
-          when :resque
-            @adapter = ResqueQueue.new(options)
-          when :delayed_job
-            @adapter = DelayedJob.new(options)
-        end
-      else
-        raise ArgumentError
-      end
+  def disconnect
+    @adapter = nil
+  end
 
-      # Initialize logger
-      @@logger = Logger.new(options[:log].nil? ? STDOUT : options[:log])
-    end
-    
-    
-    # Pushes the value (in our case it should always be an object)
-    # onto the queue using previously selected adapter
-    def push(value, *args)
-      @adapter.push(value, args)
-    end
-    
-    
-    # Pulls the data off the queue. There are two ways to do so:
-    # - Call receive with no block (gets you a single item)
-    # - Pass a block to it (creates and endles loop that constantly pulls items from the queue as they become available)
-    # All calls to the queueing server are made through the previosuly selected adaper.
-    def receive
-      if block_given?
-        obj, args = @adapter.pop
-        yield QueueObject.new(obj, args) if obj
-      else
-        raise 'No block given'
-      end
-    end
-    
-    # Calling adapter method
-    def method_missing(sym, *args, &block)
-      @adapter.send sym, *args, &block
+  # return current connection
+  def adapter
+    if @adapter
+      @adapter
+    else
+      raise RuntimeError, "RockQueue is not connected. Use setup"
     end
+  end
+
+  def push(queue, value, *args)
+    adapter.push(queue, value, args)
+  end
 
-    # Returns Rock Queue logger
-    def self.logger
-      @@logger
+  def logger
+    @logger
+  end
+
+  # Pulls the data off the queue. There are two ways to do so:
+  # - Call receive with no block (gets you a single item)
+  # - Pass a block to it (creates and endles loop that constantly pulls
+  #   items from the queue as they become available)
+  # All calls to the queueing server are made through the previosuly
+  # selecte adaper.
+  def receive(queue)
+    if block_given?
+      obj, args = @adapter.pop(queue)
+      yield QueueObject.new(obj, args) if obj
+    else
+      raise 'No block given'
     end
+  end
 
+  # Register worker for web interface
+  def register_worker(worker)
+    @adapter.register_worker(worker) if @adapter.respond_to?(:register_worker)
   end
 
+  # Calling adapter method
+  def method_missing(sym, *args, &block)
+    adapter.send sym, *args, &block
+  end
 end

data/lib/rock-queue/active_record_helper.rb

@@ -14,15 +14,21 @@ module RockQueue
         method = args.shift
         find(id).send(method, *args)
       end
+      
+      def queue
+        const_defined?(:QUEUE) ? self::QUEUE : :default
+      end   
     end
     
     module InstanceMethods 
       def async(method, *args)
-        config = RockQueue::Config.settings
-        rq = RockQueue::Base.new config.adapter, {:server => config.host, :port => config.port}
-        rq.push self.class, id, method, *args
+        RockQueue.push self.class.queue, self.class, id, method, *args
+      end
+      
+      def async_at(method, time_to_run_at, *args)
+        RockQueue.push_at(
+          self.class.queue, self.class, time_to_run_at, id, method, *args)
       end
     end 
-    
   end
 end

data/lib/rock-queue/adapters/beanstalkd.rb

@@ -1,21 +1,44 @@
 begin
   require "beanstalk-client"
 rescue
-  RockQueue::Base.logger.error "You need `beanstalk-client` gem to use the Beanstalkd rock-queue interface"
+  RockQueue.logger.error "You need `beanstalk-client` gem to use" \
+                         "the Beanstalkd rock-queue interface"
   exit
 end
 
 module RockQueue
   class Beanstalkd
-    
     attr_reader :obj
     
     def initialize(options = {})
-      @obj = Beanstalk::Pool.new(["#{options[:server]}:#{options[:port]}"])
+      @options = options
+      @addr = "#{options[:server]}:#{options[:port]}"
+      @obj = Beanstalk::Pool.new([@addr])
     end
   
-    def pop
-      loop
+    def push(queue, value, *args)
+      @obj.send(:send_to_rand_conn, :use, queue)
+      @obj.put [value.name, args].to_yaml 
+    end
+
+    def pop(queue)
+      @obj.send(:send_to_rand_conn, :use, queue)
+      r = YAML.load(@obj.reserve.body)
+      r[0] = Kernel.const_get(r[0])
+      r
     end 
+
+    def clear
+      system "pkill beanstalkd"
+      system "beanstalkd -d -p #{@options[:port]}"
+    end
+
+    def size(queue)
+      @obj.stats_tube(queue)["current-jobs-ready"]
+    end
+
+    def queues
+      @obj.list_tubes[@addr].map(&:to_sym)
+    end
   end
-end
+end

data/lib/rock-queue/adapters/delayed_job.rb

@@ -1,13 +1,13 @@
 begin
   require "delayed_job"
 rescue
-  RockQueue::Base.logger.error "You need `delayed_job` gem to use the Delayed Job rock-queue interface"
+  RockQueue.logger.error "You need `delayed_job` gem to use" \
+                         "the Delayed Job rock-queue interface"
   exit
 end
 
 module RockQueue
   class DelayedJob
-    
     attr_reader :obj
     
     def initialize(options = {})
@@ -18,7 +18,6 @@ module RockQueue
     end
   
     def pop
-      
     end 
   end
-end
+end

data/lib/rock-queue/adapters/resque.rb

@@ -1,7 +1,8 @@
 begin
   require 'resque'
 rescue
-  RockQueue::Base.logger.error "You need `resque` gem to use the Resque rock-queue interface"
+  RockQueue.logger.error "You need `resque` gem to use" \
+                         "the Resque rock-queue interface"
   exit
 end
 
@@ -13,23 +14,51 @@ module RockQueue
     # Contructor of Resque adapter
     def initialize(options)
       Resque.redis = "#{options[:server]}:#{options[:port]}"
+      Resque.redis.sadd(:queues, :default)
     end
     
     # Push item from Resque queue
-    def push(value, args)
+    def push(queue, value, args)
       if !defined?(value.queue)
         value.class_eval do 
-          @queue = :default
+          @queue = queue
         end
       end
       Resque.enqueue value, args
     end
+    
+    # Push items to Resque queue to be picked up by the worker on specified time
+    def push_at(value, time_to_run_at ,*args)
+      if !defined?(value.queue)
+        value.class_eval do 
+          @queue = :default
+        end
+      end
+      Resque.enqueue_at time_to_run_at, value, args
+    end    
 
     # Retrieve item from Resque queue
-    def pop
-      job = Resque.reserve :default
+    def pop(queue)
+      job = Resque.reserve(queue)
       [job.payload_class, job.args] if job   
     end 
     
+    # Register worker for web interface
+    def register_worker(worker)
+      Resque.redis.sadd(:workers, worker)
+    end    
+    
+    def clear
+      Resque.redis.flushall
+      Resque.redis.sadd(:queues, :default)
+    end
+
+    def size(queue)
+      Resque.size(queue)
+    end
+
+    def queues
+      Resque.queues.sort.map(&:to_sym)
+    end
   end
 end

data/lib/rock-queue/notifiers/email_notifier.rb

@@ -1,39 +1,34 @@
 module RockQueue
-  
   class EmailNotifier < AbstractNotifier
-  
     def initialize(config)
       $server_config = config
+      
+      Mail.defaults do
+        delivery_method :smtp, {
+          :address        => $server_config[:server],
+          :port           => $server_config[:port],
+          :user_name      => $server_config[:username],
+          :password       => $server_config[:password]
+        }
+      end
     end
     
     # Notify by email  
     def update(error)
-
       begin
         require 'mail'
       rescue
-        RockQueue::Base.logger.error "You need `mail` gem to use the Email Notifier"
+        RockQueue.logger.error "You need `mail` gem to use the Email Notifier"
       end
       
-      RockQueue::Base.logger.info "Sending e-mail message: #{error.message}"
-
-      Mail.defaults do
-        smtp do
-          host $server_config[:server]
-          port $server_config[:port]
-          user $server_config[:username]
-          pass $server_config[:password] 
-        end
-      end
+      RockQueue.logger.info "Sending e-mail message: #{error.message}"
 
       Mail.deliver do
           from $server_config[:from]
             to $server_config[:to]
-       subject "Processing error - '#{error.message}''"
+       subject "Processing error - '#{error.message}'"
           body error.backtrace.join("\n")
       end
-      
     end
-
   end
-end
+end

data/lib/rock-queue/tasks.rb

@@ -9,9 +9,9 @@ namespace :rock_queue do
   file_path = "#{RAILS_ROOT}/tmp/pids/rock-queue.pid"
 
   task :work do
-    worker = RockQueue::Worker.new
+    worker = RockQueue::Worker.new(ENV['QUEUE'].split(/,/))
     worker.verbose = ENV['VERBOSE']
-    RockQueue::Base.logger.info "=> Rock-queue worker initialized (#{worker})"
+    RockQueue.logger.info "=> Rock-queue worker initialized (#{worker})"
     pid = fork do
       File.open(file_path, "wb") { |f| f.write(Process.pid) }
       worker.work

data/lib/rock-queue/worker.rb

@@ -4,42 +4,50 @@ module RockQueue
     attr_accessor :verbose
     
     # Initialize connection to queue server
-    def initialize 
-      config = RockQueue::Config.settings
-      @queue = RockQueue::Base.new config.adapter, {
-        :server => config.host, 
-        :port   => config.port,
-        :log    => config.log
-      }      
-      RockQueue::Base.logger.info "=> Initializing..."
+    def initialize(*queues)
+      queues = [:default] if queues.size == 0
+      @queues = queues
+      RockQueue.logger.info "=> Initializing..."
     end
     
     # Main worker loop where all jobs are beeing pulled of the queue. 
     # This is also a place where every job starts and ends it's lifecycle.
-    def work
-      RockQueue::Base.logger.info "=> Worker ready. Hold your horses!"
+    def work(interval = 5)
+      RockQueue.logger.info "=> Worker ready. Hold your horses!"
+      stop = false
       loop do
         ActiveRecord::Base.verify_active_connections!
-        @queue.receive do |queue|
-          if queue
+        queues.each do |qname|
+          obj, args = RockQueue.pop(qname)
+          if obj
+            queue = QueueObject.new(obj, args)
             begin
               # code that actually performs the action
               args = queue.args.first
-              RockQueue::Base.logger.info "=> Processing class #{queue.object.name} with params: #{args.inspect}"
+              RockQueue.logger.info "=> Processing class #{queue.object.name} with params: #{args.inspect}"
               args.empty? ? queue.object.perform : queue.object.perform(args)
             rescue Object => e
               # Add failed processing and retry
               if queue.add_fail(e)
                 sleep(queue.get_sleep_time)
-                RockQueue::Base.logger.error "=> Processing fail! Retrying #{queue.fails.length}"
-                RockQueue::Base.logger.error "   Message: #{e.message}"
+                RockQueue.logger.error "=> Processing fail! Retrying #{queue.fails.length}"
+                RockQueue.logger.error "   Message: #{e.message}"
                 retry
               end
             end
+            stop = false
+          else
+            stop = true if interval == 0
           end
         end
+        break if stop
       end
     end
- 
+
+    # Returns a list of queues
+    # A single '*' means all queues
+    def queues
+      @queues[0] == "*" ? RockQueue.queues : @queues
+    end
   end
-end
+end

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 2
+  - 3
   - 0
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors: 
 - Grzegorz Kazulak
@@ -14,7 +14,7 @@ autorequire: rock-queue
 bindir: bin
 cert_chain: []
 
-date: 2010-05-11 00:00:00 +02:00
+date: 2010-05-28 00:00:00 +02:00
 default_executable: 
 dependencies: []