rj 0.0.4.1

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+.DS_Store
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1,2 @@
+--colour
+--format documentation

data/Gemfile

@@ -0,0 +1,13 @@
+source :rubygems
+
+gemspec
+
+gem 'rabbit_jobs', :path => './'
+
+group :development do
+  gem 'rspec', '~> 2.8'
+  gem 'rr'
+  gem 'autotest'
+  # gem 'fs-event'
+  gem 'simplecov', require: false
+end

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Pavel Lazureykis
+
+MIT License
+
+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,29 @@
+# RabbitJobs
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'rabbit_jobs'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install rabbit_jobs
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/examples/configuration.rb

@@ -0,0 +1,29 @@
+# -*- encoding : utf-8 -*-
+require 'bundler/setup'
+require 'rabbit_jobs'
+require 'json'
+
+RabbitJobs.configure do |c|
+  c.host        "127.0.0.1"
+
+  c.exchange 'test_exchange', durable: true, auto_delete: false
+
+  c.queue 'rabbit_jobs_test1', durable: true, auto_delete: false, ack: true, arguments: {'x-ha-policy' => 'all'}
+  c.queue 'rabbit_jobs_test2', durable: true, auto_delete: false, ack: true, arguments: {'x-ha-policy' => 'all'}
+  c.queue 'rabbit_jobs_test3', durable: true, auto_delete: false, ack: true, arguments: {'x-ha-policy' => 'all'}
+end
+
+puts JSON.pretty_generate(RabbitJobs.config.to_hash)
+
+puts JSON.pretty_generate(RabbitJobs.config.queues)
+
+class MyJob < RabbitJobs::Job
+
+  expires_in 60 # dont perform this job after 60 seconds
+
+  def self.perform(time)
+    puts "This job was published at #{}"
+  end
+end
+
+RabbitJobs.publish_to('rabbit_jobs_test1', MyJob, Time.now)

data/lib/rabbit_jobs.rb

@@ -0,0 +1,24 @@
+# -*- encoding : utf-8 -*-
+
+require 'rabbit_jobs/version'
+
+require 'rabbit_jobs/helpers'
+require 'rabbit_jobs/amqp_helpers'
+require 'rabbit_jobs/configuration'
+require 'rabbit_jobs/logger'
+
+require 'rabbit_jobs/job'
+require 'rabbit_jobs/publisher'
+require 'rabbit_jobs/worker'
+
+module RabbitJobs
+  extend self
+
+  def publish(klass, opts = {}, *params)
+    RabbitJobs::Publisher.publish(klass, opts, *params)
+  end
+
+  def publish_to(routing_key, klass, opts = {}, *params)
+    RabbitJobs::Publisher.publish_to(routing_key, klass, opts, *params)
+  end
+end

data/lib/rabbit_jobs/amqp_helpers.rb

@@ -0,0 +1,45 @@
+# -*- encoding : utf-8 -*-
+
+module RabbitJobs
+  module AmqpHelpers
+
+    # Calls given block with initialized amqp
+
+    def amqp_with_exchange(&block)
+      raise ArgumentError unless block
+
+      AMQP.start(host: RabbitJobs.config.host) do |connection|
+        channel  = AMQP::Channel.new(connection)
+
+        channel.on_error do |ch, channel_close|
+          puts "Channel-level error: #{channel_close.reply_text}, shutting down..."
+          connection.close { EM.stop }
+        end
+
+        exchange = channel.direct(RabbitJobs.config[:exchange], RabbitJobs.config[:exchange_params])
+
+        # go work
+        block.call(connection, exchange)
+      end
+    end
+
+    def amqp_with_queue(routing_key, &block)
+
+      raise ArgumentError unless routing_key && block
+
+      amqp_with_exchange do |connection, exchange|
+        queue = exchange.channel.queue(RabbitJobs.config.queue_name(routing_key), RabbitJobs.config[:queues][routing_key])
+        queue.bind(exchange, :routing_key => routing_key)
+
+        # go work
+        block.call(connection, queue)
+      end
+    end
+
+    def make_queue(exchange, routing_key)
+      queue = exchange.channel.queue(RabbitJobs.config.queue_name(routing_key), RabbitJobs.config[:queues][routing_key])
+      queue.bind(exchange, :routing_key => routing_key)
+      queue
+    end
+  end
+end

