tanzeeb-rufus-scheduler 2.0.7.2

data/lib/rufus/sc/scheduler.rb

@@ -0,0 +1,481 @@
+#--
+# Copyright (c) 2006-2010, John Mettraux, jmettraux@gmail.com
+#
+# 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.
+#
+# Made in Japan.
+#++
+
+
+require 'rufus/sc/version'
+require 'rufus/sc/rtime'
+require 'rufus/sc/cronline'
+require 'rufus/sc/jobs'
+require 'rufus/sc/jobqueues'
+
+
+module Rufus::Scheduler
+
+  #
+  # It's OK to pass an object responding to :trigger when scheduling a job
+  # (instead of passing a block).
+  #
+  # This is simply a helper module. The rufus-scheduler will check if scheduled
+  # object quack (respond to :trigger anyway).
+  #
+  module Schedulable
+    def call (job)
+      trigger(job.params)
+    end
+    def trigger (params)
+      raise NotImplementedError.new('implementation is missing')
+    end
+  end
+
+  #
+  # For backward compatibility
+  #
+  module ::Rufus::Schedulable
+    extend ::Rufus::Scheduler::Schedulable
+  end
+
+  # Legacy from the previous version of Rufus-Scheduler.
+  #
+  # Consider all methods here as 'deprecated'.
+  #
+  module LegacyMethods
+
+    def find_jobs (tag=nil)
+      tag ? find_by_tag(tag) : all_jobs.values
+    end
+    def at_job_count
+      @jobs.select(:at).size +
+      @jobs.select(:in).size
+    end
+    def every_job_count
+      @jobs.select(:every).size
+    end
+    def cron_job_count
+      @cron_jobs.size
+    end
+    def pending_job_count
+      @jobs.size
+    end
+    def precision
+      @frequency
+    end
+  end
+
+  #
+  # The core of a rufus-scheduler. See implementations like
+  # Rufus::Scheduler::PlainScheduler and Rufus::Scheduler::EmScheduler for
+  # directly usable stuff.
+  #
+  class SchedulerCore
+
+    include LegacyMethods
+
+    # classical options hash
+    #
+    attr_reader :options
+
+    # Instantiates a Rufus::Scheduler.
+    #
+    def initialize (opts={})
+
+      @options = opts
+
+      @jobs = get_queue(:at, opts)
+      @cron_jobs = get_queue(:cron, opts)
+
+      @frequency = @options[:frequency] || 0.330
+    end
+
+    # Instantiates and starts a new Rufus::Scheduler.
+    #
+    def self.start_new (opts={})
+
+      s = self.new(opts)
+      s.start
+      s
+    end
+
+    #--
+    # SCHEDULE METHODS
+    #++
+
+    # Schedules a job in a given amount of time.
+    #
+    #   scheduler.in '20m' do
+    #     puts "order ristretto"
+    #   end
+    #
+    # will order an espresso (well sort of) in 20 minutes.
+    #
+    def in (t, s=nil, opts={}, &block)
+
+      add_job(InJob.new(self, t, combine_opts(s, opts), &block))
+    end
+    alias :schedule_in :in
+
+    # Schedules a job at a given point in time.
+    #
+    #   scheduler.at 'Thu Mar 26 19:30:00 2009' do
+    #     puts 'order pizza'
+    #   end
+    #
+    # pizza is for Thursday at 2000 (if the shop brochure is right).
+    #
+    def at (t, s=nil, opts={}, &block)
+
+      add_job(AtJob.new(self, t, combine_opts(s, opts), &block))
+    end
+    alias :schedule_at :at
+
+    # Schedules a recurring job every t.
+    #
+    #   scheduler.every '5m1w' do
+    #     puts 'check blood pressure'
+    #   end
+    #
+    # checking blood pressure every 5 months and 1 week.
+    #
+    def every (t, s=nil, opts={}, &block)
+
+      add_job(EveryJob.new(self, t, combine_opts(s, opts), &block))
+    end
+    alias :schedule_every :every
+
+    # Schedules a job given a cron string.
+    #
+    #   scheduler.cron '0 22 * * 1-5' do
+    #     # every day of the week at 00:22
+    #     puts 'activate security system'
+    #   end
+    #
+    def cron (cronstring, s=nil, opts={}, &block)
+
+      add_cron_job(CronJob.new(self, cronstring, combine_opts(s, opts), &block))
+    end
+    alias :schedule :cron
+
+    # Unschedules a job (cron or at/every/in job) given its id.
+    #
+    # Returns the job that got unscheduled.
+    #
+    def unschedule (job_id)
+
+      @jobs.unschedule(job_id) || @cron_jobs.unschedule(job_id)
+    end
+
+    #--
+    # MISC
+    #++
+
+    # Feel free to override this method. The default implementation simply
+    # outputs the error message to STDOUT
+    #
+    def handle_exception (job, exception)
+
+      if self.respond_to?(:log_exception)
+        #
+        # some kind of backward compatibility
+
+        log_exception(exception)
+
+      else
+
+        puts '=' * 80
+        puts "scheduler caught exception :"
+        puts exception
+        exception.backtrace.each { |l| puts l }
+        puts '=' * 80
+      end
+    end
+
+    #--
+    # JOB LOOKUP
+    #++
+
+    # Returns a map job_id => job for at/in/every jobs
+    #
+    def jobs
+
+      @jobs.to_h
+    end
+
+    # Returns a map job_id => job for cron jobs
+    #
+    def cron_jobs
+
+      @cron_jobs.to_h
+    end
+
+    # Returns a map job_id => job of all the jobs currently in the scheduler
+    #
+    def all_jobs
+
+      jobs.merge(cron_jobs)
+    end
+
+    # Returns a list of jobs with the given tag
+    #
+    def find_by_tag (tag)
+
+      all_jobs.values.select { |j| j.tags.include?(tag) }
+    end
+
+    # Returns the current list of trigger threads (threads) dedicated to
+    # the execution of jobs.
+    #
+    def trigger_threads
+
+      Thread.list.select { |t|
+        t["rufus_scheduler__trigger_thread__#{self.object_id}"] == true
+      }
+    end
+
+    protected
+
+    # Returns a job queue instance.
+    #
+    # (made it into a method for easy override)
+    #
+    def get_queue (type, opts)
+
+      q = if type == :cron
+        opts[:cron_job_queue] || Rufus::Scheduler::CronJobQueue.new
+      else
+        opts[:job_queue] || Rufus::Scheduler::JobQueue.new
+      end
+
+      q.scheduler = self if q.respond_to?(:scheduler=)
+
+      q
+    end
+
+    def combine_opts (schedulable, opts)
+
+      if schedulable.respond_to?(:trigger) || schedulable.respond_to?(:call)
+
+        opts[:schedulable] = schedulable
+
+      elsif schedulable != nil
+
+        opts = schedulable.merge(opts)
+      end
+
+      opts
+    end
+
+    # The method that does the "wake up and trigger any job that should get
+    # triggered.
+    #
+    def step
+
+      @cron_jobs.trigger_matching_jobs
+      @jobs.trigger_matching_jobs
+    end
+
+    def add_job (job)
+
+      complain_if_blocking_and_timeout(job)
+
+      return if job.params[:discard_past] && Time.now.to_f >= job.at
+
+      @jobs << job
+
+      job
+    end
+
+    def add_cron_job (job)
+
+      complain_if_blocking_and_timeout(job)
+
+      @cron_jobs << job
+
+      job
+    end
+
+    # Raises an error if the job has the params :blocking and :timeout set
+    #
+    def complain_if_blocking_and_timeout (job)
+
+      raise(
+        ArgumentError.new('cannot set a :timeout on a :blocking job')
+      ) if job.params[:blocking] and job.params[:timeout]
+    end
+
+    # The default, plain, implementation. If 'blocking' is true, will simply
+    # call the block and return when the block is done.
+    # Else, it will call the block in a dedicated thread.
+    #
+    # TODO : clarify, the blocking here blocks the whole scheduler, while
+    # EmScheduler blocking triggers for the next tick. Not the same thing ...
+    #
+    def trigger_job (blocking, &block)
+
+      if blocking
+        block.call
+      else
+        Thread.new { block.call }
+      end
+    end
+  end
+
+  #--
+  # SCHEDULER 'IMPLEMENTATIONS'
+  #++
+
+  #
+  # A classical implementation, uses a sleep/step loop in a thread (like the
+  # original rufus-scheduler).
+  #
+  class PlainScheduler < SchedulerCore
+
+    def start
+
+      @thread = Thread.new do
+        loop do
+          sleep(@frequency)
+          self.step
+        end
+      end
+
+      @thread[:name] =
+        @options[:thread_name] ||
+        "#{self.class} - #{Rufus::Scheduler::VERSION}"
+    end
+
+    def stop (opts={})
+
+      @thread.exit
+    end
+
+    def join
+
+      @thread.join
+    end
+  end
+
+  # TODO : investigate idea
+  #
+  #class BlockingScheduler < PlainScheduler
+  #  # use a Queue and a worker thread for the 'blocking' jobs
+  #end
+
+  #
+  # A rufus-scheduler that steps only when the ruby process receives the
+  # 10 / USR1 signal.
+  #
+  class SignalScheduler < SchedulerCore
+
+    def initialize (opts={})
+
+      super(opts)
+
+      trap(@options[:signal] || 10) do
+        step
+      end
+    end
+
+    def stop
+
+      trap(@options[:signal] || 10)
+    end
+  end
+
+  #
+  # A rufus-scheduler that uses an EventMachine periodic timer instead of a
+  # loop.
+  #
+  class EmScheduler < SchedulerCore
+
+    def initialize (opts={})
+
+      raise LoadError.new(
+        'EventMachine missing, "require \'eventmachine\'" might help'
+      ) unless defined?(EM)
+
+      super(opts)
+    end
+
+    def start
+
+      @em_thread = nil
+
+      unless EM.reactor_running?
+        @em_thread = Thread.new { EM.run }
+        while (not EM.reactor_running?)
+          Thread.pass
+        end
+      end
+
+      #unless EM.reactor_running?
+      #  t = Thread.current
+      #  @em_thread = Thread.new { EM.run { t.wakeup } }
+      #  Thread.stop # EM will wake us up when it's ready
+      #end
+
+      @timer = EM::PeriodicTimer.new(@frequency) { step }
+    end
+
+    # Stops the scheduler.
+    #
+    # If the :stop_em option is passed and set to true, it will stop the
+    # EventMachine (but only if it started the EM by itself !).
+    #
+    def stop (opts={})
+
+      @timer.cancel
+
+      EM.stop if opts[:stop_em] and @em_thread
+    end
+
+    # Joins this scheduler. Will actually join it only if it started the
+    # underlying EventMachine.
+    #
+    def join
+
+      @em_thread.join if @em_thread
+    end
+
+    protected
+
+    # If 'blocking' is set to true, the block will get called at the
+    # 'next_tick'. Else the block will get called via 'defer' (own thread).
+    #
+    def trigger_job (blocking, &block)
+
+      m = blocking ? :next_tick : :defer
+        #
+        # :next_tick monopolizes the EM
+        # :defer executes its block in another thread
+
+      EM.send(m) { block.call }
+    end
+  end
+
+  #
+  # This error is thrown when the :timeout attribute triggers
+  #
+  class TimeOutError < RuntimeError
+  end
+end
+