qron 0.9.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8c930aec174d9935c00cd256977349028a6db517d2f3eeba15f2f4dadd01bbca
-  data.tar.gz: 21b4ce60d4cf77b01856cf624374cddc2764194bec2fb87fdc9c73815ad878fa
+  metadata.gz: f0b1115e1f100badef504e6d0837e35049add1811e63f4bcd5c588001f32aec5
+  data.tar.gz: 8df3d58f2c5cf42669372d0ac427c94a47aa3c5a48e364cde5cca55b7d8dbb2e
 SHA512:
-  metadata.gz: bcfc555cd774e231ce73c8bdab71c0482eb2a1dcbb37f534a9bdccb4942345a20c28ee52e433cabe6718d608dbef1acc0842dcdb81715eb7b728fca9199a3064
-  data.tar.gz: a23f7152c51ab2e18f6e24370d1866ee608840a0190feef28813ccf6686fc5654ccc8aba57a0ef630043029d3acffdcffe8638da0a8b2c642108cfb703b9727a
+  metadata.gz: c6dd7efe16ccda47ebe916fb75ad99cf63100399ca55b1c586502b987f04697aad3fff5a871ccae4a1c731223e07f9f08687e4feb0ef8cf0d1746c1f4fed186e
+  data.tar.gz: 75dec291fa552c5f4ab0f9d9141db0853035f67f85c2b6f5afd744f2b34fde90c7a5d8dccb0201a34d03aa8eb5345a70f95de082f177c9b277d638c050a1ab0b

data/CHANGELOG.md

@@ -2,7 +2,17 @@
 # CHANGELOG.md
 
 
-## stagnum 0.9.0 released 2025-03-23
+## qron 1.0.0 released 2025-04-01
+
+* Implement "settings"
+* Implement reload: true
+* Rework scheduling thread sleep timing
+* Implement @reboot schedule
+* Implement #on_error and #on_tab_error
+* Implement #on_tick
+
+
+## qron 0.9.0 released 2025-03-23
 
 * Initial release
 

data/README.md

@@ -10,9 +10,10 @@ A stupid Ruby cron thread that wakes up from time to time to perform according
 to what's written in a crontab.
 
 Given `etc/qrontab_dev`:
-```
-* * * * *     p [ :hello, :min, Time.now ]
-* * * * * *   p [ :hello, :sec, Time.now ]
+```ruby
+  @reboot       p [ :hello, "just started" ]
+  * * * * *     p [ :hello, :min, Time.now ]
+  * * * * * *   p [ :hello, :sec, Time.now ]
 ```
 
 and
@@ -40,6 +41,58 @@ Uses [fugit](https://github.com/floraison/fugit) for cron parsing and
 
 A little brother to [rufus-scheduler](https://github.com/jmettraux/rufus-scheduler).
 
+
+### `reload: true`
+
+Specifying `reload: true` when initializing tells the `Qron` instance to reload its crontab file at every tick.
+
+(Qron ticks usually every minute, unless it has one or more second precision crons specified, in which case it ticks every second).
+
+```ruby
+require 'qron'
+
+q = Qron.new(tab: 'etc/qrontab_dev', reload: true)
+```
+
+### Timezones
+
+It's OK to use timezones in the qrontab file:
+```ruby
+  30 * * * *     Asia/Tokyo        p [ :tokyo, :min, Time.now ]
+  30 4 1,15 * 5  Europe/Budapest   p [ :budapest, :min, Time.now ]
+```
+
+
+### "Settings"
+
+A qrontab file accepts, cron and commands but also "settings" that set
+variables in the context passed to commands:
+```ruby
+  #
+  # settings
+
+  a = 1 + 2
+  b = Time.now
+
+  #
+  # actual crons
+
+  * * * * * *  pp [ :ctx, ctx ]
+```
+where the puts might output something like:
+```ruby
+[ :ctx,
+  { time: 'Time instance...',
+    cron: 'Fugit::Cron instance...',
+    command: 'pp [ :ctx, ctx ]',
+    qron: 'The Qron instance...',
+    a: 3,
+    b: 'Time instance...' } ]
+```
+
+A context is instantied and prepare for each command when it triggers.
+
+
 ## LICENSE
 
 MIT, see [LICENSE.txt](LICENSE.txt)

data/lib/qron.rb

@@ -6,14 +6,24 @@ require 'stagnum'
 
 class Qron
 
-  VERSION = '0.9.0'.freeze
+  VERSION = '1.0.0'.freeze
 
   attr_reader :options
-  attr_reader :tab, :thread, :started, :last_sec, :work_pool
+  attr_reader :tab, :thread, :started, :work_pool
+  attr_reader :tab_res, :tab_mtime
+  attr_reader :listeners
 
   def initialize(opts={})
 
     @options = opts
+    @options[:reload] = false unless opts.has_key?(:reload)
+
+    @tab = nil
+    @tab_res = nil
+    @tab_mtime = Time.now
+
+    @booted = false
+    @listeners = []
 
     start unless opts[:start] == false
   end
@@ -21,28 +31,29 @@ class Qron
   def start
 
     @started = Time.now
-    @last_sec = @started.to_i
 
     @work_pool ||=
-      Stagnum::Pool.new("Qron-#{Qron::VERSION}-pool", @options[:workers] || 3)
+      Stagnum::Pool.new("qron-#{Qron::VERSION}-pool", @options[:workers] || 3)
 
     @thread =
       Thread.new do
+        Thread.current[:name] =
+          @options[:thread_name] || "qron-#{Qron::VERSION}-thread"
         loop do
           break if @started == nil
           now = Time.now
-          next if now.to_i == @last_sec
-          perform(now)
-          sleep 0.7 + (0.5 * rand)
+          tick(now)
+          sleep(determine_sleep_time(now))
         end
       end
-
-    # TODO rescue perform...
   end
 
   def stop
 
     @started = nil
+
+    @thread.kill
+    @thread = nil
   end
 
   def join
@@ -50,52 +61,182 @@ class Qron
     @thread && @thread.join
   end
 
-  protected
+  # In some deployments, another thread ticks the qron instance. So #tick(now)
+  # is a public method.
+  #
+  def tick(now)
+
+    fetch_tab
+
+    @tab.each do |cron, command|
+
+      perform(now, cron, command) if cron_match?(cron, now)
+    end
 
-  def read_tab
+    @booted = true
+
+    trigger_event(:on_tick, time: now)
+  end
+
+  def fetch_tab
+
+    return @tab if @tab && @options[:reload] == false
 
     t = @options[:crontab] || @options[:tab] || 'qrontab'
+    m = mtime(t)
 
-    return t if t.is_a?(Array)
-
-    # TODO timezones
-
-    File.readlines(t)
-      .inject([]) { |a, l|
-        l = l.strip
-        next a if l == ''
-        next a if l.start_with?('#')
-        ll5 = l.split(/\s+/, 6)
-        ll6 = ll5.pop.split(/\s+/, 2)
-        ll5 = ll5.join(' ')
-        ll6, r = *ll6
-        c = Fugit::Cron.parse("#{ll5} #{ll6}")
-        unless c
-          c = Fugit::Cron.parse(ll5)
-          r = "#{ll6} #{r}"
-        end
-        a << [ c, r ]
-        a }
+    if m > @tab_mtime
+      @tab = nil
+      @tab_tempo = nil
+    end
+    @tab_mtime = m
+
+    @tab ||= parse(t)
   end
 
-  def perform(now)
+  def on_tab_error(&block); @listeners << [ :on_tab_error, block ]; end
+  #def on_tick_error(&block); @listeners << [ :on_tick_error, block ]; end
+  def on_perform_error(&block); @listeners << [ :on_perform_error, block ]; end
 
-    @tab ||= read_tab
+  def on_error(&block)
+    @listeners << [ :on_tab_error, block ]
+    @listeners << [ :on_perform_error, block ]
+  end
 
-    @tab.each do |cron, command|
+  def on_tick(&block); @listeners << [ :on_tick, block ]; end
+
+  def trigger_event(event_name, ctx)
 
-      do_perform(now, cron, command) if cron.match?(now)
+    @listeners.each { |name, block| block.call(ctx) if name == event_name }
+  end
+
+  protected
+
+  def mtime(t)
+
+    if t.is_a?(String) && t.count("\n") < 1 && File.exist?(t)
+      File.mtime(t)
+    else
+      Time.now
     end
+  end
+
+  def parse(t)
+
+    case t
+    when Array then parse_lines(t)
+    when /\n/ then parse_lines(t.lines)
+    when String then parse_file(t)
+    else fail(ArgumentError.new("cannot parse instance of #{t.class}"))
+    end
+
+  rescue => err
 
-    @last_sec = now.to_i
+    trigger_event(:on_tab_error, time: Time.now, error: err)
+
+    []
   end
 
-  def do_perform(now, cron, command)
+  def parse_file(path)
+
+    parse_lines(File.readlines(path))
+  end
 
-    @work_pool.enqueue({ time: now, cron: cron, command: command }) do
+  def parse_lines(ls)
+
+    ls.map { |l| parse_line(l) }.compact
+  end
 
-      ::Kernel.eval(command)
+  def parse_line(l)
+
+    l = l.strip
+
+    return nil if l == ''
+    return nil if l.start_with?('#')
+
+    parse_setting(l) ||
+    parse_special(l) ||
+    parse_cron(l, 7) || parse_cron(l, 6) || parse_cron(l, 5) ||
+    fail(ArgumentError.new("could not parse }#{l}{"))
+  end
+
+  def parse_setting(line)
+
+    m = line.match(/^([a-z][_0-9a-zA-Z]*)\s+=\s+(.+)$/)
+
+    m ? [ 'setting', "ctx[:#{m[1]}] = #{m[2]}" ] : nil
+  end
+
+  def parse_special(line)
+
+    line.start_with?(/@reboot\s/) ?
+      [ '@reboot', line.split(/\s+/, 2).last ] :
+      nil
+  end
+
+  def parse_cron(line, word_count)
+
+    ll = line.split(/\s+/, word_count + 1)
+    c, r = Fugit::Cron.parse(ll.take(word_count).join(' ')), ll.last
+
+    c ? [ c, r] : nil
+  end
+
+  def cron_match?(cron, time)
+
+    if cron == '@reboot'
+      @booted == false
+    elsif cron.is_a?(Fugit::Cron)
+      cron.match?(time)
+    else
+      false # well...
+    end
+  end
+
+  def perform(now, cron, command)
+
+    @work_pool.enqueue(make_context(now, cron, command)) do |ctx|
+
+      Kernel.eval("Proc.new { |ctx| #{command} }").call(ctx)
+
+    rescue => err
+
+      trigger_event(:on_perform_error, time: Time.now, error: err)
+    end
+  end
+
+  def make_context(now, cron, command)
+
+    ctx = { time: now, cron: cron, command: command, qron: self }
+
+    @tab.each do |c, command|
+
+      Kernel.eval("Proc.new { |ctx| #{command} }").call(ctx) if c == 'setting'
     end
+
+    ctx
+  end
+
+  def determine_sleep_time(now)
+
+    @tab_res ||=
+      @tab.find { |c, _| c.is_a?(Fugit::Cron) && c.resolution == :second } ?
+        :second : :minute
+
+    res = @tab_res == :second ? 1.0 : 60.0
+
+    res - (now.to_f % res) + 0.021
+  end
+end
+
+
+# Should it be part of fugit?
+#
+class Fugit::Cron
+
+  def resolution
+
+    seconds == [ 0 ] ? :minute : :second
   end
 end
 

data/qron.gemspec

@@ -37,7 +37,8 @@ A Ruby thread that wakes up in time to perform what's ordered in its crontab
     "#{s.name}.gemspec",
   ]
 
-  #s.add_runtime_dependency 'raabro', '~> 1.4'
+  s.add_runtime_dependency 'fugit', '~> 1.11'
+  s.add_runtime_dependency 'stagnum', '~> 1.0'
 
   s.add_development_dependency 'probatio', '~> 1.0'
 

metadata

@@ -1,14 +1,42 @@
 --- !ruby/object:Gem::Specification
 name: qron
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 1.0.0
 platform: ruby
 authors:
 - John Mettraux
 bindir: bin
 cert_chain: []
-date: 2025-03-23 00:00:00.000000000 Z
+date: 2025-04-01 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: fugit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+- !ruby/object:Gem::Dependency
+  name: stagnum
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: probatio
   requirement: !ruby/object:Gem::Requirement