data/lib/rabbit_jobs/configuration.rb

@@ -0,0 +1,124 @@
+# -*- encoding : utf-8 -*-
+require 'yaml'
+
+module RabbitJobs
+
+  extend self
+
+  def configure(&block)
+    @@configuration ||= Configuration.new
+    block.call(@@configuration)
+  end
+
+  def config
+    @@configuration ||= load_config
+  end
+
+  def load_config
+    self.configure do |c|
+      c.host 'localhost'
+      c.exchange 'rabbit_jobs', auto_delete: false, durable: true
+      c.queue 'default', auto_delete: false, ack: true, durable: true
+    end
+    @@configuration
+  end
+
+  class Configuration
+    include Helpers
+
+    DEFAULT_QUEUE_PARAMS = {
+      auto_delete: false,
+      durable: true,
+      ack: true
+    }
+
+    DEFAULT_EXCHANGE_PARAMS = {
+      auto_delete: false,
+      durable: true
+    }
+
+    DEFAULT_MESSAGE_PARAMS = {
+      persistent: true,
+      nowait: false,
+      immediate: false
+    }
+
+    def to_hash
+      @data.dup
+    end
+
+    def initialize
+      @data = {
+        host: 'localhost',
+        exchange: 'rabbit_jobs',
+        exchange_params: DEFAULT_EXCHANGE_PARAMS,
+        queues: {}
+      }
+    end
+
+    def [](name)
+      @data[name]
+    end
+
+    def host(value = nil)
+      if value
+        raise ArgumentError unless value.is_a?(String) && value != ""
+        @data[:host] = value.to_s
+      else
+        @data[:host]
+      end
+    end
+
+    def exchange(value = nil, params = {})
+      if value
+        raise ArgumentError unless value.is_a?(String) && value != ""
+        @data[:exchange] = value.downcase
+        @data[:exchange_params] = DEFAULT_EXCHANGE_PARAMS.merge(params)
+      else
+        @data[:exchange]
+      end
+    end
+
+    def queue(name, params = {})
+      raise ArgumentError.new("name is #{name.inspect}") unless name && name.is_a?(String) && name != ""
+      raise ArgumentError.new("params is #{params.inspect}") unless params && params.is_a?(Hash)
+
+      name = name.downcase
+
+      if @data[:queues][name]
+        @data[:queues][name].merge!(params)
+      else
+        @data[:queues][name] = DEFAULT_QUEUE_PARAMS.merge(params)
+      end
+    end
+
+    def routing_keys
+      @data[:queues].keys
+    end
+
+    def queue_name(routing_key)
+      [@data[:exchange], routing_key].join('#')
+    end
+
+    def load_file(filename)
+      load_yaml(File.read(filename))
+    end
+
+    def load_yaml(text)
+      convert_yaml_config(YAML.load(text))
+    end
+
+    def convert_yaml_config(yaml)
+      if yaml['rabbit_jobs']
+        convert_yaml_config(yaml['rabbit_jobs'])
+      else
+        @data = {host: nil, exchange: nil, queues: {}}
+        host yaml['host']
+        exchange yaml['exchange'], symbolize_keys!(yaml['exchange_params'])
+        yaml['queues'].each do |name, params|
+          queue name, symbolize_keys!(params) || {}
+        end
+      end
+    end
+  end
+end

data/lib/rabbit_jobs/helpers.rb

