say_when 1.0.0 → 2.0.0

data/lib/say_when/poller/celluloid_poller.rb

@@ -0,0 +1,30 @@
+# encoding: utf-8
+
+require 'celluloid/current'
+require 'logger'
+require 'say_when/poller/base_poller'
+
+module SayWhen
+  module Poller
+    class CelluloidPoller
+      include Celluloid
+      include SayWhen::Poller::BasePoller
+
+      def initialize(tick = nil)
+        @tick_length = tick.to_i if tick
+        start
+      end
+
+      def start
+        @tick_timer = every(tick_length) { process_jobs }
+      end
+
+      def stop
+        if @tick_timer
+          @tick_timer.cancel
+          @tick_timer = nil
+        end
+      end
+    end
+  end
+end

data/lib/say_when/poller/concurrent_poller.rb

@@ -0,0 +1,31 @@
+# encoding: utf-8
+
+require 'concurrent'
+require 'logger'
+require 'say_when/poller/base_poller'
+
+module SayWhen
+  module Poller
+    class ConcurrentPoller
+      include SayWhen::Poller::BasePoller
+
+      def initialize(tick = nil)
+        @tick_length = tick.to_i if tick
+        start
+      end
+
+      def start
+        @tick_timer = Concurrent::TimerTask.new(execution_interval: tick_length) do
+          process_jobs
+        end.tap(&:execute)
+      end
+
+      def stop
+        if @tick_timer
+          @tick_timer.shutdown
+          @tick_timer = nil
+        end
+      end
+    end
+  end
+end

data/lib/say_when/poller/simple_poller.rb

@@ -0,0 +1,37 @@
+# encoding: utf-8
+
+require 'say_when/poller/base_poller'
+
+module SayWhen
+  module Poller
+    class SimplePoller
+      include SayWhen::Poller::BasePoller
+
+      attr_accessor :running
+
+      def initialize(tick = nil)
+        self.tick_length = tick.to_i if tick
+        self.running = false
+      end
+
+      def running?
+        !!running
+      end
+
+      def start
+        self.running = true
+        logger.info "SayWhen::SimplePoller started"
+        while running
+          process_jobs
+          tick
+        end
+        logger.info "SayWhen::SimplePoller stopped"
+      end
+
+      def stop
+        logger.info "SayWhen::SimplePoller stopping..."
+        self.running = false
+      end
+    end
+  end
+end

data/lib/say_when/processor/active_job_strategy.rb

@@ -0,0 +1,35 @@
+# encoding: utf-8
+
+require 'active_job'
+
+module SayWhen
+  module Processor
+    class ActiveJobStrategy
+      class << self
+        def process(job)
+          SayWhenJob.perform_later(job_to_arg(job))
+        end
+
+        def job_to_arg(job)
+          case job
+          when GlobalID::Identification
+            job
+          else
+            { class: job.class.name, attributes: job.to_hash }
+          end
+        end
+      end
+
+      class SayWhenJob < ActiveJob::Base
+        queue_as SayWhen.options[:queue]
+
+        def perform(job)
+          if job.is_a?(Hash)
+            job = job[:class].constantize.new(job[:attributes])
+          end
+          job.execute
+        end
+      end
+    end
+  end
+end

data/lib/say_when/processor/simple_strategy.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+
+module SayWhen
+  module Processor
+    class SimpleStrategy
+      class << self
+        def process(job)
+          job.execute
+        end
+      end
+    end
+  end
+end

data/lib/say_when/processor/test_strategy.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+module SayWhen
+  module Processor
+    class TestStrategy
+      class << self
+        def process(job)
+          self.jobs << job
+        end
+
+        def reset
+          self.jobs = []
+        end
+
+        def jobs
+          @jobs ||= []
+        end
+      end
+    end
+  end
+end

data/lib/say_when/scheduler.rb

@@ -1,133 +1,99 @@
 # encoding: utf-8
 
+require 'say_when/utils'
+
 module SayWhen
   class Scheduler
+    include SayWhen::Utils
 
-    DEFAULT_PROCESSOR_CLASS  = SayWhen::Processor::Simple
-    DEFAULT_STORAGE_STRATEGY = :memory
-
-    @@scheduler = nil
-    @@lock = Mutex.new
-
-    attr_accessor :storage_strategy, :processor_class, :tick_length
-
-    attr_accessor :running
+    # When passing in a job, can be a Hash, String, or Class
+    # Hash: { class: '<class name>' } or { job_class: '<class name>' }
+    # String: '<class name>'
+    # Class: <job class>
+    def schedule(job)
+      storage.create(job)
+    end
 
