tickwork 0.0.1

data/lib/tickwork/manager.rb

@@ -0,0 +1,174 @@
+module Tickwork
+  class Manager
+    class NoHandlerDefined < RuntimeError; end
+    class NoDataStoreDefined < RuntimeError; end
+    class DuplicateJobName < RuntimeError; end
+
+    MANAGER_KEY = '__manager'
+
+    attr_reader :config
+
+    def initialize
+      @events = []
+      @callbacks = {}
+      @config = default_configuration
+      @handler = nil
+      @error_handler = nil
+    end
+
+    def thread_available?
+      Thread.list.select { |t| t['creator'] == self }.count < config[:max_threads]
+    end
+
+    def configure
+      yield(config)
+      if config[:sleep_timeout]
+        config[:logger].warn 'INCORRECT USAGE: sleep_timeout is not used'
+        if config[:sleep_timeout] < 1
+          config[:logger].warn 'sleep_timeout must be >= 1 second'
+        end
+      end
+      if config[:data_store].nil?
+        raise NoDataStoreDefined.new
+      end
+      if config[:tick_size] > 60
+        config[:logger].warn 'tick_size is greater than 60. Events scheduled for a specific time may be missed'
+      end
+    end
+
+    def default_configuration
+      { 
+        logger: Logger.new(STDOUT), 
+        thread: false, 
+        max_threads: 10,
+        namespace: '_tickwork_',
+        tick_size: 60, # 1 minute
+        max_ticks: 10,
+        max_catchup: 3600 # 1 hour
+      }
+    end
+
+    def handler(&block)
+      @handler = block if block_given?
+      raise NoHandlerDefined unless @handler
+      @handler
+    end
+
+    def error_handler(&block)
+      @error_handler = block if block_given?
+      @error_handler
+    end
+
+    def data_store
+      config[:data_store]
+    end
+
+    def on(event, options={}, &block)
+      raise "Unsupported callback #{event}" unless [:before_tick, :after_tick, :before_run, :after_run].include?(event.to_sym)
+      (@callbacks[event.to_sym]||=[]) << block
+    end
+
+    def every(period, job, options={}, &block)
+      if period < config[:tick_size]
+        config[:logger].warn 'period is smaller than tick size. will fail to schedule all events'
+      end
+      if options[:at].respond_to?(:each)
+        every_with_multiple_times(period, job, options, &block)
+      else
+        register(period, job, block, options)
+      end
+    end
+
+    def fire_callbacks(event, *args)
+      @callbacks[event].nil? || @callbacks[event].all? { |h| h.call(*args) }
+    end
+
+    def data_store_key
+      @data_store_key ||= config[:namespace] + MANAGER_KEY
+    end
+
+      # pretty straight forward if you think about it
+      # run the ticks from the last time we ran to our max
+      # but don't run ticks in the future
+    def run
+      raise NoDataStoreDefined.new if data_store.nil?
+      log "Starting clock for #{@events.size} events: [ #{@events.map(&:to_s).join(' ')} ]"
+
+      last = last_t = data_store.get(data_store_key)
+      last ||= Time.now.to_i - config[:tick_size] 
+      if !config[:max_catchup].nil? && config[:max_catchup] > 0 && last < Time.now.to_i - config[:max_catchup]
+        last = Time.now.to_i - config[:max_catchup] - config[:tick_size]
+      end
+
+      ticks = 0
+      tick_time = last + config[:tick_size]
+
+      while ticks < config[:max_ticks] && tick_time <= Time.now.to_i do
+        tick(tick_time) 
+        last = tick_time
+        tick_time += config[:tick_size]
+        ticks += 1
+      end
+      data_store.set(data_store_key, last)
+      last
+    end
+
+    def tick(t=Time.now.to_i)
+      t = Time.at(t) # TODO refactor below
+      if (fire_callbacks(:before_tick))
+        events = events_to_run(t)
+        events.each do |event|
+          if (fire_callbacks(:before_run, event, t))
+            event.run(t)
+            fire_callbacks(:after_run, event, t)
+          end
+        end
+      end
+      fire_callbacks(:after_tick)
+      events
+    end
+
+    def clear!
+      data_store.set(data_store_key, nil)
+    end
+
+    def log_error(e)
+      config[:logger].error(e)
+    end
+
+    def handle_error(e)
+      error_handler.call(e) if error_handler
+    end
+
+    def log(msg)
+      config[:logger].info(msg)
+    end
+
+    private
+    def events_to_run(t)
+      @events.select{ |event| event.run_now?(t) }
+    end
+
+    def register(period, job, block, options)
+      options.merge({:namespace => config[:namespace]})
+      event = Event.new(self, period, job, block || handler, options)
+      guard_duplicate_events(event)
+      @events << event
+      event
+    end
+
+    def guard_duplicate_events(event)
+      if @events.map{|e| e.to_s }.include? event.to_s
+        raise DuplicateJobName
+      end
+    end
+
+    def every_with_multiple_times(period, job, options={}, &block)
+      each_options = options.clone
+      options[:at].each do |at|
+        each_options[:at] = at
+        register(period, job + '_' + at, block, each_options)
+      end
+    end
+  end
+end

