delayed_job_ironmq 0.1.0

data/README.md

@@ -0,0 +1,59 @@
+This is [IronMQ](http://www.iron.io/products/mq) backend for [delayed_job](http://github.com/collectiveidea/delayed_job)
+
+# Getting Started
+
+## Get credentials
+
+To start using delayed_job_ironmq, you need to sign up and get an oauth token.
+
+1. Go to http://iron.io/ and sign up.
+2. Get an Oauth Token at http://hud.iron.io/tokens
+
+## Installation
+
+Add the gems to your `Gemfile:`
+
+```ruby
+gem 'delayed_job'
+gem 'delayed_job_ironmq'
+```
+
+And add an initializer (`config/initializers/delayed_job_config.rb`):
+
+```ruby
+Delayed::Worker.configure do |config|
+  config.token = 'XXXXXXXXXXXXXXXX'
+  config.project_id = 'XXXXXXXXXXXXXXXX'
+
+  # optional params:
+  config.available_priorities = [-1,0,1,2] # Default is [0]. Please note, each new priority will speed down a bit picking job from queue
+  config.queue_name = 'default' # Specify an alternative queue name
+  config.delay = 0  # Time to wait before message will be available on the queue
+  config.timeout = 5.minutes # The time in seconds to wait after message is taken off the queue, before it is put back on. Delete before :timeout to ensure it does not go back on the queue.
+  config.expires_in = 7.days # After this time, message will be automatically removed from the queue.
+ end
+end
+```
+
+## Usage
+
+That's it. Use [delayed_job as normal](http://github.com/collectiveidea/delayed_job).
+
+Example:
+
+```ruby
+class TestJob < Struct.new(:a, :b)
+  def perform
+    puts  a/b
+  end
+end
+Delayed::Job.enqueue TestJob.new(10, 2)
+
+```
+
+# Documentation
+
+You can find more documentation here:
+
+* http://iron.io
+* http://dev.iron.io

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/delayed/backend/actions.rb

@@ -0,0 +1,75 @@
+module Delayed
+  module Backend
+    module Ironmq
+      module Actions
+        def field(name, options = {})
+          #type   = options[:type]    || String
+          default = options[:default] || nil
+          define_method name do
+            @attributes ||= {}
+            @attributes[name.to_sym] || default
+          end
+          define_method "#{name}=" do |value|
+            @attributes ||= {}
+            @attributes[name.to_sym] = value
+          end
+        end
+
+        def before_fork
+        end
+
+        def after_fork
+        end
+
+        def db_time_now
+          Time.now.utc
+        end
+
+        #def self.queue_name
+        #  Delayed::Worker.queue_name
+        #end
+
+        def find_available(worker_name, limit = 5, max_run_time = Worker.max_run_time)
+          Delayed::Worker.available_priorities.each do |priority|
+            messages = ironmq.messages.get(queue_name: queue_name(priority), n: limit)
+            jobs = messages.map do |message|
+              Delayed::Backend::Ironmq::Job.new(message)
+            end
+            return jobs if jobs.present?
+          end
+          []
+        end
+
+        def delete_all
+          deleted = 0
+          Delayed::Worker.available_priorities.each do |priority|
+            loop do
+              msgs = ironmq.messages.get(n: 1000, queue_name: queue_name(priority))
+              break if msgs.blank?
+              msgs.each do |msg|
+                ironmq.messages.delete(msg.id, queue_name: queue_name(priority))
+                deleted += 1
+              end
+            end
+          end
+          puts "Messages removed: #{deleted}"
+        end
+
+        # No need to check locks
+        def clear_locks!(*args)
+          true
+        end
+
+        private
+
+        def ironmq
+          ::Delayed::Worker.ironmq
+        end
+
+        def queue_name(priority)
+          "#{Delayed::Worker.queue_name}_#{priority || 0}"
+        end
+      end
+    end
+  end
+end

data/lib/delayed/backend/iron_mq_config.rb

@@ -0,0 +1,5 @@
+class IronMqConfig
+    attr_accessor :token, :project_id,
+                  :queue_name, :delay, :timeout,
+                  :expires_in, :available_priorities
+end

data/lib/delayed/backend/ironmq.rb

@@ -0,0 +1,123 @@
+
+
+module Delayed
+  module Backend
+    module Ironmq
+      class Job
+        include ::DelayedJobIronmq::Document
+        include Delayed::Backend::Base
+        extend  Delayed::Backend::Ironmq::Actions
+
+        field :priority,    :type => Integer, :default => 0
+        field :attempts,    :type => Integer, :default => 0
+        field :handler,     :type => String
+        field :run_at,      :type => Time
+        field :locked_at,   :type => Time
+        field :locked_by,   :type => String
+        field :failed_at,   :type => Time
+        field :last_error,  :type => String
+        field :queue,       :type => String
+
+        def initialize(data = {})
+          puts "[init] Delayed::Backend::Ironmq"
+          @id = nil
+          if data.is_a?(IronMQ::Message)
+            @id = data.id
+            data = JSON.load(data.body)
+          end
+
+          data.symbolize_keys!
+          payload_obj = data.delete(:payload_object) || data.delete(:handler)
+
+          @queue_name = data[:queue_name] || Delayed::Worker.queue_name
+          @delay      = data[:delay]      || Delayed::Worker.delay
+          @timeout    = data[:timeout]    || Delayed::Worker.timeout
+          @expires_in = data[:expires_in] || Delayed::Worker.expires_in
+          @attributes = data
+          self.payload_object = payload_obj
+        end
+
+        def payload_object
+          @payload_object ||= YAML.load(self.handler)
+        rescue TypeError, LoadError, NameError, ArgumentError => e
+          raise DeserializationError,
+            "Job failed to load: #{e.message}. Handler: #{handler.inspect}"
+        end
+
+        def payload_object=(object)
+          if object.is_a? String
+            @payload_object = YAML.load(object)
+            self.handler = object
+          else
+            @payload_object = object
+            self.handler = object.to_yaml
+          end
+        end
+
+        def save
+          puts "[SAVE] #{@attributes.inspect}"
+
+          if @attributes[:handler].blank?
+            raise "Handler missing!"
+          end
+          payload = JSON.dump(@attributes)
+
+          ironmq.messages.delete(@id, queue_name: queue_name) if @id.present?
+          ironmq.messages.post(payload,
+            timeout:    @timeout,
+            queue_name: queue_name,
+            delay:      @delay,
+            expires_in: @expires_in)
+          true
+        end
+
+        def save!
+          save
+        end
+
+        def destroy
+          if @id
+            puts "job destroyed! #{@id.inspect}"
+            ironmq.messages.delete(@id, queue_name: queue_name) if @id.present?
+          end
+        end
+
+        def fail!
+          destroy
+          # v2: move to separate queue
+        end
+
+        def update_attributes(attributes)
+          attributes.symbolize_keys!
+          @attributes.merge attributes
+          save
+        end
+
+        # No need to check locks
+        def lock_exclusively!(*args)
+          true
+        end
+
+        # No need to check locks
+        def unlock(*args)
+          true
+        end
+
+        def reload(*args)
+          # reset
+          super
+        end
+
+        private
+
+        def queue_name
+          "#{@queue_name}_#{@attributes[:priority] || 0}"
+        end
+
+        def ironmq
+          ::Delayed::Worker.ironmq
+        end
+      end
+    end
+  end
+end

data/lib/delayed/backend/worker.rb

@@ -0,0 +1,38 @@
+require_relative 'iron_mq_config'
+
+module Delayed
+  class Worker
+    class << self
+      attr_accessor :config, :ironmq,
+                    :queue_name, :delay, :timeout, :expires_in, :available_priorities
+
+      def configure
+        yield(config)
+        if config && config.token && config.project_id
+          Delayed::Worker.ironmq = IronMQ::Client.new(
+            'token' => config.token,
+            'project_id' => config.project_id
+          )
+          self.queue_name = config.queue_name || 'default'
+          self.delay      = config.delay      || 0
+          self.timeout    = config.timeout    || 5.minutes
+          self.expires_in = config.expires_in || 7.days
+
+          priorities      = config.available_priorities || [0]
+          if priorities.include?(0) && priorities.all?{|p|p.is_a?(Integer)}
+            self.available_priorities = priorities.sort
+          else
+            raise ArgumentError, "available_priorities option has wrong format. Please provide array of Integer values, includes zero. Default is [0]."
+          end
+        else
+          raise ArgumentError, "Required option missing. Please provide both 'token' and 'project_id'"
+        end
+      end
+
+      def config
+        @config ||= IronMqConfig.new
+      end
+
+    end
+  end
+end

data/lib/delayed/serialization/ironmq.rb

@@ -0,0 +1,6 @@
+# encoding: utf-8
+
+module DelayedJobIronmq
+  module Document
+  end
+end

data/lib/delayed_job_ironmq.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+require 'iron_mq'
+require 'delayed_job'
+
+require_relative 'delayed/serialization/ironmq'
+require_relative 'delayed/backend/actions'
+require_relative 'delayed/backend/iron_mq_config'
+require_relative 'delayed/backend/worker'
+require_relative 'delayed/backend/ironmq'
+
+Delayed::Worker.backend = :ironmq

metadata

@@ -0,0 +1,115 @@
+--- !ruby/object:Gem::Specification
+name: delayed_job_ironmq
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Alexander Shapiotko
+- Iron.io, Inc
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-03-06 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: iron_mq
+  requirement: &36672804 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.4.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *36672804
+- !ruby/object:Gem::Dependency
+  name: delayed_job
+  requirement: &36672300 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *36672300
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: &36672000 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *36672000
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &36671688 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: *36671688
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: &36671388 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.8.3
+  type: :development
+  prerelease: false
+  version_requirements: *36671388
+description: IronMQ backend for delayed_job
+email: info@iron.io
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE
+- README.md
+files:
+- LICENSE
+- README.md
+- VERSION
+- lib/delayed/backend/actions.rb
+- lib/delayed/backend/iron_mq_config.rb
+- lib/delayed/backend/ironmq.rb
+- lib/delayed/backend/worker.rb
+- lib/delayed/serialization/ironmq.rb
+- lib/delayed_job_ironmq.rb
+- spec/.gitkeep
+homepage: http://www.iron.io
+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'
+      segments:
+      - 0
+      hash: -931014419
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: IronMQ backend for delayed_job
+test_files: []