say_when 1.0.0 → 2.0.0

data/lib/say_when/storage/base_job.rb

@@ -0,0 +1,96 @@
+# encoding: utf-8
+
+module SayWhen
+  module Storage
+    module BaseJob
+      # ready to be run, just waiting for its turn
+      STATE_WAITING = 'waiting'
+
+      # has been acquired b/c it is time to be triggered
+      STATE_ACQUIRED = 'acquired'
+
+      # related job for the trigger is executing
+      STATE_EXECUTING = 'executing'
+
+      # "Complete" means the trigger has no remaining fire times
+      STATE_COMPLETE = 'complete'
+
+      # A Trigger arrives at the error state when the scheduler
+      # attempts to fire it, but cannot due to an error creating and executing
+      # its related job.
+      STATE_ERROR = 'error'
+
+      def lock
+        @lock ||= Mutex.new
+      end
+
+      def trigger
+        @trigger ||= load_trigger
+      end
+
+      def fired(fired_at = Time.now)
+        lock.synchronize do
+          self.last_fire_at = fired_at
+          self.next_fire_at = trigger.next_fire_at(last_fire_at + 1.second) rescue nil
+
+          if next_fire_at.nil?
+            self.status = STATE_COMPLETE
+          else
+            self.status = STATE_WAITING
+          end
+        end
+      end
+
+      def release
+        lock.synchronize do
+          if self.status == STATE_ACQUIRED
+            self.status = STATE_WAITING
+          end
+        end
+      end
+
+      def execute
+        execute_job(data)
+      end
+
+      def load_trigger
+        strategy = trigger_strategy || :once
+        require "say_when/triggers/#{strategy}_strategy"
+        trigger_class_name = "SayWhen::Triggers::#{strategy.to_s.camelize}Strategy"
+        trigger_class = trigger_class_name.constantize
+        trigger_class.new((trigger_options || {}).merge(:job=>self))
+      end
+
+      def execute_job(options)
+        task_method = (job_method || 'execute').to_s
+        task = get_task(task_method)
+        task.send(task_method, options)
+      end
+
+      def get_task(task_method)
+        task = nil
+
+        if job_class
+          tc = job_class.constantize
+          if tc.respond_to?(task_method)
+            task = tc
+          else
+            to = tc.new
+            if to.respond_to?(task_method)
+              task = to
+            else
+              raise "Neither '#{job_class}' class nor instance respond to '#{task_method}'"
+            end
+          end
+        elsif scheduled
+          if scheduled.respond_to?(task_method)
+            task = scheduled
+          else
+            raise "Scheduled '#{scheduled.inspect}' does not respond to '#{task_method}'"
+          end
+        end
+        task
+      end
+    end
+  end
+end

data/lib/say_when/storage/memory_strategy.rb

