remq-rb 0.0.2

data/Gemfile

@@ -0,0 +1,2 @@
+source :rubygems
+gemspec

data/LICENSE

@@ -0,0 +1,7 @@
+Copyright (c) 2012 Matthew Loberg
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,51 @@
+# ReMQ.rb
+
+[![Build Status](https://secure.travis-ci.org/mloberg/ReMQ.rb.png?branch=master)](https://travis-ci.org/mloberg/ReMQ.rb)
+
+Redis Message Queue (ReMQ) is a message queue built on top of the awesome Redis key-value store.
+
+This is the Ruby clone of the original [ReMQ](https://github.com/mloberg/ReMQ) PHP library.
+
+## Getting ReMQ
+
+coming soon
+
+## Jobs
+
+Jobs are stored as classes. The class must have a perform method which can take a variable number of parameters/
+
+	class Job
+
+	  def self.perform(param1, param2)
+	    puts "Ran job with #{param1} and #{param2}"
+	  end
+
+	end
+
+## Queuing Jobs
+
+Instead of creating a queue for each job, ReMQ allows multiple jobs per queue. This is for simplicity's sake, and there is no other reason behind it.
+
+	queue = ReMQ::Queue.new('name')
+	queue.enqueue(Job, 'param1', 'param2')
+
+## Processing Jobs
+
+To process a job, you need to create a worker for the queue.
+
+	worker = ReMQ::Worker.new('name')
+
+You can also add additional queues to the process.
+
+	worker.add_queue('other')
+
+You can also match queue names.
+
+	worker.add_queue('*')
+	worker.add_queue('namespaced:*')
+
+Running the worker.
+
+	worker.run(:time => 60)
+	worker.run(:count => 10)
+	worker.run()

data/Rakefile

@@ -0,0 +1,92 @@
+require "date"
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), *%w[lib]))
+
+require "ReMQ"
+
+##
+# Helper functions
+##
+
+def name
+  @name ||= Dir['*.gemspec'].first.split('.').first
+end
+
+def version
+  ReMQ::VERSION
+end
+
+def date
+  Date.today.to_s
+end
+
+def gemspec_file
+  "#{name}.gemspec"
+end
+
+def gem_file
+  "#{name}-#{version}.gem"
+end
+
+def replace_header(head, header_name)
+  head.sub!(/(\.#{header_name}\s*= ').*'/) { "#{$1}#{send(header_name)}'"}
+end
+
+task :default => [:test]
+
+require 'rake/testtask'
+Rake::TestTask.new do |t|
+  t.libs = ["lib", "test"]
+  t.warning = true
+  t.warning = true
+  t.test_files = FileList['test/*_test.rb']
+end
+
+task :doc do
+  sh "yardoc"
+end
+
+###
+# Packing tasks
+###
+
+desc "Build gem"
+task :build do
+  FileUtils.mkdir_p "pkg"
+  system "gem build #{gemspec_file}"
+  FileUtils.mv gem_file, "pkg"
+end
+
+desc "Install gem locally"
+task :install => :build do
+  system "gem install pkg/#{gem_file}"
+end
+
+desc "Clean automatically generated files"
+task :clean do
+  FileUtils.rm_rf "pkg"
+  FileUtils.rm_rf ".yardoc"
+  FileUtils.rm_rf "doc"
+end
+
+task :gemspec do
+  spec = File.read(gemspec_file)
+  head, manifest, tail = spec.split("  # = MANIFEST =\n")
+
+  replace_header(head, :name)
+  replace_header(head, :version)
+  replace_header(head, :date)
+
+  files = `git ls-files`.
+          split("\n").
+          sort.
+          reject { |file| file =~ /^\./ }.
+          reject { |file| file =~ /^(pkg)/ }.
+          map { |file| "    #{file}"}.
+          join("\n")
+
+  manifest = "  s.files = %w[\n#{files}\n  ]\n"
+  spec = [head, manifest, tail].join("  # = MANIFEST =\n")
+  File.open(gemspec_file, 'w') { |f| f.write(spec) }
+  puts "Updated #{gemspec_file}"
+end

data/lib/ReMQ.rb

@@ -0,0 +1,69 @@
+$LOAD_PATH.unshift File.dirname(__FILE__)
+
+require "redis"
+require "json"
+
+require "ReMQ/Queue"
+require "ReMQ/Worker"
+
+module ReMQ
+  VERSION = '0.0.2'
+
+  class BadJobError < StandardError
+  end
+
+  extend self
+
+  # Get a normalized ReMQ queue name.
+  #
+  # @param [String] name
+  # @return [String]
+  def normalize_queue_name(name)
+    "remq:#{name}"
+  end
+
+  # Set Redis connection options.
+  #
+  # @param [Hash] config
+  def set_redis_config(config)
+    @redis = Redis.new(config)
+  end
+
+  # Set a custom Redis connection.
+  #
+  # @param [Object] redis
+  def set_redis(redis)
+    @redis = redis
+  end
+
+  # Return the Redis connection or create a new connection.
+  #
+  # @return [Object] Redis conenction
+  def redis
+    @redis ||= Redis.new
+  end
+
+  # Check if the job is a valid job.
+  #
+  # @raise [ReMQ::BadJobError]
+  # @param [Object] job
+  # @return [Boolean]
+  def is_valid_job?(job)
+    # check if is class
+    if job.class != Class and Object.const_defined?(job)
+      job = Object.const_get(job)
+    elsif job.class != Class
+      raise BadJobError, "#{job} is not a class"
+      return false
+    end
+    # Ruby 1.9 uses a symbol for methods, while 1.8 uses strings
+    method = RUBY_VERSION.gsub(/\.\d$/, '') == '1.9' ? :perform : 'perform'
+    # check if it has the perform method
+    unless job.methods.include?(method)
+      raise BadJobError, "#{job} does not have a perform method"
+      return false
+    end
+    return true
+  end
+
+end

data/lib/ReMQ/Queue.rb

@@ -0,0 +1,29 @@
+module ReMQ
+  class Queue
+
+    # @!attribute [r] name
+    #   @return [String] the queue name
+    attr_reader :name
+
+    # Create a new queue.
+    #
+    # @param [String] name queue name
+    def initialize(name)
+      @name = ReMQ.normalize_queue_name(name)
+    end
+
+    # Add a job to the queue.
+    #
+    # @raise [ReMQ::BadJobError] if job is invalid
+    # @param [String] class Job class name
+    # @param [mixed] params Job parameters
+    # @return [Boolean] true if job was queued
+    def enqueue(*args)
+      body = args.to_json
+      if ReMQ.is_valid_job?(args.first)
+        ReMQ.redis().rpush(name, body)
+      end
+    end
+
+  end
+end

data/lib/ReMQ/Worker.rb

@@ -0,0 +1,87 @@
+module ReMQ
+  class Worker
+
+    # Create a new ReMQ worker.
+    #
+    # @param [String] name Optional name of the queue
+    def initialize(name = nil)
+      @queues = []
+      add_queue(name) if name
+    end
+
+    # Return the list of quques that this worker will run.
+    #
+    # @return [Array] Array of queues
+    def queues
+      @queues.map { |name| name.gsub(/^remq\:/, '') }
+    end
+
+    # Add a queue to the worker.
+    #
+    # @param [String] name Queue name
+    def add_queue(name)
+      queues = find_queues(name)
+      queues << ReMQ.normalize_queue_name(name)
+      @queues = @queues.concat(queues).uniq
+    end
+
+    # Remove a queue from the worker.
+    #
+    # @param [String] name Queue name
+    def remove_queue(name)
+      @queues.delete(ReMQ.normalize_queue_name(name))
+    end
+
+    # Run the worker
+    #
+    # @param [Integer] time Seconds to run the worker for
+    # @param [Integer] count Number of jobs to run
+    def run(args = {})
+      if args[:time]
+        start = Time.now
+        while (start + args[:time]) > Time.now do
+          process(1)
+        end
+      elsif args[:count]
+        args[:count].times do
+          process(0)
+        end
+      else
+        loop do
+          process(0)
+        end
+      end
+    end
+
+    private
+
+      # Find queues in Redis
+      #
+      # @param [String] match
+      def find_queues(match)
+        match = ReMQ.normalize_queue_name(match)
+        ReMQ.redis.keys(match)
+      end
+
+      # Handle the job processing
+      #
+      # @param [Integer] timeout Redis BLPOP timeout
+      def process(timeout)
+        queues = @queues << timeout
+        begin
+          queue, job = ReMQ.redis.blpop(*queues)
+          if job
+            body = JSON.parse(job)
+            job_class = body.shift
+            if ReMQ.is_valid_job?(job_class)
+              Object.const_get(job_class).perform(*body)
+            end
+          end
+        rescue Exception => e
+          ReMQ.redis.rpush(queue, job)
+          raise e
+        end
+      end
+
+  end
+end

data/remq-rb.gemspec

@@ -0,0 +1,40 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), *%w[lib]))
+
+line = File.read("lib/ReMQ.rb")[/^\s*VERSION\s*=\s*.*/]
+version = line.match(/.*VERSION\s*=\s*['"](.*)['"]/)[1]
+
+Gem::Specification.new do |s|
+  s.name        = 'remq-rb'
+  s.version     = version
+  s.summary     = "Redis based message queue."
+  s.description = "Redis Message Queue (ReMQ) is a message queue backed by the awesome key-value store, Redis."
+  s.homepage    = 'https://github.com/mloberg/ReMQ.rb'
+  s.authors     = ["Matthew Loberg"]
+  s.email       = 'm@mloberg.com'
+
+  s.require_paths = %w[lib]
+
+  s.add_runtime_dependency('redis', "~> 3.0")
+  s.add_runtime_dependency('json', "~> 1.7")
+
+  s.add_development_dependency('rake', "~> 0.9")
+  s.add_development_dependency('yard', "~> 0.8")
+
+  # = MANIFEST =
+  s.files = %w[
+    Gemfile
+    LICENSE
+    README.md
+    Rakefile
+    lib/ReMQ.rb
+    lib/ReMQ/Queue.rb
+    lib/ReMQ/Worker.rb
+    remq-rb.gemspec
+    test/helper.rb
+    test/queue_test.rb
+    test/worker_test.rb
+  ]
+  # = MANIFEST =
+
+  s.test_files = s.files.select { |path| path =~ /^test\/test_.*\.rb/ }
+end

data/test/helper.rb

@@ -0,0 +1,46 @@
+require "test/unit"
+
+require "ReMQ"
+
+module Test::Unit::Assertions
+
+  def assert_contains(needle, haystack, msg = nil)
+    unless msg
+      msg = "#{haystack} was expected to contain #{needle}"
+    end
+    assert(haystack.include?(needle), msg)
+  end
+
+  def assert_not_contains(needle, haystack, msg = nil)
+    unless msg
+      msg = "#{haystack} was expected to not contain #{needle}"
+    end
+    assert(!haystack.include?(needle), msg)
+  end
+
+end
+
+class TestJob
+
+  extend Test::Unit::Assertions
+
+  def self.perform(foo, bar)
+    assert_equal(foo, 'foo')
+    assert_equal(bar, 'bar')
+  end
+
+end
+
+class FailingJobError < StandardError
+end
+
+class FailingJob
+
+  def self.perform
+    raise FailingJobError, "did not run job"
+  end
+
+end
+
+class BadJob
+end

data/test/queue_test.rb

@@ -0,0 +1,25 @@
+require "helper"
+
+class TestQueue < Test::Unit::TestCase
+
+  def setup
+    @redis_mock = Object.new
+    @redis_mock.extend(Test::Unit::Assertions)
+    ReMQ.set_redis(@redis_mock)
+    @queue = ReMQ::Queue.new('test')
+  end
+
+  def test_enqueue
+    def @redis_mock.rpush(key, value)
+      assert_equal('remq:test', key)
+      assert_equal(['TestJob', 'foo', 'bar'].to_json, value)
+      return true
+    end
+    assert(@queue.enqueue(TestJob, 'foo', 'bar'))
+  end
+
+  def test_throws_error_on_bad_job
+    assert_raise(ReMQ::BadJobError) { @queue.enqueue(BadJob) }
+  end
+
+end

data/test/worker_test.rb

@@ -0,0 +1,63 @@
+require "helper"
+
+class TestWorker < Test::Unit::TestCase
+
+  def setup
+    @redis_mock = Object.new
+    @redis_mock.extend(Test::Unit::Assertions)
+    ReMQ.set_redis(@redis_mock)
+    @worker = ReMQ::Worker.new
+  end
+
+  def redis_keys_returns_empty
+    def @redis_mock.keys(match)
+      []
+    end
+  end
+
+  def test_add_queue
+    redis_keys_returns_empty
+    @worker.add_queue('example')
+    assert_contains('example', @worker.queues)
+    @worker.add_queue('test')
+    assert_contains('test', @worker.queues)
+    # assert that the previous queue is still in place
+    assert_contains('test', @worker.queues)
+  end
+
+  def test_remove_queue
+    redis_keys_returns_empty
+    @worker.add_queue('example')
+    @worker.add_queue('test')
+    @worker.remove_queue('example')
+    assert_not_contains('example', @worker.queues)
+  end
+
+  def test_process
+    def @redis_mock.blpop(*args)
+      [ 'example', [ 'TestJob', 'foo', 'bar' ].to_json ]
+    end
+    @worker.run(:count => 1)
+  end
+
+  def test_reenqueue_after_exception
+    def @redis_mock.rpush(key, value)
+      assert_equal('example', key)
+      assert_equal(['FailingJob'].to_json, value)
+    end
+    def @redis_mock.blpop(*args)
+      [ 'example', [ 'FailingJob' ].to_json ]
+    end
+    assert_raise(FailingJobError) { @worker.run(:count => 1) }
+  end
+
+  def test_throws_exception_if_not_valid_job
+    def @redis_mock.blpop(*args)
+      [ 'example', [ 'BadJob' ].to_json ]
+    end
+    def @redis_mock.rpush(key, value)
+    end
+    assert_raise(ReMQ::BadJobError) { @worker.run(:count => 1) }
+  end
+
+end

metadata

@@ -0,0 +1,121 @@
+--- !ruby/object:Gem::Specification
+name: remq-rb
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+  prerelease: 
+platform: ruby
+authors:
+- Matthew Loberg
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-11-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.8'
+description: Redis Message Queue (ReMQ) is a message queue backed by the awesome key-value
+  store, Redis.
+email: m@mloberg.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/ReMQ.rb
+- lib/ReMQ/Queue.rb
+- lib/ReMQ/Worker.rb
+- remq-rb.gemspec
+- test/helper.rb
+- test/queue_test.rb
+- test/worker_test.rb
+homepage: https://github.com/mloberg/ReMQ.rb
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Redis based message queue.
+test_files: []
+has_rdoc: