CronR 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c9bd8a1c64b404ecffe432983d48a7d168e6c539
+  data.tar.gz: 8b153052e7e12c4cf79382731ec0fe4944694f45
+SHA512:
+  metadata.gz: bd1eb218a75187eef9d1a1f11e1049a541fd9f40ab136cd1ad4cc55998ea40d75f83256705af845d3ddd780ed8ab8b769352e925934e439553958eb734b02128
+  data.tar.gz: 121c5104873409d3cc58551ecc84926271176a5b26cf2d796161a04efa377befe5ead289279bb88d102e944348cf25881e0560475a2e512fa5e793d1dd6b70a1

data/lib/CronR.rb

@@ -0,0 +1,11 @@
+# The files in this directory are part of CronR, a ruby library.
+# Copyright (C) 2014 Daniel Bush
+# This program is distributed under the terms of the MIT License. A
+# copy of the license should be enclosed with this project in the file
+# LICENSE.txt.
+
+module CronR
+  require_relative 'CronR/utils'
+  require_relative 'CronR/Cron'
+  require_relative 'CronR/CronJob'
+end

data/lib/CronR/Cron.rb

@@ -0,0 +1,198 @@
+# The files in this directory are part of CronR, a ruby library.
+# Copyright (C) 2014 Daniel Bush
+# This program is distributed under the terms of the MIT License. A
+# copy of the license should be enclosed with this project in the file
+# LICENSE.txt.
+
+require_relative 'utils'
+
+module CronR
+
+  # This is an array that is modified to represent a cron table along
+  # with the necessary machinery to run it.
+  #
+  #   cron = Cron.new
+  #   # Or
+  #   cron = Cron.new(job1,job2,...)
+  #
+  # To start cron:
+  # 
+  #   cron.start
+  #   
+  # Jobs are instances of CronJob (although these are just glorified
+  # hashes).
+  # In fact, Cron expects job instances to respond to:
+  # 
+  #   runnable?(time) => if we can run now
+  #   once? => this job is a one-off
+  #   
+  # @see CronJob 
+  #   
+  # Cron uses ruby's Time object to establish what the curren time is.
+  # 
+  #   cron.time => current time
+  #   
+  # You can however override cron's idea of the current time.
+  # eg using ActiveSupport time zones:
+  # 
+  #   cron.time {
+  #     Time.use_zone("Sydney") {
+  #       Time.zone.now  
+  #     }
+  #   }
+  #   
+  #   cron.time => <the time in new timezone>
+  # 
+  # To alter cron after it's started (remember, it's just an array):
+  # 
+  #   cron.suspend {|arr|
+  #     ... do something with cron ...
+  #     ... arr == this cron instance ...
+  #     arr << cron_job  # for example
+  #   }
+  #   
+  # #suspend will wait for the thread dispatching jobs to be safely
+  # sleeping.
+  #
+  # To gracefully stop cron:
+  #
+  #   cron.stop {
+  #      ... do something now we've stopped ...
+  #   }
+  #
+  #
+  # RUNNABLE ITEMS
+  # 
+  # If a runnable item carries a proc, we don't run it - the thread
+  # used in Cron is just for doing cron.
+  # So runnable items are basically enqueued to @schedule.
+  # @schedule is just a queue.
+  # You can create an thread and have it dequeue this queue.
+  # You can also replace queue with something.  It should respond
+  # to #enq and #deq and be thread-safe.  One example might be
+  # to have #enq insert a record into a table.
+
+  class Cron < Array
+
+    attr_reader :thread,:mutex,:stopped,:suspended
+    attr_accessor :debug,:queue
+
+    # *items should consist of 0 or more items of form:
+    #   [job_id(string),CronJob.new(...),thing]
+
+    def initialize *jobs
+      super()
+      @stopped = true
+      @suspended = false
+      @queue = Queue.new
+      jobs.each{|job|
+        self.push(job)
+      }
+      @mutex = Mutex.new
+    end
+
+    # Get current time.
+    # 
+    # If passed a block, the block will be used to get the time.
+
+    def time &block
+      if block_given? then
+        @time = block
+      else
+        @time ||= lambda{Time.now}
+        @time.call
+      end
+    end
+
+    # Check each item in this array, if runnable push it on a queue.
+    #
+    # We assume that this item is or simlar to CronJob. We don't call
+    # cron_job#job. That is the work for another thread esp. if #job
+    # is a Proc.
+
+    def run time=nil
+
+      puts "[cron] run called #{Time.now}" if @debug
+      time = self.time if time.nil?
+      self.each{|cron_job|
+        ok,details = cron_job.runnable?(time)
+        if ok then
+          @queue.enq(cron_job)
+          if cron_job.once? then
+            self.delete(cron_job)
+          end
+        end
+      }
+
+    end
+
+    # Start cron.
+    #
+    # Will wake up every minute and perform #run.
+
+    def start debug=false,method=:every_minute,*args
+      @stopped = false
+      @suspended = false
+      @dead = Queue.new
+      @thread = CronR::Utils.send(method,debug,*args) {
+        time = self.time
+        @mutex.synchronize {
+          if @stopped then
+            # It's important we put something on this queue ONLY AFTER
+            # we've acquired the mutex...
+            @dead.enq(true)
+            true
+          elsif @suspended then
+          else
+            self.run(time)
+          end
+        }
+      }
+    end
+
+    # Suspend the thread.
+    #
+    # If block is given, it will only be called once the thread is
+    # sleeping again.
+    # You can use this to safely modify this array.
+
+    def suspend &block
+      if block_given? then
+        @mutex.synchronize {
+          begin
+            @suspended = true
+            block.call(self)
+          ensure
+            @suspended = false
+          end
+        }
+      end
+    end
+
+    # Gracefully stop the thread.
+    #
+    # If block is given, it will be called once the thread has
+    # stopped.
+
+    def stop &block
+      if block_given? then
+        @stopped = true
+        @suspended = false
+        # Wait till something is put on the dead queue...
+        # This stops us from acquiring the mutex until after @thread
+        # has processed @stopped set to true.
+        sig = @dead.deq
+        # The cron thread should be dead now, or wrapping up (with the
+        # acquired mutex)... 
+        @mutex.synchronize {
+          while @thread.alive?
+            sleep 0.2
+          end
+          block.call(self)
+        }
+      end
+    end
+
+  end
+
+end

