rufus-scheduler 2.0.24 → 3.0.0

data/lib/rufus/sc/rtime.rb

@@ -1,363 +0,0 @@
-#--
-# Copyright (c) 2005-2013, 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.
-#
-# Hecho en Costa Rica
-#++
-
-
-require 'date'
-
-
-module Rufus
-
-  #--
-  #
-  # keeping that as a note.
-  #
-  #require 'tzinfo'
-  #def time_zone(time)
-  #  offset = time.utc_offset / 3600
-  #  offset = offset < 0 ? offset.to_s : "+#{offset}"
-  #  TZInfo::Timezone.get("Etc/GMT#{offset}")
-  #end
-  #def timeshift(time, tz)
-  #  tz = TZInfo::Timezone.get(tz) unless tz.is_a?(TZInfo::Timezone)
-  #  t = tz.utc_to_local(time.getutc)
-  #  Time.parse(t.to_s[0..-5])
-  #end
-  #++
-
-  # Returns the current time as an ISO date string
-  #
-  def Rufus.now
-
-    to_iso8601_date(Time.new)
-  end
-
-  # As the name implies.
-  #
-  def Rufus.to_iso8601_date(date)
-
-    date = case date
-      when Date then date
-      when Float then to_datetime(Time.at(date))
-      when Time then to_datetime(date)
-      else DateTime.parse(date)
-    end
-
-    s = date.to_s # this is costly
-    s[10] = ' '
-
-    s
-  end
-
-  # the old method we used to generate our ISO datetime strings
-  #
-  def Rufus.time_to_iso8601_date(time)
-
-    s = time.getutc.strftime(TIME_FORMAT)
-    o = time.utc_offset / 3600
-    o = "#{o}00"
-    o = "0#{o}" if o.length < 4
-    o = "+#{o}" unless o[0..1] == '-'
-
-    "#{s} #{o}"
-  end
-
-  # Returns a Ruby time
-  #
-  def Rufus.to_ruby_time(sdate)
-
-    DateTime.parse(sdate)
-  end
-
-  # Equivalent to java.lang.System.currentTimeMillis()
-  #
-  def Rufus.current_time_millis
-
-    (Time.new.to_f * 1000).to_i
-  end
-
-  # Turns a string like '1m10s' into a float like '70.0', more formally,
-  # turns a time duration expressed as a string into a Float instance
-  # (millisecond count).
-  #
-  # w -> week
-  # d -> day
-  # h -> hour
-  # m -> minute
-  # s -> second
-  # M -> month
-  # y -> year
-  # 'nada' -> millisecond
-  #
-  # Some examples :
-  #
-  #   Rufus.parse_time_string "0.5"    # => 0.5
-  #   Rufus.parse_time_string "500"    # => 0.5
-  #   Rufus.parse_time_string "1000"   # => 1.0
-  #   Rufus.parse_time_string "1h"     # => 3600.0
-  #   Rufus.parse_time_string "1h10s"  # => 3610.0
-  #   Rufus.parse_time_string "1w2d"   # => 777600.0
-  #
-  # Note will call #to_s on the input "string", so anything that is a String
-  # or responds to #to_s will be OK.
-  #
-  def self.parse_time_string(string)
-
-    string = string.to_s
-
-    return 0.0 if string == ''
-
-    m = string.match(/^(-?)([\d\.#{DURATION_LETTERS}]+)$/)
-
-    raise ArgumentError.new("cannot parse '#{string}'") unless m
-
-    mod = m[1] == '-' ? -1.0 : 1.0
-    val = 0.0
-
-    s = m[2]
-
-    while s.length > 0
-      m = nil
-      if m = s.match(/^(\d+|\d+\.\d*|\d*\.\d+)([#{DURATION_LETTERS}])(.*)$/)
-        val += m[1].to_f * DURATIONS[m[2]]
-      elsif s.match(/^\d+$/)
-        val += s.to_i / 1000.0
-      elsif s.match(/^\d*\.\d*$/)
-        val += s.to_f
-      else
-        raise ArgumentError.new("cannot parse '#{string}' (especially '#{s}')")
-      end
-      break unless m && m[3]
-      s = m[3]
-    end
-
-    mod * val
-  end
-
-  class << self
-    alias_method :parse_duration_string, :parse_time_string
-  end
-
-  #--
-  # conversion methods between Date[Time] and Time
-  #++
-
-  #--
-  # Ruby Cookbook 1st edition p.111
-  # http://www.oreilly.com/catalog/rubyckbk/
-  # a must
-  #++
-
-  # Converts a Time instance to a DateTime one
-  #
-  def Rufus.to_datetime(time)
-
-    s = time.sec + Rational(time.usec, 10**6)
-    o = Rational(time.utc_offset, 3600 * 24)
-
-    begin
-
-      DateTime.new(time.year, time.month, time.day, time.hour, time.min, s, o)
-
-    rescue Exception => e
-
-      DateTime.new(
-        time.year,
-        time.month,
-        time.day,
-        time.hour,
-        time.min,
-        time.sec,
-        time.utc_offset)
-    end
-  end
-
-  def Rufus.to_gm_time(dtime)
-
-    to_ttime(dtime.new_offset, :gm)
-  end
-
-  def Rufus.to_local_time(dtime)
-
-    to_ttime(dtime.new_offset(DateTime.now.offset - offset), :local)
-  end
-
-  def Rufus.to_ttime(d, method)
-
-    usec = (d.sec_fraction * 3600 * 24 * (10**6)).to_i
-    Time.send(method, d.year, d.month, d.day, d.hour, d.min, d.sec, usec)
-  end
-
-  # Turns a number of seconds into a a time string
-  #
-  #   Rufus.to_duration_string 0                    # => '0s'
-  #   Rufus.to_duration_string 60                   # => '1m'
-  #   Rufus.to_duration_string 3661                 # => '1h1m1s'
-  #   Rufus.to_duration_string 7 * 24 * 3600        # => '1w'
-  #   Rufus.to_duration_string 30 * 24 * 3600 + 1   # => "4w2d1s"
-  #
-  # It goes from seconds to the year. Months are not counted (as they
-  # are of variable length). Weeks are counted.
-  #
-  # For 30 days months to be counted, the second parameter of this
-  # method can be set to true.
-  #
-  #   Rufus.to_time_string 30 * 24 * 3600 + 1, true   # => "1M1s"
-  #
-  # (to_time_string is an alias for to_duration_string)
-  #
-  # If a Float value is passed, milliseconds will be displayed without
-  # 'marker'
-  #
-  #   Rufus.to_duration_string 0.051                       # =>"51"
-  #   Rufus.to_duration_string 7.051                       # =>"7s51"
-  #   Rufus.to_duration_string 0.120 + 30 * 24 * 3600 + 1  # =>"4w2d1s120"
-  #
-  # (this behaviour mirrors the one found for parse_time_string()).
-  #
-  # Options are :
-  #
-  # * :months, if set to true, months (M) of 30 days will be taken into
-  #   account when building up the result
-  # * :drop_seconds, if set to true, seconds and milliseconds will be trimmed
-  #   from the result
-  #
-  def Rufus.to_duration_string(seconds, options={})
-
-    return (options[:drop_seconds] ? '0m' : '0s') if seconds <= 0
-
-    h = to_duration_hash(seconds, options)
-
-    s = DU_KEYS.inject('') { |r, key|
-      count = h[key]
-      count = nil if count == 0
-      r << "#{count}#{key}" if count
-      r
-    }
-
-    ms = h[:ms]
-    s << ms.to_s if ms
-
-    s
-  end
-
-  class << self
-    alias_method :to_time_string, :to_duration_string
-  end
-
-  # Turns a number of seconds (integer or Float) into a hash like in :
-  #
-  #   Rufus.to_duration_hash 0.051
-  #     # => { :ms => "51" }
-  #   Rufus.to_duration_hash 7.051
-  #     # => { :s => 7, :ms => "51" }
-  #   Rufus.to_duration_hash 0.120 + 30 * 24 * 3600 + 1
-  #     # => { :w => 4, :d => 2, :s => 1, :ms => "120" }
-  #
-  # This method is used by to_duration_string (to_time_string) behind
-  # the scene.
-  #
-  # Options are :
-  #
-  # * :months, if set to true, months (M) of 30 days will be taken into
-  #   account when building up the result
-  # * :drop_seconds, if set to true, seconds and milliseconds will be trimmed
-  #   from the result
-  #
-  def Rufus.to_duration_hash(seconds, options={})
-
-    h = {}
-
-    if seconds.is_a?(Float)
-      h[:ms] = (seconds % 1 * 1000).to_i
-      seconds = seconds.to_i
-    end
-
-    if options[:drop_seconds]
-      h.delete(:ms)
-      seconds = (seconds - seconds % 60)
-    end
-
-    durations = options[:months] ? DURATIONS2M : DURATIONS2
-
-    durations.each do |key, duration|
-
-      count = seconds / duration
-      seconds = seconds % duration
-
-      h[key.to_sym] = count if count > 0
-    end
-
-    h
-  end
-
-  # Ensures that a duration is a expressed as a Float instance.
-  #
-  #   duration_to_f("10s")
-  #
-  # will yield 10.0
-  #
-  def Rufus.duration_to_f(s)
-
-    return s if s.kind_of?(Float)
-    return parse_time_string(s) if s.kind_of?(String)
-    Float(s.to_s)
-  end
-
-  # Ensures an 'at' value is translated to a float
-  # (to be compared with the float coming from time.to_f)
-  #
-  def Rufus.at_to_f(at)
-
-    # TODO : use chronic if present
-
-    at = to_ruby_time(at) if at.is_a?(String)
-    at = to_gm_time(at) if at.is_a?(DateTime)
-    #at = at.to_f if at.is_a?(Time)
-    at = at.to_f if at.respond_to?(:to_f)
-
-    raise ArgumentError.new(
-      "cannot determine 'at' time from : #{at.inspect}"
-    ) unless at.is_a?(Float)
-
-    at
-  end
-
-  DURATIONS2M = [
-    [ 'y', 365 * 24 * 3600 ],
-    [ 'M', 30 * 24 * 3600 ],
-    [ 'w', 7 * 24 * 3600 ],
-    [ 'd', 24 * 3600 ],
-    [ 'h', 3600 ],
-    [ 'm', 60 ],
-    [ 's', 1 ]
-  ]
-  DURATIONS2 = DURATIONS2M.dup
-  DURATIONS2.delete_at(1)
-
-  DURATIONS = DURATIONS2M.inject({}) { |r, (k, v)| r[k] = v; r }
-  DURATION_LETTERS = DURATIONS.keys.join
-
-  DU_KEYS = DURATIONS2M.collect { |k, v| k.to_sym }
-end
-

data/lib/rufus/sc/scheduler.rb

@@ -1,636 +0,0 @@
-#--
-# Copyright (c) 2006-2013, 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
-
-      @mutexes = {}
-    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).
-    #
-    # Returns the job that got unscheduled.
-    #
-    def unschedule(job_or_id)
-
-      job_id = job_or_id.respond_to?(:job_id) ? job_or_id.job_id : job_or_id
-
-      @jobs.unschedule(job_id) || @cron_jobs.unschedule(job_id)
-    end
-
-    # Given a tag, unschedules all the jobs that bear that tag.
-    #
-    def unschedule_by_tag(tag)
-
-      jobs = find_by_tag(tag)
-      jobs.each { |job| unschedule(job.job_id) }
-
-      jobs
-    end
-
-    # Pauses a given job. If the argument is an id (String) and the
-    # corresponding job cannot be found, an ArgumentError will get raised.
-    #
-    def pause(job_or_id)
-
-      find(job_or_id).pause
-    end
-
-    # Resumes a given job. If the argument is an id (String) and the
-    # corresponding job cannot be found, an ArgumentError will get raised.
-    #
-    def resume(job_or_id)
-
-      find(job_or_id).resume
-    end
-
-    #--
-    # MISC
-    #++
-
-    # Determines if there is #log_exception, #handle_exception or #on_exception
-    # method. If yes, hands the exception to it, else defaults to outputting
-    # details to $stderr.
-    #
-    def do_handle_exception(job, exception)
-
-      begin
-
-        [ :log_exception, :handle_exception, :on_exception ].each do |m|
-
-          next unless self.respond_to?(m)
-
-          if method(m).arity == 1
-            self.send(m, exception)
-          else
-            self.send(m, job, exception)
-          end
-
-          return
-            # exception was handled successfully
-        end
-
-      rescue Exception => e
-
-        $stderr.puts '*' * 80
-        $stderr.puts 'the exception handling method itself had an issue:'
-        $stderr.puts e
-        $stderr.puts *e.backtrace
-        $stderr.puts '*' * 80
-      end
-
-      $stderr.puts '=' * 80
-      $stderr.puts 'scheduler caught exception:'
-      $stderr.puts exception
-      $stderr.puts *exception.backtrace
-      $stderr.puts '=' * 80
-    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
-
-    # Mostly used to find a job given its id. If the argument is a job, will
-    # simply return it.
-    #
-    # If the argument is an id, and no job with that id is found, it will
-    # raise an ArgumentError.
-    #
-    def find(job_or_id)
-
-      return job_or_id if job_or_id.respond_to?(:job_id)
-
-      job = all_jobs[job_or_id]
-
-      raise ArgumentError.new(
-        "couldn't find job #{job_or_id.inspect}"
-      ) unless job
-
-      job
-    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}"]
-      }
-    end
-
-    # Returns the list of the currently running jobs (jobs that just got
-    # triggered and are executing).
-    #
-    def running_jobs
-
-      Thread.list.collect { |t|
-        t["rufus_scheduler__trigger_thread__#{self.object_id}"]
-      }.compact
-    end
-
-    # This is a blocking call, it will return when all the jobs have been
-    # unscheduled, waiting for any running one to finish before unscheduling
-    # it.
-    #
-    def terminate_all_jobs
-
-      all_jobs.each do |job_id, job|
-        job.unschedule
-      end
-
-      while running_jobs.size > 0
-        sleep 0.01
-      end
-    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 nil 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(params, &block)
-
-      if params[:blocking]
-        block.call
-      elsif m = params[:mutex]
-        Thread.new { synchronize_with_mutex(m, &block) }
-      else
-        Thread.new { block.call }
-      end
-    end
-
-    def synchronize_with_mutex(mutex, &block)
-      case mutex
-      when Mutex
-        mutex.synchronize { block.call }
-      when Array
-        mutex.reduce(block) do |memo, m|
-          m = (@mutexes[m.to_s] ||= Mutex.new) unless m.is_a?(Mutex)
-          lambda { m.synchronize { memo.call } }
-        end.call
-      else
-        (@mutexes[mutex.to_s] ||= Mutex.new).synchronize { 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)
-          step
-        end
-      end
-
-      @thread[:name] =
-        @options[:thread_name] ||
-        "#{self.class} - #{Rufus::Scheduler::VERSION}"
-    end
-
-    # Stops this scheduler.
-    #
-    # == :terminate => true
-    #
-    # If the option :terminate is set to true,
-    # the method will return once all the jobs have been unscheduled and
-    # are done with their current run if any.
-    #
-    # (note that if a job is
-    # currently running, this method will wait for it to terminate, it
-    # will not interrupt the job run).
-    #
-    def stop(opts={})
-
-      @thread.exit
-
-      terminate_all_jobs if opts[:terminate]
-    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
-
-
-    # Stops this scheduler.
-    #
-    # == :terminate => true
-    #
-    # If the option :terminate is set to true,
-    # the method will return once all the jobs have been unscheduled and
-    # are done with their current run if any.
-    #
-    # (note that if a job is
-    # currently running, this method will wait for it to terminate, it
-    # will not interrupt the job run).
-    #
-    def stop(opts={})
-
-      trap(@options[:signal] || 10)
-
-      terminate_all_jobs if opts[:terminate]
-    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.
-    #
-    # == :stop_em => true
-    #
-    # 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 !).
-    #
-    # == :terminate => true
-    #
-    # If the option :terminate is set to true,
-    # the method will return once all the jobs have been unscheduled and
-    # are done with their current run if any.
-    #
-    # (note that if a job is
-    # currently running, this method will wait for it to terminate, it
-    # will not interrupt the job run).
-    #
-    def stop(opts={})
-
-      @timer.cancel
-
-      terminate_all_jobs if opts[:terminate]
-
-      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(params, &block)
-
-      # :next_tick monopolizes the EM
-      # :defer executes its block in another thread
-      # (if I read the doc carefully...)
-
-      if params[:blocking]
-        EM.next_tick { block.call }
-      elsif m = params[:mutex]
-        EM.defer { synchronize_with_mutex(m, &block) }
-      else
-        EM.defer { block.call }
-      end
-    end
-  end
-
-  #
-  # This error is thrown when the :timeout attribute triggers
-  #
-  class TimeOutError < RuntimeError
-  end
-end
-