@@ -0,0 +1,53 @@
+# -*- encoding : utf-8 -*-
+
+module RabbitJobs
+  module Helpers
+    def symbolize_keys!(hash)
+      hash.inject({}) do |options, (key, value)|
+        options[(key.to_sym rescue key) || key] = value
+        options
+      end
+    end
+
+
+    # Tries to find a constant with the name specified in the argument string:
+    #
+    # constantize("Module") # => Module
+    # constantize("Test::Unit") # => Test::Unit
+    #
+    # The name is assumed to be the one of a top-level constant, no matter
+    # whether it starts with "::" or not. No lexical context is taken into
+    # account:
+    #
+    # C = 'outside'
+    # module M
+    #   C = 'inside'
+    #   C # => 'inside'
+    #   constantize("C") # => 'outside', same as ::C
+    # end
+    #
+    # NameError is raised when the constant is unknown.
+    def constantize(camel_cased_word)
+      camel_cased_word = camel_cased_word.to_s
+
+      if camel_cased_word.include?('-')
+        camel_cased_word = classify(camel_cased_word)
+      end
+
+      names = camel_cased_word.split('::')
+      names.shift if names.empty? || names.first.empty?
+
+      constant = Object
+      names.each do |name|
+        args = Module.method(:const_get).arity != 1 ? [false] : []
+
+        if constant.const_defined?(name, *args)
+          constant = constant.const_get(name)
+        else
+          constant = constant.const_missing(name)
+        end
+      end
+      constant
+    end
+  end
+end

data/lib/rabbit_jobs/job.rb

@@ -0,0 +1,88 @@
+# -*- encoding : utf-8 -*-
+require 'json'
+require 'digest/md5'
+
+module RabbitJobs::Job
+  extend RabbitJobs::Helpers
+  extend RabbitJobs::Logger
+  extend self
+
+  def self.included(base)
+    include RabbitJobs::Logger
+    base.extend (ClassMethods)
+
+    def initialize(*perform_params)
+      self.params = *perform_params
+      self.opts = {}
+    end
+
+    attr_accessor :params, :opts, :child_pid
+
+    def run_perform
+      if @child_pid = fork
+        srand # Reseeding
+        log "Forked #{@child_pid} at #{Time.now} to process #{self.class}.perform(#{ params.map(&:inspect).join(', ') })"
+        Process.wait(@child_pid)
+        yield if block_given?
+      else
+        begin
+          # log 'before perform'
+          self.class.perform(*params)
+          # log 'after perform'
+        rescue
+          puts $!.inspect
+        end
+        exit!
+      end
+    end
+
+    def payload
+      {'class' => self.class.to_s, 'opts' => (self.opts || {}), 'params' => params}.to_json
+      # ([self.class.to_s] + params).to_json
+    end
+
+    def expires_in
+      self.class.rj_expires_in
+    end
+
+    def expires?
+      !!self.expires_in
+    end
+
+    def expired?
+      if self.opts['expires_at']
+        Time.now > Time.new(opts['expires_at'])
+      elsif expires? && opts['created_at']
+        Time.now > (Time.new(opts['created_at']) + expires_in)
+      else
+        false
+      end
+    end
+  end
+
+  module ClassMethods
+    attr_accessor :rj_expires_in
+
+    # DSL method for jobs
+    def expires_in(seconds)
+     @rj_expires_in = seconds
+    end
+  end
+
+  def self.parse(payload)
+    begin
+      encoded = JSON.parse(payload)
+      job_klass = constantize(encoded['class'])
+      job = job_klass.new(*encoded['params'])
+      job.opts = encoded['opts']
+      job
+    rescue
+      log "JOB INIT ERROR at #{Time.now.to_s}:"
+      log $!.inspect
+      log $!.backtrace
+      log "message: #{payload.inspect}"
+      # Mailer.send(klass_name, params, $!)
+      # raise $!
+    end
+  end
+end

data/lib/rabbit_jobs/logger.rb

@@ -0,0 +1,18 @@
+module RabbitJobs
+  module Logger
+    extend self
+
+    def log(string)
+      puts string
+    end
+
+    def log!(string)
+      @@verbose ||= false
+      log(string) if RabbitJobs::Logger.verbose
+    end
+
+    class << self
+      attr_accessor :verbose
+    end
+  end
+end

