whenever-benlangfeld 0.9.5

data/Rakefile

@@ -0,0 +1,10 @@
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |test|
+  test.libs      << 'lib' << 'test'
+  test.pattern   = 'test/{functional,unit}/**/*_test.rb'
+  test.verbose   = true
+end
+
+task :default => :test

data/bin/whenever

@@ -0,0 +1,41 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+require 'whenever'
+require 'whenever/version'
+
+options = {}
+
+OptionParser.new do |opts|
+  opts.banner = "Usage: whenever [options]"
+  opts.on('-i', '--update-crontab [identifier]', 'Default: full path to schedule.rb file') do |identifier|
+    options[:update] = true
+    options[:identifier] = identifier if identifier
+  end
+  opts.on('-w', '--write-crontab [identifier]', 'Default: full path to schedule.rb file') do |identifier|
+     options[:write] = true
+     options[:identifier] = identifier if identifier
+  end
+  opts.on('-c', '--clear-crontab [identifier]') do |identifier|
+    options[:clear] = true
+    options[:identifier] = identifier if identifier
+  end
+  opts.on('-s', '--set [variables]', 'Example: --set \'environment=staging&path=/my/sweet/path\'') do |set|
+    options[:set] = set if set
+  end
+  opts.on('-f', '--load-file [schedule file]', 'Default: config/schedule.rb') do |file|
+    options[:file] = file if file
+  end
+  opts.on('-u', '--user [user]', 'Default: current user') do |user|
+    options[:user] = user if user
+  end
+  opts.on('-k', '--cut [lines]', 'Cut lines from the top of the cronfile') do |lines|
+    options[:cut] = lines.to_i if lines
+  end
+  opts.on('-r', '--roles [role1,role2]', 'Comma-separated list of server roles to generate cron jobs for') do |roles|
+    options[:roles] = roles.split(',').map(&:to_sym) if roles
+  end
+  opts.on('-v', '--version') { puts "Whenever v#{Whenever::VERSION}"; exit(0) }
+end.parse!
+
+Whenever::CommandLine.execute(options)

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.exist?(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.exist?(file)
+  warn "[skip] `#{file}' already exists"
+elsif File.exist?(file.downcase)
+  warn "[skip] `#{file.downcase}' exists, which could conflict with `#{file}'"
+elsif !File.exist?(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/gemfiles/activesupport4.1.gemfile

@@ -0,0 +1,5 @@
+source "https://rubygems.org"
+
+gem "activesupport", "~> 4.1.0"
+
+gemspec path: "../"

data/gemfiles/activesupport4.2.gemfile

@@ -0,0 +1,5 @@
+source "https://rubygems.org"
+
+gem "activesupport", "~> 4.2.0"
+
+gemspec path: "../"

data/lib/whenever.rb

@@ -0,0 +1,34 @@
+require 'whenever/numeric'
+require 'whenever/numeric_seconds'
+require 'whenever/job_list'
+require 'whenever/job'
+require 'whenever/command_line'
+require 'whenever/cron'
+require 'whenever/output_redirection'
+require 'whenever/os'
+
+module Whenever
+  def self.cron(options)
+    Whenever::JobList.new(options).generate_cron_output
+  end
+
+  def self.seconds(number, units)
+    Whenever::NumericSeconds.seconds(number, units)
+  end
+
+  def self.path
+    Dir.pwd
+  end
+
+  def self.bin_rails?
+    File.exist?(File.join(path, 'bin', 'rails'))
+  end
+
+  def self.script_rails?
+    File.exist?(File.join(path, 'script', 'rails'))
+  end
+
+  def self.bundler?
+    File.exist?(File.join(path, 'Gemfile'))
+  end
+end

data/lib/whenever/capistrano.rb

@@ -0,0 +1,7 @@
+require 'capistrano/version'
+
+if defined?(Capistrano::VERSION) && Gem::Version.new(Capistrano::VERSION).release >= Gem::Version.new('3.0.0')
+  load File.expand_path("../tasks/whenever.rake", __FILE__)
+else
+  require 'whenever/capistrano/v2/hooks'
+end

data/lib/whenever/capistrano/v2/hooks.rb

@@ -0,0 +1,8 @@
+require "whenever/capistrano/v2/recipes"
+
+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"
+end

data/lib/whenever/capistrano/v2/recipes.rb

@@ -0,0 +1,48 @@
+require 'whenever/capistrano/v2/support'
+
+Capistrano::Configuration.instance(:must_exist).load do
+  Whenever::CapistranoSupport.load_into(self)
+
+  _cset(:whenever_roles)        { :db }
+  _cset(:whenever_options)      { {:roles => fetch(:whenever_roles)} }
+  _cset(:whenever_command)      { "whenever" }
+  _cset(:whenever_identifier)   { fetch :application }
+  _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}" }
+
+  namespace :whenever do
+    desc "Update application's crontab entries using Whenever"
+    task :update_crontab do
+      args = {
+        :command => fetch(:whenever_command),
+        :flags   => fetch(:whenever_update_flags),
+        :path    => fetch(:latest_release)
+      }
+
+      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
+          args = whenever_prepare_for_rollback(args)
+          whenever_run_commands(args)
+        end
+      end
+    end
+
+    desc "Clear application's crontab entries using Whenever"
+    task :clear_crontab do
+      if whenever_servers.any?
+        args = {
+          :command => fetch(:whenever_command),
+          :flags   => fetch(:whenever_clear_flags),
+          :path    => fetch(:latest_release)
+        }
+
+        whenever_run_commands(args)
+      end
+    end
+  end
+end

data/lib/whenever/capistrano/v2/support.rb

@@ -0,0 +1,53 @@
+module Whenever
+  module CapistranoSupport
+    def self.load_into(capistrano_configuration)
+      capistrano_configuration.load do
+
+        def whenever_options
+          fetch(:whenever_options)
+        end
+
+        def whenever_roles
+          Array(whenever_options[:roles])
+        end
+
+        def whenever_servers
+          find_servers(whenever_options)
+        end
+
+        def whenever_server_roles
+          whenever_servers.inject({}) do |map, server|
+            map[server] = role_names_for_host(server) & whenever_roles
+            map
+          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"
+          end
+
+          whenever_server_roles.each do |server, roles|
+            roles_arg = roles.empty? ? "" : " --roles #{roles.join(',')}"
+
+            command = "cd #{args[:path]} && #{args[:command]} #{args[:flags]}#{roles_arg}"
+            run command, whenever_options.merge(:hosts => server)
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+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 release_path do
+        with rails_env: fetch(:whenever_environment) do
+          with fetch(:whenever_command_environment_variables) do
+            execute *args_for_host
+          end
+        end
+      end
+    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}"]
+    end
+  end
+
+  desc "Clear application's crontab entries using Whenever"
+  task :clear_crontab do
+    setup_whenever_task(fetch(:whenever_clear_flags))
+  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, ->{ {} }
+    set :whenever_identifier,   ->{ fetch :application }
+    set :whenever_environment,  ->{ fetch :rails_env, fetch(:stage, "production") }
+    set :whenever_variables,    ->{ "environment=#{fetch :whenever_environment}" }
+    set :whenever_update_flags, ->{ "--update-crontab #{fetch :whenever_identifier} --set #{fetch :whenever_variables}" }
+    set :whenever_clear_flags,  ->{ "--clear-crontab #{fetch :whenever_identifier}" }
+  end
+end

data/lib/whenever/command_line.rb

@@ -0,0 +1,135 @@
+require 'fileutils'
+
+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
+
+      if !File.exist?(@options[:file]) && @options[:clear].nil?
+        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)
+      command = ['crontab']
+      command << "-u #{@options[:user]}" if @options[:user]
+      # 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
+
+      success = $?.exitstatus.zero?
+
+      if success
+        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