@@ -0,0 +1,140 @@
+require 'active_record'
+require 'say_when/storage/base_job'
+
+module SayWhen
+  module Storage
+    class MemoryStrategy
+      class << self
+        def acquire_next(no_later_than = nil)
+          SayWhen::Storage::MemoryStrategy::Job.acquire_next(no_later_than)
+        end
+
+        def reset_acquired(older_than_seconds)
+          SayWhen::Storage::MemoryStrategy::Job.reset_acquired(older_than_seconds)
+        end
+
+        def fired(job, fired_at = Time.now)
+          job.fired(fired_at)
+        end
+
+        def release(job)
+          job.release
+        end
+
+        def create(job)
+          SayWhen::Storage::MemoryStrategy::Job.create(job)
+        end
+
+        def serialize(job)
+          job.to_hash
+        end
+
+        def deserialize(job)
+          SayWhen::Storage::MemoryStrategy::Job.new(job)
+        end
+      end
+
+      class Job
+        include SayWhen::Storage::BaseJob
+
+        class << self
+          def acquire_lock
+            @acquire_lock ||= Mutex.new
+          end
+
+          def jobs
+            @jobs ||= SortedSet.new
+          end
+
+          def props
+            @props ||= []
+          end
+
+          def reset_acquired(older_than_seconds)
+            return unless older_than_seconds.to_i > 0
+            older_than = (Time.now - older_than_seconds.to_i)
+            acquire_lock.synchronize do
+              jobs.select do |j|
+                j.status == SayWhen::Storage::BaseJob::STATE_ACQUIRED && j.updated_at < older_than
+              end.each{ |j| j.status = SayWhen::Storage::BaseJob::STATE_WAITING }
+            end
+          end
+
+          def acquire_next(no_later_than)
+            acquire_lock.synchronize do
+              next_job = jobs.detect(nil) do |j|
+                (j.status == SayWhen::Storage::BaseJob::STATE_WAITING) &&
+                (j.next_fire_at.to_i <= no_later_than.to_i)
+              end
+              if next_job
+                next_job.status = SayWhen::Storage::BaseJob::STATE_ACQUIRED
+                next_job.updated_at = Time.now
+              end
+              next_job
+            end
+          end
+
+          def create(job)
+            if existing_job = find_named_job(job[:group], job[:name])
+              self.jobs.delete(existing_job)
+            end
+
+            new(job).save
+          end
+
+          def find_named_job(group, name)
+            group && name && jobs.detect { |j| j.group == group && j.name == name }
+          end
+
+          def has_properties(*args)
+            args.each do |a|
+              unless props.member?(a.to_s)
+                props << a.to_s
+                class_eval { attr_accessor(a.to_sym) }
+              end
+            end
+          end
+        end
+
+        has_properties :group, :name, :status, :start_at, :end_at
+        has_properties :trigger_strategy, :trigger_options, :last_fire_at, :next_fire_at
+        has_properties :job_class, :job_method, :data, :updated_at, :scheduled
+
+        def initialize(options = {})
+          options.each do |k,v|
+            if self.class.props.member?(k.to_s)
+              send("#{k}=", v)
+            end
+          end
+
+          self.updated_at = Time.now
+          self.status = STATE_WAITING unless self.status
+          self.next_fire_at = trigger.next_fire_at
+        end
+
+        def to_hash
+          [:job_class, :job_method, :data].inject({}) { |h,k| h[k] = send(k); h }
+        end
+
+        def save
+          self.class.jobs << self
+          self
+        end
+
+        def <=>(job)
+          self.next_fire_at.to_i <=> job.next_fire_at.to_i
+        end
+
+        def fired(fired_at=Time.now)
+          super
+          self.updated_at = Time.now
+        end
+
+        def release
+          super
+          self.updated_at = Time.now
+        end
+      end
+    end
+  end
+end

data/lib/say_when/tasks.rb

@@ -1,9 +1,21 @@
 # encoding: utf-8
 
 namespace :say_when do
-  desc 'Start the SayWhen Scheduler'
-  task start: :environment do
+  desc 'Start the SayWhen Scheduler with Rails environment'
+  task start_rails: :environment do
     require 'say_when'
-    SayWhen::Scheduler.start
+    require 'say_when/poller/simple_poller'
+
+    SayWhen::Poller::SimplePoller.new.start
+  end
+
+  desc 'Start the SayWhen Scheduler standalone'
+  task :start do
+    require 'say_when'
+    require 'say_when/poller/simple_poller'
+
+    SayWhen.configure
+    puts "SayWhen starting with options: #{SayWhen.options.inspect}"
+    SayWhen::Poller::SimplePoller.new.start
   end
 end

data/lib/say_when/triggers/base.rb

@@ -3,14 +3,14 @@
 module SayWhen
   module Triggers
     module Base
-
       attr_accessor :job
 
-      def initialize(options={})
+      def initialize(options = {})
         self.job = options.delete(:job)
+        raise ArgumentError.new("job must be provided to create a trigger") unless job
       end
 
-      def next_fire_at(time=nil)
+      def next_fire_at(time = nil)
         raise NotImplementedError.new('You need to implement next_fire_at in your strategy')
       end
     end

data/lib/say_when/triggers/cron_strategy.rb

@@ -6,17 +6,16 @@ require 'say_when/cron_expression'
 module SayWhen
   module Triggers
     class CronStrategy
-
       include SayWhen::Triggers::Base
 
       attr_accessor :cron_expression
 
-      def initialize(options={})
+      def initialize(options = {})
         super
         self.cron_expression = SayWhen::CronExpression.new(options)
       end
 
-      def next_fire_at(time=nil)
+      def next_fire_at(time = nil)
         cron_expression.next_fire_at(time || Time.now)
       end
     end

data/lib/say_when/triggers/instance_strategy.rb

@@ -5,18 +5,17 @@ require 'say_when/triggers/base'
 module SayWhen
   module Triggers
     class InstanceStrategy
-
       include SayWhen::Triggers::Base
 
       attr_accessor :instance, :next_at_method
 
-      def initialize(options={})
+      def initialize(options = {})
         super
-        self.instance       = job.scheduled
+        self.instance = job.scheduled
         self.next_at_method = options[:next_at_method] || 'next_fire_at'
       end
 