-    # support for a singleton scheduler, but you are not restricted to this
-    class << self
-      def scheduler
-        return @@scheduler if @@scheduler
-        @@lock.synchronize { @@scheduler = self.new if @@scheduler.nil? }
-        @@scheduler
-      end
+    def schedule_cron(expression, job)
+      time_zone = if job.is_a?(Hash)
+        job.delete(:time_zone)
+      end || 'UTC'
+      options = job_options(job)
+      options[:trigger_strategy] = :cron
+      options[:trigger_options]  = { expression: expression, time_zone: time_zone }
+      schedule(options)
+    end
 
-      def configure
-        yield scheduler
-        scheduler
-      end
+    def schedule_instance(next_at_method = 'next_fire_at', job = {})
+      options = job_options(job)
+      options[:trigger_strategy] = 'instance'
+      options[:trigger_options]  = { next_at_method: next_at_method }
+      schedule(options)
+    end
 
-      def schedule(job)
-        scheduler.schedule(job)
-      end
+    def schedule_once(time, job = {})
+      options = job_options(job)
+      options[:trigger_strategy] = 'once'
+      options[:trigger_options]  = { at: time}
+      schedule(options)
+    end
 
-      def start
-        scheduler.start
-      end
+    def schedule_in(after, job = {})
+      options = job_options(job)
+      options[:trigger_strategy] = 'once'
+      options[:trigger_options]  = { at: (Time.now + after)}
+      schedule(options)
     end
 
-    def initialize
-      self.tick_length = [ENV['SAY_WHEN_TICK_LENGTH'].to_i, 5].max
+    def job_options(job)
+      {
+        scheduled: extract_scheduled(job),
+        job_class: extract_job_class(job),
+        job_method: extract_job_method(job),
+        data: extract_data(job)
+      }
     end
 
-    def processor
-      if @processor.nil?
-        @processor_class ||= DEFAULT_PROCESSOR_CLASS
-        @processor = @processor_class.new(self)
-      end
-      @processor
+    def extract_scheduled(job)
+      job[:scheduled] if job.is_a?(Hash)
     end
 
-    def start
-      logger.info "SayWhen::Scheduler starting"
-
-      [$stdout, $stderr].each{|s| s.sync = true; s.flush}
-
-      trap("TERM", "EXIT")
-
-      begin
-
-        self.running = true
-
-        logger.info "SayWhen::Scheduler running"
-        job = nil
-        while running
-          begin
-            time_now = Time.now
-            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)
-            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"
-
-              # this should update next fire at, and put back in list of scheduled jobs
-              job.fired(time_now)
-              logger.debug "SayWhen:: job fired complete"
-            end
-          rescue StandardError => 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_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
+    def extract_job_class(job)
+      job_class = if job.is_a?(Hash)
+        job[:class] || job[:job_class]
+      elsif job.is_a?(Class)
+        job.name
+      elsif job.is_a?(String)
+        job
       end
 
-      logger.info "SayWhen::Scheduler stopped"
-    end
+      if !job_class
+        raise "Could not identify job class from: #{job}"
+      end
 
-    def safe_release(job)
-      job.release if job
-    rescue
-      logger "Failed to release job: #{job.inspect}" rescue nil
+      job_class
     end
 
-    def stop
-      logger.info "SayWhen::Scheduler stopping..."
-      self.running = false
+    def extract_job_method(job)
+      if job.is_a?(Hash)
+        job[:method] || job[:job_method]
+      end || 'execute'
     end
 
-    def job_class
-      @job_class ||= load_job_class
+    def extract_data(job)
+      job[:data] if job && job.is_a?(Hash)
     end
 
-    def load_job_class
-      strategy = @storage_strategy || DEFAULT_STORAGE_STRATEGY
-      require "say_when/storage/#{strategy}/job"
-      job_class_name = "SayWhen::Storage::#{strategy.to_s.camelize}::Job"
-      job_class_name.constantize
+    def storage=(s)
+      @storage = s
     end
 
-    def schedule(job)
-      job_class.create(job)
+    def storage
+      @storage ||= load_strategy(:storage, SayWhen.options[:storage_strategy])
     end
 
     def logger
-      SayWhen::logger
+      SayWhen.logger
     end
   end
 end

data/lib/say_when/storage/active_record_strategy.rb

