say_when 0.3.0 → 1.0.0

data/lib/say_when/processor/active_messaging.rb

@@ -1,22 +1,21 @@
+# encoding: utf-8
+
 require 'activemessaging/message_sender'
 
 module SayWhen
   module Processor
-  
     class ActiveMessaging < SayWhen::Processor::Base
-      
+
       include ::ActiveMessaging::MessageSender
-    
+
       def initialize(scheduler)
         super(scheduler)
       end
 
       # send the job to the other end, then in the a13g processor, call the execute method
       def process(job)
-        publish(:say_when, {:job_id=>job.id}.to_yaml)
+        publish(:say_when, { job_id: job.id }.to_yaml )
       end
-      
-    end
-
+    end if defined?(::ActiveMessaging)
   end
-end
+end

data/lib/say_when/processor/base.rb

@@ -1,13 +1,15 @@
+# encoding: utf-8
+
 module SayWhen
   module Processor
-    
+
     class Base
       attr_accessor :scheduler
-    
+
       def initialize(scheduler)
         @scheduler = scheduler
       end
-    
+
       def process(job)
         raise NotImplementedError.new('You need to implement process(job)')
       end

data/lib/say_when/processor/shoryuken.rb

@@ -0,0 +1,14 @@
+# encoding: utf-8
+
+module SayWhen
+  module Processor
+    class Shoryuken < SayWhen::Processor::Base
+      def initialize(scheduler)
+        super(scheduler)
+      end
+
+      def process(job)
+      end
+    end
+  end
+end

data/lib/say_when/processor/simple.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 module SayWhen
   module Processor
 

data/lib/say_when/railtie.rb

@@ -0,0 +1,9 @@
+# encoding: utf-8
+
+module SayWhen
+  class Railtie < Rails::Railtie
+    rake_tasks do
+      require 'say_when/tasks'
+    end
+  end
+end

data/lib/say_when/scheduler.rb

@@ -1,50 +1,42 @@
-module SayWhen
+# encoding: utf-8
 
+module SayWhen
   class Scheduler
 
     DEFAULT_PROCESSOR_CLASS  = SayWhen::Processor::Simple
     DEFAULT_STORAGE_STRATEGY = :memory
 
     @@scheduler = nil
-    @@lock = nil
+    @@lock = Mutex.new
 
-    attr_accessor :storage_strategy, :processor_class, :tick_length, :reset_acquired_length
+    attr_accessor :storage_strategy, :processor_class, :tick_length
 
     attr_accessor :running
 
     # support for a singleton scheduler, but you are not restricted to this
     class << self
-
       def scheduler
-        self.lock.synchronize {
-          if @@scheduler.nil?
-            @@scheduler = self.new
-          end
-        }
+        return @@scheduler if @@scheduler
+        @@lock.synchronize { @@scheduler = self.new if @@scheduler.nil? }
         @@scheduler
       end
 
       def configure
-        yield self.scheduler
-        self.scheduler
-      end
-
-      def lock
-        @@lock ||= Mutex.new
+        yield scheduler
+        scheduler
       end
 
       def schedule(job)
-        self.scheduler.schedule(job)
+        scheduler.schedule(job)
       end
 
       def start
-        self.scheduler.start
+        scheduler.start
       end
     end
 
     def initialize
-      self.tick_length = 1
-      self.reset_acquired_length = 3600
+      self.tick_length = [ENV['SAY_WHEN_TICK_LENGTH'].to_i, 5].max
     end
 
     def processor
@@ -68,67 +60,50 @@ module SayWhen
 
         logger.info "SayWhen::Scheduler running"
         job = nil
-        reset_next_at = Time.now
         while running
           begin
             time_now = Time.now
-
-            if reset_acquired_length > 0 && reset_next_at <= time_now
-              reset_next_at = time_now + reset_acquired_length
-              logger.debug "SayWhen:: reset acquired at #{time_now}, try again at #{reset_next_at}"
-              job_class.reset_acquired(reset_acquired_length)
-            end
-
-            begin
-              logger.debug "SayWhen:: Looking for job that should be ready to fire before #{time_now}"
-              job = job_class.acquire_next(time_now)
-            rescue StandardError => ex
-              job_error("Failure to acquire job", job, ex)
-              job = nil
-            end
-
+            logger.debug "SayWhen:: Looking for job that should be ready to fire before #{time_now}"
+            job = job_class.acquire_next(time_now)
             if job.nil?
               logger.debug "SayWhen:: no jobs to acquire, sleep"
               sleep(tick_length)
-              next
-            end
-
-            begin
+            else
               logger.debug "SayWhen:: got a job: #{job.inspect}"
               # delegate processing the trigger to the processor
               self.processor.process(job)
               logger.debug "SayWhen:: job processed"
 
