say_when 1.0.0 → 2.0.0

data/lib/say_when/processor/active_messaging.rb

@@ -1,21 +0,0 @@
-# encoding: utf-8
-
-require 'activemessaging/message_sender'
-
-module SayWhen
-  module Processor
-    class ActiveMessaging < SayWhen::Processor::Base
-
-      include ::ActiveMessaging::MessageSender
-
-      def initialize(scheduler)
-        super(scheduler)
-      end
-
-      # send the job to the other end, then in the a13g processor, call the execute method
-      def process(job)
-        publish(:say_when, { job_id: job.id }.to_yaml )
-      end
-    end if defined?(::ActiveMessaging)
-  end
-end

data/lib/say_when/processor/base.rb

@@ -1,19 +0,0 @@
-# encoding: utf-8
-
-module SayWhen
-  module Processor
-
-    class Base
-      attr_accessor :scheduler
-
-      def initialize(scheduler)
-        @scheduler = scheduler
-      end
-
-      def process(job)
-        raise NotImplementedError.new('You need to implement process(job)')
-      end
-    end
-
-  end
-end

data/lib/say_when/processor/shoryuken.rb

@@ -1,14 +0,0 @@
-# encoding: utf-8
-
-module SayWhen
-  module Processor
-    class Shoryuken < SayWhen::Processor::Base
-      def initialize(scheduler)
-        super(scheduler)
-      end
-
-      def process(job)
-      end
-    end
-  end
-end

data/lib/say_when/processor/simple.rb

@@ -1,17 +0,0 @@
-# encoding: utf-8
-
-module SayWhen
-  module Processor
-
-    class Simple < SayWhen::Processor::Base
-      def initialize(scheduler)
-        super(scheduler)
-      end
-
-      def process(job)
-        job.execute
-      end
-    end
-
-  end
-end

data/lib/say_when/storage/active_record/acts.rb

@@ -1,92 +0,0 @@
-# encoding: utf-8
-
-module SayWhen #:nodoc:
-  module Storage #:nodoc:
-    module ActiveRecord #:nodoc:
-      module Acts #:nodoc:
-
-        extend ActiveSupport::Concern
-
-        module ClassMethods
-          def acts_as_scheduled
-            include SayWhen::Storage::ActiveRecord::Acts::InstanceMethods
-
-            has_many :scheduled_jobs, as: :scheduled, class_name: 'SayWhen::Storage::ActiveRecord::Job', dependent: :destroy
-          end
-        end
-
-        module InstanceMethods
-
-          def schedule_instance(next_at_method, job={})
-            options = job_options(job)
-            options[:trigger_strategy] = 'instance'
-            options[:trigger_options]  = { next_at_method: next_at_method }
-            Scheduler.schedule(options)
-          end
-
-          def schedule_cron(expression, time_zone, job={})
-            options = job_options(job)
-            options[:trigger_strategy] = 'cron'
-            options[:trigger_options]  = { expression: expression, time_zone: time_zone }
-            Scheduler.schedule(options)
-          end
-
-          def schedule_once(time, job={})
-            options = job_options(job)
-            options[:trigger_strategy] = 'once'
-            options[:trigger_options]  = { at: time}
-            Scheduler.schedule(options)
-          end
-
-          def schedule_in(after, job={})
-            options = job_options(job)
-            options[:trigger_strategy] = 'once'
-            options[:trigger_options]  = { at: (Time.now + after)}
-            Scheduler.schedule(options)
-          end
-
-          # helpers
-
-          def job_options(job)
-            {
-              scheduled:  self,
-              job_class:  extract_job_class(job),
-              job_method: extract_job_method(job),
-              data:       extract_data(job)
-            }
-          end
-
-          def extract_job_class(job)
-            if job.is_a?(Hash)
-              job[:class]
-            elsif job.is_a?(Class)
-              job.name
-            elsif job.is_a?(String)
-              job
-            else
-              raise "Could not identify job class from: #{job}"
-            end
-          end
-
-          def extract_job_method(job)
-            if job.is_a?(Hash)
-              job[:method]
-            else
-              'execute'
-            end
-          end
-
-          def extract_data(job)
-            if job.is_a?(Hash)
-              job[:data]
-            else
-              nil
-            end
-          end
-        end # InstanceMethods
-      end
-    end
-  end
-end
-
-ActiveRecord::Base.send(:include, SayWhen::Storage::ActiveRecord::Acts) unless ActiveRecord::Base.include?(SayWhen::Storage::ActiveRecord::Acts)

data/lib/say_when/storage/active_record/job.rb

