whenever 0.8.2 → 1.0.0

data/lib/whenever/capistrano/{recipes.rb → v2/recipes.rb}

@@ -1,4 +1,4 @@
-require 'whenever/capistrano/support'
+require 'whenever/capistrano/v2/support'
 
 Capistrano::Configuration.instance(:must_exist).load do
   Whenever::CapistranoSupport.load_into(self)
@@ -7,10 +7,11 @@ Capistrano::Configuration.instance(:must_exist).load do
   _cset(:whenever_options)      { {:roles => fetch(:whenever_roles)} }
   _cset(:whenever_command)      { "whenever" }
   _cset(:whenever_identifier)   { fetch :application }
-  _cset(:whenever_environment)  { fetch :rails_env, "production" }
+  _cset(:whenever_environment)  { fetch :rails_env, fetch(:stage, "production") }
   _cset(:whenever_variables)    { "environment=#{fetch :whenever_environment}" }
   _cset(:whenever_update_flags) { "--update-crontab #{fetch :whenever_identifier} --set #{fetch :whenever_variables}" }
   _cset(:whenever_clear_flags)  { "--clear-crontab #{fetch :whenever_identifier}" }
+  _cset(:whenever_path)         { fetch :latest_release }
 
   namespace :whenever do
     desc "Update application's crontab entries using Whenever"
@@ -18,22 +19,15 @@ Capistrano::Configuration.instance(:must_exist).load do
       args = {
         :command => fetch(:whenever_command),
         :flags   => fetch(:whenever_update_flags),
-        :path    => fetch(:latest_release)
+        :path    => fetch(:whenever_path)
       }
 
       if whenever_servers.any?
+        args = whenever_prepare_for_rollback(args) if task_call_frames[0].task.fully_qualified_name == 'deploy:rollback'
         whenever_run_commands(args)
 
         on_rollback do
-          if fetch(:previous_release)
-            # rollback to the previous release's crontab
-            args[:path] = fetch(:previous_release)
-          else
-            # clear the crontab if no previous release
-            args[:path]  = fetch(:release_path)
-            args[:flags] = fetch(:whenever_clear_flags)
-          end
-
+          args = whenever_prepare_for_rollback(args)
           whenever_run_commands(args)
         end
       end
@@ -45,7 +39,7 @@ Capistrano::Configuration.instance(:must_exist).load do
         args = {
           :command => fetch(:whenever_command),
           :flags   => fetch(:whenever_clear_flags),
-          :path    => fetch(:latest_release)
+          :path    => fetch(:whenever_path)
         }
 
         whenever_run_commands(args)

data/lib/whenever/capistrano/{support.rb → v2/support.rb}

@@ -22,6 +22,18 @@ module Whenever
           end
         end
 
+        def whenever_prepare_for_rollback args
+          if fetch(:previous_release)
+            # rollback to the previous release's crontab
+            args[:path] = fetch(:previous_release)
+          else
+            # clear the crontab if no previous release
+            args[:path]  = fetch(:release_path)
+            args[:flags] = fetch(:whenever_clear_flags)
+          end
+          args
+        end
+
         def whenever_run_commands(args)
           unless [:command, :path, :flags].all? { |a| args.include?(a) }
             raise ArgumentError, ":command, :path, & :flags are required"

data/lib/whenever/capistrano/v3/tasks/whenever.rake

@@ -0,0 +1,56 @@
+namespace :whenever do
+  def setup_whenever_task(*args, &block)
+    args = Array(fetch(:whenever_command)) + args
+
+    on roles fetch(:whenever_roles) do |host|
+      args_for_host = block_given? ? args + Array(yield(host)) : args
+      within fetch(:whenever_path) do
+        with fetch(:whenever_command_environment_variables) do
+          execute(*args_for_host)
+        end
+      end
+    end
+  end
+
+  def load_file
+    file = fetch(:whenever_load_file)
+    if file
+      "-f #{file}"
+    else
+      ''
+    end
+  end
+
+  desc "Update application's crontab entries using Whenever"
+  task :update_crontab do
+    setup_whenever_task do |host|
+      roles = host.roles_array.join(",")
+      [fetch(:whenever_update_flags), "--roles=#{roles}", load_file]
+    end
+  end
+
+  desc "Clear application's crontab entries using Whenever"
+  task :clear_crontab do
+    setup_whenever_task do |host|
+      [fetch(:whenever_clear_flags), load_file]
+    end
+  end
+
+  after "deploy:updated",  "whenever:update_crontab"
+  after "deploy:reverted", "whenever:update_crontab"
+end
+
+namespace :load do
+  task :defaults do
+    set :whenever_roles,        ->{ :db }
+    set :whenever_command,      ->{ [:bundle, :exec, :whenever] }
+    set :whenever_command_environment_variables, ->{ fetch(:default_env).merge(rails_env: fetch(:whenever_environment)) }
+    set :whenever_identifier,   ->{ fetch :application }
+    set :whenever_environment,  ->{ fetch :rails_env, fetch(:stage, "production") }
+    set :whenever_variables,    ->{ "environment=#{fetch :whenever_environment}" }
+    set :whenever_load_file,    ->{ nil }
+    set :whenever_update_flags, ->{ "--update-crontab #{fetch :whenever_identifier} --set #{fetch :whenever_variables}" }
+    set :whenever_clear_flags,  ->{ "--clear-crontab #{fetch :whenever_identifier}" }
+    set :whenever_path,         ->{ release_path }
+  end
+end

