lowang-whenever 0.7.0.1

data/bin/wheneverize

@@ -0,0 +1,68 @@
+#!/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
+
+unless ARGV.empty?
+  if !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
+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 :output, "/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.empty? ? '.' : 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/whenever.rb

@@ -0,0 +1,29 @@
+require 'active_support'
+require 'thread'
+
+module Whenever
+  autoload :JobList,     'whenever/job_list'
+  autoload :Job,         'whenever/job'
+  autoload :CommandLine, 'whenever/command_line'
+  
+  module Output
+    autoload :Cron,        'whenever/cron'
+    autoload :Redirection, 'whenever/output_redirection'
+  end
+  
+  def self.cron(options)
+    Whenever::JobList.new(options).generate_cron_output
+  end
+  
+  def self.path
+    Dir.pwd
+  end
+
+  def self.rails3?
+    File.exists?(File.join(path, 'script', 'rails'))
+  end
+
+  def self.bundler?
+    File.exists?(File.join(path, 'Gemfile'))
+  end
+end

data/lib/whenever/capistrano.rb

@@ -0,0 +1,62 @@
+Capistrano::Configuration.instance(:must_exist).load do
+  _cset(:whenever_roles)        { :db }
+  _cset(:whenever_command)      { "whenever" }
+  _cset(:whenever_identifier)   { fetch :application }
+  _cset(:whenever_environment)  { fetch :rails_env, "production" }
+  _cset(:whenever_update_flags) { "--update-crontab #{fetch :whenever_identifier} --set environment=#{fetch :whenever_environment}" }
+  _cset(:whenever_clear_flags)  { "--clear-crontab #{fetch :whenever_identifier}" }
+
+  # Disable cron jobs at the begining of a deploy.
+  after "deploy:update_code", "whenever:clear_crontab"
+  # Write the new cron jobs near the end.
+  after "deploy:symlink", "whenever:update_crontab"
+  # If anything goes wrong, undo.
+  after "deploy:rollback", "whenever:update_crontab"
+
+  namespace :whenever do
+    desc <<-DESC
+      Update application's crontab entries using Whenever. You can configure \
+      the command used to invoke Whenever by setting the :whenever_command \
+      variable, which can be used with Bundler to set the command to \
+      "bundle exec whenever". You can configure the identifier used by setting \
+      the :whenever_identifier variable, which defaults to the same value configured \
+      for the :application variable. You can configure the environment by setting \
+      the :whenever_environment variable, which defaults to the same value \
+      configured for the :rails_env variable which itself defaults to "production". \
+      Finally, you can completely override all arguments to the Whenever command \
+      by setting the :whenever_update_flags variable. Additionally you can configure \
+      which servers the crontab is updated on by setting the :whenever_roles variable.
+    DESC
+    task :update_crontab do
+      options = { :roles => fetch(:whenever_roles) }
+
+      if find_servers(options).any?
+        on_rollback do
+          if fetch :previous_release
+            run "cd #{fetch :previous_release} && #{fetch :whenever_command} #{fetch :whenever_update_flags}", options
+          else
+            run "cd #{fetch :release_path} && #{fetch :whenever_command} #{fetch :whenever_clear_flags}", options
+          end
+        end
+
+        run "cd #{fetch :current_path} && #{fetch :whenever_command} #{fetch :whenever_update_flags}", options
+      end
+    end
+
+    desc <<-DESC
+      Clear application's crontab entries using Whenever. You can configure \
+      the command used to invoke Whenever by setting the :whenever_command \
+      variable, which can be used with Bundler to set the command to \
+      "bundle exec whenever". You can configure the identifier used by setting \
+      the :whenever_identifier variable, which defaults to the same value configured \
+      for the :application variable. Finally, you can completely override all \
+      arguments to the Whenever command by setting the :whenever_clear_flags variable. \
+      Additionally you can configure which servers the crontab is cleared on by setting \
+      the :whenever_roles variable.
+    DESC
+    task :clear_crontab do
+      options = { :roles => whenever_roles }
+      run "cd #{fetch :release_path} && #{fetch :whenever_command} #{fetch :whenever_clear_flags}", options if find_servers(options).any?
+    end
+  end
+end

data/lib/whenever/command_line.rb

