hybridgroup-whenever 0.39

data/lib/job_list.rb

@@ -0,0 +1,152 @@
+module Whenever
+  class JobList
+  
+    def initialize(options)
+      @jobs = Hash.new
+      @env  = Hash.new
+      
+      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
+
+      eval(config)
+    end
+    
+    def set(variable, value)
+      return if instance_variable_defined?("@#{variable}".to_sym)
+      
+      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, :path => @path).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
+      set_path_environment_variable
+      
+      [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('=')
+        set(variable.strip, value.strip) unless variable.blank? || value.blank?
+      end
+    end
+    
+    def set_path_environment_variable
+      return if path_should_not_be_set_automatically?
+      @env[:PATH] = read_path unless read_path.blank?
+    end
+    
+    def read_path
+      ENV['PATH'] if ENV
+    end
+    
+    def path_should_not_be_set_automatically?
+      @set_path_automatically === false || @env[:PATH] || @env["PATH"]
+    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?
+      
+      output = []
+      @jobs.each do |time, jobs|
+        jobs.each do |job|
+          Whenever::Output::Cron.output(time, job) do |cron|
+            cron << " >> #{job.cron_log} 2>&1" if job.cron_log 
+            cron << "\n\n"
+            output << cron
+          end
+        end
+      end
+      
+      combine(output).join
+    end
+    
+  end
+end

data/lib/job_types/default.rb

@@ -0,0 +1,48 @@
+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
+        @lockrun     = options[:lockrun]
+      end
+    
+      def output
+        output = wrap_task(task)
+        if @lockrun
+          lockrunify output
+        else
+          output
+        end
+      end
+
+    protected
+      
+      def path_required
+        raise ArgumentError, "No path available; set :path, '/your/path' in your schedule file" if @path.blank?
+      end
+
+      def wrap_task(task)
+        task
+      end
+
+      def lockrunify(output)
+        path_required
+        %Q{/usr/bin/env lockrun --lockfile=#{lockfile_path} -- sh -c '#{output}'}
+      end
+
+      def lockfile_path
+        path_required
+        filename_prefix = @lockrun == true ? "default" : @lockrun
+        "#{@path}/log/#{filename_prefix}.lockrun"
+      end
+      
+    end
+  end
+end

data/lib/job_types/rake_task.rb

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

data/lib/job_types/runner.rb

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

data/lib/outputs/cron.rb

@@ -0,0 +1,131 @@
+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|
+            out = new(time, job.output, at)
+            yield "#{out.time_in_cron_syntax} #{out.task}"
+          end
+        end
+      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 > 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)
+          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/version.rb

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

data/lib/whenever.rb

@@ -0,0 +1,36 @@
+unless defined?(Whenever)
+  $:.unshift(File.dirname(__FILE__))
+   
+  # Hoping to load Rails' Rakefile
+  begin
+    load 'Rakefile'
+  rescue LoadError => e
+    nil
+  end
+end
+
+require 'chronic'
+
+# If Rails' rakefile was loaded than so was activesupport, but
+# if this is being used in a non-rails enviroment we need to require it.
+# It was previously defined as a dependency of this gem, but that became
+# problematic. See: http://github.com/javan/whenever/issues#issue/1
+begin
+  require 'active_support'
+rescue LoadError => e
+  warn 'To user Whenever you need the activesupport gem:'
+  warn '$ sudo gem install activesupport'
+  exit(1)
+end
+
+# Whenever files
+%w{ 
+base 
+version 
+job_list 
+job_types/default 
+job_types/rake_task 
+job_types/runner 
+outputs/cron
+command_line 
+}.each { |file| require	File.expand_path(File.dirname(__FILE__) + "/#{file}") }

data/test/command_line_test.rb

@@ -0,0 +1,101 @@
+require File.expand_path(File.dirname(__FILE__) + "/test_helper")
+
+class CommandLineTest < Test::Unit::TestCase
+  
+  context "A command line write" do
+    setup do
+      File.expects(:exists?).with('config/schedule.rb').returns(true)
+      @command = Whenever::CommandLine.new(:write => true, :identifier => 'My identifier')
+      @task = "#{two_hours} /my/command"
+      Whenever.expects(:cron).returns(@task)
+    end
+
+    should "output the cron job with identifier blocks" do
+      output = <<-EXPECTED
+# Begin Whenever generated tasks for: My identifier
+#{@task}
+# End Whenever generated tasks for: My identifier
+EXPECTED
+      
+      assert_equal output, @command.send(:whenever_cron)
+    end
+    
+    should "write the crontab when run" do
+      @command.expects(:write_crontab).returns(true)
+      assert @command.run
+    end
+  end
+  
+  context "A command line update" do
+    setup do
+      File.expects(:exists?).with('config/schedule.rb').returns(true)
+      @command = Whenever::CommandLine.new(:update => true, :identifier => 'My identifier')
+      @task = "#{two_hours} /my/command"
+      Whenever.expects(:cron).returns(@task)
+    end
+
+    should "add the cron to the end of the file if there is no existing identifier block" do
+      existing = '# Existing crontab'
+      @command.expects(:read_crontab).at_least_once.returns(existing)
+      
+      new_cron = <<-EXPECTED
+#{existing}
+
+# Begin Whenever generated tasks for: My identifier
+#{@task}
+# End Whenever generated tasks for: My identifier
+EXPECTED
+      
+      assert_equal new_cron, @command.send(:updated_crontab)
+      
+      @command.expects(:write_crontab).with(new_cron).returns(true)
+      assert @command.run
+    end
+    
+    should "replace an existing block if the identifier matches" do
+      existing = <<-EXISTING_CRON
+# Something
+
+# Begin Whenever generated tasks for: My identifier
+My whenever job that was already here
+# End Whenever generated tasks for: My identifier
+
+# Begin Whenever generated tasks for: Other identifier
+This shouldn't get replaced
+# End Whenever generated tasks for: Other identifier
+EXISTING_CRON
+
+      @command.expects(:read_crontab).at_least_once.returns(existing)
+      
+      new_cron = <<-NEW_CRON
+# Something
+
+# Begin Whenever generated tasks for: My identifier
+#{@task}
+# End Whenever generated tasks for: My identifier
+
+# Begin Whenever generated tasks for: Other identifier
+This shouldn't get replaced
+# End Whenever generated tasks for: Other identifier
+NEW_CRON
+      
+      assert_equal new_cron, @command.send(:updated_crontab)
+      
+      @command.expects(:write_crontab).with(new_cron).returns(true)
+      assert @command.run
+    end
+  end
+  
+  context "A command line update with no identifier" do
+    setup do
+      File.expects(:exists?).with('config/schedule.rb').returns(true)
+      Whenever::CommandLine.any_instance.expects(:default_identifier).returns('DEFAULT')
+      @command = Whenever::CommandLine.new(:update => true, :file => @file)
+    end
+
+    should "use the default identifier" do
+      assert_equal "Whenever generated tasks for: DEFAULT", @command.send(:comment_base)
+    end
+  end
+  
+end