richmeyers-whenever 0.6.2

data/lib/whenever/capistrano.rb

@@ -0,0 +1,31 @@
+Capistrano::Configuration.instance(:must_exist).load do
+  
+  _cset(:whenever_roles)        { :db }
+  _cset(:whenever_command)      { "whenever" }
+  _cset(:whenever_identifier)   { application }
+  _cset(:whenever_update_flags) { "--update-crontab #{whenever_identifier}" }
+  _cset(:whenever_clear_flags)  { "--clear-crontab #{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 "Update application's crontab entries using Whenever"
+    task :update_crontab, :roles => whenever_roles do
+      # Hack by Jamis to skip a task if the role has no servers defined. http://tinyurl.com/ckjgnz
+      next if find_servers_for_task(current_task).empty?
+      run "cd #{current_path} && #{whenever_command} #{whenever_update_flags}"
+    end
+
+    desc "Clear application's crontab entries using Whenever"
+    task :clear_crontab, :roles => whenever_roles do
+      next if find_servers_for_task(current_task).empty?
+      run "cd #{release_path} && #{whenever_command} #{whenever_clear_flags}"
+    end
+  end
+  
+end

data/lib/whenever/command_line.rb

@@ -0,0 +1,129 @@
+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)
+        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}$") && (read_crontab =~ Regexp.new("^#{comment_close}$")).nil?
+        warn "[fail] Unclosed indentifier; Your crontab file contains '#{comment_open}', but no '#{comment_close}'"
+        exit(1)
+      elsif (read_crontab =~ Regexp.new("^#{comment_open}$")).nil? && read_crontab =~ Regexp.new("^#{comment_close}$")
+        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}$") && read_crontab =~ Regexp.new("^#{comment_close}$")
+        # 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}$.+^#{comment_close}$", 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)
+      # Some cron implementations require all non-comment lines to be newline-terminated.
+      # Preserve any whitespace at the end of contents. (issue #95)
+      stripped_contents = contents.strip
+      tail = contents[stripped_contents.length..-1]
+      stripped_contents.split("\n")[@options[:cut]..-1].join("\n") + tail
+    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,132 @@
+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.enumerate(item)
+        if item and item.is_a?(String)
+          items = item.split(',')
+        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).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 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, :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'
+        end
+        
+        if 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,47 @@
+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

data/lib/whenever/job_list.rb

@@ -0,0 +1,148 @@
+module Whenever
+  class JobList
+  
+    def initialize(options)
+      @jobs, @env, @set_variables, @pre_set_variables = {}, {}, {}, {}
+      
+      case options
+        when String
+          config = options
+        when Hash
+          config = if options[:string]
+            options[:string]
+          elsif options[:file]
+            File.read(options[:file])
+          end
+          pre_set(options[:set])
+      end
+      
+      setup = File.read("#{File.expand_path(File.dirname(__FILE__))}/setup.rb")
+      
+      eval(setup + config)
+    end
+    
+    def set(variable, value)
+      variable = variable.to_sym
+      return if @pre_set_variables[variable]
+      
+      instance_variable_set("@#{variable}".to_sym, value)
+      self.class.send(:attr_reader, variable.to_sym)
+      @set_variables[variable] = value
+    end
+    
+    def env(variable, value)
+      @env[variable.to_s] = value
+    end
+  
+    def every(frequency, options = {})
+      @current_time_scope = frequency
+      @options = options
+      yield
+    end
+    
+    def job_type(name, template)
+      class_eval do
+        define_method(name) do |task, *args|
+          options = { :task => task, :template => template }
+          options.merge!(args[0]) if args[0].is_a? Hash
+          
+          # :cron_log was an old option for output redirection, it remains for backwards compatibility
+          options[:output] = (options[:cron_log] || @cron_log) if defined?(@cron_log) || options.has_key?(:cron_log)
+          # :output is the newer, more flexible option.
+          options[:output] = @output if defined?(@output) && !options.has_key?(:output)
+          
+          @jobs[@current_time_scope] ||= []
+          @jobs[@current_time_scope] << Whenever::Job.new(@options.merge(@set_variables).merge(options))
+        end
+      end
+    end
+  
+    def generate_cron_output      
+      [environment_variables, cron_jobs].compact.join
+    end
+    
+  private
+    
+    #
+    # Takes a string like: "variable1=something&variable2=somethingelse"
+    # and breaks it into variable/value pairs. Used for setting variables at runtime from the command line.
+    # Only works for setting values as strings.
+    #
+    def pre_set(variable_string = nil)
+      return if variable_string.blank?
+      
+      pairs = variable_string.split('&')
+      pairs.each do |pair|
+        next unless pair.index('=')
+        variable, value = *pair.split('=')
+        unless variable.blank? || value.blank?
+          variable = variable.strip.to_sym
+          set(variable, value.strip)
+          @pre_set_variables[variable] = value
+        end
+      end
+    end
+  
+    def environment_variables
+      return if @env.empty?
+      
+      output = []
+      @env.each do |key, val|
+        output << "#{key}=#{val}\n"
+      end
+      output << "\n"
+      
+      output.join
+    end
+    
+    #
+    # Takes the standard cron output that Whenever generates and finds
+    # similar entries that can be combined. For example: If a job should run
+    # at 3:02am and 4:02am, instead of creating two jobs this method combines
+    # them into one that runs on the 2nd minute at the 3rd and 4th hour.
+    #
+    def combine(entries)
+      entries.map! { |entry| entry.split(/ +/, 6) }
+      0.upto(4) do |f|
+        (entries.length-1).downto(1) do |i|
+          next if entries[i][f] == '*'
+          comparison = entries[i][0...f] + entries[i][f+1..-1]
+          (i-1).downto(0) do |j|
+            next if entries[j][f] == '*'
+            if comparison == entries[j][0...f] + entries[j][f+1..-1]
+              entries[j][f] += ',' + entries[i][f]
+              entries.delete_at(i)
+              break
+            end
+          end
+        end
+      end
+
+      entries.map { |entry| entry.join(' ') }
+    end
+
+    def cron_jobs
+      return if @jobs.empty?
+      
+      shortcut_jobs = []
+      regular_jobs = []
+      
+      @jobs.each do |time, jobs|
+        jobs.each do |job|
+          Whenever::Output::Cron.output(time, job) do |cron|
+            cron << "\n\n"
+            
+            if cron.starts_with?("@")
+              shortcut_jobs << cron
+            else
+              regular_jobs << cron
+            end
+          end
+        end
+      end
+
+      shortcut_jobs.join + combine(regular_jobs).join
+    end
+    
+  end
+end