@@ -1,100 +0,0 @@
-# encoding: utf-8
-
-require 'active_record'
-require 'say_when/base_job'
-require 'say_when/storage/active_record/job_execution'
-require 'say_when/storage/active_record/acts'
-
-module SayWhen
-  module Storage
-    module ActiveRecord
-
-      class Job  < ::ActiveRecord::Base
-
-        include SayWhen::BaseJob
-
-        self.table_name = 'say_when_jobs'
-
-        serialize :trigger_options
-        serialize :data
-
-        belongs_to :scheduled, polymorphic: true
-        has_many  :job_executions, class_name: 'SayWhen::Storage::ActiveRecord::JobExecution'
-
-        before_create :set_defaults
-
-        def self.acquire_next(no_later_than)
-          next_job = nil
-
-          hide_logging do
-            SayWhen::Storage::ActiveRecord::Job.transaction do
-              # select and lock the next job that needs executin' (status waiting, and after no_later_than)
-              next_job = where('status = ? and next_fire_at < ?', STATE_WAITING, no_later_than.in_time_zone('UTC')).
-                order('next_fire_at ASC').
-                lock(true).first
-
-              # set status to acquired to take it out of rotation
-              next_job.update_attribute(:status, STATE_ACQUIRED) unless next_job.nil?
-            end
-          end
-          next_job
-        end
-
-        def set_defaults
-          # puts "SayWhen::Storage::ActiveRecord::Job - set_defaults start"
-          self.status = STATE_WAITING
-          self.next_fire_at = self.trigger.next_fire_at
-          # puts "SayWhen::Storage::ActiveRecord::Job - set_defaults, next_fire_at: #{self.next_fire_at}"
-        end
-
-        def fired(fired_at=Time.now)
-          Job.transaction {
-            super
-            self.save!
-          }
-        end
-
-        def release
-          Job.transaction {
-            super
-            self.save!
-          }
-        end
-
-        # default impl with some error handling and result recording
-        def execute
-          result = nil
-          execution = SayWhen::Storage::ActiveRecord::JobExecution.create(:job=>self, :status=>'executing', :start_at=>Time.now)
-
-          begin
-            result = self.execute_job(data)
-            execution.result = result
-            execution.status = 'complete'
-          rescue Object=>ex
-            execution.result = "#{ex.class.name}: #{ex.message}\n\t#{ex.backtrace.join("\n\t")}"
-            execution.status = 'error'
-          end
-
-          execution.end_at = Time.now
-          execution.save!
-          result
-        end
-
-        protected
-
-        def self.hide_logging
-          old_logger = nil
-          begin
-            old_logger = ::ActiveRecord::Base.logger
-            ::ActiveRecord::Base.logger = nil
-
-            yield
-
-          ensure
-            ::ActiveRecord::Base.logger = old_logger
-          end
-        end
-      end
-    end
-  end
-end

data/lib/say_when/storage/active_record/job_execution.rb

@@ -1,14 +0,0 @@
-# encoding: utf-8
-
-require 'active_record'
-
-module SayWhen
-  module Storage
-    module ActiveRecord
-      class JobExecution < ::ActiveRecord::Base
-        self.table_name = "say_when_job_executions"
-        belongs_to :job, class_name: 'SayWhen::Storage::ActiveRecord::Job'
-      end
-    end
-  end
-end

data/lib/say_when/storage/memory/base.rb

@@ -1,36 +0,0 @@
-# encoding: utf-8
-
-module SayWhen
-  module Storage
-    module Memory
-
-      module Base
-
-        attr_accessor :props
-
-        def has_properties(*args)
-          @props ||= []
-          args.each do |a|
-            unless @props.member?(a.to_s)
-              @props << a.to_s
-              class_eval { attr_accessor(a.to_sym) }
-            end
-          end
-        end
-
-        def self.included(base)
-          base.extend self
-        end
-
-        def initialize(args={})
-          args.each do |k,v|
-            if self.class.props.member?(k.to_s)
-              self.send("#{k}=", v)
-            end
-          end
-        end
-      end
-
-    end
-  end
-end

data/lib/say_when/storage/memory/job.rb

