scheduler_daemon_robertcigan 1.1.3

data/Gemfile

@@ -0,0 +1,7 @@
+source "http://rubygems.org"
+gemspec
+gem 'eventmachine', '>= 0.12.8'
+gem 'daemons', '>= 1.0.10'
+gem 'rufus-scheduler', '>= 2.0.1'
+gem 'chronic', '>= 0.2.0'
+gem 'activesupport'

data/Gemfile.lock

@@ -0,0 +1,35 @@
+PATH
+  remote: .
+  specs:
+    scheduler_daemon_robertcigan (1.1.3)
+      activesupport
+      chronic (>= 0.2.0)
+      daemons (>= 1.0.10)
+      eventmachine (>= 0.12.8)
+      rufus-scheduler (>= 2.0.1)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activesupport (3.2.12)
+      i18n (~> 0.6)
+      multi_json (~> 1.0)
+    chronic (0.9.1)
+    daemons (1.1.9)
+    eventmachine (1.0.0)
+    i18n (0.6.2)
+    multi_json (1.6.1)
+    rufus-scheduler (2.0.17)
+      tzinfo (>= 0.3.23)
+    tzinfo (0.3.35)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activesupport
+  chronic (>= 0.2.0)
+  daemons (>= 1.0.10)
+  eventmachine (>= 0.12.8)
+  rufus-scheduler (>= 2.0.1)
+  scheduler_daemon_robertcigan!

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Steven Soroka
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.markdown