data/lib/rabbit_jobs/publisher.rb

@@ -0,0 +1,56 @@
+# -*- encoding : utf-8 -*-
+
+require 'json'
+require 'amqp'
+require 'eventmachine'
+
+module RabbitJobs
+  module Publisher
+    extend self
+    extend AmqpHelpers
+
+    def publish(klass, opts = {}, *params)
+      key = RabbitJobs.config.routing_keys.first
+      publish_to(key, klass, opts, *params)
+    end
+
+    def publish_to(routing_key, klass, opts = {}, *params)
+      raise ArgumentError unless klass && routing_key
+      opts ||= {}
+
+      job = klass.new(*params)
+      job.opts = opts
+
+      publish_job_to(routing_key, job)
+    end
+
+    def publish_job_to(routing_key, job)
+      amqp_with_exchange do |connection, exchange|
+
+        queue = make_queue(exchange, routing_key)
+
+        job.opts['created_at'] = Time.now.to_s
+
+        payload = job.payload
+        exchange.publish(job.payload, Configuration::DEFAULT_MESSAGE_PARAMS.merge({routing_key: routing_key})) {
+          connection.close { EM.stop }
+        }
+      end
+    end
+
+    def purge_queue(routing_key)
+      raise ArgumentError unless routing_key
+
+      amqp_with_queue(routing_key) do |connection, queue|
+        queue.status do |number_of_messages, number_of_consumers|
+          queue.purge {
+            connection.close {
+              EM.stop
+              return number_of_messages
+            }
+          }
+        end
+      end
+    end
+  end
+end

data/lib/rabbit_jobs/tasks.rb

@@ -0,0 +1,51 @@
+# require 'resque/tasks'
+# will give you the resque tasks
+
+namespace :rj do
+  task :setup
+
+  desc "Start a Rabbit Jobs worker"
+  task :work => [ :preload, :setup ] do
+    require 'rabbit_jobs'
+
+    queues = (ENV['QUEUES'] || ENV['QUEUE']).to_s.split(',')
+
+    begin
+      worker = RabbitJobs::Worker.new(*queues)
+      worker.pidfile = ENV['PIDFILE']
+      worker.background = %w(yes true).include? ENV['BACKGROUND']
+      RabbitJobs::Logger.verbose = true if ENV['VERBOSE']
+      # worker.very_verbose = ENV['VVERBOSE']
+    end
+
+    # worker.log "Starting worker #{worker.pid}"
+    # worker.verbose = true
+    worker.work 10
+    # worker.work(ENV['INTERVAL'] || 5) # interval, will block
+  end
+
+  desc "Start multiple Resque workers. Should only be used in dev mode."
+  task :workers do
+    threads = []
+
+    ENV['COUNT'].to_i.times do
+      threads << Thread.new do
+        system "rake resque:work"
+      end
+    end
+
+    threads.each { |thread| thread.join }
+  end
+
+  # Preload app files if this is Rails
+  task :preload => :setup do
+    if defined?(Rails) && Rails.respond_to?(:application)
+      # Rails 3
+      Rails.application.eager_load!
+    elsif defined?(Rails::Initializer)
+      # Rails 2.3
+      $rails_rake_task = false
+      Rails::Initializer.run :load_application_classes
+    end
+  end
+end

data/lib/rabbit_jobs/version.rb

@@ -0,0 +1,3 @@
+module RabbitJobs
+  VERSION = "0.0.4.1"
+end

data/lib/rabbit_jobs/worker.rb

