say_when 0.1.0

data/lib/say_when/scheduler.rb

@@ -0,0 +1,129 @@
+module SayWhen
+
+  class Scheduler
+
+    DEFAULT_PROCESSOR_CLASS  = SayWhen::Processor::Simple
+    DEFAULT_STORAGE_STRATEGY = :memory
+
+    @@scheduler = nil
+    @@lock = nil
+    
+    attr_accessor :storage_strategy, :processor_class, :tick_length
+
+    attr_accessor :running
+
+    # support for a singleton scheduler, but you are not restricted to this
+    class << self
+
+      def scheduler
+        self.lock.synchronize {
+          if @@scheduler.nil?
+            @@scheduler = self.new
+          end
+        }
+        @@scheduler
+      end
+
+      def configure
+        yield self.scheduler
+        self.scheduler
+      end
+
+      def lock
+        @@lock ||= Mutex.new
+      end
+
+      def schedule(job)
+        self.scheduler.schedule(job)
+      end
+
+      def start
+        self.scheduler.start
+      end
+
+    end
+
+    def initialize
+      self.tick_length = 1
+    end
+
+    def processor
+      if @processor.nil?
+        @processor_class ||= DEFAULT_PROCESSOR_CLASS
+        @processor = @processor_class.new(self)
+      end
+      @processor
+    end
+    
+    def start
+      logger.info "SayWhen::Scheduler starting"
+
+      [$stdout, $stderr].each{|s| s.sync = true; s.flush}
+      trap("TERM", "EXIT")
+      trap("QUIT") { stop }
+
+      begin
+        self.running = true
+
+        logger.info "SayWhen::Scheduler running"
+        job = nil
+        while running
+          begin
+            time_now = Time.now
+            logger.debug "SayWhen:: Looking for job that should be ready to fire before #{time_now}"
+            job = job_class.acquire_next(time_now)
+            if job.nil?
+              logger.debug "SayWhen:: no jobs to acquire, sleep"
+              sleep(tick_length)
+            else
+              logger.debug "SayWhen:: got a job: #{job.inspect}"
+              # delegate processing the trigger to the processor
+              self.processor.process(job)
+              logger.debug "SayWhen:: job processed"
+
+              # this should update next fire at, and put back in list of scheduled jobs
+              job.fired
+              logger.debug "SayWhen:: job fired complete"
+
+            end
+          rescue Object=>ex
+            begin
+              job_msg = job && " job:'#{job.inspect}'"
+              logger.error "SayWhen:: Failure to process#{job_msg}: #{ex.message}\n\t#{ex.backtrace.join("\t\n")}"
+              job.release if job
+            rescue
+              puts ex
+            end
+          end
+        end
+      end
+
+      logger.info "SayWhen::Scheduler stopped"
+    end
+
+    def stop
+      logger.info "SayWhen::Scheduler stopping..."
+      self.running = false
+    end
+
+    def job_class
+      @job_class ||= load_job_class
+    end
+
+    def load_job_class
+      strategy = @storage_strategy || DEFAULT_STORAGE_STRATEGY
+      require "say_when/storage/#{strategy}/job"
+      job_class_name = "SayWhen::Storage::#{strategy.to_s.camelize}::Job"
+      job_class_name.constantize
+    end
+
+    def schedule(job)
+      job_class.create(job)
+    end
+
+    def logger
+      SayWhen::logger
+    end
+
+  end
+end

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

@@ -0,0 +1,85 @@
+module SayWhen #:nodoc:
+  module Storage #:nodoc:
+    module ActiveRecord #:nodoc:
+      module Acts #:nodoc:
+
+        def self.included(base) # :nodoc:
+          base.extend ClassMethods
+        end
+
+        module ClassMethods
+          def acts_as_scheduled
+            include SayWhen::Storage::ActiveRecord::Acts::InstanceMethods
+          
+            has_many :scheduled_jobs, :as=>:scheduled, :class_name=>'SayWhen::Storage::ActiveRecord::Job'
+          end
+        end
+    
+        module InstanceMethods
+
+          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]  = time
+            Scheduler.schedule(options)
+          end
+
+          def schedule_in(after, job={})
+            options = job_options(job)
+            options[:trigger_strategy] = :once
+            options[:trigger_options]  = 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