@@ -0,0 +1,146 @@
+Scheduler Daemon
+================
+
+Rails 3+ compatible scheduler daemon (see branches for older versions).
+
+Replaces cron/rake pattern of periodically running rake tasks 
+to perform maintenance tasks in Rails apps. Scheduler Daemon is made specifically for your Rails app, 
+and only loads the environment once, no matter how many tasks run.
+
+What's so great about it?  Well, I'm glad you asked!
+
+- Only loads your Rails environment once on daemon start, not every time a task is run
+- Allows you to easily deploy the scheduled tasks with your Rails app instead of depending on an
+  administrator to update crontab
+- Can be installed as a gem or a plugin (I suggest gem)
+- It doesn't use rake or cron!
+- Gets you up and running with your own daemon in under 2 minutes
+- Specially designed to work with your rails app!
+
+Setup
+=====
+
+Install as a gem or plugin.
+
+As a gem, the old-fashioned way:
+
+    gem install scheduler_daemon
+
+As a gem with bundler, add to your ./Gemfile:
+
+    gem 'scheduler_daemon'
+    
+I pretty much assume you chose this option below and prefix most commands with "bundle exec"
+
+As a plugin: (might be awkward to call the binary to start up the daemon...)
+
+    script/plugin install git://github.com/ssoroka/scheduler_daemon.git
+    # Install required gems
+    gem install daemons rufus-scheduler eventmachine chronic -s http://gemcutter.org
+
+Optionally generate the default scheduler daemon task for your rails app:
+
+    script/rails generate scheduler_task MyNewTask
+
+which will create an task named:
+
+    scheduled_tasks/my_new_task.rb
+
+Usage
+=====
+
+generate a new scheduled task:
+
+    script/rails generate scheduler_task MyTaskName
+
+If you have problems with that, the template for new tasks is in the gem under:
+  
+    lib/scheduler_daemon/rails/generators/scheduler_task/templates/scheduled_tasks/example_task.rb
+    
+you can always copy it and make modifications, or see "Manually create tasks" below.
+
+Tasks support their own special DSL; commands are:
+
+    environments :production, :staging             # run only in environments listed. (:all by default)
+    every '1d'                                     # run every day
+    every '1d', :first_at => Chronic.parse("2 am") # run every day, starting at 2 am (see caveat below)
+    at Cronic.parse('5 pm')                        # run *once* at 5 pm today
+                                                   #   (relative to scheduler start/restart time    )
+                                                   #   (happens every time scheduler starts/restarts)
+                                                   #   (see caveat below                            )
+    cron '* 4 * * *'                               # cron style (run every 4 am)
+    in '30s'                                       # run once, 30 seconds from scheduler start/restart
+
+fire up the daemon in console mode to test it out
+
+    bundle exec scheduler_daemon run
+
+For production environments, add the daemon to the system start-up, and
+capistrano deploy scripts, etc.  Something like:
+
+    export RAILS_ENV=production
+    bundle exec scheduler_daemon start
+
+Selectively run tasks like so:
+
+    bundle exec scheduler_daemon start -- --only=task_name1,task_name2 --except=not_me
+
+Manually create tasks
+=====================
+
+If you don't want to use this gem with Rails, you can manually create tasks in a scheduled_tasks/ subdirectory and start the daemon with --skip-rails (though it'll figure it out anyway if there's no config/environment.rb file in the launch directory or --dir=/path)
+
+Here's an example task file.
+
+    class CleanUpTask < Scheduler::SchedulerTask
+      every '2m'
+  
+      def run
+        do_something
+        log("I've done things")
+      end
+    end
+
+Specs
+=====
+
+See the spec for session cleaner for an idea on how to write specs for your tasks
+
+To Do
+=====
+
+Looking for suggestions!
+
+Send requests to ssoroka78@gmail.com or on twitter, @ssoroka
+
+Bugs
+====
+
+Submit bugs here http://github.com/ssoroka/scheduler_daemon/issues
+
+Caveats
+=======
+
+When using the cronic gem to parse dates, be careful of how it interprets your date,
+for example:
+
+    every '24h', :first_at => Chronic.parse('noon')
+
+will be once a day at noon, but the first time the server starts up (or restarts), noon
+is relative to the current time of day.  Before lunch, and it's in the future.  If the
+daemon starts up after lunch, the date is in the past, *and the task is immediately run*
+because it thinks it missed its last execution time.  Depending on what your task is,
+this may or may not be a problem.  If you always want the date to resolve in the future
+with terms like "noon", "3 am" and "midnight", prepend "next" to it.  ie:
+
+    every '24h', :first_at => Chronic.parse('next noon')
+
+Author
+======
+
+Steven Soroka
+
+* [@ssoroka](http://twitter.com/ssoroka)
+* [My Github repo](http://github.com/ssoroka)
+* [My blog](http://blog.stevensoroka.ca)
+

data/Rakefile

@@ -0,0 +1,71 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "scheduler_daemon"
+    gem.summary = %Q{Rails 3 compatible scheduler daemon.  Replaces cron/rake pattern of periodically running rake tasks 
+    to perform maintenance tasks in Rails apps. Scheduler Daemon is made specifically for your Rails app, 
+    and only loads the environment once, no matter how many tasks run.
+
+    What's so great about it?  Well, I'm glad you asked!
+
+    - Only loads your Rails environment once on daemon start, not every time a task is run
+    - Allows you to easily deploy the scheduled tasks with your Rails app instead of depending on an
+      administrator to update crontab
+    - It doesn't use rake or cron!
+    - Gets you up and running with your own daemon in under 2 minutes
+    }
+    gem.version = File.read('VERSION').chomp
+    gem.description = 'a Rails 2.3, Rails 3, and Ruby compatible scheduler daemon.  Replaces cron/rake pattern of periodically running rake tasks to perform maintenance tasks, only loading the environment ONCE.'
+    gem.email = "ssoroka78@gmail.com"
+    gem.homepage = "http://github.com/ssoroka/scheduler_daemon"
+    gem.authors = ["Steven Soroka"]
+    gem.add_dependency('eventmachine', '>= 0.12.8')
+    gem.add_dependency('daemons', '>= 1.0.10')
+    gem.add_dependency('rufus-scheduler', '>= 2.0.1')
+    gem.add_dependency('chronic', '>= 0.2.0')
+
+    gem.executables = ['scheduler_daemon']
+    
+    everything_from_dirs = %w(bin lib spec)
+    gem.files = everything_from_dirs.map{|d| Dir["#{d}/**/*"] }.flatten
+    gem.files += Dir['*'] - (everything_from_dirs + ['pkg'])
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+# require 'spec/rake/spectask'
+# Spec::Rake::SpecTask.new(:spec) do |spec|
+#   spec.libs << 'lib' << 'spec'
+#   spec.spec_files = FileList['spec/**/*_spec.rb']
+# end
+# 
+# Spec::Rake::SpecTask.new(:rcov) do |spec|
+#   spec.libs << 'lib' << 'spec'
+#   spec.pattern = 'spec/**/*_spec.rb'
+#   spec.rcov = true
+# end
+# 
+# 
+# task :default => :spec
+# 
+# require 'rake/rdoctask'
+# Rake::RDocTask.new do |rdoc|
+#   if File.exist?('VERSION.yml')
+#     config = YAML.load(File.read('VERSION.yml'))
+#     version = "#{config[:major]}.#{config[:minor]}.#{config[:patch]}"
+#   else
+#     version = ""
+#   end
+# 
+#   rdoc.rdoc_dir = 'rdoc'
+#   rdoc.title = "scheduler_daemon #{version}"
+#   rdoc.rdoc_files.include('README*')
+#   rdoc.rdoc_files.include('lib/**/*.rb')
+# end
+# 

data/VERSION

@@ -0,0 +1 @@
+1.1.2

data/bin/scheduler_daemon

@@ -0,0 +1,59 @@
+#!/usr/bin/env ruby
+# This file launches the scheduler as a daemon.
+# USAGE: 
+# 
+#     scheduler_daemon run           # start the daemon and stay on top
+#     scheduler_daemon start         # start the daemon and stay on top
+#     scheduler_daemon stop          # stop all instances of the application
+#     scheduler_daemon restart       # stop all instances and restart them afterwards
+#
+# options can be passed to the scheduler like so:
+#
+#     scheduler_daemon start -- --except=session_cleaner
+#
+# options can be passed to the daemon:
+#
+#     scheduler_daemon start --dir=/my/rails/root/
+#
+# see README for more info
+require 'rubygems'
+require 'daemons'
+require 'scheduler_daemon/command_line_args_to_hash'
+
+# arguments to pass to the daemon launcher
+def launch_args(options = {})
+  params = options.map{|k,v| "--#{k}=#{v}"}
+  if params.empty?
+    ARGV
+  else
+    args = ARGV.dup
+    args << '--' unless args.include?('--')
+    args + params
+  end
+end
+
+# app arguments
+app_args = {}
+# only take args after the '--' arg.
+if separator_index = ARGV.index('--')
+  app_args = CommandLineArgsToHash.parse(ARGV[separator_index+1..-1])
+end
+
+app_args[:dir] ||= Dir.pwd
+app_args[:pid_dir] ||= File.expand_path(File.join(app_args[:dir], 'log'))
+scheduler = File.join(File.dirname(__FILE__), %w(.. lib loader scheduler_loader.rb))
+
+raise "#{pid_dir} does not exist" unless File.exist?(app_args[:pid_dir])
+
+app_options = {
+  :app_name => 'scheduler_daemon',
+  :ARGV => launch_args(app_args),
+  :dir_mode => :normal,
+  :dir => app_args[:pid_dir],
+  :multiple => false,
+  :backtrace => true,
+  :log_output => true,
+  :monitor => true
+}
+
+Daemons.run(scheduler, app_options)

data/lib/loader/scheduler_loader.rb

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+# This file loads the rails environment and starts the scheduler.
+# do not use it directly unless you don't intend for the scheduler to run as a daemon.
+require 'scheduler_daemon/command_line_args_to_hash'
+args = CommandLineArgsToHash.parse(ARGV)
+daemons_lib_dir = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+Dir.chdir(args[:dir])
+
+require File.join(daemons_lib_dir, 'scheduler_daemon', 'base')
+
+Scheduler::Base.new(args)

data/lib/scheduler_daemon.rb

@@ -0,0 +1,2 @@
+require 'scheduler_daemon/rails/railtie' if defined?(Rails) && Rails.version =~ /^3\./
+require 'scheduler_daemon/base'

data/lib/scheduler_daemon/base.rb

@@ -0,0 +1,149 @@
+require 'eventmachine'
+require 'rufus/scheduler'
+begin
+  require 'active_support/hash_with_indifferent_access'
+rescue LoadError
+  begin
+    require 'active_support/core_ext/hash'
+  rescue LoadError
+    puts "can't load activesupport gem not loaded"
+    raise $!
+  end
+end
+
+require 'scheduler_daemon/scheduler_task'
+require 'scheduler_daemon/exception_handler'
+require 'scheduler_daemon/command_line_args_to_hash'
+
+module Scheduler
+  class Base
+    attr_reader :tasks, :options, :env_name
+
+    # :root_dir is a required option, because the scheduler likely has no idea what the original
+    #     root directory was after the process was daemonized (which changes the current directory)
+    # :silent
+    #     doesn't output anything to STDOUT or logs.
+    # :root_dir
+    #     root dir of the application.
+    # :only
+    #     load only tasks in this list
+    # :except
+    #     load all tasks except ones in this list
+    # :env_name
+    #     if used without rails, you can manually set something in place of the environment name
+    def initialize(opts = {}, command_line_args = [])
+      @options = ::HashWithIndifferentAccess.new(opts)
+      @options.merge!(CommandLineArgsToHash.parse(command_line_args, :array_args => ['only', 'except']))
+      @options['only'] ||= []
+      @options['except'] ||= []
+      @env_name = @options['env_name'] || 'scheduler'
+      @rufus_scheduler = nil
+      @tasks = []
+      
+      log("initialized with settings: #{@options.inspect}")
+
+      if !@options['skip_init']
+        load_rails_env
+        load_tasks
+        run_scheduler
+      end
+    end
+    
+    # registers a task class with the scheduler
+    def register_task(task)
+      
+    end
+    
+    def load_rails_env
+      if File.exists?('config/environment.rb') && !@options['skip_rails']
+        log("loading rails environment")
+        require File.expand_path('./config/environment')
+        @env_name = ::Rails.env
+      end
+    rescue
+      log("Error loading rails environment; #{$!.class.name}: #{$!.message}")
+      raise $!
+    end
+    
+    # time redefines itself with a faster implementation, since it gets called a lot.
+    def time
+      if Time.respond_to?(:zone) && Time.zone
+        self.class.send(:define_method, :time) { Time.zone.now.to_s }
+      else
+        self.class.send(:define_method, :time) { Time.now.to_s }
+      end
+      time
+    end
+    
+    def log(*args)
+      return if @options[:silent]
+      Kernel::puts(%([#{time}] #{args.join("\n")}))
+    end
+    alias :puts :log
+
+    def run_scheduler
+      if defined?(::Rails)
+        log "Starting Scheduler in #{::Rails.env}"
+      else
+        log "Starting Scheduler"
+      end
+
+      $daemon_scheduler = self
+
+      EventMachine::run {
+        @rufus_scheduler = Rufus::Scheduler::EmScheduler.start_new
+
+        def @rufus_scheduler.handle_exception(job, exception)
+          msg = "[#{env_name}] scheduler job #{job.job_id} (#{job.tags * ' '}) caught exception #{exception.inspect}"
+          log msg
+          log exception.backtrace.join("\n")
+          Scheduler::ExceptionHandler.handle_exception(exception, job, message)
+        end
+
+        def @rufus_scheduler.daemon_scheduler
+          $daemon_scheduler
+        end
+
+        # This is where the magic happens.  tasks in scheduled_tasks/*.rb are loaded up.
+        tasks.each do |task|
+          if task.should_run_in_current_environment?(env_name)
+            task.add_to(@rufus_scheduler)
+          else
+            log "[#{env_name}] #{task} not configured to run; skipping."
+          end
+        end
+      }
+    end
+
+    def load_tasks
+      tasks_to_run.each{|f|
+        begin
+          unless options[:only].any? && options[:only].all?{|m| f !~ Regexp.new(Regexp.escape(m)) }
+            require File.expand_path("./#{f}")
+            filename = f.split('/').last.split('.').first
+            log "Loading task #{filename}..."
+            @tasks << filename.camelcase.constantize # "path/newsfeed_task.rb" => NewsfeedTask
+          end
+        rescue Exception => e
+          msg = "Error loading task #{filename}: #{e.class.name}: #{e.message}"
+          log msg
+          log e.backtrace.join("\n")
+          Scheduler::ExceptionHandler.handle_exception(e, nil, msg)
+        end
+      }
+    end
+
+    def tasks_to_run
+      task_files = Dir[File.join(%w(scheduled_tasks *.rb))]# + File.join(%w(lib scheduled_tasks *.rb))
+
+      if options[:only].any?
+        task_files.reject!{|f| options[:only].all?{|m| f !~ Regexp.new(Regexp.escape(m))}}
+      end
+
+      if options[:except].any?
+        task_files.reject!{|f| options[:except].any?{|m| f =~ Regexp.new(Regexp.escape(m))}}
+      end
+      task_files
+    end
+  end
+end

data/lib/scheduler_daemon/command_line_args_to_hash.rb

@@ -0,0 +1,47 @@
+begin
+  require 'active_support/hash_with_indifferent_access'
+rescue LoadError
+  begin
+    require 'active_support/core_ext/hash'
+  rescue LoadError
+    puts "can't load activesupport gem not loaded"
+    raise $!
+  end
+end
+
+class CommandLineArgsToHash
+  def self.parse(args, options = {})
+    new(args, options).parse
+  end
+  
+  def initialize(args, options = {})
+    @args = args
+    @options = options
+  end
+  
+  def parse
+    hash = ::HashWithIndifferentAccess.new
+    @args.each{|arg|
+      k, v = read_argument(arg)
+      hash[k] = v
+    }
+    hash
+  end
+  
+  def read_argument(arg)
+    k, v = arg.sub(/^\-\-/, '').split('=')
+    k = k.gsub(/-/, '_') # replace - to _ so that --skip-init becomes options[:skip_init]
+    v = true if v.nil? # default passed in args to true.
+    v = format_value(k, v)
+    [k, v]
+  end
+  
+  def format_value(k, v)
+    if @options[:array_args] && @options[:array_args].include?(k)
+      v = v.split(/,\s*/) if v.respond_to?(:split)
+    end
+    v = false if v == 'false'
+    v = true if v == 'true'
+    v
+  end
+end

data/lib/scheduler_daemon/exception_handler.rb

@@ -0,0 +1,30 @@
+# override this in your app to do something meaningful,
+# like post to campfire or hoptoad.
+# 
+# Example campfire code below, using 'tinder' gem:
+module Scheduler
+  class ExceptionHandler
+    # @@campfire_subdomain = ''
+    # @@campfire_username = ''
+    # @@campfire_password = ''
+    # @@campfire_room_name = ''
+    # @@campfire_room = nil
+
+    def self.handle_exception(exception, job, message)
+      # If your team all hangs out in Campfire, you might want to try
+      # something like Tinder here to write these messages out to campfire,
+      # Such as:
+      # 
+      # if Rails.env.production? || Rails.env.staging?
+      #   msg = "#{message}, see log for backtrace"
+      # 
+      #   unless @@campfire_room
+      #     campfire = Tinder::Campfire.new(@@campfire_subdomain, :ssl => true)
+      #     campfire.login(@@campfire_username, @@campfire_password)
+      #     @@campfire_room = campfire.find_room_by_name(@@campfire_room_name)
+      #   end
+      #   @@campfire_room.speak(msg)
+      # end
+    end
+  end
+end

data/lib/scheduler_daemon/rails/generators/scheduler/USAGE

@@ -0,0 +1,6 @@
+Description:
+    Creates the scheduler folder and basic scripts for it to run
+
+Example:
+    `./script/generate scheduler`
+

data/lib/scheduler_daemon/rails/generators/scheduler/scheduler_generator.rb

@@ -0,0 +1,16 @@
+class SchedulerGenerator < Rails::Generator::Base
+  def banner
+    "Usage: #{$0} #{spec.name}"
+  end
+
+  def manifest
+    record do |m|
+      m.directory File.join('lib', 'scheduled_tasks')
+
+      m.template 'lib/scheduled_tasks/session_cleaner_task.rb',
+        'lib/scheduled_tasks/session_cleaner_task.rb'
+      
+      m.readme('README')
+    end
+  end
+end

data/lib/scheduler_daemon/rails/generators/scheduler/templates/README

@@ -0,0 +1,11 @@
+
+GREAT!
+
+Now that you've generated the scheduler daemon and a default task, 
+you can take a look at the new task:
+
+  lib/scheduled_tasks/session_cleaner_task.rb
+
+or make your own:
+
+  script/generate scheduler_task MyTaskName

data/lib/scheduler_daemon/rails/generators/scheduler/templates/lib/scheduled_tasks/session_cleaner_task.rb

@@ -0,0 +1,29 @@
+class SessionCleanerTask < Scheduler::SchedulerTask
+  environments :all
+  
+  every '1d', :first_at => Chronic.parse('next 2 am')
+  
+  def run
+    remove_old_sessions
+  end
+  
+  def remove_old_sessions
+    log "running the session cleaner"
+    if ActionController::Base.session_store == session_store_class
+      ActiveRecord::Base.connection.execute("DELETE FROM #{session_table_name} WHERE updated_at < '#{7.days.ago.to_s(:db)}'")
+      log "old sessions are gone!"
+    else
+      log "sessions are not stored in the database; nothing to do."
+    end
+  end
+
+  def session_store_class
+    return ActiveRecord::SessionStore if defined?(ActiveRecord::SessionStore)
+    # pre rails 2.3 support...
+    return CGI::Session::ActiveRecordStore if defined?(CGI::Session::ActiveRecordStore)
+  end
+
+  def session_table_name
+    ActiveRecord::Base.pluralize_table_names ? :sessions : :session
+  end
+end

data/lib/scheduler_daemon/rails/generators/scheduler_task/scheduler_task_generator.rb

@@ -0,0 +1,21 @@
+class SchedulerTaskGenerator < Rails::Generators::NamedBase
+  check_class_collision :suffix => 'Task'
+  
+  def create_task
+    template File.join(source_dir, 'example_task.rb'), "scheduled_tasks/#{file_name}_task.rb"
+    readme(File.join(template_dir, 'README'))
+  end
+  
+  def self.source_root
+    File.dirname(File.expand_path(__FILE__))
+  end
+  
+  private
+    def source_dir
+      File.join(template_dir, 'scheduled_tasks')
+    end
+    
+    def template_dir
+      File.join(File.dirname(__FILE__), 'templates')
+    end
+end

data/lib/scheduler_daemon/rails/generators/scheduler_task/templates/README

@@ -0,0 +1,14 @@
+
+Awesome! Now that you've created a scheduler, you can test it out with:
+
+  bundle exec scheduler_daemon run
+
+to run it in the background (a la system start-up):
+
+  bundle exec scheduler_daemon start
+
+
+You'll probably want to add tests or specs for your new task.
+You can find existing specs for scheduler_daemon in the scheduler_daemon/spec folder.
+
+Be sure to copy them to your spec folder if you're using rspec.

data/lib/scheduler_daemon/rails/generators/scheduler_task/templates/scheduled_tasks/example_task.rb

@@ -0,0 +1,19 @@
+class <%= class_name %>Task < Scheduler::SchedulerTask
+  environments :all
+  # environments :staging, :production
+  
+  every '10s'
+  # other examples:
+  # every '24h', :first_at => Chronic.parse('next midnight')
+  # cron '* 4 * * *'  # cron style
+  # in '30s'          # run once, 30 seconds from scheduler start/restart
+  
+  
+  def run
+    # Your code here, eg: 
+    # User.send_due_invoices!
+    
+    # use log() for writing to scheduler daemon log
+    log("I've sent invoices!")
+  end
+end

data/lib/scheduler_daemon/rails/railtie.rb

@@ -0,0 +1,9 @@
+module Scheduler
+  module Rails
+    class Railtie < ::Rails::Railtie
+      generators do
+        require 'scheduler_daemon/rails/generators/scheduler_task/scheduler_task_generator'
+      end
+    end
+  end
+end

data/lib/scheduler_daemon/scheduler_task.rb

@@ -0,0 +1,78 @@
+module Scheduler
+  class SchedulerTask
+    attr_accessor :daemon_scheduler, :rufus_scheduler
+    class <<self
+      def add_to(schedule)
+        %w(every in at cron).each{|time_cmd|
+          if args = self.instance_variable_get("@#{time_cmd}")
+            # add a default tag to the arguments so we know which task was running
+            options = args.extract_options!
+            options.merge!(:tags => [name])
+            args << options
+
+            schedule.send(time_cmd, *args) do
+              begin
+                a_task = new
+                a_task.daemon_scheduler = schedule.daemon_scheduler
+                a_task.rufus_scheduler = schedule
+                a_task.run
+              ensure
+                # Note: AR's ActiveRecord::Base.connection_pool.with_connection(&block) seems broken;
+                # it doesn't release the connection properly.
+                ActiveRecord::Base.connection_pool.release_connection
+              end
+            end
+          end
+        }
+      end
+
+      # run the task every... '5m', etc. see rufus-scheduler docs
+      def every(*args)
+        @every = args
+      end
+
+      # run the task in '30s', etc. see rufus-scheduler docs
+      def in(*args)
+        @in = args
+      end
+
+      # run the task at... Cronic.parse('5 pm'), etc. see rufus-scheduler docs
+      def at(*args)
+        @at = args
+      end
+
+      # run the task cron '* 4 * * *', etc. see rufus-scheduler docs
+      def cron(*args)
+        @cron = args
+      end
+
+      # what environments should this task run in?
+      # accepts the usual :development, :production, as well as :all
+      #
+      # examples:
+      #   environments :all
+      #   environments :staging, :production
+      #   environments :development
+      #
+      def environments(*args)
+        @environments = args.map{|arg| arg.to_sym }
+      end
+
+      def should_run_in_current_environment?(env)
+        @environments.nil? || @environments == [:all] || @environments.include?(env.to_sym)
+      end
+    end
+
+    # override me to do stuff
+    def run
+      nil
+    end
+    
+    def log(*args)
+      daemon_scheduler.log(*args)
+    end
+    alias :puts :log
+  end
+end
+# alias this for backwards compatability
+# SchedulerTask = Scheduler::SchedulerTask unless defined?(::SchedulerTask)

data/scheduler_daemon_robertcigan.gemspec

@@ -0,0 +1,82 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{scheduler_daemon_robertcigan}
+  s.version = "1.1.3"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Steven Soroka"]
+  s.date = %q{2013-02-26}
+  s.description = %q{a Rails 2.3, Rails 3, and Ruby compatible scheduler daemon.  Replaces cron/rake pattern of periodically running rake tasks to perform maintenance tasks, only loading the environment ONCE.}
+  s.email = %q{ssoroka78@gmail.com}
+  s.executables = ["scheduler_daemon"]
+  s.extra_rdoc_files = [
+    "README.markdown"
+  ]
+  s.files = [
+    "Gemfile",
+    "Gemfile.lock",
+    "MIT-LICENSE",
+    "README.markdown",
+    "Rakefile",
+    "VERSION",
+    "bin/scheduler_daemon",
+    "lib/loader/scheduler_loader.rb",
+    "lib/scheduler_daemon.rb",
+    "lib/scheduler_daemon/base.rb",
+    "lib/scheduler_daemon/command_line_args_to_hash.rb",
+    "lib/scheduler_daemon/exception_handler.rb",
+    "lib/scheduler_daemon/rails/generators/scheduler/USAGE",
+    "lib/scheduler_daemon/rails/generators/scheduler/scheduler_generator.rb",
+    "lib/scheduler_daemon/rails/generators/scheduler/templates/README",
+    "lib/scheduler_daemon/rails/generators/scheduler/templates/lib/scheduled_tasks/session_cleaner_task.rb",
+    "lib/scheduler_daemon/rails/generators/scheduler_task/scheduler_task_generator.rb",
+    "lib/scheduler_daemon/rails/generators/scheduler_task/templates/README",
+    "lib/scheduler_daemon/rails/generators/scheduler_task/templates/scheduled_tasks/example_task.rb",
+    "lib/scheduler_daemon/rails/railtie.rb",
+    "lib/scheduler_daemon/scheduler_task.rb",
+    "scheduler_daemon_robertcigan.gemspec",
+    "spec/command_line_args_to_hash_spec.rb",
+    "spec/scheduled_tasks/session_cleaner_task_spec.rb",
+    "spec/scheduler_spec.rb",
+    "spec/spec_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/ssoroka/scheduler_daemon}
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.7.2}
+  s.summary = %q{Rails 3 compatible scheduler daemon.  Replaces cron/rake pattern of periodically running rake tasks  to perform maintenance tasks in Rails apps. Scheduler Daemon is made specifically for your Rails app,  and only loads the environment once, no matter how many tasks run.  What's so great about it?  Well, I'm glad you asked!  - Only loads your Rails environment once on daemon start, not every time a task is run - Allows you to easily deploy the scheduled tasks with your Rails app instead of depending on an administrator to update crontab - It doesn't use rake or cron! - Gets you up and running with your own daemon in under 2 minutes}
+  s.test_files = [
+    "spec/command_line_args_to_hash_spec.rb",
+    "spec/scheduled_tasks/session_cleaner_task_spec.rb",
+    "spec/scheduler_spec.rb",
+    "spec/spec_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<eventmachine>, [">= 0.12.8"])
+      s.add_runtime_dependency(%q<daemons>, [">= 1.0.10"])
+      s.add_runtime_dependency(%q<rufus-scheduler>, [">= 2.0.1"])
+      s.add_runtime_dependency(%q<chronic>, [">= 0.2.0"])
+      s.add_runtime_dependency(%q<activesupport>, [">= 0"])
+    else
+      s.add_dependency(%q<eventmachine>, [">= 0.12.8"])
+      s.add_dependency(%q<daemons>, [">= 1.0.10"])
+      s.add_dependency(%q<rufus-scheduler>, [">= 2.0.1"])
+      s.add_dependency(%q<chronic>, [">= 0.2.0"])
+      s.add_dependency(%q<activesupport>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<eventmachine>, [">= 0.12.8"])
+    s.add_dependency(%q<daemons>, [">= 1.0.10"])
+    s.add_dependency(%q<rufus-scheduler>, [">= 2.0.1"])
+    s.add_dependency(%q<chronic>, [">= 0.2.0"])
+    s.add_dependency(%q<activesupport>, [">= 0"])
+  end
+end
+

data/spec/command_line_args_to_hash_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+require 'scheduler_daemon/command_line_args_to_hash'
+
+describe CommandLineArgsToHash do
+  it 'should process arguments' do
+    h = CommandLineArgsToHash.parse('--hello')
+    h['hello'].should == true
+  end
+  
+  it 'should change key names with - to _' do
+    h = CommandLineArgsToHash.parse(['--hi-there'])
+    h['hi_there'].should == true
+  end
+  
+  it 'should play nice with array args' do
+    h = CommandLineArgsToHash.parse(['--only=one,two,three'], :array_args => 'only')
+    h['only'].should == %w(one two three)
+  end
+  
+  it 'should handle multiple args ok' do
+    h = CommandLineArgsToHash.parse(['--one', '--two=three'])
+    h['one'].should == true
+    h['two'].should == 'three'
+  end
+  
+end

data/spec/scheduled_tasks/session_cleaner_task_spec.rb

@@ -0,0 +1,35 @@
+# copy this spec to your project after installing the plugin if you want to run the specs.
+# suggested file name for this file: spec/scheduler_daemon/scheduled_tasks/session_cleaner_task_spec.rb
+
+# require File.join(File.dirname(__FILE__), %w(.. spec_helper))
+require 'spec_helper'
+require 'scheduler_daemon/scheduler_task'
+require 'scheduler_daemon/rails/generators/scheduler/templates/lib/scheduled_tasks/session_cleaner_task'
+
+describe SessionCleanerTask do
+  before(:each) do
+    @task = SessionCleanerTask.new
+    @task.stub!(:log)
+  end
+
+  it "should remove old sessions" do
+    # this test only matters if we're using AR's session store.
+    if defined?(ActionController) && defined?(ActiveRecord) && 
+        ActionController::Base.session_store == ActiveRecord::SessionStore
+
+      # insert old session
+      ActiveRecord::Base.connection.execute(%(delete from #{@task.session_table_name} where session_id = 'abc123'))
+      ActiveRecord::Base.connection.execute(%(insert into #{@task.session_table_name} (session_id, updated_at) values ('abc123', '#{2.years.ago.to_s(:db)}')))
+
+      get_session_count = lambda {
+        ActiveRecord::Base.connection.select_one(%(select count(*) as count from #{@task.session_table_name}))['count'].to_i
+      }
+
+      lambda {
+        @task.run
+      }.should change(get_session_count, :call).by_at_most(-1)
+    else
+      pending 'skipping SessionCleanerTask test since it depends on rails and ActiveRecord::SessionStore; try copying this spec to your rails application.'
+    end
+  end
+end

data/spec/scheduler_spec.rb

@@ -0,0 +1,21 @@
+require File.dirname(__FILE__) + '/spec_helper'
+require 'scheduler_daemon/base'
+
+describe Scheduler::Base do
+  before(:each) do
+    @scheduler = Scheduler::Base.new(:skip_init => true, :silent => true)
+    @scheduler.stub!(:log)
+  end
+
+  describe 'decide_what_to_run' do
+    it "should support --only" do
+      @scheduler = Scheduler::Base.new({:skip_init => true, :silent => true}, ['--only=alphabets'])
+      @scheduler.options['only'].should == ['alphabets']
+    end
+
+    it "should support --except" do
+      @scheduler = Scheduler::Base.new({:skip_init => true, :silent => true}, ['--except=balloons,monkeys'])
+      @scheduler.options['except'].should == ['balloons', 'monkeys']
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,16 @@
+require 'rubygems'
+spec_runner = nil
+begin
+  require 'rspec'
+  spec_runner = RSpec
+rescue
+  require 'spec'
+  spec_runner = Spec::Runner
+end
+require 'chronic'
+require 'active_support'
+
+RAILS_ENV = 'test' unless defined?(RAILS_ENV) && RAILS_ENV == 'test'
+
+spec_runner.configure do |config|
+end

metadata

@@ -0,0 +1,140 @@
+--- !ruby/object:Gem::Specification
+name: scheduler_daemon_robertcigan
+version: !ruby/object:Gem::Version
+  version: 1.1.3
+  prerelease: 
+platform: ruby
+authors:
+- Steven Soroka
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-02-26 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: eventmachine
+  requirement: &70144495925840 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.12.8
+  type: :runtime
+  prerelease: false
+  version_requirements: *70144495925840
+- !ruby/object:Gem::Dependency
+  name: daemons
+  requirement: &70144495922360 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.10
+  type: :runtime
+  prerelease: false
+  version_requirements: *70144495922360
+- !ruby/object:Gem::Dependency
+  name: rufus-scheduler
+  requirement: &70144495919080 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.0.1
+  type: :runtime
+  prerelease: false
+  version_requirements: *70144495919080
+- !ruby/object:Gem::Dependency
+  name: chronic
+  requirement: &70144495918340 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *70144495918340
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: &70144495917540 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70144495917540
+description: a Rails 2.3, Rails 3, and Ruby compatible scheduler daemon.  Replaces
+  cron/rake pattern of periodically running rake tasks to perform maintenance tasks,
+  only loading the environment ONCE.
+email: ssoroka78@gmail.com
+executables:
+- scheduler_daemon
+extensions: []
+extra_rdoc_files:
+- README.markdown
+files:
+- Gemfile
+- Gemfile.lock
+- MIT-LICENSE
+- README.markdown
+- Rakefile
+- VERSION
+- bin/scheduler_daemon
+- lib/loader/scheduler_loader.rb
+- lib/scheduler_daemon.rb
+- lib/scheduler_daemon/base.rb
+- lib/scheduler_daemon/command_line_args_to_hash.rb
+- lib/scheduler_daemon/exception_handler.rb
+- lib/scheduler_daemon/rails/generators/scheduler/USAGE
+- lib/scheduler_daemon/rails/generators/scheduler/scheduler_generator.rb
+- lib/scheduler_daemon/rails/generators/scheduler/templates/README
+- lib/scheduler_daemon/rails/generators/scheduler/templates/lib/scheduled_tasks/session_cleaner_task.rb
+- lib/scheduler_daemon/rails/generators/scheduler_task/scheduler_task_generator.rb
+- lib/scheduler_daemon/rails/generators/scheduler_task/templates/README
+- lib/scheduler_daemon/rails/generators/scheduler_task/templates/scheduled_tasks/example_task.rb
+- lib/scheduler_daemon/rails/railtie.rb
+- lib/scheduler_daemon/scheduler_task.rb
+- scheduler_daemon_robertcigan.gemspec
+- spec/command_line_args_to_hash_spec.rb
+- spec/scheduled_tasks/session_cleaner_task_spec.rb
+- spec/scheduler_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/ssoroka/scheduler_daemon
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Rails 3 compatible scheduler daemon.  Replaces cron/rake pattern of periodically
+  running rake tasks  to perform maintenance tasks in Rails apps. Scheduler Daemon
+  is made specifically for your Rails app,  and only loads the environment once, no
+  matter how many tasks run.  What's so great about it?  Well, I'm glad you asked!  -
+  Only loads your Rails environment once on daemon start, not every time a task is
+  run - Allows you to easily deploy the scheduled tasks with your Rails app instead
+  of depending on an administrator to update crontab - It doesn't use rake or cron!
+  - Gets you up and running with your own daemon in under 2 minutes
+test_files:
+- spec/command_line_args_to_hash_spec.rb
+- spec/scheduled_tasks/session_cleaner_task_spec.rb
+- spec/scheduler_spec.rb
+- spec/spec_helper.rb