data/lib/tickwork.rb

@@ -0,0 +1,56 @@
+require 'logger'
+require 'active_support/time'
+
+require 'tickwork/at'
+require 'tickwork/event'
+require 'tickwork/manager'
+
+module Tickwork
+  class << self
+    def included(klass)
+      klass.send "include", Methods
+      klass.extend Methods
+    end
+
+    def manager
+      @manager ||= Manager.new
+    end
+
+    def manager=(manager)
+      @manager = manager
+    end
+  end
+
+  module Methods
+    def configure(&block)
+      Tickwork.manager.configure(&block)
+    end
+
+    def handler(&block)
+      Tickwork.manager.handler(&block)
+    end
+
+    def error_handler(&block)
+      Tickwork.manager.error_handler(&block)
+    end
+
+    def on(event, options={}, &block)
+      Tickwork.manager.on(event, options, &block)
+    end
+
+    def every(period, job, options={}, &block)
+      Tickwork.manager.every(period, job, options, &block)
+    end
+
+    def run
+      Tickwork.manager.run
+    end
+
+    def clear!
+      Tickwork.manager.clear! unless Tickwork.manager.nil?
+      Tickwork.manager = Manager.new
+    end
+  end
+
+  extend Methods
+end

data/test/at_test.rb

@@ -0,0 +1,116 @@
+require File.expand_path('../../lib/tickwork', __FILE__)
+require "minitest/autorun"
+require 'mocha/mini_test'
+require 'time'
+require 'active_support/time'
+
+describe 'Tickwork::At' do
+  def time_in_day(hour, minute)
+    Time.new(2013, 1, 1, hour, minute, 0)
+  end
+
+  it '16:20' do
+    at = Tickwork::At.parse('16:20')
+    assert !at.ready?(time_in_day(16, 19))
+    assert  at.ready?(time_in_day(16, 20))
+    assert !at.ready?(time_in_day(16, 21))
+  end
+
+  it '8:20' do
+    at = Tickwork::At.parse('8:20')
+    assert !at.ready?(time_in_day(8, 19))
+    assert  at.ready?(time_in_day(8, 20))
+    assert !at.ready?(time_in_day(8, 21))
+  end
+
+  it '**:20 with two stars' do
+    at = Tickwork::At.parse('**:20')
+
+    assert !at.ready?(time_in_day(15, 19))
+    assert  at.ready?(time_in_day(15, 20))
+    assert !at.ready?(time_in_day(15, 21))
+
+    assert !at.ready?(time_in_day(16, 19))
+    assert  at.ready?(time_in_day(16, 20))
+    assert !at.ready?(time_in_day(16, 21))
+  end
+
+  it '*:20 with one star' do
+    at = Tickwork::At.parse('*:20')
+
+    assert !at.ready?(time_in_day(15, 19))
+    assert  at.ready?(time_in_day(15, 20))
+    assert !at.ready?(time_in_day(15, 21))
+
+    assert !at.ready?(time_in_day(16, 19))
+    assert  at.ready?(time_in_day(16, 20))
+    assert !at.ready?(time_in_day(16, 21))
+  end
+
+  it '16:**' do
+    at = Tickwork::At.parse('16:**')
+
+    assert !at.ready?(time_in_day(15, 59))
+    assert  at.ready?(time_in_day(16, 00))
+    assert  at.ready?(time_in_day(16, 30))
+    assert  at.ready?(time_in_day(16, 59))
+    assert !at.ready?(time_in_day(17, 00))
+  end
+
+  it '8:**' do
+    at = Tickwork::At.parse('8:**')
+
+    assert !at.ready?(time_in_day(7, 59))
+    assert  at.ready?(time_in_day(8, 00))
+    assert  at.ready?(time_in_day(8, 30))
+    assert  at.ready?(time_in_day(8, 59))
+    assert !at.ready?(time_in_day(9, 00))
+  end
+
+  it 'Saturday 12:00' do
+    at = Tickwork::At.parse('Saturday 12:00')
+
+    assert !at.ready?(Time.new(2010, 1, 1, 12, 00))
+    assert  at.ready?(Time.new(2010, 1, 2, 12, 00)) # Saturday
+    assert !at.ready?(Time.new(2010, 1, 3, 12, 00))
+    assert  at.ready?(Time.new(2010, 1, 9, 12, 00))
+  end
+
+  it 'sat 12:00' do
+    at = Tickwork::At.parse('sat 12:00')
+
+    assert !at.ready?(Time.new(2010, 1, 1, 12, 00))
+    assert  at.ready?(Time.new(2010, 1, 2, 12, 00))
+    assert !at.ready?(Time.new(2010, 1, 3, 12, 00))
+  end
+
+  it 'invalid time 32:00' do
+    assert_raises Tickwork::At::FailedToParse do
+      Tickwork::At.parse('32:00')
+    end
+  end
+
+  it 'invalid multi-line with Sat 12:00' do
+    assert_raises Tickwork::At::FailedToParse do
+      Tickwork::At.parse("sat 12:00\nreally invalid time")
+    end
+  end
+
+  it 'invalid multi-line with 8:30' do
+    assert_raises Tickwork::At::FailedToParse do
+      Tickwork::At.parse("8:30\nreally invalid time")
+    end
+  end
+
+  it 'invalid multi-line with *:10' do
+    assert_raises Tickwork::At::FailedToParse do
+      Tickwork::At.parse("*:10\nreally invalid time")
+    end
+  end
+
+  it 'invalid multi-line with 12:**' do
+    assert_raises Tickwork::At::FailedToParse do
+      Tickwork::At.parse("12:**\nreally invalid time")
+    end
+  end
+end