@@ -0,0 +1,119 @@
+# -*- encoding : utf-8 -*-
+
+module RabbitJobs
+  class Worker
+    include AmqpHelpers
+    include Logger
+
+    attr_accessor :pidfile, :background
+
+    # Workers should be initialized with an array of string queue
+    # names. The order is important: a Worker will check the first
+    # queue given for a job. If none is found, it will check the
+    # second queue name given. If a job is found, it will be
+    # processed. Upon completion, the Worker will again check the
+    # first queue given, and so forth. In this way the queue list
+    # passed to a Worker on startup defines the priorities of queues.
+    #
+    # If passed a single "*", this Worker will operate on all queues
+    # in alphabetical order. Queues can be dynamically added or
+    # removed without needing to restart workers using this method.
+    def initialize(*queues)
+      @queues = queues.map { |queue| queue.to_s.strip }.flatten.uniq
+      if @queues == ['*'] || @queues.empty?
+        @queues = RabbitJobs.config.routing_keys
+      end
+    end
+
+    def queues
+      @queues || ['default']
+    end
+
+    # Subscribes to channel and working on jobs
+    def work(time = 0)
+      startup
+
+      processed_count = 0
+      amqp_with_exchange do |connection, exchange|
+        exchange.channel.prefetch(1)
+
+        check_shutdown = Proc.new {
+          if @shutdown
+            log "Processed jobs: #{processed_count}"
+            log "Stopping worker..."
+
+            connection.close {
+              File.delete(self.pidfile) if self.pidfile
+              EM.stop { exit! }
+            }
+          end
+        }
+
+        queues.each do |routing_key|
+          queue = make_queue(exchange, routing_key)
+
+          log "Worker ##{Process.pid} <= #{exchange.name}##{routing_key}"
+
+          queue.subscribe(ack: true) do |metadata, payload|
+            @job = RabbitJobs::Job.parse(payload)
+            @job.run_perform unless @job.expired?
+            metadata.ack
+            processed_count += 1
+            check_shutdown.call
+          end
+        end
+
+        if time > 0
+          # for debugging
+          EM.add_timer(time) do
+            self.shutdown
+          end
+        end
+
+        EM.add_periodic_timer(1) do
+          check_shutdown.call
+        end
+      end
+    end
+
+    def shutdown
+      @shutdown = true
+    end
+
+    def startup
+      # prune_dead_workers
+
+      Process.daemon(true) if self.background
+
+      if self.pidfile
+        File.open(self.pidfile, 'w') { |f| f << Process.pid }
+      end
+
+      # Fix buffering so we can `rake rj:work > resque.log` and
+      # get output from the child in there.
+      $stdout.sync = true
+
+      @shutdown = false
+
+      Signal.trap('TERM') { shutdown }
+      Signal.trap('INT')  { shutdown! }
+    end
+
+    def shutdown!
+      shutdown
+      kill_child
+    end
+
+    def kill_child
+      if @job && @job.child_pid
+        # log! "Killing child at #{@child}"
+        if Kernel.system("ps -o pid,state -p #{@job.child_pid}")
+          Process.kill("KILL", @job.child_pid) rescue nil
+        else
+          # log! "Child #{@child} not found, restarting."
+          # shutdown
+        end
+      end
+    end
+  end
+end

data/lib/tasks/rabbit_jobs.rake

@@ -0,0 +1,3 @@
+
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../../lib'
+require 'rabbit_jobs/tasks'

data/rabbit_jobs.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require 'rabbit_jobs/version'
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Pavel Lazureykis"]
+  gem.email         = ["lazureykis@gmail.com"]
+  gem.description   = %q{Background jobs on RabbitMQ}
+  gem.summary       = %q{Background jobs on RabbitMQ}
+  gem.homepage      = ""
+  gem.date          = Time.now.strftime('%Y-%m-%d')
+
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.name          = "rj"
+  gem.require_paths = ["lib"]
+  gem.version       = RabbitJobs::VERSION
+
+  gem.add_dependency "amqp", "~> 0.9"
+  gem.add_dependency "rake"
+end

data/spec/fixtures/config.yml

@@ -0,0 +1,17 @@
+rabbit_jobs:
+  host: example.com
+  exchange: 'my_exchange'
+  exchange_params:
+    durable: true
+    auto_delete: false
+  queues:
+    durable_queue:
+      durable: true
+      auto_delete: false
+      ack: true
+      arguments:
+        x-ha-policy: all
+    fast_queue:
+      durable: false
+      auto_delete: true
+      ack: false