-              # if successful, update next fire at, put back to waiting / ended
+              # this should update next fire at, and put back in list of scheduled jobs
               job.fired(time_now)
               logger.debug "SayWhen:: job fired complete"
-            rescue StandardError=>ex
-              job_error("Failure to process", job, ex)
             end
-
-          rescue Interrupt => ex
-            job_error("Interrupt!", job, ex)
-            raise ex
           rescue StandardError => ex
-            job_error("Error!", job, ex)
+            job_msg = job && "job: #{job.inspect} "
+            logger.error "SayWhen:: Failure: #{job_msg}exception: #{ex.message}\n\t#{ex.backtrace.join("\t\n")}"
+            safe_release(job)
             sleep(tick_length)
+          rescue Interrupt => ex
+            job_msg = job && "\n - interrupted job: #{job.inspect}\n"
+            logger.error "\nSayWhen:: Interrupt! #{ex.inspect}#{job_msg}"
+            safe_release(job)
+            exit
           rescue Exception => ex
-            job_error("Exception!", job, ex)
-            raise ex
+            job_msg = job && "job: #{job.inspect} "
+            logger.error "SayWhen:: Exception: #{job_msg}exception: #{ex.message}\n\t#{ex.backtrace.join("\t\n")}"
+            safe_release(job)
+            exit
           end
         end
-      rescue Exception=>ex
-        logger.error "SayWhen::Scheduler stopping, error: #{ex.class.name}: #{ex.message}"
-        exit
       end
 
       logger.info "SayWhen::Scheduler stopped"
     end
 
-    def job_error(msg, job, ex)
-      job_msg = job && " job:'#{job.inspect}'"
-      logger.error "SayWhen::Scheduler #{msg}#{job_msg}: #{ex.message}\n\t#{ex.backtrace.join("\t\n")}"
+    def safe_release(job)
       job.release if job
+    rescue
+      logger "Failed to release job: #{job.inspect}" rescue nil
     end
 
     def stop
@@ -154,6 +129,5 @@ module SayWhen
     def logger
       SayWhen::logger
     end
-
   end
 end

data/lib/say_when/storage/active_record/acts.rb

@@ -1,57 +1,59 @@
+# encoding: utf-8
+
 module SayWhen #:nodoc:
   module Storage #:nodoc:
     module ActiveRecord #:nodoc:
       module Acts #:nodoc:
 
-        def self.included(base) # :nodoc:
-          base.extend ClassMethods
-        end
+        extend ActiveSupport::Concern
 
         module ClassMethods
           def acts_as_scheduled
             include SayWhen::Storage::ActiveRecord::Acts::InstanceMethods
-          
-            has_many :scheduled_jobs, :as=>:scheduled, :class_name=>'SayWhen::Storage::ActiveRecord::Job', :dependent => :destroy
+
+            has_many :scheduled_jobs, as: :scheduled, class_name: 'SayWhen::Storage::ActiveRecord::Job', dependent: :destroy
           end
         end
-    
+
         module InstanceMethods
 
           def schedule_instance(next_at_method, job={})
             options = job_options(job)
             options[:trigger_strategy] = 'instance'
-            options[:trigger_options]  = {:next_at_method => next_at_method}
+            options[:trigger_options]  = { next_at_method: next_at_method }
             Scheduler.schedule(options)
           end
 
           def schedule_cron(expression, time_zone, job={})
             options = job_options(job)
             options[:trigger_strategy] = 'cron'
-            options[:trigger_options]  = {:expression => expression, :time_zone => time_zone}
+            options[:trigger_options]  = { expression: expression, time_zone: time_zone }
             Scheduler.schedule(options)
           end
 
           def schedule_once(time, job={})
             options = job_options(job)
             options[:trigger_strategy] = 'once'
-            options[:trigger_options]  = {:at => time}
+            options[:trigger_options]  = { at: time}
             Scheduler.schedule(options)
           end
 
           def schedule_in(after, job={})
             options = job_options(job)
             options[:trigger_strategy] = 'once'
-            options[:trigger_options]  = {:at => (Time.now + after)}
+            options[:trigger_options]  = { at: (Time.now + after)}
             Scheduler.schedule(options)
           end
 
           # helpers
 
           def job_options(job)
-            { :scheduled        => self,
-              :job_class        => extract_job_class(job),
-              :job_method       => extract_job_method(job),
-              :data             => extract_data(job) }
+            {
+              scheduled:  self,
+              job_class:  extract_job_class(job),
+              job_method: extract_job_method(job),
+              data:       extract_data(job)
+            }
           end
 
           def extract_job_class(job)
@@ -81,9 +83,7 @@ module SayWhen #:nodoc:
               nil
             end
           end
-
         end # InstanceMethods
-      
       end
     end
   end