data/test/data_stores/fake_store.rb

@@ -0,0 +1,21 @@
+module Tickwork
+  class FakeStore 
+
+    def initialize
+      @data_store = {}
+    end
+
+    def get(key)
+      @data_store[key]
+    end
+
+    def set(key, value)
+      @data_store[key] = value
+    end
+
+    # not part of the interface but used for testing
+    def size
+      @data_store.size
+    end
+  end
+end

data/test/event_test.rb

@@ -0,0 +1,67 @@
+require File.expand_path('../../lib/tickwork', __FILE__)
+require File.expand_path('../data_stores/fake_store.rb', __FILE__)
+require 'mocha/mini_test'
+require "minitest/autorun"
+
+describe Tickwork::Event do
+  describe '#thread?' do
+    before do
+      @manager = Class.new
+      @data_store = Tickwork::FakeStore.new
+    end
+
+    describe 'manager config thread option set to true' do
+      before do
+        @manager.stubs(:config).returns({ :thread => true })
+        @manager.stubs(:data_store).returns(@data_store)
+      end
+
+      it 'is true' do
+        event = Tickwork::Event.new(@manager, nil, 'unnamed', nil)
+        assert_equal true, event.thread?
+      end
+
+      it 'is false when event thread option set' do
+        event = Tickwork::Event.new(@manager, nil, 'unnamed', nil, :thread => false)
+        assert_equal false, event.thread?
+      end
+    end
+
+    describe 'manager config thread option not set' do
+      before do
+        @manager.stubs(:config).returns({})
+      end
+
+      it 'is true if event thread option is true' do
+        event = Tickwork::Event.new(@manager, nil, 'unnamed', nil, :thread => true)
+        assert_equal true, event.thread?
+      end
+    end
+
+    describe 'job name' do 
+      before do
+        @manager.stubs(:config).returns({})
+      end
+      it 'is required' do 
+        assert_raises(Tickwork::Event::IllegalJobName) do  
+          Tickwork::Event.new(@manager, nil, nil, nil)
+        end
+      end
+      it 'must be a string' do 
+        assert_raises(Tickwork::Event::IllegalJobName) do  
+          Tickwork::Event.new(@manager, nil, Class.new, nil)
+        end
+      end
+      it 'must not be empty' do 
+        assert_raises(Tickwork::Event::IllegalJobName) do  
+          Tickwork::Event.new(@manager, nil, '', nil)
+        end
+      end
+      it 'raises exception on manager key name clash' do      
+        assert_raises(Tickwork::Event::IllegalJobName) do  
+          Tickwork::Event.new(@manager, nil, '__manager', nil)
+        end
+      end
+    end
+  end
+end