data/spec/fixtures/jobs.rb

@@ -0,0 +1,29 @@
+# -*- encoding : utf-8 -*-
+
+class TestJob
+  include RabbitJobs::Job
+end
+
+class PrintTimeJob
+  include RabbitJobs::Job
+
+  def self.perform(time)
+    puts "Running job queued at #{time}"
+  end
+end
+
+class JobWithExpire
+  include RabbitJobs::Job
+  expires_in 60*60 # expires in 1 hour
+  def self.perform
+
+  end
+end
+
+class ExpiredJob
+  include RabbitJobs::Job
+
+  def self.perform
+
+  end
+end

data/spec/integration/publisher_spec.rb

@@ -0,0 +1,19 @@
+# -*- encoding : utf-8 -*-
+require 'spec_helper'
+require 'json'
+
+describe RabbitJobs::Publisher do
+
+  before(:each) do
+    queue_name = 'test'
+    RabbitJobs.configure do |c|
+      c.exchange 'test'
+      c.queue 'rspec_queue'
+    end
+  end
+
+  it 'should publish message to queue' do
+    RabbitJobs.publish(TestJob, nil, 'some', 'other', 'params')
+    RabbitJobs::Publisher.purge_queue('rspec_queue').should == 1
+  end
+end

data/spec/integration/worker_spec.rb

@@ -0,0 +1,18 @@
+# -*- encoding : utf-8 -*-
+require 'spec_helper'
+
+require 'eventmachine'
+describe RabbitJobs::Worker do
+  it 'should listen for messages' do
+    RabbitJobs.configure do |c|
+      c.exchange 'test_durable', auto_delete: false, durable: true
+      c.queue 'rspec_durable_queue', auto_delete: false, durable: true, ack: true
+    end
+
+    5.times { RabbitJobs.publish(PrintTimeJob, nil, Time.now) }
+    5.times { RabbitJobs.publish(ExpiredJob, { :expires_at => Time.now - 10 }) }
+    worker = RabbitJobs::Worker.new
+
+    worker.work(1) # work for 1 second
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,22 @@
+# -*- encoding : utf-8 -*-
+require 'simplecov'
+SimpleCov.start do
+  add_filter "spec" # ignore spec files
+end
+
+require 'rr'
+
+require 'rabbit_jobs'
+
+require 'fixtures/jobs'
+
+RSpec.configure do |config|
+  config.mock_with :rr
+  # or if that doesn't work due to a version incompatibility
+  # config.mock_with RR::Adapters::Rspec
+
+  config.before(:each) do
+    # clear config options
+    RabbitJobs.class_variable_set '@@configuration', nil
+  end
+end

data/spec/unit/configuration_spec.rb