data/lib/say_when/storage/active_record/job.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require 'active_record'
 require 'say_when/base_job'
 require 'say_when/storage/active_record/job_execution'
@@ -8,41 +10,34 @@ module SayWhen
     module ActiveRecord
 
       class Job  < ::ActiveRecord::Base
+
         include SayWhen::BaseJob
-        self.table_name = "say_when_jobs"
+
+        self.table_name = 'say_when_jobs'
+
         serialize :trigger_options
         serialize :data
-        belongs_to :scheduled, :polymorphic => true
-        has_many  :job_executions, :class_name=>'SayWhen::Storage::ActiveRecord::JobExecution'
-        before_create :set_defaults
 
-        def self.reset_acquired(older_than_seconds)
-          return unless older_than_seconds.to_i > 0
-          older_than = (Time.now - older_than_seconds.to_i)
-          update_all(
-            "status = '#{STATE_WAITING}'",
-            ["status = ? and updated_at < ?", STATE_ACQUIRED, older_than]
-          )
-        end
+        belongs_to :scheduled, polymorphic: true
+        has_many  :job_executions, class_name: 'SayWhen::Storage::ActiveRecord::JobExecution'
+
+        before_create :set_defaults
 
         def self.acquire_next(no_later_than)
-          @next_job = nil
+          next_job = nil
+
           hide_logging do
             SayWhen::Storage::ActiveRecord::Job.transaction do
               # select and lock the next job that needs executin' (status waiting, and after no_later_than)
-              @next_job = find(:first,
-                              :lock       => true,
-                              :order      => 'next_fire_at ASC',
-                              :conditions => ['status = ? and ? >= next_fire_at',
-                                              STATE_WAITING,
-                                              no_later_than.in_time_zone('UTC')])
+              next_job = where('status = ? and next_fire_at < ?', STATE_WAITING, no_later_than.in_time_zone('UTC')).
+                order('next_fire_at ASC').
+                lock(true).first
 
               # set status to acquired to take it out of rotation
-              @next_job.update_attribute(:status, STATE_ACQUIRED) unless @next_job.nil?
-
+              next_job.update_attribute(:status, STATE_ACQUIRED) unless next_job.nil?
             end
           end
-          @next_job
+          next_job
         end
 
         def set_defaults
@@ -99,9 +94,7 @@ module SayWhen
             ::ActiveRecord::Base.logger = old_logger
           end
         end
-
       end
-
     end
   end
 end

data/lib/say_when/storage/active_record/job_execution.rb

@@ -1,17 +1,14 @@
+# encoding: utf-8
+
 require 'active_record'
 
 module SayWhen
   module Storage
     module ActiveRecord
-
-      class JobExecution  < ::ActiveRecord::Base
-
+      class JobExecution < ::ActiveRecord::Base
         self.table_name = "say_when_job_executions"
-        
-        belongs_to :job, :class_name=>'SayWhen::Storage::ActiveRecord::Job'
-
+        belongs_to :job, class_name: 'SayWhen::Storage::ActiveRecord::Job'
       end
-
     end
   end
-end
+end

data/lib/say_when/storage/memory/base.rb

@@ -1,9 +1,11 @@
+# encoding: utf-8
+
 module SayWhen
   module Storage
     module Memory
 
       module Base
-        
+
         attr_accessor :props
 
         def has_properties(*args)

data/lib/say_when/storage/memory/job.rb

@@ -1,81 +1,53 @@
+# encoding: utf-8
+
 require 'say_when/storage/memory/base'
 
 module SayWhen
-  module Store
+  module Storage
     module Memory
 
       # define a trigger class
       class Job
 
-        cattr_accessor :jobs
-        @@jobs = SortedSet.new
-
         include SayWhen::Storage::Memory::Base
-      	include SayWhen::BaseJob
+        include SayWhen::BaseJob
 
         has_properties :group, :name, :status, :start_at, :end_at
         has_properties :trigger_strategy, :trigger_options, :last_fire_at, :next_fire_at
         has_properties :job_class, :job_method, :data
         has_properties :scheduled
-        has_properties :updated_at
-
-        def self.class_lock
-          @@_lock ||= Mutex.new
-        end
 
-        def self._reset
-          @@jobs = SortedSet.new
-        end
-
-        def self.reset_acquired(older_than_seconds)
-          return unless older_than_seconds.to_i > 0
-          older_than = (Time.now - older_than_seconds.to_i)
-          self.class_lock.synchronize {
-            jobs.select do |j|
-              j.status == STATE_ACQUIRED && j.updated_at < older_than
-            end.each{ |j| j.status = STATE_WAITING }
-          }
-        end
+        cattr_accessor :jobs
+        @@jobs = SortedSet.new
+        @@acquire_lock = Mutex.new
 
         def self.acquire_next(no_later_than)
