cascade 0.0.0 → 0.0.1

data/lib/cascade.rb

@@ -0,0 +1,3 @@
+require 'cascade/worker'
+require 'cascade/job'
+require 'cascade/job_spec'

data/lib/cascade/job.rb

@@ -0,0 +1,27 @@
+require 'cascade/job/callbacks'
+
+module Cascade
+  module Job
+    include Callbacks
+
+    def self.included(mod)
+      mod.extend(ClassMethods)
+    end
+
+    def run
+      true
+    end
+
+    def describe
+      self.class.name
+    end
+
+    module ClassMethods
+      include Callbacks::ClassMethods
+
+      def enqueue(*args)
+        Worker.enqueue(name, *args)
+      end
+    end
+  end
+end

data/lib/cascade/job/callbacks.rb

@@ -0,0 +1,31 @@
+module Cascade
+  module Job
+    module Callbacks
+      def run_callbacks(action, job_spec)
+        if self.class.instance_variable_defined?('@callbacks')
+          callbacks = self.class.instance_variable_get('@callbacks')
+          callbacks[action].each do |callback|
+            if callback.is_a?(Symbol)
+              send(callback, job_spec)
+            else
+              instance_exec job_spec, &callback
+            end
+          end
+        end
+      end
+
+      module ClassMethods
+        %w(before_queue before_run on_success on_error after_run).each do |action|
+          define_method(action) do |*args, &block|
+            add_callback(action.to_sym, args[0], &block)
+          end
+        end
+
+        def add_callback(action, method = nil, &block)
+          callbacks = @callbacks ||= Hash.new { |h,k| h[k] = [] }
+          callbacks[action] << (method || block)
+        end
+      end
+    end
+  end
+end

data/lib/cascade/job_spec.rb

@@ -0,0 +1,21 @@
+module Cascade
+  class JobSpec
+    include ::MongoMapper::Document
+    set_collection_name 'cascade_jobs'
+
+    key :class_name, String, :required => true
+    key :arguments, Array
+    key :priority, Integer, :default => 1
+    key :run_at, Time, :default => lambda { Time.now.utc }
+    key :attempts, Integer, :default => 0
+    key :locked_at, Time
+    key :locked_by, String
+    key :failed_at, Time
+    key :last_error, String
+    key :re_run, Boolean, :default => false
+
+    def job
+      @job ||= class_name.constantize.new(*arguments)
+    end
+  end
+end

data/lib/cascade/worker.rb

@@ -0,0 +1,109 @@
+module Cascade
+  class Worker
+    def self.start
+      trap('TERM') { $exit = true }
+      trap('INT') { $exit = true }
+
+      loop do
+        run
+      end
+    end
+
+    def self.run
+      find_available.each do |job_spec|
+        break if $exit
+        if lock_exclusively!(job_spec)
+          run_forked(job_spec)
+        end
+      end
+    end
+
+    def self.run_forked(job_spec)
+      pid = fork do
+        job = job_spec.job
+        $0 = "Cascade::Job : #{name} : #{job.describe}"
+        run_job(job_spec, job)
+      end
+      Process.wait(pid)
+    end
+
+    def self.run_job(job_spec, job)
+      completed_successully = true
+      begin
+        job.run_callbacks(:before_run, job_spec)
+        job.run
+        job.run_callbacks(:on_success, job_spec)
+      rescue Exception => ex
+        job_spec.last_error = [ex, ex.backtrace].flatten.join("\n")
+        job_spec.failed_at = Time.now.utc
+        job.run_callbacks(:on_error, job_spec)
+        completed_successully = false
+      ensure
+        job.run_callbacks(:after_run, job_spec)
+      end
+      if completed_successully && !job_spec.re_run?
+        job_spec.destroy
+      else
+        job_spec.save!
+      end
+      completed_successully
+    end
+
+    def self.enqueue(class_name, *args)
+      job_spec = JobSpec.new(:class_name => class_name,
+                             :arguments => args,
+                             :run_at => Time.now.utc,
+                             :priority => 1)
+
+      job = job_spec.job
+      job.run_callbacks(:before_queue, job_spec)
+
+      job_spec.save!
+      job_spec
+    end
+
+    def self.name=(name)
+      @name = name
+    end
+
+    def self.name
+      @name ||= generate_name
+    end
+
+    def self.generate_name
+      "#{Socket.gethostname} pid:#{Process.pid}" rescue "pid:#{Process.pid}"
+    end
+
+    private
+      def self.find_available
+        right_now = Time.now.utc
+
+        conditions = {
+          :run_at => {'$lte' => right_now},
+          :failed_at => nil,
+          :locked_at => nil
+        }
+
+        job_specs = JobSpec.where(conditions).limit(-1).sort([[:priority, 1], [:run_at, 1]]).all
+        job_specs
+      end
+
+      def self.lock_exclusively!(job_spec)
+        right_now = Time.now.utc
+
+        conditions = {
+          :_id => job_spec.id,
+          :run_at => {'$lte' => right_now}
+        }
+        job_spec.collection.update(conditions, {'$set' => {:locked_at => right_now, :locked_by => name}})
+        affected_rows = job_spec.collection.find({:_id => job_spec.id, :locked_by => name}).count
+        if affected_rows == 1
+          job_spec.locked_at = right_now
+          job_spec.locked_by = name
+          true
+        else
+          false
+        end
+      end
+  end
+end

metadata

@@ -2,7 +2,7 @@
 name: cascade
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.0.0
+  version: 0.0.1
 platform: ruby
 authors: 
 - Andrew Timberlake
@@ -35,6 +35,11 @@ extra_rdoc_files:
 - README.rdoc
 files: 
 - LICENSE
+- lib/cascade/job/callbacks.rb
+- lib/cascade/job.rb
+- lib/cascade/job_spec.rb
+- lib/cascade/worker.rb
+- lib/cascade.rb
 - README.rdoc
 has_rdoc: true
 homepage: http://github.com/andrewtimberlake/cascade