lita-timing 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0d2e91447e7269858bf093d62e62d73afc1ae09a
-  data.tar.gz: cb8aa371af84923e55f20e10447e7fccd02ed731
+  metadata.gz: ebd69051f02f3a9b071894c529a1f8368b279810
+  data.tar.gz: e514daea0faffad2604c124e52fa7bbac9c9871c
 SHA512:
-  metadata.gz: 330c5b008e3b22ad996837ca7dc624d93caa48fe15c9033f5f30753a036b426497812f251127fbc853d609dcbb8d2568839766ec834fd31c9e86f073456bf763
-  data.tar.gz: 74cb5eb59284c284be1659d5b58d44f3cd811f7d4143acb03bcbd0a697441332e302905ede9e035c0a724cbd08f8c69acd0dcaf2b7a97a02807560f421d00ade
+  metadata.gz: 7f44239929f965ce57d97839366b7b200b1173bb88597aaa52ee5f65e0de44aa157a98745ec64bb53c163e6cdc5a1ed64c4aac6afa15627963e61d1f8bea7eb9
+  data.tar.gz: 5d5b54431727d312c634801198ea19709901bc596c237e86753b4327249cf06dd883c07a462d0ae6887171cfb576982ad1dfc977a3d3a8b3e14d6d23c0647683

data/README.md

@@ -32,6 +32,40 @@ class can be used in conjunction with the built in every() helper:
       end
     end
 
+### Scheduled Timing
+
+If you have code that should execute at a fixed time each day or week, Lita::Timing::Scheduled
+can be used in conjunction with the built-in every() helper.
+
+For daily execution:
+
+    one_minute = 60
+    every(one_minute) do
+      Lita::Timing::Scheduled.new("interval-name", redis).daily_at("11:00") do
+        # daily code in here
+      end
+    end
+
+For daily execution on certain days:
+
+    one_minute = 60
+    every(one_minute) do
+      Lita::Timing::Scheduled.new("interval-name", redis).daily_at("11:00", [:monday, :tuesday]) do
+        # daily code in here
+      end
+    end
+
+For weekly execution:
+
+    one_minute = 60
+    every(one_minute) do
+      Lita::Timing::Scheduled.new("interval-name", redis).weekly_at("11:00", :friday) do
+        # weekly code in here
+      end
+    end
+
+All times should be specified in UTC.
+
 ### Sliding Windows
 
 Sometimes a handler wants to periodically execute a block of code with a start
@@ -54,3 +88,8 @@ block doesn't execute again until that window is passed.
 
 Call this as often as you like, and the block passed to advance() will
 only execute if it's been 30 minutes since the last time it executed.
+
+## TODO
+
+* Add timezone support to Scheduled
+

data/lib/lita/timing/mutex.rb

@@ -0,0 +1,46 @@
+require 'securerandom'
+
+module Lita
+  module Timing
+    class Mutex
+
+      LOCK_TIMEOUT = 30 # seconds
+
+      DEL_SCRIPT = <<-EOS
+        if redis.call("get",KEYS[1]) == ARGV[1]
+        then
+          return redis.call("del",KEYS[1])
+        else
+            return 0
+        end
+      EOS
+
+      def initialize(name, redis)
+        @name, @redis = name, redis
+      end
+
+      def syncronise(&block)
+        token = SecureRandom.hex(10)
+        val = nil
+        set_with_retry(@name, token, LOCK_TIMEOUT + 1)
+        yield
+        @redis.eval(DEL_SCRIPT, keys: [@name], argv: [token])
+      end
+
+      private
+
+      def set_with_retry(name, token, timeout)
+        give_up_at = Time.now + timeout
+        loop do
+          val = @redis.set(name, token, nx: true, ex: timeout)
+          if val
+            return true
+          elsif Time.now > give_up_at
+            raise "Unable to obtain lock for #{@name} after #{LOCK_TIMEOUT + 2} seconds"
+          end
+          sleep 1
+        end
+      end
+    end
+  end
+end

data/lib/lita/timing/rate_limit.rb

@@ -3,12 +3,15 @@ module Lita
     class RateLimit
       def initialize(name, redis)
         @name, @redis = name, redis
+        @mutex = Timing::Mutex.new("#{name}-lock", redis)
       end
 
       def once_every(seconds, &block)
-        if last_time.nil? || last_time + seconds < Time.now
-          yield
-          @redis.set(@name, Time.now.to_i, ex: seconds * 2)
+        @mutex.syncronise do
+          if last_time.nil? || last_time + seconds < Time.now
+            yield
+            @redis.set(@name, Time.now.to_i, ex: seconds * 2)
+          end
         end
       end
 

data/lib/lita/timing/scheduled.rb