@@ -0,0 +1,133 @@
+require 'fileutils'
+require 'tempfile'
+
+module Whenever
+  class CommandLine
+    def self.execute(options={})
+      new(options).run
+    end
+    
+    def initialize(options={})
+      @options = options
+      
+      @options[:file]       ||= 'config/schedule.rb'
+      @options[:cut]        ||= 0
+      @options[:identifier] ||= default_identifier
+      
+      unless File.exists?(@options[:file])
+        warn("[fail] Can't find file: #{@options[:file]}")
+        exit(1)
+      end
+
+      if [@options[:update], @options[:write], @options[:clear]].compact.length > 1
+        warn("[fail] Can only update, write or clear. Choose one.")
+        exit(1)
+      end
+
+      unless @options[:cut].to_s =~ /[0-9]*/
+        warn("[fail] Can't cut negative lines from the crontab #{options[:cut]}")
+        exit(1)
+      end
+      @options[:cut] = @options[:cut].to_i
+    end
+    
+    def run
+      if @options[:update] || @options[:clear]
+        write_crontab(updated_crontab)
+      elsif @options[:write]
+        write_crontab(whenever_cron)
+      else
+        puts Whenever.cron(@options)
+        puts "## [message] Above is your schedule file converted to cron syntax; your crontab file was not updated."
+        puts "## [message] Run `whenever --help' for more options."
+        exit(0)
+      end
+    end
+    
+  protected
+    
+    def default_identifier
+      File.expand_path(@options[:file])
+    end
+  
+    def whenever_cron
+      return '' if @options[:clear]
+      @whenever_cron ||= [comment_open, Whenever.cron(@options), comment_close].compact.join("\n") + "\n"
+    end
+    
+    def read_crontab
+      return @current_crontab if @current_crontab
+      
+      command = ['crontab -l']
+      command << "-u #{@options[:user]}" if @options[:user]
+      
+      command_results  = %x[#{command.join(' ')} 2> /dev/null]
+      @current_crontab = $?.exitstatus.zero? ? prepare(command_results) : ''
+    end
+    
+    def write_crontab(contents)
+      tmp_cron_file = Tempfile.new('whenever_tmp_cron').path
+      File.open(tmp_cron_file, File::WRONLY | File::APPEND) do |file|
+        file << contents
+      end
+
+      command = ['crontab']
+      command << "-u #{@options[:user]}" if @options[:user]
+      command << tmp_cron_file
+
+      if system(command.join(' '))
+        action = 'written' if @options[:write]
+        action = 'updated' if @options[:update]
+        puts "[write] crontab file #{action}"
+        exit(0)
+      else
+        warn "[fail] Couldn't write crontab; try running `whenever' with no options to ensure your schedule file is valid."
+        exit(1)
+      end
+    end
+    
+    def updated_crontab   
+      # Check for unopened or unclosed identifier blocks
+      if read_crontab =~ Regexp.new("^#{comment_open}\s*$") && (read_crontab =~ Regexp.new("^#{comment_close}\s*$")).nil?
+        warn "[fail] Unclosed indentifier; Your crontab file contains '#{comment_open}', but no '#{comment_close}'"
+        exit(1)
+      elsif (read_crontab =~ Regexp.new("^#{comment_open}\s*$")).nil? && read_crontab =~ Regexp.new("^#{comment_close}\s*$")
+        warn "[fail] Unopened indentifier; Your crontab file contains '#{comment_close}', but no '#{comment_open}'"
+        exit(1)
+      end
+      
+      # If an existing identier block is found, replace it with the new cron entries
+      if read_crontab =~ Regexp.new("^#{comment_open}\s*$") && read_crontab =~ Regexp.new("^#{comment_close}\s*$")
+        # If the existing crontab file contains backslashes they get lost going through gsub.
+        # .gsub('\\', '\\\\\\') preserves them. Go figure.
+        read_crontab.gsub(Regexp.new("^#{comment_open}\s*$.+^#{comment_close}\s*$", Regexp::MULTILINE), whenever_cron.chomp.gsub('\\', '\\\\\\'))
+      else # Otherwise, append the new cron entries after any existing ones
+        [read_crontab, whenever_cron].join("\n\n")
+      end.gsub(/\n{3,}/, "\n\n") # More than two newlines becomes just two.
+    end
+    
+    def prepare(contents)
+      # Strip n lines from the top of the file as specified by the :cut option.
+      # Use split with a -1 limit option to ensure the join is able to rebuild
+      # the file with all of the original seperators in-tact.
+      stripped_contents = contents.split($/,-1)[@options[:cut]..-1].join($/)
+
+      # Some cron implementations require all non-comment lines to be newline-
+      # terminated. (issue #95) Strip all newlines and replace with the default 
+      # platform record seperator ($/)
+      stripped_contents.gsub!(/\s+$/, $/)
+    end
+    
+    def comment_base
+      "Whenever generated tasks for: #{@options[:identifier]}"
+    end
+    
+    def comment_open
+      "# Begin #{comment_base}"
+    end
+    
+    def comment_close
+      "# End #{comment_base}"
+    end
+  end
+end

data/lib/whenever/cron.rb

@@ -0,0 +1,149 @@
+require 'chronic'
+
+module Whenever
+  module Output
+    class Cron
+      REGEX = /^.+ .+ .+ .+ .+.?$/
+
+      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.enumerate(item, detect_cron = true)
+        if item and item.is_a?(String)
+          items = 
+            if detect_cron && item =~ REGEX
+              [item]
+            else
+              item.split(',')
+            end
+        else
+          items = item
+          items = [items] unless items and items.respond_to?(:each)
+        end
+        items
+      end
+
+      def self.output(times, job)
+        enumerate(times).each do |time|
+          enumerate(job.at, false).each do |at|
+            yield new(time, job.output, at).output
+          end
+        end
+      end
+      
+      def output
+        [time_in_cron_syntax, task].compact.join(' ').strip
+      end
+
+      def time_in_cron_syntax
+        case @time
+          when REGEX  then @time # raw cron sytax given
+          when Symbol then parse_symbol
+          when String then parse_as_string
+          else parse_time
+        end
+      end
+
+    protected
+
+      def parse_symbol
+        shortcut = case @time
+          when :reboot   then '@reboot'
+          when :year     then 12.months
+          when :yearly, 
+               :annually then '@annually'
+          when :day      then 1.day
+          when :daily    then '@daily'
+          when :midnight then '@midnight'
+          when :month    then 1.month
+          when :monthly  then '@monthly'
+          when :week     then 1.week
+          when :weekly   then '@weekly'
+          when :hour     then 1.hour
+          when :hourly   then '@hourly'
+        end
+        
+        if shortcut.is_a?(Numeric)
+          @time = shortcut
+          parse_time
+        elsif shortcut
+          if @at.is_a?(Time) || (@at.is_a?(Numeric) && @at > 0)
+            raise ArgumentError, "You cannot specify an ':at' when using the shortcuts for times."
+          else
+            return shortcut
+          end
+        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, @at || 0)
+          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
+
+        timing = Array.new(4, '*')
+        timing[0] = @at.is_a?(Time) ? @at.min  : 0
+        timing[1] = @at.is_a?(Time) ? @at.hour : 0
+
+        return (timing << '1-5') * " " if string.downcase.index('weekday')
+        return (timing << '6,0') * " " if string.downcase.index('weekend')
+
+        %w(sun mon tue wed thu fri sat).each_with_index do |day, i|
+          return (timing << i) * " " 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/whenever/job.rb