@@ -1,53 +0,0 @@
-# encoding: utf-8
-
-require 'say_when/storage/memory/base'
-
-module SayWhen
-  module Storage
-    module Memory
-
-      # define a trigger class
-      class Job
-
-        include SayWhen::Storage::Memory::Base
-        include SayWhen::BaseJob
-
-        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
-        has_properties :scheduled
-
-        cattr_accessor :jobs
-        @@jobs = SortedSet.new
-        @@acquire_lock = Mutex.new
-
-        def self.acquire_next(no_later_than)
-          @@acquire_lock.synchronize {
-
-            next_job = jobs.detect(nil) do |j|
-              (j.status == STATE_WAITING) && (j.next_fire_at.to_i <= no_later_than.to_i)
-            end
-
-            next_job.status = STATE_ACQUIRED if next_job
-            next_job
-          }
-        end
-
-        def self.create(job)
-          job = new(job) if job.is_a?(Hash)
-          self.jobs << job
-        end
-
-        def initialize(options={})
-          super
-          self.status = STATE_WAITING unless self.status
-          self.next_fire_at = trigger.next_fire_at
-        end
-
-        def <=>(job)
-          self.next_fire_at.to_i <=> job.next_fire_at.to_i
-        end
-      end
-    end
-  end
-end

data/test/say_when/cron_expression_spec.rb

@@ -1,74 +0,0 @@
-# encoding: utf-8
-
-require File.dirname(__FILE__) + '/../spec_helper'
-
-describe SayWhen::CronExpression do
-
-  it 'should set the time_zone' do
-    @ce = SayWhen::CronExpression.new("0 0 12 ? * 1#1 *", 'Pacific Time (US & Canada)')
-    @ce.time_zone.must_equal 'Pacific Time (US & Canada)'
-  end
-
-  describe 'get first sunday in the month with "1#1' do
-
-    before do
-      @ce = SayWhen::CronExpression.new("0 0 12 ? * 1#1 *", 'Pacific Time (US & Canada)')
-    end
-
-    it 'finds first sunday in the same month' do
-      @ce.next_fire_at(Time.utc(2008,1,1)).must_equal Time.parse('2008-01-06 12:00:00 -0800')
-    end
-
-
-    it 'finds first sunday in the next month' do
-      @ce.next_fire_at(Time.utc(2008,1,7)).must_equal Time.parse('2008-02-03 12:00:00 -0800')
-    end
-
-    it 'finds last sunday in the same month' do
-      @ce.last_fire_at(Time.utc(2008,1,10)).must_equal Time.parse('2008-01-06 12:00:00 -0800')
-    end
-
-    it 'finds sundays in the prior months and years' do
-      @ce.last_fire_at(Time.utc(2008,1,5)).must_equal Time.parse('2007-12-02 12:00:00 -0800')
-      @ce.last_fire_at(Time.parse('2007-12-02 12:00:00 -0800') - 1.second).must_equal Time.parse('2007-11-04 12:00:00 -0800')
-      @ce.last_fire_at(Time.parse('2007-11-04 12:00:00 -0800') - 1.second).must_equal Time.parse('2007-10-07 12:00:00 -0700')
-      @ce.next_fire_at(Time.parse('2007-10-07 12:00:00 -0700') + 1.second).must_equal Time.parse('2007-11-04 12:00:00 -0800')
-    end
-  end
-
-  describe 'get last sunday in the month with "1L"' do
-    before do
-      @ce = SayWhen::CronExpression.new("0 0 12 ? * 1L *", 'Pacific Time (US & Canada)')
-    end
-
-    it 'gets next final sunday for same month' do
-      @ce.next_fire_at(Time.utc(2008,1,1)).must_equal Time.parse('2008-01-27 12:00:00 -0800')
-    end
-
-
-    it 'gets next final sunday for next month' do
-      @ce.next_fire_at(Time.utc(2008,1,28)).must_equal Time.parse('2008-02-24 12:00:00 -0800')
-    end
-
-    it 'gets last final sunday for same month' do
-      @ce.last_fire_at(Time.utc(2008,1,28)).must_equal Time.parse('2008-01-27 12:00:00 -0800')
-    end
-
-    it 'gets last sunday for prior month and year' do
-      @ce.last_fire_at(Time.utc(2008,1,1)).must_equal Time.parse('2007-12-30 12:00:00 -0800')
-    end
-
-
-    it 'gets last sunday for prior month and year' do
-      nfa = @ce.last_fire_at(Time.utc(2007,12,1))
-      nfa.must_equal Time.parse('2007-11-25 12:00:00 -0800')
-
-      nfa = @ce.last_fire_at(nfa - 1.second)
-      nfa.must_equal Time.parse('2007-10-28 12:00:00 -0700')
-
-      nfa = @ce.next_fire_at(nfa + 1.second)
-      nfa.must_equal Time.parse('2007-11-25 12:00:00 -0800')
-    end
-
-  end
-end