asyncron 0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 24f97fc5986f15a6700155eee1635d9c7f9591ff
+  data.tar.gz: 3baa3caef38cf1cd215594c2b7182b1ab05420be
+SHA512:
+  metadata.gz: 108c1f461020fb2efcf83ac2dff00173c1f1c7dd9837ff86f94fa3011515ab3b4c8a125bc160ca6188c728e7228853d04c78ba09a6e149dc695fe96d778e8e2c
+  data.tar.gz: 69a1560ca11a79c9ecbc850532994fd7ff5b27a160a331192faf0cc56f0f1e6a3e53f964b94a54d73c3ab843ba1d83807bc16cfa017a20315cae01ea8954b2e1

data/lib/asyncron.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "redis"
+require "json"
+
+require "asyncron/cron"
+require "asyncron/schedule"
+
+module Asyncron
+  extend self
+
+  DEFAULT_OPTS = {
+    redis: Redis.new,
+    key: "sorted_set_asyncron/%{callback_str}"
+  }
+
+  def insert(opts = {}, callback_str, payload)
+    unless payload.key?(:expr)
+      raise RuntimeError.new("#{payload.inspect} has no :expr key")
+    end
+    time = Schedule.next(payload[:expr])
+    if time.nil?
+      raise RuntimeError.new("#{payload[:expr]} for #{callback_str} and " \
+        "#{payload.inspect} has no future execution time")
+    end
+    set_key = key(opts, callback_str)
+    return if redis(opts).zscore(set_key, payload.to_json)
+    return redis(opts).zadd(set_key, time.to_i, payload.to_json)
+  end
+
+  def remove(opts = {}, callback_str, payload)
+    redis(opts).zrem(key(opts, callback_str), payload.to_json)
+  end
+
+  def due(opts = {})
+    t = Time.now
+    redis(opts).keys(key(opts, "*")).each do |set_key|
+      cb = callback(set_key.split("/").last)
+      redis(opts).zrangebyscore(set_key, 0, t.to_i).each do |payload|
+        parsed_payload = JSON.parse(payload, symbolize_names: true)
+        cb.call(parsed_payload)
+        redis(opts).zrem(set_key, payload)
+        insert(opts, set_key.split("/").last, parsed_payload)
+      end
+    end
+  end
+
+  def redis(opts)
+    opts[:redis] || DEFAULT_OPTS[:redis]
+  end
+
+  def key(opts, callback_str)
+    (opts[:key] || DEFAULT_OPTS[:key]) % {callback_str: callback_str}
+  end
+
+  def callback(callback_str)
+    mod, method = callback_str.split(".")
+    mods = mod.split("::")
+    ref = mods.reduce(Object) { |acc, m| acc.const_get(m) }
+    return ref.method(method)
+  end
+end

data/lib/asyncron/cron.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Asyncron
+  module Cron
+    extend self
+
+    MINUTE = (0..59).to_a
+    HOUR = (0..23).to_a
+    MONTHDAY = (1..31).to_a
+    MONTH = (1..12).to_a
+    WEEKDAY = (1..7).to_a
+    YEAR = (1900..3000).to_a
+
+    POSITION = %w(minute hour monthday month weekday year)
+
+    def parse(expr)
+      expr.split(/[\s\t]+/).map.with_index { |e, i| transform(i, e) }
+    end
+
+    def validate(value)
+      value =~ /^((\d+(-\d+)?(,\d+(-\d+)?)*)(\/\d+)?|\*(\/\d+)?)$/
+    end
+
+    def transform(pos, value)
+      unless validate(value)
+        raise ArgumentError.new("invalid format for #{POSITION[pos]}")
+      end
+      return divide(value) do |no_divide|
+        range = single_num(no_divide) || extend_asterisk(pos, value)
+        next range if range
+        next filter(expand(pos), value)
+      end
+    end
+
+    private
+
+    def expand(pos)
+      const_get(POSITION[pos].upcase)
+    end
+
+    def single_num(value)
+      return if value !~ /^\d+$/
+      return [value.to_i]
+    end
+
+    def extend_asterisk(pos, value)
+      return if value != "*"
+      return expand(pos)
+    end
+
+    def filter(range, value)
+      values = value.split(",")
+      last_value = values.pop
+      values.push(last_value.match(/^([^\/]+)/).captures.first)
+      return range unless values.all? { |v| v =~ /^\d+(-\d+)?$/ }
+      values = values.reduce([]) do |acc, value|
+        min, _, max = value.match(/^(\d+)(-(\d+))?$/).captures
+        if max.nil?
+          acc << min.to_i
+        else
+          acc += (min.to_i..max.to_i).to_a
+        end
+        next acc
+      end
+      return range & values
+    end
+
+    def divide(value)
+      arg, _, divider = value.match(/^([^\/]+)(\/(\d+))?$/).captures
+      range = yield(arg)
+      return range if divider !~ /^\d+$/
+      divider = divider.to_i
+      return range.each.with_index.reduce([]) do |acc, (r, i)|
+        acc << r if i % divider == 0
+        next acc
+      end
+    end
+  end
+end