@@ -0,0 +1,204 @@
+require 'active_record'
+require 'say_when/storage/base_job'
+
+module SayWhen
+  module Storage
+    class ActiveRecordStrategy
+      class << self
+        def acquire_next(no_later_than = nil)
+          SayWhen::Storage::ActiveRecordStrategy::Job.acquire_next(no_later_than)
+        end
+
+        def reset_acquired(older_than_seconds)
+          SayWhen::Storage::ActiveRecordStrategy::Job.reset_acquired(older_than_seconds)
+        end
+
+        def create(job)
+          SayWhen::Storage::ActiveRecordStrategy::Job.job_create(job)
+        end
+
+        def fired(job, fired_at = Time.now)
+          job.fired(fired_at)
+        end
+
+        def release(job)
+          job.release
+        end
+
+        def serialize(job)
+          job
+        end
+
+        def deserialize(job)
+          job
+        end
+      end
+
+      class JobExecution < ActiveRecord::Base
+        self.table_name = 'say_when_job_executions'
+        belongs_to :job, class_name: 'SayWhen::Storage::ActiveRecordStrategy::Job'
+      end
+
+      class Job < ActiveRecord::Base
+        include SayWhen::Storage::BaseJob
+
+        self.table_name = 'say_when_jobs'
+
+        serialize :trigger_options
+        serialize :data
+
+        belongs_to :scheduled, polymorphic: true
+        has_many  :job_executions, class_name: 'SayWhen::Storage::ActiveRecordStrategy::JobExecution'
+
+        before_create :set_defaults
+
+        def self.job_create(job)
+          if existing_job = find_named_job(job[:group], job[:name])
+            existing_job.tap { |j| j.update_attributes(job) }
+          else
+            create(job)
+          end
+        end
+
+        def self.find_named_job(group, name)
+          group && name && where(name: name, group: group).first
+        end
+
+        def self.acquire_next(no_later_than = nil)
+          next_job = nil
+          no_later_than = (no_later_than || Time.now).in_time_zone('UTC')
+
+          check_connection
+          hide_logging do
+            SayWhen::Storage::ActiveRecordStrategy::Job.transaction do
+              # select and lock the next job that needs executin' (status waiting, and after no_later_than)
+              next_job = where(status: STATE_WAITING).
+                         where('next_fire_at < ?', no_later_than).
+                         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) if next_job
+            end
+          end
+          next_job
+        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)
+          where('status = ? and updated_at < ?', STATE_ACQUIRED, older_than).update_all("status = '#{STATE_WAITING}'")
+        end
+
+        def self.check_connection
+          if ActiveRecord::Base.respond_to?(:clear_active_connections!)
+            ActiveRecord::Base.clear_active_connections!
+          elsif ActiveRecord::Base.respond_to?(:verify_active_connections!)
+            ActiveRecord::Base.verify_active_connections!
+          end
+        end
+
+        def self.hide_logging
+          old_logger = nil
+          begin
+            old_logger = ::ActiveRecord::Base.logger
+            ::ActiveRecord::Base.logger = nil
+            yield
+          ensure
+            ::ActiveRecord::Base.logger = old_logger
+          end
+        end
+
+        def set_defaults
+          self.status = STATE_WAITING
+          self.next_fire_at = self.trigger.next_fire_at
+        end
+
+        def fired(fired_at=Time.now)
+          self.class.transaction {
+            super
+            self.save!
+          }
+        end
+
+        def release
+          self.class.transaction {
+            super
+            self.save!
+          }
+        end
+
+        # default impl with some error handling and result recording
+        def execute
+          result = nil
+          execution = JobExecution.create(job: self, status: STATE_EXECUTING, start_at: Time.now)
+
+          begin
+            result = self.execute_job(data)
+            execution.result = result
+            execution.status = 'complete'
+          rescue Object => ex
+            execution.result = "#{ex.class.name}: #{ex.message}\n\t#{ex.backtrace.join("\n\t")}"
+            execution.status = 'error'
+          end
+
+          execution.end_at = Time.now
+          execution.save!
+          result
+        end
+      end
+
+      module Acts #:nodoc:
+        extend ActiveSupport::Concern
+
+        module ClassMethods
+          def acts_as_scheduled
+            include SayWhen::Storage::ActiveRecordStrategy::Acts::InstanceMethods
+
+            has_many :scheduled_jobs,
+              as: :scheduled,
+              class_name: 'SayWhen::Storage::ActiveRecordStrategy::Job',
+              dependent: :destroy
+          end
+        end
+
+        module InstanceMethods
+          def schedule(job)
+            Scheduler.schedule(set_scheduled(job))
+          end
+
+          def schedule_instance(next_at_method = 'next_fire_at', job = {})
+            Scheduler.schedule_instance(next_at_method, set_scheduled(job))
+          end
+
+          def schedule_cron(expression, job = {})
+            Scheduler.schedule_cron(expression, set_scheduled(job))
+          end
+
+          def schedule_once(time, job = {})
+            Scheduler.schedule_once(time, set_scheduled(job))
+          end
+
+          def schedule_in(after, job = {})
+            Scheduler.schedule_in(after, set_scheduled(job))
+          end
+
+          def set_scheduled(job)
+            if job.is_a?(Hash)
+              job[:scheduled] = self
+            elsif job.respond_to?(:scheduled)
+              job.scheduled = self
+            end
+            job
+          end
+        end # InstanceMethods
+      end # class << self
+    end
+  end
+end
+
+aas = SayWhen::Storage::ActiveRecordStrategy::Acts
+unless ActiveRecord::Base.include?(aas)
+  ActiveRecord::Base.send(:include, aas)
+end