@@ -0,0 +1,45 @@
+module Whenever
+  class Job
+    attr_reader :at
+  
+    def initialize(options = {})
+      @options = options
+      @at                      = options.delete(:at)
+      @template                = options.delete(:template)
+      @job_template            = options.delete(:job_template) || ":job"
+      @options[:output]        = Whenever::Output::Redirection.new(options[:output]).to_s if options.has_key?(:output)
+      @options[:environment] ||= :production
+      @options[:path]        ||= Whenever.path
+    end
+  
+    def output
+      job = process_template(@template, @options).strip
+      process_template(@job_template, { :job => job }).strip
+    end
+    
+  protected
+  
+    def process_template(template, options)
+      template.gsub(/:\w+/) do |key|
+        before_and_after = [$`[-1..-1], $'[0..0]]
+        option = options[key.sub(':', '').to_sym]
+
+        if before_and_after.all? { |c| c == "'" }
+          escape_single_quotes(option)
+        elsif before_and_after.all? { |c| c == '"' }
+          escape_double_quotes(option)
+        else
+          option
+        end
+      end
+    end
+
+    def escape_single_quotes(str)
+      str.gsub(/'/) { "'\\''" }
+    end
+    
+    def escape_double_quotes(str)
+      str.gsub(/"/) { '\"' }
+    end
+  end
+end