data/lib/asyncron/schedule.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+module Asyncron
+  module Schedule
+    extend self
+
+    def map(time = nil)
+      time = Time.now + 60 if time.nil?
+      %w(min hour day month wday year).map { |m| time.send(m) }
+    end
+
+    def next(expr)
+      cron = Cron.parse(expr)
+      current = map
+      year(cron, current) do
+        month(cron, current) do
+          day(cron, current) do
+            hour(cron, current) do
+              min(cron, current) do
+                Time.new(current[5], current[3], current[2], current[1],
+                  current[0])
+              end
+            end
+          end
+        end
+      end
+    end
+
+    private
+
+    def detect_next_weekday(cron, from)
+      while(!cron[4].include?(from.wday))
+        next_day = cron[2].detect { |d| d > from.day }
+        if next_day
+          from += (next_day - from.day) * 24 * 60 * 60
+          next
+        end
+        next_month = cron[3].detect { |m| m > from.month }
+        if next_month
+          from = Time.new(from.year, next_month, cron[2].first,
+            from.hour, from.min)
+          next
+        end
+        next_year = cron[5].detect { |y| y > from.year }
+        if next_year
+          from = Time.new(next_year, cron[3].first, cron[2].first,
+            from.hour, from.min)
+          next
+        else
+          from = nil
+          break
+        end
+      end
+      return from
+    end
+
+    def year(cron, current)
+      if cron[5].include?(current[5])
+        return yield
+      else
+        next_year = cron[5].detect { |y| y > current[5] }
+        return if next_year.nil?
+        min, hour, day, month = cron[0..3].map(&:first)
+
+        return detect_next_weekday(cron,
+          Time.new(next_year, month, day, hour, min))
+      end
+    end
+
+    def month(cron, current)
+      if cron[3].include?(current[3])
+        return yield
+      else
+        next_year = current[5]
+        next_month = cron[3].detect { |m| m > current[3] }
+        if next_month.nil?
+          next_year = cron[5].detect { |y| y > next_year }
+          return if next_year.nil?
+          next_month = cron[3].first
+        end
+        min, hour, day = cron[0..2].map(&:first)
+        return detect_next_weekday(cron,
+          Time.new(next_year, next_month, day, hour, min))
+      end
+    end
+
+    def day(cron, current)
+      if cron[2].include?(current[2]) && cron[4].include?(current[4])
+        return yield
+      else
+        next_year = current[5]
+        next_month = current[3]
+        next_day = cron[2].detect { |d| d > current[2] }
+        if next_day.nil?
+          next_day = cron[2].first
+          next_month = cron[3].detect { |m| m > next_month }
+          if next_month.nil?
+            next_year = cron[5].detect { |y| y > next_year }
+            return if next_year.nil?
+            next_month = cron[3].first
+          end
+        end
+        min, hour = cron[0..1].map(&:first)
+        return detect_next_weekday(cron,
+          Time.new(next_year, next_month, next_day, hour, min))
+      end
+    end
+
+    def hour(cron, current)
+      if cron[1].include?(current[1])
+        return yield
+      else
+        next_year = current[5]
+        next_month = current[3]
+        next_day = current[2]
+        next_hour = cron[1].detect { |h| h > current[1] }
+        if next_hour.nil?
+          next_hour = cron[1].first
+          next_day = cron[2].detect { |d| d > current[2] }
+          if next_day.nil?
+            next_day = cron[2].first
+            next_month = cron[3].detect { |m| m > next_month }
+            if next_month.nil?
+              next_year = cron[5].detect { |y| y > next_year }
+              return if next_year.nil?
+              next_month = cron[3].first
+            end
+          end
+        end
+        min = cron[0].first
+        return detect_next_weekday(cron,
+          Time.new(next_year, next_month, next_day, next_hour, min))
+      end
+    end
+
+    def min(cron, current)
+      if cron[0].include?(current[0])
+        return yield
+      else
+        next_year = current[5]
+        next_month = current[3]
+        next_day = current[2]
+        next_hour = current[1]
+        next_min = cron[0].detect { |m| m > current[0] }
+        if next_min.nil?
+          next_min = cron[0].first
+          next_hour = cron[1].detect { |h| h > current[1] }
+          if next_hour.nil?
+            next_hour = cron[1].first
+            next_day = cron[2].detect { |d| d > current[2] }
+            if next_day.nil?
+              next_day = cron[2].first
+              next_month = cron[3].detect { |m| m > next_month }
+              if next_month.nil?
+                next_year = cron[5].detect { |y| y > next_year }
+                return if next_year.nil?
+                next_month = cron[3].first
+              end
+            end
+          end
+        end
+        return detect_next_weekday(cron,
+          Time.new(next_year, next_month, next_day, next_hour, next_min))
+      end
+    end
+  end
+end