@@ -0,0 +1,89 @@
+# -*- encoding : utf-8 -*-
+require 'spec_helper'
+
+describe RabbitJobs::Configuration do
+  it 'builds configuration from configure block' do
+    RabbitJobs.configure do |c|
+      c.host "somehost.lan"
+
+      c.exchange 'my_exchange', durable: true, auto_delete: false
+
+      c.queue 'durable_queue', durable: true,  auto_delete: false, ack: true, arguments: {'x-ha-policy' => 'all'}
+      c.queue 'fast_queue',    durable: false, auto_delete: true,  ack: false
+    end
+
+    RabbitJobs.config.to_hash.should == {
+      host: "somehost.lan",
+      exchange: "my_exchange",
+      exchange_params: {
+        durable: true,
+        auto_delete: false
+      },
+      queues: {
+        "durable_queue" => {
+          durable: true,
+          auto_delete: false,
+          ack: true,
+          arguments: {"x-ha-policy"=>"all"}
+        },
+        "fast_queue" => {
+          durable: false,
+          auto_delete: true,
+          ack: false
+        },
+      }
+    }
+  end
+
+  it 'builds configuration from yaml' do
+    RabbitJobs.config.load_file(File.expand_path('../../fixtures/config.yml', __FILE__))
+
+    RabbitJobs.config.to_hash.should == {
+      host: "example.com",
+      exchange: "my_exchange",
+      exchange_params: {
+        durable: true,
+        auto_delete: false
+      },
+      queues: {
+        "durable_queue" => {
+          durable: true,
+          auto_delete: false,
+          ack: true,
+          arguments: {"x-ha-policy"=>"all"}
+        },
+        "fast_queue" => {
+          durable: false,
+          auto_delete: true,
+          ack: false
+        }
+      }
+    }
+  end
+
+  it 'use default config' do
+    RabbitJobs.config.to_hash.should == {
+      host: "localhost",
+      exchange: "rabbit_jobs",
+      exchange_params: {
+        auto_delete: false,
+        durable: true
+      },
+      queues: {
+        "default" => {
+          auto_delete: false,
+          ack: true,
+          durable: true
+        }
+      }
+    }
+  end
+
+  it 'returns settings on some methods' do
+    RabbitJobs.config.host.should == 'localhost'
+    RabbitJobs.config[:host].should == 'localhost'
+    RabbitJobs.config.routing_keys.should == ['default']
+    RabbitJobs.config.exchange.should == 'rabbit_jobs'
+    RabbitJobs.config.queue_name('default').should == 'rabbit_jobs#default'
+  end
+end

data/spec/unit/job_spec.rb

@@ -0,0 +1,29 @@
+# -*- encoding : utf-8 -*-
+require 'spec_helper'
+
+describe RabbitJobs::Job do
+  it 'should parse class and params' do
+    job = RabbitJobs::Job.parse({class: 'TestJob', params: [1,2,3]}.to_json)
+    job.params.should == [1, 2, 3]
+  end
+
+  it 'should understand expires_in' do
+    job = JobWithExpire.new(1, 2, 3)
+    job.expires_in.should == 60*60
+    job.expires?.should == true
+  end
+
+  context 'job expiration' do
+    it 'should expire job by expires_in option' do
+      job = TestJob.new
+      job.opts['expires_at'] = (Time.now - 10).to_s
+      job.expired?.should == true
+    end
+
+    it 'should expire job by expires_in option in job class and current_time' do
+      job = JobWithExpire.new(1, 2, 3)
+      job.opts['created_at'] = (Time.now - job.expires_in - 10).to_s
+      job.expired?.should == true
+    end
+  end
+end

data/spec/unit/logger_spec.rb

@@ -0,0 +1,23 @@
+# -*- encoding : utf-8 -*-
+require 'spec_helper'
+
+describe RabbitJobs::Logger do
+  it '#log should write messages to stdout' do
+    mock($stdout).puts "hello"
+    RabbitJobs::Logger.log("hello")
+  end
+
+  it '#log! should not write messages to stdout in normal mode' do
+    RabbitJobs::Logger.verbose = false
+
+    dont_allow(RabbitJobs::Logger).log("hello")
+    RabbitJobs::Logger.log!("hello")
+  end
+
+  it '#log! should write messages to stdout in verbose mode' do
+    RabbitJobs::Logger.verbose = true
+
+    mock(RabbitJobs::Logger).log("hello")
+    RabbitJobs::Logger.log!("hello")
+  end
+end

data/spec/unit/rabbit_jobs_spec.rb

@@ -0,0 +1,11 @@
+# -*- encoding : utf-8 -*-
+
+describe RabbitJobs do
+  it 'should pass publish methods to publisher' do
+    mock(RabbitJobs::Publisher).publish(TestJob, nil, 1, 2, "string")
+    RabbitJobs.publish(TestJob, nil, 1, 2, "string")
+
+    mock(RabbitJobs::Publisher).publish_to('default_queue', TestJob, nil, 1, 2, "string")
+    RabbitJobs.publish_to('default_queue', TestJob, nil, 1, 2, "string")
+  end
+end