@@ -0,0 +1,85 @@
+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'
+
+        def self.acquire_next(no_later_than)
+         SayWhen::Storage::ActiveRecord::Job.transaction do
+            # select and lock the next job that needs executin' (status waiting, and after no_later_than)
+            next_job = find(:first,
+                                :lock       => true,
+                                :order      => 'next_fire_at ASC',
+                                :conditions => ['status = ? and ? >= next_fire_at', 
+                                                STATE_WAITING,
+                                                no_later_than.in_time_zone('UTC')])
+
+            # make sure there is a job ready to run
+            return nil if next_job.nil?
+      
+            # set status to acquired to take it out of rotation
+            next_job.update_attribute(:status, STATE_ACQUIRED)
+      
+            return next_job
+          end
+        end
+
+        def before_create
+          self.status = STATE_WAITING
+          self.next_fire_at = self.trigger.next_fire_at(Time.now)
+        end
+
+        def fired
+          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
+        
+      end
+    
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1,34 @@
+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

@@ -0,0 +1,48 @@
+require 'say_when/storage/memory/base'
+
+module SayWhen
+  module Store
+    module Memory
+
+      # define a trigger class
+      class Job
+
+        cattr_accessor :jobs
+        @@jobs = SortedSet.new
+
+        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
+
+        def self.acquire_next(no_later_than)
+          self.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 initialize(options={})
+          super
+          self.status = STATE_WAITING unless self.status          
+          self.next_fire_at = self.trigger.next_fire_at(Time.now)
+          self.class.jobs << self
+        end
+
+        def <=>(job)
+          self.next_fire_at.to_i <=> job.next_fire_at.to_i
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+require 'mongoid'
+
+module SayWhen
+  module Store
+    module Mongoid
+
+      class Job
+
+        include Mongoid::Document
+
+      end
+
+    end
+  end
+end

data/lib/say_when/tasks.rb

@@ -0,0 +1,22 @@
+namespace :say_when do
+  task :setup
+
+  desc "Start the SayWhen Scheduler"
+  task :start => [ :preload ] do
+    require 'say_when'
+    SayWhen::Scheduler.start
+  end
+
+  # Preload app files if this is Rails
+  # thanks resque
+  task :preload => :setup do
+    if defined?(Rails) && Rails.respond_to?(:application)
+      # Rails 3
+      Rails.application.eager_load!
+    elsif defined?(Rails::Initializer)
+      # Rails 2.3
+      $rails_rake_task = false
+      Rails::Initializer.run :load_application_classes
+    end
+  end
+end

data/lib/say_when/triggers/base.rb

@@ -0,0 +1,11 @@
+module SayWhen
+  module Triggers
+    module Base
+
+      def next_fire_at(time=Time.now)
+        raise NotImplementedError.new('You need to implement next_fire_at in your strategy')
+      end
+
+    end
+  end
+end

data/lib/say_when/triggers/cron_strategy.rb

@@ -0,0 +1,22 @@
+require 'say_when/triggers/base'
+require 'say_when/cron_expression'
+
+module SayWhen
+  module Triggers
+    class CronStrategy
+
+      include SayWhen::Triggers::Base
+
+      attr_accessor :cron_expression
+
+      def initialize(options={})
+        @cron_expression = SayWhen::CronExpression.new(options)            
+      end
+
+      def next_fire_at(time=Time.now)
+        cron_expression.next_fire_at(time)
+      end
+
+    end
+  end
+end

data/lib/say_when/triggers/once_strategy.rb