data/lib/asyncron/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Asyncron
+  VERSION = "0.1"
+end

data/test/asyncron_spec.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Callbacker
+  def self.with(cb)
+    @cb = cb
+    yield
+    @cb = nil
+  end
+
+  def self.callback(payload)
+    @cb.call(payload)
+  end
+end
+
+describe "asyncron" do
+  before do
+    @callback = "Callbacker.callback"
+    @payload = {expr: "* * * * * *", moo: "bar"}
+    @redis = Asyncron::DEFAULT_OPTS[:redis]
+    @key = Asyncron.key({}, @callback)
+  end
+
+  after do
+    @redis.keys(Asyncron.key({}, "*")).each { |k| @redis.del(k) }
+    %w(callback payload redis key).each do |i|
+      remove_instance_variable("@#{i}")
+    end
+  end
+
+  describe "insert" do
+    it "inserts a new entry with payload at the next possible slot" do
+      assert_nil @redis.zscore(@key, @payload.to_json)
+      t = Time.now
+      t = Time.new(t.year, t.month, t.day, t.hour, t.min).to_i + 60
+      Asyncron.insert(@callback, @payload)
+      assert_equal t, @redis.zscore(@key, @payload.to_json)
+    end
+  end
+
+  describe "due" do
+    it "sends the payload to the callback module" do
+      @redis.zadd(@key, Time.now.to_i, @payload.to_json)
+      ran = false
+      Callbacker.with(
+        ->(payload) { ran = true; assert_equal payload, @payload }
+      ) { Asyncron.due }
+      assert ran
+    end
+
+    it "does not send the payload for future work" do
+      @redis.zadd(@key, Time.now.to_i + 5, @payload.to_json)
+      ran = false
+      Callbacker.with(->(payload) { ran = true; }) { Asyncron.due }
+      refute ran
+    end
+
+    it "adds the payload for the next execution again after running" do
+      @redis.zadd(@key, Time.now.to_i, @payload.to_json)
+      ran = false
+      Callbacker.with(->(payload) { ran = true; }) { Asyncron.due }
+      assert ran
+      t = Time.now
+      t = Time.new(t.year, t.month, t.day, t.hour, t.min).to_i + 60
+      assert_equal t, @redis.zscore(@key, @payload.to_json)
+    end
+  end
+
+  describe "remove" do
+    it "returns true when removal was successful" do
+      @redis.zadd(@key, Time.now.to_i + 5, @payload.to_json)
+      assert Asyncron.remove(@callback, @payload)
+    end
+
+    it "returns false when removal was unsuccessful" do
+      refute Asyncron.remove(@callback, @payload)
+    end
+  end
+end

data/test/test_runner.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require "asyncron"
+require "minitest/autorun"
+
+Dir["test/**/*_spec.rb"].each { |f| load f }

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification
+name: asyncron
+version: !ruby/object:Gem::Version
+  version: '0.1'
+platform: ruby
+authors:
+- Matthias Geier
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-09-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5'
+description: Takes a cron expression, a payload and a callback for later execution
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/asyncron.rb
+- lib/asyncron/cron.rb
+- lib/asyncron/schedule.rb
+- lib/asyncron/version.rb
+- test/asyncron_spec.rb
+- test/test_runner.rb
+homepage: https://github.com/matthias-geier/asyncron
+licenses:
+- BSD-2-Clause
+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.5.1
+signing_key: 
+specification_version: 4
+summary: Asynchronous execution of cron jobs
+test_files:
+- test/test_runner.rb
+- test/asyncron_spec.rb