data/lib/whenever/capistrano.rb

@@ -1,8 +1,7 @@
-require "whenever/capistrano/recipes"
+require 'capistrano/version'
 
-Capistrano::Configuration.instance(:must_exist).load do
-  # Write the new cron jobs near the end.
-  before "deploy:finalize_update", "whenever:update_crontab"
-  # If anything goes wrong, undo.
-  after "deploy:rollback", "whenever:update_crontab"
+if defined?(Capistrano::VERSION) && Gem::Version.new(Capistrano::VERSION).release >= Gem::Version.new('3.0.0')
+  load File.expand_path("../capistrano/v3/tasks/whenever.rake", __FILE__)
+else
+  require 'whenever/capistrano/v2/hooks'
 end

data/lib/whenever/command_line.rb

@@ -1,20 +1,20 @@
 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])
+
+      @options[:crontab_command] ||= 'crontab'
+      @options[:file]            ||= 'config/schedule.rb'
+      @options[:cut]             ||= 0
+      @options[:identifier]      ||= default_identifier
+
+      if !File.exist?(@options[:file]) && @options[:clear].nil?
         warn("[fail] Can't find file: #{@options[:file]}")
         exit(1)
       end
@@ -29,8 +29,10 @@ module Whenever
         exit(1)
       end
       @options[:cut] = @options[:cut].to_i
+
+      @timestamp = Time.now.to_s
     end
-    
+
     def run
       if @options[:update] || @options[:clear]
         write_crontab(updated_crontab)
@@ -43,70 +45,73 @@ module Whenever
         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']
+      return @current_crontab if instance_variable_defined?(:@current_crontab)
+
+      command = [@options[:crontab_command]]
+      command << '-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.open('whenever_tmp_cron')
-      tmp_cron_file << contents
-      tmp_cron_file.fsync
 
-      command = ['crontab']
+    def write_crontab(contents)
+      command = [@options[:crontab_command]]
       command << "-u #{@options[:user]}" if @options[:user]
-      command << tmp_cron_file.path
+      # Solaris/SmartOS cron does not support the - option to read from stdin.
+      command << "-" unless OS.solaris?
+
+      IO.popen(command.join(' '), 'r+') do |crontab|
+        crontab.write(contents)
+        crontab.close_write
+      end
 
-      if system(command.join(' '))
+      success = $?.exitstatus.zero?
+
+      if success
         action = 'written' if @options[:write]
         action = 'updated' if @options[:update]
         puts "[write] crontab file #{action}"
-        tmp_cron_file.close!
         exit(0)
       else
         warn "[fail] Couldn't write crontab; try running `whenever' with no options to ensure your schedule file is valid."
-        tmp_cron_file.close!
         exit(1)
       end
     end
-    
-    def updated_crontab   
+
+    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}'"
+      if read_crontab =~ Regexp.new("^#{comment_open_regex}\s*$") && (read_crontab =~ Regexp.new("^#{comment_close_regex}\s*$")).nil?
+        warn "[fail] Unclosed indentifier; Your crontab file contains '#{comment_open(false)}', but no '#{comment_close(false)}'"
         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}'"
+      elsif (read_crontab =~ Regexp.new("^#{comment_open_regex}\s*$")).nil? && read_crontab =~ Regexp.new("^#{comment_close_regex}\s*$")
+        warn "[fail] Unopened indentifier; Your crontab file contains '#{comment_close(false)}', but no '#{comment_open(false)}'"
         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 an existing identifier block is found, replace it with the new cron entries