data/spec/unit/worker_spec.rb

@@ -0,0 +1,60 @@
+# -*- encoding : utf-8 -*-
+require 'spec_helper'
+
+describe RabbitJobs::Worker do
+  describe 'methods' do
+    before :each do
+      @worker = RabbitJobs::Worker.new
+    end
+
+    it '#initialize with default options' do
+      @worker.queues.should == ['default']
+    end
+
+    it '#startup should set @shutdown to false' do
+      @worker.instance_variable_get('@shutdown').should_not == true
+
+      mock(Signal).trap('TERM')
+      mock(Signal).trap('INT')
+
+      @worker.startup
+
+      @worker.instance_variable_get('@shutdown').should_not == true
+    end
+
+    it '#startup should write process id to file' do
+      mock(Signal).trap('TERM')
+      mock(Signal).trap('INT')
+
+      filename = 'test_worker.pid'
+      mock(File).open(filename, 'w') {}
+      @worker.pidfile = filename
+      @worker.startup
+      @worker.pidfile.should == filename
+    end
+
+    it '#shutdown should set @shutdown to true' do
+      @worker.instance_variable_get('@shutdown').should_not == true
+      @worker.shutdown
+      @worker.instance_variable_get('@shutdown').should == true
+    end
+
+    it '#shutdown! should kill child process' do
+      mock(@worker.kill_child)
+      mock(@worker.shutdown)
+
+      @worker.shutdown!
+    end
+
+    it '#kill_child' do
+      job = TestJob.new()
+      job.instance_variable_set '@child_pid', 123123
+      @worker.instance_variable_set('@job', job)
+
+      mock(Kernel).system("ps -o pid,state -p #{123123}") { true }
+      mock(Process).kill("KILL", 123123)
+
+      @worker.kill_child
+    end
+  end
+end

metadata

@@ -0,0 +1,106 @@
+--- !ruby/object:Gem::Specification
+name: rj
+version: !ruby/object:Gem::Version
+  version: 0.0.4.1
+  prerelease: 
+platform: ruby
+authors:
+- Pavel Lazureykis
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-01-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: amqp
+  requirement: &70272887573820 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70272887573820
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &70272887573200 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70272887573200
+description: Background jobs on RabbitMQ
+email:
+- lazureykis@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- examples/configuration.rb
+- lib/rabbit_jobs.rb
+- lib/rabbit_jobs/amqp_helpers.rb
+- lib/rabbit_jobs/configuration.rb
+- lib/rabbit_jobs/helpers.rb
+- lib/rabbit_jobs/job.rb
+- lib/rabbit_jobs/logger.rb
+- lib/rabbit_jobs/publisher.rb
+- lib/rabbit_jobs/tasks.rb
+- lib/rabbit_jobs/version.rb
+- lib/rabbit_jobs/worker.rb
+- lib/tasks/rabbit_jobs.rake
+- rabbit_jobs.gemspec
+- spec/fixtures/config.yml
+- spec/fixtures/jobs.rb
+- spec/integration/publisher_spec.rb
+- spec/integration/worker_spec.rb
+- spec/spec_helper.rb
+- spec/unit/configuration_spec.rb
+- spec/unit/job_spec.rb
+- spec/unit/logger_spec.rb
+- spec/unit/rabbit_jobs_spec.rb
+- spec/unit/worker_spec.rb
+homepage: ''
+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.15
+signing_key: 
+specification_version: 3
+summary: Background jobs on RabbitMQ
+test_files:
+- spec/fixtures/config.yml
+- spec/fixtures/jobs.rb
+- spec/integration/publisher_spec.rb
+- spec/integration/worker_spec.rb
+- spec/spec_helper.rb
+- spec/unit/configuration_spec.rb
+- spec/unit/job_spec.rb
+- spec/unit/logger_spec.rb
+- spec/unit/rabbit_jobs_spec.rb
+- spec/unit/worker_spec.rb