lita-task-scheduler 0.1.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c1c534abd255cca4223c3d12ac9fed05cbb065a2
-  data.tar.gz: 4bc8e533d727d056ee1430a2c1354cfa9aeec931
+  metadata.gz: 23f66b45e3100b728a6a53a23fa9f166552d7989
+  data.tar.gz: 4b23ad6c9ed0638905152bb6ac960fa98978a47d
 SHA512:
-  metadata.gz: 7701aaef31efb81503dc8eb0f6e4505d8429335757e0b3cbd118747bf6ac8d48aed92a195731b621cdfcc797f7f185b5b68c8741c9a836dffbd4e05d1dbc00db
-  data.tar.gz: a865d1c5ddc0cab514cdfbc2b219e43a3979619ab88b741736627c0d1265c796ce62bdfbd51ae088ed2ec9bff28c2485ff8ab9d5a2f54c05b47f61b823a582a2
+  metadata.gz: 468d8b5438c5d815e570d72d14c727b093f7d584104017c459b1c0a72d2ec6097fba77df538f2e02acfccb7e1615c3b7ab130419845363dbd23ffcc12aff929d
+  data.tar.gz: 969dc2317064912351a8bdf4af531fd0e1095186d4100298587b298c0cf5c027339672e2311ad08481dad6757b178ec8f4df5d897e5dbd54ee54739f4acb6c6e

data/lib/lita/handlers/task_scheduler.rb

@@ -1,20 +1,135 @@
+require 'pry'
+require 'json'
+
 module Lita
   module Handlers
     class TaskScheduler < Handler
 
-      route /^schedule\s+"(.+)"\s+in\s+(.+)$/i, :schedule
+      route(/^schedule\s+"(.+)"\s+in\s+(.+)$/i, :schedule_command, command: true)
+      route(/^show schedule$/i, :show_schedule, command: true)
+      route(/^empty schedule$/i, :empty_schedule, command: true)
+
+      REDIS_TASKS_KEY = name.to_s
+
+      def show_schedule(payload)
+        schedule = redis.hgetall(REDIS_TASKS_KEY)
+
+        payload.reply schedule_report(schedule)
+      end
+
+      def empty_schedule(payload)
+        redis.del(REDIS_TASKS_KEY)
+        show_schedule payload
+      end
+
+      def schedule_report(schedule)
+        reply = 'Scheduled tasks: '
+        descriptions = []
+
+        schedule.keys.each do |timestamp|
+          play_time = Time.at(timestamp.to_i)
+          tasks_json = schedule[timestamp]
+          tasks = JSON.parse(tasks_json)
+
+          tasks.each do |task|
+            descriptions << "\n - \"#{task.fetch('body')}\" at #{play_time}"
+          end
+        end
+
+        reply + (descriptions.empty? ? 'None.' : descriptions.join)
+      end
+
+      def schedule_command(payload)
+        task, timing = payload.matches.last
+        run_at = parse_timing(timing)
+        serialized = serialize_message(payload.message, new_body: task)
+
+        defer_task(serialized, run_at)
+        show_schedule(payload)
+      end
+
+      def defer_task(serialized_task, run_at)
+        key_time = run_at.to_i.to_s
+
+        redis.watch(REDIS_TASKS_KEY)
+
+        tasks = redis.hget(REDIS_TASKS_KEY, key_time) || []
+
+        tasks = JSON.parse(tasks) unless tasks.empty?
+        tasks << serialized_task
+
+        redis.hset(REDIS_TASKS_KEY, key_time, tasks.to_json)
 
-      def schedule(payload)
-        payload.matches.each do |task, timing|
-          serialized = serialize_message(payload.message, new_body: task)
-          resend(serialized)
+        redis.unwatch
+
+        tasks
+      end
+
+      def execute_tasks(serialized_tasks)
+        serialized_tasks.each do |serialized_task|
+          Lita.logger.debug "Resending task #{serialized_task}"
+          resend serialized_task
+        end
+      end
+
+      def run_loop
+        Thread.new do
+          loop do
+            tick
+            sleep 1
+          end
         end
       end
 
+      def tick
+        tasks = find_tasks_due
+        tasks.each { |t| resend t }
+        Lita.logger.debug "Task loop done for #{Time.now}"
+      end
+
+      def find_tasks_due
+        results = []
+        timestamps = redis.hkeys(REDIS_TASKS_KEY)
+
+        timestamps.each do |t|
+          key_time = Time.at(t.to_i)
+          next unless key_time <= Time.now
+
+          tasks_raw = redis.hget(REDIS_TASKS_KEY, t)
+          tasks = JSON.parse(tasks_raw)
+
+          results += tasks
+          redis.hdel(REDIS_TASKS_KEY, t)
+        end
+
+        results
+      end
+
+      def parse_timing(timing)
+        count, unit = timing.split
+        count = count.to_i
+        unit = unit.downcase.strip.gsub(/s$/, '')
+
+        seconds = case unit
+                  when 'second'
+                    count
+                  when 'minute'
+                    count * 60
+                  when 'hour'
+                    count * 60 * 60
+                  when 'day'
+                    count * 60 * 60 * 24
+                  else
+                    raise ArgumentError, "I don't recognize #{unit}"
+                  end
+
+        Time.now.utc + seconds
+      end
+
       def rebroadcast(payload)
         serialized = serialize_message(payload.message)
 
