adg-whenever 0.2.2

data/lib/job_list.rb

@@ -0,0 +1,144 @@
+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]
+            @filename = options[:file]
+            file_read = File.read(@filename)
+          end
+      end
+      
+      if file_read
+        eval(ERB.new(file_read).result(binding))
+      else
+        eval(config)
+      end
+    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
+
+    def scheduled_jobs
+      @scheduled_jobs ||= begin
+        returning scheduled = [] do
+          @jobs.each do |time, jobs|
+            jobs.each do |j|
+              scheduled << ScheduledJob.new(j, time)
+            end
+          end
+        end
+      end
+    end
+
+    def schedule_for_task(task)
+      scheduled_job = scheduled_job_for_task(task)
+      scheduled_job ? scheduled_job.schedule : "Schedule for #{task} not found"
+    end
+
+    def schedule_data_for_task(task)
+      if scheduled_job = scheduled_job_for_task(task)
+        scheduled_job.schedule_data
+      end
+    end
+
+    # Expect arguments in form:
+    # - task: "Otl::Eirb::ProtocolJob" # => class name as string
+    # - schedule: {"interval"=>"days", "frequency"=>"2", "at"=>"10:00pm"}
+    def update_schedule_for_task(task, schedule)
+      lines = File.readlines(@filename)
+      lines.each_with_index do |line, i|
+        if line.include?(task)
+          j = i - 1
+          until lines[j] =~ /^every/
+            j -= 1
+          end
+          lines[j] = "every #{schedule['frequency']}.#{schedule['interval']}, :at => '#{schedule['at']}' do\n"
+          File.open(@filename, 'w') do |f|
+            lines.each do |line|
+              f.write(line)
+            end
+          end
+        end
+      end
+      scheduled_job_for_task(task)
+    end
+
+    def scheduled_job_for_task(task)
+      scheduled_jobs.detect { |sj| sj.task =~ Regexp.new(task) }
+    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,117 @@
+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
+        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 << 'mon-fri') * " " if string.downcase.index('weekday')
+        return (timing << 'sat,sun') * " " if string.downcase.index('weekend')
+
+        %w(sun mon tue wed thu fri sat).each do |day|
+          return (timing << 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,9 @@
+module Whenever
+  module VERSION #:nodoc:
+    MAJOR = 0
+    MINOR = 2
+    TINY  = 2
+
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+end unless defined?(Whenever::VERSION)

data/lib/whenever.rb

@@ -0,0 +1,27 @@
+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 
+scheduled_job 
+}.each { |file| require	File.expand_path(File.dirname(__FILE__) + "/#{file}") }

data/test/command_line_test.rb

@@ -0,0 +1,107 @@
+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 unindent(output).chomp, @command.send(:whenever_cron).chomp
+    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 unindent(new_cron).chomp, @command.send(:updated_crontab).chomp
+      
+      @command.expects(:write_crontab).with(unindent(new_cron)).returns(true)
+      assert @command.run
+    end
+    
+    should "replace an existing block if the identifier matches" do
+      existing = <<-existing
+      # 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
+      @command.expects(:read_crontab).at_least_once.returns(unindent(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 unindent(new_cron).chomp, @command.send(:updated_crontab).chomp
+      
+      @command.expects(:write_crontab).with(unindent(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
+  
+private
+  
+  def unindent(string)
+    indentation = string[/\A\s*/]
+    string.strip.gsub(/^#{indentation}/, "")
+  end
+  
+end