data/lib/CronR/CronJob.rb

@@ -0,0 +1,140 @@
+# The files in this directory are part of CronR, a ruby library.
+# Copyright (C) 2014 Daniel Bush
+# This program is distributed under the terms of the MIT License. A
+# copy of the license should be enclosed with this project in the file
+# LICENSE.txt.
+
+module CronR
+
+  # An instance (cp) of this class (a subclass of hash) represents the
+  # standard cron parameters along with an id and something
+  # representing the job (eg a lambda).
+  #
+  # cp = CronJob.new('id1')
+  #   => '* * * * *' cron job id1 with no job
+  # cp = CronJob.new('id2') {... a proc...}
+  #   => '* * * * *' cron job id1 with a proc
+  #   => #job => will 'call' the proc
+  # cp = CronJob.new('id2')
+  # cp.job = {...} => a non-proc job
+  # 
+  # CRON PARAMETERS:
+  # 
+  # cp[s] where s can be :minute,:hour,:day,:dow,:month .
+  # 
+  # cp[s] = true
+  #   ie '*' in a crontab
+  # cp[s] = i  (i.kind_of?(Fixnum))
+  #   => for minutes we have 0-5, hours 0-23, etc
+  # cp[s] = [i,...] (array)
+  #   => cp[:minute] =
+  # cp[s] = (0..58).step(2)
+  #   => equivalent to */2 in cron
+  #
+  # For each component: [:minute,:hour,:day,:dow,:month] we can
+  # then interpret the settings as:
+  # 
+  # [true,true,true,true,true]
+  #   => run every minute of every hour of every month of every day of
+  #      the week
+  # [5,true,true,true,true]
+  #   => run 5 minutes past the hour
+  # [(0..55).step(5),true,true,true,true]
+  #   => run every 5 minutes
+  # [[10,30,50],true,true,true,true]
+  #   => run on 10th, 30th and 50th minute of the hour
+
+  class CronJob < Hash
+
+    def initialize id,minute=true,hour=true,day=true,month=true,dow=true,&block
+      super() {nil}
+      self.set(minute,hour,day,month,dow)
+      self[:id] = id
+      if block_given? then
+        self.job &block
+      end
+    end
+
+    def set minute=true,hour=true,day=true,month=true,dow=true
+      self[:minute] = minute
+      self[:hour] = hour
+      self[:day] = day
+      self[:month] = month
+      self[:dow] = dow # 0=sunday,...,6=Saturday
+    end
+
+    # Get job or set job via block.
+    #
+    # cj.job
+    # cj.job {|cj|...}
+
+    def job &block
+      if block_given? then
+        #self[:job] = block.call(self)
+        self[:job] = block
+      else
+        self[:job]
+      end
+    end
+
+    def job= thing
+      self[:job] = thing
+    end
+
+    # Run the job.
+    #
+    # This is a convenience method to handle calling proc based
+    # :job's.
+
+    def run
+      case self[:job]
+      when Proc
+        self[:job].call
+      else
+        self[:job]
+      end
+    end
+
+    # Return true if job is runnable at the given time.
+    #
+    # Note we expect an instance of Time.
+    # ActiveSupport can be used to give us time zones in Time.
+    #
+    # Example
+    #   ok,details = runnable?(Time.now)
+
+    def runnable? time
+      result = [:minute,:hour,:day,:dow,:month].map{|ct|
+        if self[ct] == true then
+          true
+        else
+          case ct
+          when :month,:day,:hour
+            val = time.send(ct)
+          when :dow
+            val = time.wday
+          when :minute
+            val = time.min
+          end
+
+          case self[ct]
+          when Numeric # Should be Fixnum
+            self[ct] == val
+          else # Assume array-like thing...
+            self[ct].include?(val)
+          end
+        end
+      }
+      # Everything should be true to make us eligible for running:
+      [result.inject(true){|s,v| s && v},result]
+    end
+
+    # Return true if the job is intended to only be run as a one-off.
+
+    def once?
+      self[:once] || false
+    end
+
+  end
+
+end