-        key = "delay_#{rand(100..10000)}"
+        key = "delay_#{rand(100..10_000)}"
         redis.set(key, serialized.to_json)
         reloaded = JSON.parse redis.get(key), symbolize_names: true
 
@@ -22,10 +137,10 @@ module Lita
       end
 
       def resend(serialized)
-        user = Lita::User.new(serialized.fetch(:user_name))
-        room = Lita::Room.new(serialized.fetch(:room_name))
+        user = Lita::User.new(serialized.fetch('user_name'))
+        room = Lita::Room.new(serialized.fetch('room_name'))
         source = Lita::Source.new(user: user, room: room)
-        body = "#{robot.name} #{serialized.fetch(:body)}"
+        body = "#{robot.name} #{serialized.fetch('body')}"
 
         newmsg = Lita::Message.new(
           robot,
@@ -45,6 +160,10 @@ module Lita
       end
 
       Lita.register_handler(self)
+
+      on :loaded do
+        run_loop
+      end
     end
   end
 end

data/lita-task-scheduler.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |spec|
   spec.name          = "lita-task-scheduler"
-  spec.version       = "0.1.1"
+  spec.version       = "1.0.0"
   spec.authors       = ["Daniel J. Pritchett"]
   spec.email         = ["dpritchett@gmail.com"]
   spec.description   = "Schedule jobs in Lita"

data/spec/lita/handlers/task_scheduler_spec.rb

@@ -1,4 +1,115 @@
-require "spec_helper"
+require 'spec_helper'
 
 describe Lita::Handlers::TaskScheduler, lita_handler: true do
+  let(:robot) { Lita::Robot.new(registry) }
+
+  subject { described_class.new(robot) }
+
+  describe 'routing' do
+    it { is_expected.to route('Lita schedule "show schedule" in 2 hours') }
+    it { is_expected.to route('Lita show schedule') }
+  end
+
+  describe 'functionality' do
+
+    describe ':schedule_report' do
+      context 'tasks are scheduled'
+      before do
+        send_message 'Lita schedule "show schedule" in 1 seconds'
+        send_message 'Lita schedule "show schedule" in 6 seconds'
+      end
+
+      it 'should list scheduled tasks on demand' do
+        message = double 'message'
+        expect(message).to receive(:reply)
+        subject.show_schedule(message)
+        send_message 'Lita show schedule'
+      end
+    end
+
+    describe ':defer_task' do
+      it 'defers any single task' do
+        message = { canary_message: Time.now }
+        run_at = Time.now + 5
+        result = subject.defer_task(message, run_at)
+        expect(result).to include(message)
+      end
+
+      it 'stores multiple same-second tasks in an array' do
+        message = { 'canary_message' => Time.now.to_i }
+        run_at = Time.now + 5
+
+        5.times do
+          subject.defer_task(message, run_at)
+        end
+
+        result = subject.defer_task(message, run_at)
+
+        expect(result).to eq([message] * 6)
+      end
+    end
+
+    describe ':find_tasks_due' do
+      context 'two tasks are scheduled for five seconds ago' do
+        before { 2.times { subject.defer_task('past_task', Time.now - 5) } }
+
+        it 'returns all past due tasks' do
+          result = subject.find_tasks_due
+          expected = %w[past_task past_task]
+          expect(result).to eq(expected)
+        end
+      end
+
+      context 'one task scheduled in the future' do
+        before { subject.defer_task('future_task', Time.now + 100) }
+
+        it 'does not return that new task' do
+          result = subject.find_tasks_due
+          expect(result).to_not include('future_task')
+        end
+      end
+    end
+  end
+
+  describe 'execute_tasks' do
+    it 'resends each task' do
+      tasks = [{}, {}]
+
+      expect(subject).to receive(:resend).exactly(2).times
+      subject.execute_tasks(tasks)
+    end
+  end
+
+  describe 'tick' do
+    before { subject.stub(:find_tasks_due).and_return ['a_task'] }
+
+    it 'should find tasks due and resend them' do
+      expect(subject).to receive(:find_tasks_due)
+      expect(subject).to receive(:resend).with('a_task')
+
+      subject.tick
+    end
+  end
+
+  describe ':parse_timing' do
+    def time_drift(time, expected_seconds:)
+      delta = (Time.now.utc - time).abs
+      (expected_seconds - delta).abs
+    end
+
+    it 'parses seconds, minutes, hours, and days' do
+      test_table = [
+        ['3 seconds', 3],
+        ['4 minutes', 4 * 60],
+        ['2 hours', 2 * 60 * 60],
+        ['5 days', 5 * 60 * 60 * 24]
+      ]
+
+      test_table.each do |input, expected|
+        response = subject.parse_timing(input)
+        drift = time_drift(response, expected_seconds: expected)
+        expect(drift < 0.1).to be_truthy, "#{input}:\t #{expected}"
+      end
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lita-task-scheduler
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 1.0.0
 platform: ruby
 authors:
 - Daniel J. Pritchett
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-03-14 00:00:00.000000000 Z
+date: 2018-04-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: lita