cwninja-whenever 0.1.5.1

data/CHANGELOG.rdoc

@@ -0,0 +1,26 @@
+== 0.1.5 / February 19th, 2009
+
+* Fixed load path so Whenever's files don't conflict with anything in Rails. Thanks Ryan Koopmans. [Javan Makhmali]
+
+
+== 0.1.4 / February 17th, 2009
+
+* Added --load-file and --user opts to whenever binary. [Javan Makhmali]
+
+
+== 0.1.3 / February 16th, 2009
+
+* Added 'rake' helper for defining scheduled rake tasks. [Javan Makhmali]
+
+* Renamed :cron_environment and :cron_path to :enviroment and :path for better (word) compatibility with rake tasks. [Javan Makhmali]
+
+* Improved test load paths so tests can be run individually. [Javan Makhmali]
+
+* Got rid of already initialized constant warning. [Javan Makhmali]
+
+* Requiring specific gem versions: Chronic >=0.2.3 and activesupport >= 1.3.0 [Javan Makhmali]
+
+
+== 0.1.0 / February 15th, 2009
+
+* Initial release [Javan Makhmali]

data/README.rdoc

@@ -0,0 +1,127 @@
+== Introduction
+
+Whenever is a ruby gem that provides a ruby syntax for defining cron jobs. It outputs valid cron syntax and can even write your crontab file for you. It is designed to work well with Rails applications and can be deployed with Capistrano. Whenever works fine independently as well.
+
+== Installation
+
+Regular (non-Rails) install:
+  
+  $ gem sources -a http://gems.github.com (you only need to run this once)
+  $ sudo gem install javan-whenever
+
+In a Rails (2.1 or greater) application:
+  
+in your "config/environment.rb" file:
+
+  Rails::Initializer.run do |config|
+    config.gem 'javan-whenever', :lib => false, :version => '>= 0.1.5' :source => 'http://gems.github.com'
+  end
+  
+To install this gem (and all other missing gem dependencies), run rake gems:install (use sudo if necessary).
+
+In older versions of Rails:
+
+  $ gem sources -a http://gems.github.com (you only need to run this once)
+  $ gem install javan-whenever
+
+in your "config/environment.rb" file:
+
+  Rails::Initializer.run do |config|
+    ...
+  end
+
+  require 'whenever'
+  
+NOTE: Requiring the whenever gem inside your Rails application is technically optional. However, if you plan to use something like Capistrano to automatically deploy and write your crontab file, you'll need to have the gem installed on your servers, and requiring it in your app is one to ensure this.
+
+== Getting started
+
+  $ cd /my/rails/app
+  $ wheneverize .
+
+This will create an initial "config/schedule.rb" file you.
+
+== Example schedule.rb file
+
+  every 3.hours do
+    runner "MyModel.some_process"       
+    rake "my:rake:task"                 
+    command "/usr/bin/my_great_command"
+  end
+
+  every 1.day, :at => '4:30 am' do 
+    runner "DB.Backup"
+  end
+
+  every :hour do # Many shortcuts available: :hour, :day, :month, :year, :reboot
+    runner "SomeModel.ladeeda"
+  end
+
+  every :sunday do # Use any day of the week or :weekend, :weekday 
+    runner "Task.do_something_great"
+  end
+
+More examples on the wiki: http://wiki.github.com/javan/whenever/instructions-and-examples
+  
+== Cron output
+
+  $ cd /my/rails/app
+  $ whenever
+
+And you'll see your schedule.rb converted to cron sytax
+
+== Capistrano integration
+
+in your "config/deploy.rb" file do something like:
+
+  after "deploy:symlink", "deploy:write_crontab"
+
+  namespace :deploy do
+    desc "write the crontab file"
+    task :write_crontab, :roles => :app do
+      run "cd #{release_path} && whenever --write-crontab"
+    end
+  end
+  
+By mixing and matching the "--load-file" and "--user" options with your various :roles in Capistrano it is entirely possible to deploy different crontab schedules under different users to all your various servers. Get creative!
+  
+USING THE "--write-crontab" OPTION WILL COMPLETELY OVERWRITE ANY EXISTING CRONTAB ENTRIES!
+
+You can use --update-crontab to simply update whenever generated tasks.
+
+== Credit
+
+Whenever was created for use at Inkling (http://inklingmarkets.com) where I work.
+
+While building Whenever, I learned a lot by digging through the source code of Capistrano - http://github.com/jamis/capistrano
+
+== Feedback
+
+Lighthouse: http://javan.lighthouseapp.com/projects/25781-whenever/overview
+
+Email me: javan [at] javan (dot) us
+
+== License
+
+Copyright (c) 2009 Javan Makhmali
+
+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/Rakefile

@@ -0,0 +1,26 @@
+require 'rubygems'
+require 'rake'
+require 'rake/testtask'
+
+begin
+require 'echoe'
+
+require File.expand_path(File.dirname(__FILE__) + "/lib/version")
+
+Echoe.new('whenever', Whenever::VERSION::STRING) do |p|
+  p.description    = "Provides clean ruby syntax for defining messy cron jobs and running them Whenever."
+  p.url            = "http://github.com/javan/whenever"
+  p.author         = "Javan Makhmali"
+  p.email          = "javan@javan.us"
+  p.dependencies   = ["chronic >=0.2.3", "activesupport >=1.3.0"]
+end
+rescue LoadError
+  puts "Could not load echoe"
+end
+
+Rake::TestTask.new do |t|
+  t.test_files = FileList['test/*_test.rb']
+  t.verbose = true
+end
+
+task :default => [:test]

data/bin/whenever

@@ -0,0 +1,42 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'optparse'
+require 'fileutils'
+require 'tempfile'
+require 'whenever'
+
+require File.expand_path(File.dirname(__FILE__) + "/../lib/version")
+
+options = Hash.new
+
+OptionParser.new do |opts|
+  opts.banner = "Usage: whenever [options]"
+  opts.on('-v', '--version') { puts "Whenever v#{Whenever::VERSION::STRING}"; exit }
+  opts.on('-w', '--write-crontab') { options[:write] = true }
+  opts.on('-p', '--update-crontab') { options[:update] = true }
+  opts.on('-f', '--load-file [schedule file]', 'default: config/schedule.rb') do |file|
+    options[:file] = file if file
+  end
+  opts.on('-u', '--user [user]', 'default: current user') do |user| 
+    options[:user] = user if user
+  end
+end.parse!
+
+options[:file] ||= 'config/schedule.rb'
+
+unless File.exists?(options[:file])
+  warn("[fail] can't find file: #{options[:file]}")
+  exit(1)
+end
+
+command_line = CommandLine.new(options)
+
+if options[:write]
+  command_line.write!
+elsif options[:update]
+  command_line.update!
+else
+  puts Whenever.cron(:file => options[:file])
+  exit
+end

data/bin/wheneverize

@@ -0,0 +1,69 @@
+#!/usr/bin/env ruby
+
+# This file is based heavily on Capistrano's `capify` command
+
+require 'optparse'
+require 'fileutils'
+
+OptionParser.new do |opts|
+  opts.banner = "Usage: #{File.basename($0)} [path]"
+
+  begin
+    opts.parse!(ARGV)
+  rescue OptionParser::ParseError => e
+    warn e.message
+    puts opts
+    exit 1
+  end
+end
+
+if ARGV.empty?
+  abort "Please specify the directory to wheneverize, e.g. `#{File.basename($0)} .'"
+elsif !File.exists?(ARGV.first)
+  abort "`#{ARGV.first}' does not exist."
+elsif !File.directory?(ARGV.first)
+  abort "`#{ARGV.first}' is not a directory."
+elsif ARGV.length > 1
+  abort "Too many arguments; please specify only the directory to wheneverize."
+end
+
+
+content = <<-FILE
+# Use this file to easily define all of your cron jobs.
+#
+# It's helpful, but not entirely necessary to understand cron before proceeding.
+# http://en.wikipedia.org/wiki/Cron
+
+# Example:
+#
+# set :cron_log, "/path/to/my/cron_log.log"
+#
+# every 2.hours do
+#   command "/usr/bin/some_great_command"
+#   runner "MyModel.some_method"
+#   rake "some:great:rake:task"
+# end
+#
+# every 4.days do
+#   runner "AnotherModel.prune_old_records"
+# end
+
+# Learn more: http://github.com/javan/whenever
+FILE
+
+file = 'config/schedule.rb'
+base = ARGV.shift
+
+file = File.join(base, file)
+if File.exists?(file)
+  warn "[skip] `#{file}' already exists"
+elsif File.exists?(file.downcase)
+  warn "[skip] `#{file.downcase}' exists, which could conflict with `#{file}'"
+elsif !File.exists?(File.dirname(file))
+  warn "[skip] directory `#{File.dirname(file)}' does not exist"
+else
+  puts "[add] writing `#{file}'"
+  File.open(file, "w") { |f| f.write(content) }
+end
+
+puts "[done] wheneverized!"

data/lib/base.rb

@@ -0,0 +1,15 @@
+module Whenever
+  
+  def self.cron(options)
+    Whenever::JobList.new(options).generate_cron_output
+  end
+  
+  def self.path
+    if defined?(RAILS_ROOT)
+      RAILS_ROOT 
+    elsif defined?(::RAILS_ROOT)
+      ::RAILS_ROOT
+    end
+  end
+  
+end

data/lib/command_line.rb

@@ -0,0 +1,68 @@
+
+class CommandLine
+  START_MARKER = "### BEGIN whenever generated crontab ###"
+  END_MARKER =   "### END   whenever generated crontab ###"
+
+  attr_reader :options
+
+  def initialize(options = {})
+    @options = options
+  end
+
+  def write!
+    cron_output = Whenever.cron(:file => options[:file])
+    write_crontab(cron_output)
+  end
+
+  def update!
+    before, after = strip_whenever_crontab(read_crontab)
+    whenever_cron = Whenever.cron(:file => options[:file])
+    write_crontab((before + [START_MARKER, whenever_cron, END_MARKER] + after).compact.join("\n"))
+  end
+
+  private
+  def strip_whenever_crontab(existing_crontab)
+    return [], [] if existing_crontab.nil? or existing_crontab == ""
+    lines = existing_crontab.split("\n")
+    if start = lines.index(START_MARKER)
+      if finish = lines.index(END_MARKER)
+        return lines[0...start], lines[(finish + 1)..-1]
+      else
+        warn "[fail] could not find END marker in existing crontab"
+        exit(1)
+      end
+    else
+      return lines, []
+    end
+  end
+
+  def read_crontab
+    command = ['crontab']
+    command << "-u #{options[:user]}" if options[:user]
+    command << "-l"
+
+    IO.popen(command.join(' ')) do |io|
+      return io.read
+    end
+  end
+
+  def write_crontab(data)
+    tmp_cron_file = Tempfile.new('whenever_tmp_cron').path
+    File.open(tmp_cron_file, File::WRONLY | File::APPEND) do |file|
+      file.puts data
+    end
+
+    command = ['crontab']
+    command << "-u #{options[:user]}" if options[:user]
+    command << tmp_cron_file
+
+    if system(command.join(' '))
+      puts "[write] crontab file updated"
+      exit
+    else
+      warn "[fail] couldn't write crontab"
+      exit(1)
+    end
+  end
+
+end

data/lib/job_list.rb

@@ -0,0 +1,90 @@
+module Whenever
+  class JobList
+  
+    def initialize(options)
+      @jobs = Hash.new
+      @env  = Hash.new
+      
+      config = case options
+        when String then options
+        when Hash
+          if options[:string]
+            options[:string]
+          elsif options[:file]
+            File.read(options[:file])
+          end
+      end
+
+      eval(config)
+    end
+    
+    def set(variable, value)
+      instance_variable_set("@#{variable}".to_sym, value)
+      self.class.send(:attr_reader, variable.to_sym)
+    end
+    
+    def env(variable, value)
+      @env[variable.to_s] = value
+    end
+  
+    def every(frequency, options = {})
+      @current_time_scope = frequency
+      @options = options
+      yield
+    end
+    
+    def command(task, options = {})
+      options[:cron_log] ||= @cron_log unless options[:cron_log] === false
+      options[:class]    ||= Whenever::Job::Default
+      @jobs[@current_time_scope] ||= []
+      @jobs[@current_time_scope] << options[:class].new(@options.merge(:task => task).merge(options))
+    end
+    
+    def runner(task, options = {})
+      options.reverse_merge!(:environment => @environment, :path => @path)
+      options[:class] = Whenever::Job::Runner
+      command(task, options)
+    end
+    
+    def rake(task, options = {})
+      options.reverse_merge!(:environment => @environment, :path => @path)
+      options[:class] = Whenever::Job::RakeTask
+      command(task, options)
+    end
+  
+    def generate_cron_output
+      [environment_variables, cron_jobs].compact.join
+    end
+    
+  private
+  
+    def environment_variables
+      return if @env.empty?
+      
+      output = []
+      @env.each do |key, val|
+        output << "#{key}=#{val}\n"
+      end
+      output << "\n"
+      
+      output.join
+    end
+    
+    def cron_jobs
+      return if @jobs.empty?
+      
+      output = []
+      @jobs.each do |time, jobs|
+        jobs.each do |job|
+          cron = Whenever::Output::Cron.output(time, job)
+          cron << " >> #{job.cron_log} 2>&1" if job.cron_log 
+          cron << "\n\n"
+          output << cron
+        end
+      end
+      
+      output.join
+    end
+    
+  end
+end

data/lib/job_types/default.rb

@@ -0,0 +1,27 @@
+module Whenever
+  module Job
+    class Default
+      
+      attr_accessor :task, :at, :cron_log
+    
+      def initialize(options = {})
+        @task        = options[:task]
+        @at          = options[:at]
+        @cron_log    = options[:cron_log]
+        @environment = options[:environment] || :production
+        @path        = options[:path] || Whenever.path
+      end
+    
+      def output
+        task
+      end
+      
+    protected
+      
+      def path_required
+        raise ArgumentError, "No path available; set :path, '/your/path' in your schedule file" if @path.blank?
+      end
+      
+    end
+  end
+end

data/lib/job_types/rake_task.rb

@@ -0,0 +1,12 @@
+module Whenever
+  module Job
+    class RakeTask < Whenever::Job::Default
+      
+      def output
+        path_required
+        "cd #{@path} && RAILS_ENV=#{@environment} /usr/bin/env rake #{task}"
+      end
+      
+    end
+  end
+end

data/lib/job_types/runner.rb

@@ -0,0 +1,12 @@
+module Whenever
+  module Job
+    class Runner < Whenever::Job::Default
+
+      def output
+        path_required
+        %Q(#{File.join(@path, 'script', 'runner')} -e #{@environment} "#{task}")
+      end
+      
+    end
+  end
+end

data/lib/outputs/cron.rb

@@ -0,0 +1,104 @@
+module Whenever
+  module Output
+    
+    class Cron
+      
+      attr_accessor :time, :task
+      
+      def initialize(time = nil, task = nil, at = nil)
+        @time = time
+        @task = task
+        @at   = at.is_a?(String) ? (Chronic.parse(at) || 0) : (at || 0)
+      end
+      
+      def self.output(time, job)
+        out = new(time, job.output, job.at)
+        "#{out.time_in_cron_syntax} #{out.task}"
+      end
+      
+      def time_in_cron_syntax
+        case @time
+          when Symbol then parse_symbol
+          when String then parse_as_string
+          else parse_time
+        end
+      end
+      
+    protected
+    
+      def parse_symbol
+        case @time
+          when :reboot          then '@reboot'
+          when :year, :yearly   then '@annually'
+          when :day, :daily     then '@daily'
+          when :midnight        then '@midnight'
+          when :month, :monthly then '@monthly'
+          when :week, :weekly   then '@weekly'
+          when :hour, :hourly   then '@hourly'
+          else parse_as_string
+        end
+      end
+      
+      def parse_time
+        timing = Array.new(5, '*')
+        case @time
+          when 0.seconds...1.minute
+            raise ArgumentError, "Time must be in minutes or higher"
+          when 1.minute...1.hour
+            minute_frequency = @time / 60
+            timing[0] = comma_separated_timing(minute_frequency, 59)
+          when 1.hour...1.day
+            hour_frequency = (@time / 60 / 60).round
+            timing[0] = @at.is_a?(Time) ? @at.min : @at  
+            timing[1] = comma_separated_timing(hour_frequency, 23)
+          when 1.day...1.month
+            day_frequency = (@time / 24 / 60 / 60).round
+            timing[0] = @at.is_a?(Time) ? @at.min  : 0
+            timing[1] = @at.is_a?(Time) ? @at.hour : @at
+            timing[2] = comma_separated_timing(day_frequency, 31, 1)
+          when 1.month..12.months
+            month_frequency = (@time / 30  / 24 / 60 / 60).round
+            timing[0] = @at.is_a?(Time) ? @at.min  : 0
+            timing[1] = @at.is_a?(Time) ? @at.hour : 0
+            timing[2] = @at.is_a?(Time) ? @at.day  : (@at.zero? ? 1 : @at)
+            timing[3] = comma_separated_timing(month_frequency, 12, 1)
+          else
+            return parse_as_string
+        end
+        timing.join(' ')
+      end
+      
+      def parse_as_string
+        return unless @time
+        string = @time.to_s
+        
+        return "0 0 * * mon-fri" if string.downcase.index('weekday')
+        return "0 0 * * sat,sun" if string.downcase.index('weekend')
+        
+        %w(sun mon tue wed thu fri sat).each do |day|
+          return "0 0 * * #{day}" if string.downcase.index(day)
+        end
+        
+        raise ArgumentError, "Couldn't parse: #{@time}"
+      end
+      
+      def comma_separated_timing(frequency, max, start = 0)
+        return start     if frequency.blank? || frequency.zero?
+        return '*'       if frequency == 1
+        return frequency if frequency > (max * 0.5).ceil
+        
+        original_start = start
+        
+        start += frequency unless (max + 1).modulo(frequency).zero? || start > 0
+        output = (start..max).step(frequency).to_a
+        
+        max_occurances = (max.to_f  / (frequency.to_f)).round
+        max_occurances += 1 if original_start.zero?
+        
+        output[0, max_occurances].join(',')
+      end
+
+    end
+    
+  end
+end

data/lib/version.rb

@@ -0,0 +1,10 @@
+module Whenever
+  module VERSION #:nodoc:
+    MAJOR = 0
+    MINOR = 1
+    TINY  = 5
+    FORK  = 1
+
+    STRING = [MAJOR, MINOR, TINY, FORK].join('.')
+  end
+end unless defined?(Whenever::VERSION)

data/lib/whenever.rb

@@ -0,0 +1,19 @@
+unless defined?(Whenever)
+  $:.unshift(File.dirname(__FILE__))
+   
+  # Hoping to load Rails' Rakefile
+  begin
+    load 'Rakefile'
+  rescue LoadError => e
+    nil
+  end
+end
+
+# Dependencies
+require 'activesupport'
+require 'chronic'
+
+# Whenever files
+%w{ base version job_list job_types/default job_types/rake_task job_types/runner outputs/cron command_line}.each do |file|
+  require	File.expand_path(File.dirname(__FILE__) + "/#{file}")
+end