@@ -0,0 +1,71 @@
+require 'lita/timing/time_parser'
+require 'lita/timing/mutex'
+
+module Lita
+  module Timing
+    class Scheduled
+      ONE_WEEK_IN_SECONDS = 60 * 60 * 24 * 7
+
+      def initialize(name, redis)
+        @name, @redis = name, redis
+        @mutex = Timing::Mutex.new("#{name}-lock", redis)
+      end
+
+      def daily_at(time, days = nil, &block)
+        @mutex.syncronise do
+          days ||= [:monday, :tuesday, :wednesday, :thursday, :friday, :saturday, :sunday]
+          last_run_at = get_last_run_at
+          next_run = calc_next_daily_run(time, days, last_run_at)
+          if next_run < Time.now
+            yield
+            @redis.set(@name, Time.now.to_i, ex: ONE_WEEK_IN_SECONDS * 2)
+          end
+        end
+      end
+
+      def weekly_at(time, day, &block)
+        @mutex.syncronise do
+          last_run_at = get_last_run_at
+          next_run = calc_next_weekly_run(time, day, last_run_at)
+          if next_run < Time.now
+            yield
+            @redis.set(@name, Time.now.to_i, ex: ONE_WEEK_IN_SECONDS * 2)
+          end
+        end
+      end
+
+      private
+
+      def calc_next_daily_run(time, days, last_run_at)
+        hours, minutes = TimeParser.extract_hours_and_minutes(time)
+        wdays = TimeParser.day_strings_to_ints(days)
+
+        next_run_at = last_run_at + 1
+        loop do
+          if next_run_at.hour == hours && next_run_at.min == minutes && next_run_at.sec == 0 && wdays.include?(next_run_at.wday)
+            return next_run_at
+          end
+          next_run_at += 1
+        end
+      end
+
+      def calc_next_weekly_run(time, day, last_run_at)
+        hours, minutes = TimeParser.extract_hours_and_minutes(time)
+        wday = TimeParser.day_string_to_int(day)
+
+        next_run_at = last_run_at + 1
+        loop do
+          if next_run_at.hour == hours && next_run_at.min == minutes && next_run_at.sec == 0 && next_run_at.wday == wday
+            return next_run_at
+          end
+          next_run_at += 1
+        end
+      end
+
+      def get_last_run_at
+        value = @redis.get(@name)
+        value ? Time.at(value.to_i).utc : Time.now.utc
+      end
+    end
+  end
+end

data/lib/lita/timing/sliding_window.rb

@@ -3,19 +3,22 @@ module Lita
     class SlidingWindow
       def initialize(name, redis)
         @name, @redis = name, redis
+        @mutex = Timing::Mutex.new("#{name}-lock", redis)
 
         initialise_last_time_if_not_set
       end
 
       def advance(duration_minutes: 30, buffer_minutes: 0, &block)
-        start_time = Time.now - mins_to_seconds(duration_minutes) - mins_to_seconds(buffer_minutes)
-        advance_to = start_time + mins_to_seconds(duration_minutes)
+        @mutex.syncronise do
+          start_time = Time.now - mins_to_seconds(duration_minutes) - mins_to_seconds(buffer_minutes)
+          advance_to = start_time + mins_to_seconds(duration_minutes)
 
-        return unless start_time > last_time
+          return unless start_time > last_time
 
-        yield last_time + 1, advance_to
+          yield last_time + 1, advance_to
 
-        @redis.set(@name, advance_to.to_i)
+          @redis.set(@name, advance_to.to_i)
+        end
       end
 
       private
@@ -29,7 +32,9 @@ module Lita
       end
 
       def initialise_last_time_if_not_set
-        @redis.setnx(@name, two_weeks_ago.to_i)
+        @mutex.syncronise do
+          @redis.setnx(@name, two_weeks_ago.to_i)
+        end
       end
 
       def two_weeks_ago

data/lib/lita/timing/time_parser.rb

@@ -0,0 +1,36 @@
+module Lita
+  module Timing
+    class TimeParser
+      DAYS = {
+        sunday: 0,
+        monday: 1,
+        tuesday: 2,
+        wednesday: 3,
+        thursday: 4,
+        friday: 5,
+        saturday: 6,
+      }
+
+      def self.day_string_to_int(string)
+        wday = DAYS[string.to_s.downcase.to_sym]
+        raise ArgumentError, "Expected one of: monday, tuesday, wednesday, thursday, friday, saturday or sunday" if wday.nil?
+        wday
+      end
+
+      def self.day_strings_to_ints(strings)
+        strings.map { |string| day_string_to_int(string) }
+      end
+
+      def self.extract_hours_and_minutes(string)
+        _, hours, minutes = *string.match(/\A(\d\d):(\d\d)\Z/)
+        if hours.nil? || minutes.nil?
+          raise ArgumentError, "time should be HH:MM"
+        end
+        if hours.to_i < 0 || hours.to_i > 23 || minutes.to_i < 0 || minutes.to_i > 59
+          raise ArgumentError, "time should be HH:MM"
+        end
+        return hours.to_i, minutes.to_i
+      end
+    end
+  end
+end

data/lib/lita-timing.rb

@@ -1,2 +1,5 @@
+require 'lita/timing/mutex'
 require 'lita/timing/rate_limit'
 require 'lita/timing/sliding_window'
+require 'lita/timing/time_parser'
+require 'lita/timing/scheduled'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lita-timing
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - James Healy
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-06-19 00:00:00.000000000 Z
+date: 2016-08-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -78,8 +78,11 @@ files:
 - MIT-LICENSE
 - README.md
 - lib/lita-timing.rb
+- lib/lita/timing/mutex.rb
 - lib/lita/timing/rate_limit.rb
+- lib/lita/timing/scheduled.rb
 - lib/lita/timing/sliding_window.rb
+- lib/lita/timing/time_parser.rb
 homepage: http://github.com/yob/lita-timing
 licenses:
 - MIT