-          self.class_lock.synchronize {
+          @@acquire_lock.synchronize {
 
             next_job = jobs.detect(nil) do |j|
               (j.status == STATE_WAITING) && (j.next_fire_at.to_i <= no_later_than.to_i)
             end
 
-            if next_job
-              next_job.status = STATE_ACQUIRED
-              next_job.updated_at = Time.now
-            end
-
+            next_job.status = STATE_ACQUIRED if next_job
             next_job
           }
         end
 
+        def self.create(job)
+          job = new(job) if job.is_a?(Hash)
+          self.jobs << job
+        end
+
         def initialize(options={})
           super
-          self.updated_at = Time.now
           self.status = STATE_WAITING unless self.status
           self.next_fire_at = trigger.next_fire_at
-          self.class.jobs << self
         end
 
         def <=>(job)
           self.next_fire_at.to_i <=> job.next_fire_at.to_i
         end
-
-        def fired(fired_at=Time.now)
-          super
-          self.updated_at = Time.now
-        end
-
-        def release
-          super
-          self.updated_at = Time.now
-        end
       end
-
     end
   end
 end

data/lib/say_when/tasks.rb

@@ -1,9 +1,9 @@
-namespace :say_when do
+# encoding: utf-8
 
-  desc "Start the SayWhen Scheduler"
-  task :start => :environment do
+namespace :say_when do
+  desc 'Start the SayWhen Scheduler'
+  task start: :environment do
     require 'say_when'
     SayWhen::Scheduler.start
   end
-
 end

data/lib/say_when/triggers/base.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 module SayWhen
   module Triggers
     module Base
@@ -5,13 +7,12 @@ module SayWhen
       attr_accessor :job
 
       def initialize(options={})
-        @job = options.delete(:job)
+        self.job = options.delete(:job)
       end
 
       def next_fire_at(time=nil)
         raise NotImplementedError.new('You need to implement next_fire_at in your strategy')
       end
-
     end
   end
-end
+end

data/lib/say_when/triggers/cron_strategy.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require 'say_when/triggers/base'
 require 'say_when/cron_expression'
 
@@ -11,13 +13,12 @@ module SayWhen
 
       def initialize(options={})
         super
-        @cron_expression = SayWhen::CronExpression.new(options)            
+        self.cron_expression = SayWhen::CronExpression.new(options)
       end
 
       def next_fire_at(time=nil)
         cron_expression.next_fire_at(time || Time.now)
       end
-
     end
   end
-end
+end

data/lib/say_when/triggers/instance_strategy.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require 'say_when/triggers/base'
 
 module SayWhen
@@ -10,14 +12,13 @@ module SayWhen
 
       def initialize(options={})
         super
-        @instance       = @job.scheduled
-        @next_at_method = options[:next_at_method] || 'next_fire_at'
+        self.instance       = job.scheduled
+        self.next_at_method = options[:next_at_method] || 'next_fire_at'
       end
 
       def next_fire_at(time=Time.now)
         instance.send(next_at_method, time)
       end
-
     end
   end
 end

data/lib/say_when/triggers/once_strategy.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require 'say_when/triggers/base'
 
 module SayWhen
@@ -10,14 +12,13 @@ module SayWhen
 
       def initialize(options=nil)
         super
-        @once_at = options[:at] || Time.now
+        self.once_at = options[:at] || Time.now
       end
 
       def next_fire_at(time=nil)
         nfa = once_at if (!time || (time <= once_at))
         return nfa
       end
-      
     end
   end
 end

data/lib/say_when/version.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 module SayWhen
-  VERSION = "0.3.0"
+  VERSION = '1.0.0'
 end

data/lib/say_when.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require 'active_support'
 
 require "say_when/version"
@@ -7,25 +9,24 @@ require 'say_when/processor/base'
 require 'say_when/processor/simple'
 require 'say_when/scheduler'
 
-require 'say_when/processor/active_messaging' if defined?(ActiveMessaging)
-
-require 'say_when/storage/active_record/job' if defined?(ActiveRecord)
+require 'say_when/processor/active_messaging' if defined?(::ActiveMessaging)
+require 'say_when/processor/shoryuken' if defined?(::Shoryuken)
+require 'say_when/storage/active_record/job' if defined?(::ActiveRecord)
+require 'say_when/railtie' if defined?(Rails)
 
 module SayWhen
-
   def SayWhen.logger=(logger)
     @@logger = logger
   end
-  
+
   def SayWhen.logger
     if !defined?(@@logger) || !@@logger
       if defined?(Rails.logger) && Rails.logger
         @@logger = Rails.logger
       end
-      
+
       @@logger = Logger.new(STDOUT) unless defined?(@@logger)
     end
     @@logger
   end
-
 end