+      if read_crontab =~ Regexp.new("^#{comment_open_regex}\s*$") && read_crontab =~ Regexp.new("^#{comment_close_regex}\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('\\', '\\\\\\'))
+        read_crontab.gsub(Regexp.new("^#{comment_open_regex}\s*$.+^#{comment_close_regex}\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
@@ -114,21 +119,37 @@ module Whenever
       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 
+      # 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]}"
+
+    def comment_base(include_timestamp = true)
+      if include_timestamp
+        "Whenever generated tasks for: #{@options[:identifier]} at: #{@timestamp}"
+      else
+        "Whenever generated tasks for: #{@options[:identifier]}"
+      end
     end
-    
-    def comment_open
-      "# Begin #{comment_base}"
+
+    def comment_open(include_timestamp = true)
+      "# Begin #{comment_base(include_timestamp)}"
     end
-    
-    def comment_close
-      "# End #{comment_base}"
+
+    def comment_close(include_timestamp = true)
+      "# End #{comment_base(include_timestamp)}"
+    end
+
+    def comment_open_regex
+      "#{comment_open(false)}(#{timestamp_regex}|)"
+    end
+
+    def comment_close_regex
+      "#{comment_close(false)}(#{timestamp_regex}|)"
+    end
+
+    def timestamp_regex
+      " at: \\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2} ([+-]\\d{4}|UTC)"
     end
   end
 end

data/lib/whenever/cron.rb

@@ -3,16 +3,20 @@ require 'chronic'
 module Whenever
   module Output
     class Cron
+      DAYS = %w(sun mon tue wed thu fri sat)
+      MONTHS = %w(jan feb mar apr may jun jul aug sep oct nov dec)
       KEYWORDS = [:reboot, :yearly, :annually, :monthly, :weekly, :daily, :midnight, :hourly]
-      REGEX = /^(@(#{KEYWORDS.join '|'})|.+\s+.+\s+.+\s+.+\s+.+.?)$/
+      REGEX = /^(@(#{KEYWORDS.join '|'})|((\*?[\d\/,\-]*)\s){3}(\*?([\d\/,\-]|(#{MONTHS.join '|'}))*\s)(\*?([\d\/,\-]|(#{DAYS.join '|'}))*))$/i
 
       attr_accessor :time, :task
 
-      def initialize(time = nil, task = nil, at = nil)
+      def initialize(time = nil, task = nil, at = nil, options = {})
+        chronic_options = options[:chronic_options] || {}
+
         @at_given = at
         @time = time
         @task = task
-        @at   = at.is_a?(String) ? (Chronic.parse(at) || 0) : (at || 0)
+        @at   = at.is_a?(String) ? (Chronic.parse(at, chronic_options) || 0) : (at || 0)
       end
 
       def self.enumerate(item, detect_cron = true)
@@ -30,10 +34,10 @@ module Whenever
         items
       end
 
-      def self.output(times, job)
+      def self.output(times, job, options = {})
         enumerate(times).each do |time|
           enumerate(job.at, false).each do |at|
-            yield new(time, job.output, at).output
+            yield new(time, job.output, at, options).output
           end
         end
       end
@@ -43,8 +47,9 @@ module Whenever
       end
 
       def time_in_cron_syntax
+        @time = @time.to_i if @time.is_a?(Numeric) # Compatibility with `1.day` format using ruby 2.3 and activesupport
         case @time
-          when REGEX  then @time # raw cron sytax given
+          when REGEX  then @time # raw cron syntax given
           when Symbol then parse_symbol
           when String then parse_as_string
           else parse_time
@@ -53,18 +58,18 @@ module Whenever
 
     protected
       def day_given?
-        months = %w(jan feb mar apr may jun jul aug sep oct nov dec)
-        @at_given.is_a?(String) && months.any? { |m| @at_given.downcase.index(m) }
+        @at_given.is_a?(String) && (MONTHS.any? { |m| @at_given.downcase.index(m) } || @at_given[/\d\/\d/])
       end
 
       def parse_symbol
         shortcut = case @time
           when *KEYWORDS then "@#{@time}" # :reboot => '@reboot'
-          when :year     then 12.months
-          when :day      then 1.day
-          when :month    then 1.month
-          when :week     then 1.week
-          when :hour     then 1.hour
+          when :year     then Whenever.seconds(1, :year)
+          when :day      then Whenever.seconds(1, :day)
+          when :month    then Whenever.seconds(1, :month)
+          when :week     then Whenever.seconds(1, :week)
+          when :hour     then Whenever.seconds(1, :hour)
+          when :minute   then Whenever.seconds(1, :minute)
         end
 
         if shortcut.is_a?(Numeric)
@@ -84,30 +89,43 @@ module Whenever
       def parse_time
         timing = Array.new(5, '*')
         case @time
-          when 0.seconds...1.minute
+          when Whenever.seconds(0, :seconds)...Whenever.seconds(1, :minute)
             raise ArgumentError, "Time must be in minutes or higher"
-          when 1.minute...1.hour
+          when Whenever.seconds(1, :minute)...Whenever.seconds(1, :hour)
             minute_frequency = @time / 60
             timing[0] = comma_separated_timing(minute_frequency, 59, @at || 0)
-          when 1.hour...1.day
+          when Whenever.seconds(1, :hour)...Whenever.seconds(1, :day)
             hour_frequency = (@time / 60 / 60).round
-            timing[0] = @at.is_a?(Time) ? @at.min : @at
+            timing[0] = @at.is_a?(Time) ? @at.min : range_or_integer(@at, 0..59, 'Minute')
             timing[1] = comma_separated_timing(hour_frequency, 23)
-          when 1.day...1.month
+          when Whenever.seconds(1, :day)...Whenever.seconds(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[1] = @at.is_a?(Time) ? @at.hour : range_or_integer(@at, 0..23, 'Hour')
             timing[2] = comma_separated_timing(day_frequency, 31, 1)
-          when 1.month..12.months
-            month_frequency = (@time / 30  / 24 / 60 / 60).round
+          when Whenever.seconds(1, :month)...Whenever.seconds(1, :year)
+            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] = if @at.is_a?(Time)
               day_given? ? @at.day : 1
             else
-              @at.zero? ? 1 : @at
+              @at == 0 ? 1 : range_or_integer(@at, 1..31, 'Day')
             end
             timing[3] = comma_separated_timing(month_frequency, 12, 1)
+          when Whenever.seconds(1, :year)
+            timing[0] = @at.is_a?(Time) ? @at.min  : 0
+            timing[1] = @at.is_a?(Time) ? @at.hour : 0
+            timing[2] = if @at.is_a?(Time)
+              day_given? ? @at.day : 1
+            else
+              1
+            end
+            timing[3] = if @at.is_a?(Time)
+              day_given? ? @at.month : 1
+            else
+              @at == 0 ? 1 : range_or_integer(@at, 1..12, 'Month')
+            end
           else
             return parse_as_string
         end
@@ -125,15 +143,26 @@ module Whenever
         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|
+        DAYS.each_with_index do |day, i|
           return (timing << i) * " " if string.downcase.index(day)
         end
 
-        raise ArgumentError, "Couldn't parse: #{@time}"
+        raise ArgumentError, "Couldn't parse: #{@time.inspect}"
+      end
+
+      def range_or_integer(at, valid_range, name)
+        must_be_between = "#{name} must be between #{valid_range.min}-#{valid_range.max}"
+        if at.is_a?(Range)
+          raise ArgumentError, "#{must_be_between}, #{at.min} given" unless valid_range.include?(at.min)
+          raise ArgumentError, "#{must_be_between}, #{at.max} given" unless valid_range.include?(at.max)
+          return "#{at.min}-#{at.max}"
+        end
+        raise ArgumentError, "#{must_be_between}, #{at} given" unless valid_range.include?(at)
+        at
       end
 
       def comma_separated_timing(frequency, max, start = 0)
-        return start     if frequency.blank? || frequency.zero?
+        return start     if frequency.nil? || frequency == "" || frequency.zero?
         return '*'       if frequency == 1
         return frequency if frequency > (max * 0.5).ceil
 

data/lib/whenever/job.rb

@@ -2,25 +2,24 @@ require 'shellwords'
 
 module Whenever
   class Job
-    attr_reader :at, :roles
+    attr_reader :at, :roles, :mailto
 
     def initialize(options = {})
       @options = options
-      @at                      = options.delete(:at)
-      @template                = options.delete(:template)
-      @job_template            = options.delete(:job_template) || ":job"
-      @roles                   = Array.wrap(options.delete(:roles))
-      @options[:output]        = options.has_key?(:output) ? Whenever::Output::Redirection.new(options[:output]).to_s : ''
-      @options[:environment] ||= :production
-      @options[:path]          = Shellwords.shellescape(@options[:path] || Whenever.path)
+      @at                               = options.delete(:at)
+      @template                         = options.delete(:template)
+      @mailto                           = options.fetch(:mailto, :default_mailto)
+      @job_template                     = options.delete(:job_template) || ":job"
+      @roles                            = Array(options.delete(:roles))
+      @options[:output]                 = options.has_key?(:output) ? Whenever::Output::Redirection.new(options[:output]).to_s : ''
+      @options[:environment_variable] ||= "RAILS_ENV"
+      @options[:environment]          ||= :production
+      @options[:path]                   = Shellwords.shellescape(@options[:path] || Whenever.path)
     end
 
     def output
-      job = process_template(@template, @options).strip
-      out = process_template(@job_template, { :job => job }).strip
-      if out =~ /\n/
-        raise ArgumentError, "Task contains newline"
-      end
+      job = process_template(@template, @options)
+      out = process_template(@job_template, @options.merge(:job => job))
       out.gsub(/%/, '\%')
     end
 
@@ -42,7 +41,7 @@ module Whenever
         else
           option
         end
-      end
+      end.gsub(/\s+/m, " ").strip
     end
 
     def escape_single_quotes(str)