scheduler_daemon 0.5.1 → 1.1.1

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,36 @@
+PATH
+  remote: .
+  specs:
+    scheduler_daemon (1.1.0)
+      activesupport
+      chronic (>= 0.2.0)
+      chronic (>= 0.2.0)
+      daemons (>= 1.0.10)
+      daemons (>= 1.0.10)
+      eventmachine (>= 0.12.8)
+      eventmachine (>= 0.12.8)
+      rufus-scheduler (>= 2.0.1)
+      rufus-scheduler (>= 2.0.1)
+      scheduler_daemon
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activesupport (3.0.6)
+    chronic (0.3.0)
+    daemons (1.1.2)
+    eventmachine (0.12.10)
+    rufus-scheduler (2.0.8)
+      tzinfo (>= 0.3.23)
+    tzinfo (0.3.26)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activesupport
+  chronic (>= 0.2.0)
+  daemons (>= 1.0.10)
+  eventmachine (>= 0.12.8)
+  rufus-scheduler (>= 2.0.1)
+  scheduler_daemon!

data/README.markdown

@@ -1,7 +1,9 @@
 Scheduler Daemon
 ================
 
-Rails 2.3.2 compatible scheduler daemon.  Replaces cron/rake pattern of periodically running rake tasks 
+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.
 
@@ -10,71 +12,128 @@ 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 the plugin
+Install as a gem or plugin.
 
-    script/plugin install git://github.com/ssoroka/scheduler_daemon.git
+As a gem, the old-fashioned way:
+
+    gem install scheduler_daemon
 
-Install required gems
+As a gem with bundler, add to your ./Gemfile:
 
-    gem sources -a http://gems.github.com # if you haven't already...
+    gem 'scheduler_daemon'
+    
+I pretty much assume you chose this option below and prefix most commands with "bundle exec"
 
-    sudo gem install daemons rufus-scheduler eventmachine chronic
+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
 
-You'll need the chronic gem if you want to be able to use english time descriptions in your scheduled tasks, like:
+Optionally generate the default scheduler daemon task for your rails app:
 
-    every '3h', :first_at => Chronic.parse('midnight')
+    script/rails generate scheduler_task MyNewTask
 
-generate the scheduler daemon files in your rails app:
+which will create an task named:
 
-    script/generate scheduler
+    scheduled_tasks/my_new_task.rb
 
 Usage
 =====
 
 generate a new scheduled task:
 
-    script/generate scheduler_task MyTaskName
+    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 once a day
-    every '1d', :first_at => Chronic.parse("2 am") # run once a day, starting at 2 am
-    at Cronic.parse('5 pm')                        # run once at 5 pm, today (today would be relative to scheduler start/restart)
-    cron '* 4 * * *'                               # cron style (the example is run at 4 am, I do believe)
+    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
 
-    ruby scheduler/bin/scheduler_daemon.rb run
+    bundle exec scheduler_daemon run
 
-When you're done, get your system admin (or switch hats) to add the daemon to the system start-up, and
+For production environments, add the daemon to the system start-up, and
 capistrano deploy scripts, etc.  Something like:
 
-    RAILS_ENV=production ruby scheduler/bin/scheduler_daemon.rb start
+    export RAILS_ENV=production
+    bundle exec scheduler_daemon start
 
-Run individual tasks like so:
+Selectively run tasks like so:
 
-    ruby daemons/bin/task_runner.rb run -- --only=task_name1,task_name2
+    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
 =====
 
-There are some default specs supplied, you are encouraged to write more specs for your tasks as you create them.  Use the existing spec as a template.
-
-See spec/README for more information
+See the spec for session cleaner for an idea on how to write specs for your tasks
 
 To Do
 =====
 
-- dynamically add and remove tasks while daemon is running (? anyone want this?) Perhaps a web interface?
+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
 ======
@@ -85,7 +144,3 @@ Steven Soroka
 * [My Github repo](http://github.com/ssoroka)
 * [My blog](http://blog.stevensoroka.ca)
 
-Thanks
-======
-
-Special thanks to [Goldstar](http://www.goldstar.com) for sponsoring the plugin and promoting open-sourcesness.

data/Rakefile

@@ -5,7 +5,7 @@ begin
   require 'jeweler'
   Jeweler::Tasks.new do |gem|
     gem.name = "scheduler_daemon"
-    gem.summary = %Q{Rails 2.3.2 compatible scheduler daemon.  Replaces cron/rake pattern of periodically running rake tasks 
+    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.
 
@@ -17,6 +17,8 @@ begin
     - 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"]
@@ -24,6 +26,12 @@ begin
     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
 
@@ -31,33 +39,33 @@ 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
-
+# 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

@@ -1 +1 @@
-0.5.1
+1.1.1

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 '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 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