data/lib/CronR/utils.rb

@@ -0,0 +1,124 @@
+# The files in this directory are part of CronR, a ruby ibrary.
+# Copyright (C) 2014 Daniel Bush
+# This program is distributed under the terms of the MIT License. A
+# copy of the license should be enclosed with this project in the file
+# LICENSE.txt.
+
+module CronR
+  module Utils
+
+    # Wake up every minute and call &block.
+    #
+    # Returns the thread that does the waking up.
+    # If &block returns true, then stop.
+
+    def self.every_minute debug=false,&block
+      mil = 1000000
+      secs = 60.0
+      Thread.new {
+        now = Time.now
+        wait = secs-now.sec-now.usec.to_f/mil
+        p "[every_minute] sleeping #{wait}" if debug
+        sleep wait
+        loop {
+          result = block.call
+          if result==true then
+            break
+          end
+          now = Time.now
+          wait = secs-now.sec-now.usec.to_f/mil
+          p "[every_minute] sleeping #{wait}" if debug
+          sleep(wait)
+        }
+      }
+    end
+
+    # Wake up every 'secs' number of seconds and call block.
+    #
+    # We measure 'secs' after the function call.  So it is not aligned
+    # to anything.
+
+    def self.every secs,debug=false,&block
+      Thread.new {
+        loop {
+          result = block.call
+          if result==true then
+            break
+          end
+          p "[every] sleeping #{secs}" if debug
+          sleep secs
+        }
+      }
+    end
+
+    # Make a function that returns time to wait till the next secs-th
+    # second of each minute.
+    #
+    # MOTIVATION
+    # 
+    # every_minute wakes up every minute on the minute.
+    # Can we wake up every several seconds, on the second?
+    # Can we break a minute up into intervals starting from the 0th
+    # second in the minute?
+    # 
+    #   l = make_waitsecs_time(3)
+    #   wait = l.call
+    #   sleep(wait)
+    #   # So, right *now*:
+    #   # Time.now.sec ~ s where (0..57).step(3).to_a.include?(s)
+    #
+
+    def self.make_waitsecs_time secs
+      if secs < 1 || secs > 60 then
+        raise "secs must be 1-60"
+      end
+      mil = 1000000
+      lambda{|time=nil|
+        time = Time.now if time.nil?
+        sec = time.sec
+        usec = time.usec
+        frac = usec.to_f/mil
+        remainder = secs - ((sec+1) % secs)
+        remainder -= frac
+        if remainder < 0
+          # TODO if frac is almost zero, return zero here?
+          remainder + secs
+        else
+          remainder
+        end
+      }
+    end
+
+    # Make a function that returns time to wait till the next secs-th
+    # second of the unix epoch.
+    # 
+    # MOTIVATION
+    # 
+    # make_waitsecs_time breaks up the minute starting from the 0th second
+    # and the maximum cycle is therefore 60.
+    # Here we can apply '% secs' for arbitrary value 'secs' up to the current
+    # epoch, although such large values would be of little use.
+
+    def self.make_waitsecs_epoch secs
+      if secs < 1 then
+        raise "secs must be > 1"
+      end
+      mil = 1000000
+      lambda{|time=nil|
+        time = Time.now if time.nil?
+        sec = time.to_i # unix timestamp
+        usec = time.tv_usec # fraction unix component
+        frac = usec.to_f/mil
+        remainder = secs - ((sec+1) % secs)
+        remainder -= frac
+        if remainder < 0
+          # TODO if frac is almost zero, return zero here?
+          remainder + secs
+        else
+          remainder
+        end
+      }
+    end
+
+  end
+end

metadata

@@ -0,0 +1,47 @@
+--- !ruby/object:Gem::Specification
+name: CronR
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Daniel Bush
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-04-19 00:00:00.000000000 Z
+dependencies: []
+description: Simple, thread-based, light-weight cron implementation.
+email: dlb.id.au@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/CronR.rb
+- lib/CronR/utils.rb
+- lib/CronR/CronJob.rb
+- lib/CronR/Cron.rb
+homepage: http://github.com/danielbush/RubyCron
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.1.10
+signing_key: 
+specification_version: 4
+summary: An implementation of cron in ruby.
+test_files: []