-      def next_fire_at(time=Time.now)
+      def next_fire_at(time = Time.now)
         instance.send(next_at_method, time)
       end
     end

data/lib/say_when/triggers/once_strategy.rb

@@ -5,19 +5,18 @@ require 'say_when/triggers/base'
 module SayWhen
   module Triggers
     class OnceStrategy
-
       include SayWhen::Triggers::Base
 
       attr_accessor :once_at
 
-      def initialize(options=nil)
+      def initialize(options = nil)
         super
         self.once_at = options[:at] || Time.now
       end
 
-      def next_fire_at(time=nil)
+      def next_fire_at(time = nil)
         nfa = once_at if (!time || (time <= once_at))
-        return nfa
+        nfa
       end
     end
   end

data/lib/say_when/utils.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+
+module SayWhen
+  module Utils
+    def load_strategy(strategy_type, strategy)
+      if strategy.is_a?(Symbol) || strategy.is_a?(String)
+        require "say_when/#{strategy_type}/#{strategy}_strategy"
+        class_name = "SayWhen::#{strategy_type.to_s.camelize}::#{strategy.to_s.camelize}Strategy"
+        strategy_class = class_name.constantize
+        strategy_class
+      else
+        strategy
+      end
+    end
+  end
+end

data/lib/say_when/version.rb

@@ -1,5 +1,5 @@
 # encoding: utf-8
 
 module SayWhen
-  VERSION = '1.0.0'
+  VERSION = '2.0.0'
 end

data/say_when.gemspec

@@ -1,4 +1,4 @@
-# -*- encoding: utf-8 -*-
+# coding: utf-8
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'say_when/version'
@@ -20,12 +20,17 @@ Gem::Specification.new do |spec|
 
   spec.add_runtime_dependency('activesupport')
 
-  spec.add_development_dependency('activerecord')
-  spec.add_development_dependency('shoryuken')
-  spec.add_development_dependency('activemessaging')
-  spec.add_development_dependency('bundler', '~> 1.3')
+  spec.add_development_dependency('bundler')
   spec.add_development_dependency('rake')
   spec.add_development_dependency('minitest')
+  spec.add_development_dependency('guard')
+  spec.add_development_dependency('guard-minitest')
   spec.add_development_dependency('simplecov')
+  spec.add_development_dependency('coveralls')
+
   spec.add_development_dependency('sqlite3')
+  spec.add_development_dependency('activerecord')
+  spec.add_development_dependency('celluloid')
+  spec.add_development_dependency('concurrent-ruby')
+  spec.add_development_dependency('activejob')
 end

data/test/minitest_helper.rb

@@ -1,5 +1,15 @@
 # encoding: utf-8
 
+ENV['RAILS_ENV'] ||= 'test'
+
+require 'simplecov'
+SimpleCov.start #'rails'
+
+if ENV['TRAVIS']
+  require 'coveralls'
+  Coveralls.wear!
+end
+
 $LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
 require 'say_when'
 
@@ -9,35 +19,55 @@ require 'minitest/spec'
 require 'minitest/mock'
 require 'fileutils'
 
-Dir[File.expand_path(File.join(File.dirname(__FILE__),'support','**','*.rb'))].each {|f| require f}
-
 require 'active_support'
+require 'active_job'
+
+require 'celluloid/test'
+
+ActiveJob::Base.queue_adapter = :inline
+
+Celluloid.boot
+
+SayWhen.configure do |options|
+  options[:storage_strategy]   = :memory
+  options[:processor_strategy] = :test
+end
+
+SayWhen.logger = Logger.new('/dev/null')
 
 module SayWhen
   module Test
-
     class TestTask
-      def execute(data)
+      @@executed = false
+
+      def self.reset
+        @@executed = false
+      end
+
+      def self.execute(data)
+        @@executed = true
         data[:result] || 0
       end
+
+      def self.executed?
+        @@executed
+      end
     end
 
-    class TestProcessor < SayWhen::Processor::Base
-      attr_accessor :jobs
+    class TestActsAsScheduled
+      @@_has_many = false
 
-      def initialize(scheduler)
-        super(scheduler)
-        reset
+      def self.has_many_called?
+        @@_has_many
       end
 
-      def process(job)
-        self.jobs << job
+      def self.has_many(*args)
+        @@_has_many = true
       end
 
-      def reset
-        self.jobs = []
-      end
+      require 'say_when/storage/active_record_strategy'
+      include SayWhen::Storage::ActiveRecordStrategy::Acts
+      acts_as_scheduled
     end
-
   end
 end