@@ -0,0 +1,30 @@
+require 'say_when/triggers/base'
+
+module SayWhen
+  module Triggers
+    class OnceStrategy
+
+      include SayWhen::Triggers::Base
+
+      attr_accessor :once_at
+
+      def initialize(options=nil)
+        options ||= Time.now
+        # if it's a hash, pull out the time
+        @once_at = if options.is_a?(Time) || options.acts_like_time?
+          options
+        elsif options.is_a?(Hash) && options[:at]
+          options[:at]
+        else
+          Time.now
+        end
+      
+      end
+
+      def next_fire_at(time=Time.now)
+        once_at if once_at >= time
+      end
+      
+    end
+  end
+end

data/lib/say_when/version.rb

@@ -0,0 +1,3 @@
+module SayWhen
+  VERSION = "0.1.0"
+end

data/lib/say_when.rb

@@ -0,0 +1,28 @@
+require 'active_support'
+
+require "say_when/version"
+require 'say_when/base_job'
+require 'say_when/cron_expression'
+require 'say_when/processor/base'
+require 'say_when/processor/simple'
+require 'say_when/scheduler'
+
+require 'say_when/processor/active_messaging' if defined?(ActiveMessaging)
+
+require 'say_when/storage/active_record/job' if defined?(ActiveRecord)
+
+module SayWhen
+
+  def SayWhen.logger=(logger)
+    @@logger = logger
+  end
+  
+  def SayWhen.logger
+    unless defined?(@@logger)
+      @@logger = Rails.logger if defined?(Rails.logger) && Rails.logger
+      @@logger = Logger.new(STDOUT) unless defined?(@@logger)
+    end
+    @@logger
+  end
+
+end

data/lib/tasks/say_when.rake

@@ -0,0 +1,2 @@
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../../lib'
+require 'say_when/tasks'

data/say_when.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "say_when/version"
+
+Gem::Specification.new do |s|
+  s.name        = "say_when"
+  s.version     = SayWhen::VERSION
+  s.authors     = ["Andrew Kuklewicz"]
+  s.email       = ["andrew@prx.org"]
+  s.homepage    = "http://labs.prx.org"
+  s.summary     = %q{Scheduling system for programmatically defined and stored jobs.}
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency "activemessaging", '~> 0.9.0'
+  s.add_development_dependency "activesupport", '~> 2.3.14'
+  s.add_development_dependency "activerecord", '~> 2.3.14'
+  s.add_development_dependency "mongoid", '~> 1.9.5'
+  s.add_development_dependency 'rspec', "~> 1.3"
+  s.add_development_dependency 'sqlite3'
+  s.add_development_dependency 'rake'
+
+end

data/spec/active_record_spec_helper.rb

@@ -0,0 +1,11 @@
+require 'active_record'
+require 'sqlite3'
+
+ActiveRecord::Base.logger = Logger.new(STDOUT)
+
+ActiveRecord::Base.establish_connection(
+  :adapter => "sqlite3",
+  :database  => (File.dirname(__FILE__) + "/db/test.db")
+)
+
+require (File.dirname(__FILE__) + "/db/schema.rb")

data/spec/db/schema.rb

@@ -0,0 +1,36 @@
+ActiveRecord::Schema.define(:version => 0) do
+
+  create_table :say_when_jobs, :force => true do |t|
+
+    t.string    :status
+
+    t.string    :trigger_strategy
+    t.text      :trigger_options
+    t.string    :time_zone
+
+    t.timestamp :last_fire_at
+    t.timestamp :next_fire_at
+
+    t.timestamp :start_at
+    t.timestamp :end_at
+
+    t.string    :job_class
+    t.string    :job_method
+    t.text      :data
+
+    t.timestamps
+  end
+
+  create_table :say_when_job_executions, :force => true do |t|
+    t.integer  :job_id
+    t.string   :status
+    t.text     :result
+    t.datetime :start_at
+    t.datetime :end_at
+  end
+  
+  add_index :say_when_jobs, :status
+  add_index :say_when_jobs, :next_fire_at
+
+
+end

data/spec/mongoid_spec_helper.rb

@@ -0,0 +1,7 @@
+require 'mongoid'
+
+Mongoid.configure do |config|
+  config.master = Mongo::Connection.new.db("say_when_test")
+end
+
+# Mongoid.logger = Logger.new($stdout)