chrono_trigger 0.1.7

data/History.txt

@@ -0,0 +1,13 @@
+== 0.0.4 2009-04-09
+* 1 enhancement
+  * Added chrono_trigger binary and supporting files
+
+== 0.0.2 2009-04-02
+
+* 1 minor enhancement:
+  * Updated to add tasks file
+
+== 0.0.1 2009-04-02
+
+* 1 major enhancement:
+  * Initial release

data/Manifest.txt

@@ -0,0 +1,24 @@
+History.txt
+Manifest.txt
+PostInstall.txt
+README.rdoc
+Rakefile
+bin/chrono_trigger
+lib/chrono_trigger.rb
+lib/chrono_trigger/cron_entry.rb
+lib/chrono_trigger/process.rb
+lib/chrono_trigger/runner.rb
+lib/chrono_trigger/shell.rb
+lib/chrono_trigger/tasks.rb
+lib/chrono_trigger/trigger.rb
+lib/triggers/test_triggers.rb
+script/console
+script/destroy
+script/generate
+tasks/chrono_trigger.rake
+test/test_chrono_trigger.rb
+test/test_cron_entry.rb
+test/test_helper.rb
+test/test_shell.rb
+test/test_trigger.rb
+test/triggers.rb

data/PostInstall.txt

@@ -0,0 +1 @@
+

data/README.rdoc

@@ -0,0 +1,59 @@
+= chrono_trigger
+
+This is a branch of http://github.com/gregfitz23/chrono_trigger/tree/master as it hasn't been updated in sometime.
+New code can be found at https://github.com/darful/chrono_trigger.
+
+== DESCRIPTION:
+
+A cron framework for defining cron tasks using a readable DSL.
+
+== FEATURES/PROBLEMS:
+
+== SYNOPSIS:
+
+Create trigger files directory.
+Triggers should follow the pattern:
+
+	trigger "name" do
+		runs { code to execute }
+		on  :monday
+		every :minutes=>10
+		at :hour=>9, :minute=>[30,50]
+	end
+Run `chrono_trigger -t{full path to trigger file}`.
+Other available options are:
+ * -a - Specify an application context for the triggers to run against.
+ * -e - Specify the environment the triggers should run against
+
+== REQUIREMENTS:
+
+*  ActiveSupport >= 2.0.2
+
+== INSTALL:
+
+* sudo gem install chrono_trigger
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2009 FIXME full name
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,50 @@
+%w[rubygems rake rake/clean fileutils newgem rubigen rake/testtask].each { |f| require f }
+require File.dirname(__FILE__) + '/lib/chrono_trigger'
+
+## Generate all the Rake tasks
+## Run 'rake -T' to see list of generated tasks (from gem root directory)
+# $hoe = Hoe.new('chrono_trigger', ChronoTrigger::VERSION) do |p|
+#   p.developer('Greg Fitzgerald', 'fitzgerald@healthcentral.com')
+#   p.changes              = p.paragraphs_of("History.txt", 0..1).join("\n\n")
+#   # p.post_install_message = 'PostInstall.txt' # TODO remove if post-install message not required
+#   p.rubyforge_name       = "gregfitz23-chrono_trigger"
+#   p.extra_deps         = [
+# #    ['activesupport','>= 2.0.2'],
+#   ]
+#   p.extra_dev_deps = [
+#     ['newgem', ">= #{::Newgem::VERSION}"],
+#     ['thoughtbot_shoulda', ">= 2.0.6"]
+#   ]
+#   
+#   p.clean_globs |= %w[**/.DS_Store tmp *.log]
+#   path = (p.rubyforge_name == p.name) ? p.rubyforge_name : "\#{p.rubyforge_name}/\#{p.name}"
+#   p.remote_rdoc_dir = File.join(path.gsub(/^#{p.rubyforge_name}\/?/,''), 'rdoc')
+#   p.rsync_args = '-av --delete --ignore-errors'
+# end
+# 
+# require 'newgem/tasks' # load /tasks/*.rake
+# Dir['tasks/**/*.rake'].each { |t| load t }
+# 
+# # TODO - want other tests/tasks run by default? Add them to the list
+# task :default => [:spec, :features]
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+end
+
+desc "Run tests"
+task :default => :test
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |s|
+    s.name = "chrono_trigger"
+    s.summary = "TODO"
+    s.email = "darful@gmail.com"
+    s.homepage = ""
+    s.description = "TODO"
+    s.authors = ["Jon Ciccone"]
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:major: 0
+:minor: 1
+:patch: 7

data/bin/chrono_trigger

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+
+require 'chrono_trigger/runner'
+
+ChronoTrigger::Runner.run
+

data/chrono_trigger.gemspec

@@ -0,0 +1,69 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE
+# Instead, edit Jeweler::Tasks in Rakefile, and run `rake gemspec`
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = "chrono_trigger"
+  s.version = "0.1.7"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Jon Ciccone"]
+  s.date = "2012-08-22"
+  s.description = "Binding to tag"
+  s.email = "darful@gmail.com"
+  s.executables = ["chrono_trigger"]
+  s.extra_rdoc_files = [
+    "README.rdoc"
+  ]
+  s.files = [
+    "History.txt",
+     "Manifest.txt",
+     "PostInstall.txt",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION.yml",
+     "bin/chrono_trigger",
+     "chrono_trigger.gemspec",
+     "lib/chrono_trigger.rb",
+     "lib/chrono_trigger/cron_entry.rb",
+     "lib/chrono_trigger/process.rb",
+     "lib/chrono_trigger/runner.rb",
+     "lib/chrono_trigger/shell.rb",
+     "lib/chrono_trigger/tasks.rb",
+     "lib/chrono_trigger/trigger.rb",
+     "lib/tasks/chrono_trigger.rake",
+     "lib/triggers/test_triggers.rb",
+     "script/console",
+     "script/destroy",
+     "script/generate",
+     "test/test_chrono_trigger.rb",
+     "test/test_cron_entry.rb",
+     "test/test_helper.rb",
+     "test/test_shell.rb",
+     "test/test_trigger.rb",
+     "test/triggers.rb"
+  ]
+  s.homepage = ""
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = "1.8.24"
+  s.summary = "binding to tag"
+  s.test_files = [
+    "test/test_chrono_trigger.rb",
+     "test/test_cron_entry.rb",
+     "test/test_helper.rb",
+     "test/test_shell.rb",
+     "test/test_trigger.rb",
+     "test/triggers.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end

data/lib/chrono_trigger.rb

@@ -0,0 +1,11 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+module ChronoTrigger
+  VERSION = '0.0.2'
+end
+
+require "activesupport" unless defined? ActiveSupport
+require "chrono_trigger/shell"
+require "chrono_trigger/trigger"
+require "chrono_trigger/cron_entry"

data/lib/chrono_trigger/cron_entry.rb

@@ -0,0 +1,71 @@
+module ChronoTrigger
+  
+  class CronEntry
+   
+    def initialize(options={})
+      set_days(options[:days])
+      set_hours(options[:hours])
+      set_minutes(options[:minutes])
+    end
+
+    DAYS_CONVERSION = {
+      :sunday     => 0,
+      :monday     => 1,
+      :tuesday    => 2,
+      :wednesday  => 3,
+      :thursday   => 4,
+      :friday     => 5,
+      :saturday   => 6
+    }
+    
+    CALENDAR_DAYS = *(1..31)
+    
+    def set_hours(*args)
+      args.compact!
+      args.flatten!
+      raise ChronoTrigger::ConfigurationException.new("Hours must be less than 24") if args.any? {|hour| hour >= 24}
+      @hours = args
+    end
+    
+    def set_days(*args)
+      args.compact!
+      args.flatten!
+      args.each {|day| raise ChronoTrigger::ConfigurationException.new("Day #{day} setting is invalid") if !DAYS_CONVERSION.keys.include?(day)}
+      @days = args.map { |day| DAYS_CONVERSION[day] }
+    end
+
+    def set_minutes(*args)
+      args.compact!
+      args.flatten!
+      raise ChronoTrigger::ConfigurationException.new("Minutes must be less than 60") if args.any? {|minute| minute >= 60}      
+      @minutes = args
+    end
+    
+    def set_calendar_days(*args)
+      args.compact!
+      args.flatten!
+      args.each {|calendar_day| raise ChronoTrigger::ConfigurationException.new("Calendar Day #{calendar_day} setting is invalid") if !CALENDAR_DAYS.include?(calendar_day)}
+      @calendar_days = args
+    end 
+
+    def matches?(datetime)
+      if @minutes.blank? && !@days.blank?
+        raise ChronoTrigger::ConfigurationException.new("Days were specified for a CronEntry with no minutes specified") 
+      end
+      
+      if (@minutes.blank? || @hours.blank?) && !@calendar_days.blank?
+        raise ChronoTrigger::ConfigurationException.new("Calendar Days were specified for a CronEntry with no minutes and/or no hours specified")  
+      end
+
+      if !@days.blank? && !@calendar_days.blank?
+        raise ChronoTrigger::ConfigurationException.new("Calendar Days and Days were specified.  This is unsupported.")    
+      end
+      
+      return false if !@minutes.blank? && !@minutes.include?(datetime.min)
+      return false if !@hours.blank? && !@hours.include?(datetime.hour)
+      return false if (!@days.blank? && !@days.include?(datetime.wday)) || (!@calendar_days.blank? && !@calendar_days.include?(datetime.day))
+      return true
+    end
+
+  end
+end

data/lib/chrono_trigger/process.rb

@@ -0,0 +1,37 @@
+module ChronoTrigger
+  
+  class Process
+
+    def run(options={})
+      @t = Thread.new do
+        setup(options)
+        
+        shell = ChronoTrigger::Shell.new
+        options[:trigger_files] ? shell.load_triggers(options[:trigger_files].split(":")) : shell.load_triggers 
+        loop do
+          shell.execute_triggers
+          sleep 1.minute.to_i
+        end
+      end
+      
+      @t.join
+    end
+    
+    def stop
+      @t.exit
+    end
+    
+    private
+    def setup(options={})
+      if application_context = options[:application_context]
+        ENV['RAILS_ENV'] = options[:env] || "development"
+        
+        application_path = File.join(application_context, 'config', 'environment')
+        STDOUT.puts "Loading application environment at #{File.join(application_context, 'config', 'environment')} for '#{ENV['RAILS_ENV']}' enviroment."
+        require(application_path)              
+      end
+      
+      require "chrono_trigger"
+    end
+  end    
+end

data/lib/chrono_trigger/runner.rb

@@ -0,0 +1,292 @@
+require File.join(File.dirname(__FILE__), 'process')
+require "logger"
+require 'optparse'
+require 'yaml'
+
+module ChronoTrigger
+  class Runner
+
+    attr_accessor :options
+    private :options, :options=
+
+    def self.run
+      new
+    end
+    
+    def self.shutdown
+      @@instance.shutdown
+    end
+
+    def initialize
+      @@instance = self
+      parse_options
+
+      @process = ProcessHelper.new(options[:logger], options[:pid_file], options[:user], options[:group])
+
+      if options[:stop]
+        @process.kill 
+        exit(1) 
+      end
+
+      pid = @process.running?
+      if pid
+        if options[:force]
+          STDOUT.puts "Shutting down existing ChronoTrigger."
+          @process.kill
+          @process = ProcessHelper.new(options[:logger], options[:pid_file], options[:user], options[:group])
+        else
+          STDERR.puts "There is already a ChronoTrigger process running (pid #{pid}), exiting."
+          exit(1)
+        end
+      elsif pid.nil?
+        STDERR.puts "Cleaning up stale pidfile at #{options[:pid_file]}."
+      end
+
+      start
+    end
+
+    def parse_options
+      self.options =  { 
+                       :log_level => Logger::INFO,
+                       :daemonize => false,
+                       :pid_file => File.join('', 'var', 'run', 'chrono_trigger.pid'),
+                       :env => "development"
+                      }
+
+      OptionParser.new do |opts|
+        opts.summary_width = 25
+
+        opts.banner = "ChronoTrigger - Execute cron jobs within the context of a Rails application\n\n",
+                      "usage: chrono_trigger [options...]\n",
+                      "       chrono_trigger --help\n",
+                      "       chrono_trigger --version\n"
+
+        opts.separator ""
+        opts.separator ""; opts.separator "ChronoTrigger Options:"
+        
+        opts.on("-tTRIGGER_FILES", "--triggers TRIGGER_FILES", "Path to file(s) specifying triggers to be executed.  Multiple files should be separated by a :.  When also specifying -a, this path will be relative to the application path") do |trigger_files|
+          options[:trigger_files] = trigger_files
+        end
+        
+        opts.on("-f", "--force", "Force restart of ChronoTrigger process (can be used in conjunction with -P).") do
+          options[:force] = true
+        end
+        
+        opts.on("-s", "--stop", "Stop a currently running ChronoTrigger process (can be used in conjunction with -P).") do
+          options[:stop] = true
+        end
+        
+        opts.separator ""
+        opts.separator ""; opts.separator "Rails options:"
+        
+        opts.on("-aAPPLICATION", "--application RAILS", "Path to Rails application context to execture triggers in.") do |application_context|
+          options[:application_context]  = application_context
+        end
+        
+        opts.on("-eENVIRONMENT", "--environment ENVIRONMENT", "Rails environment to execute triggers in.") do |environment|
+          options[:env] = environment
+        end
+        
+        opts.separator ""
+        opts.separator ""; opts.separator "Process:"
+
+        opts.on("-PFILE", "--pid FILENAME", "save PID in FILENAME when using -d option.", "(default: #{options[:pid_file]})") do |pid_file|
+          options[:pid_file] = File.expand_path(pid_file)
+        end
+
+        opts.on("-u", "--user USER", "User to run as") do |user|
+          options[:user] = user.to_i == 0 ? Etc.getpwnam(user).uid : user.to_i
+        end
+
+        opts.on("-gGROUP", "--group GROUP", "Group to run as") do |group|
+          options[:group] = group.to_i == 0 ? Etc.getgrnam(group).gid : group.to_i
+        end
+
+        opts.separator ""; opts.separator "Logging:"
+
+        opts.on("-L", "--log [FILE]", "Path to print debugging information.") do |log_path|
+          options[:logger] = File.expand_path(log_path)
+        end
+
+        opts.on("-v", "Increase logging verbosity (may be used multiple times).") do
+          options[:log_level] -= 1
+        end
+
+        opts.on("-d", "Run as a daemon.") do
+          options[:daemonize] = true
+        end
+      end.parse!
+    end
+
+    def start
+      drop_privileges
+
+      @process.daemonize if options[:daemonize]
+
+      if application_context = options[:application_context]
+        Dir.chdir(application_context)
+      end
+      
+      setup_signal_traps
+      @process.write_pid_file
+
+      STDOUT.puts "Starting ChronoTrigger."
+      @chrono_trigger_process = ChronoTrigger::Process.new
+      @chrono_trigger_process.run(options)
+
+      @process.remove_pid_file
+    end
+
+    def drop_privileges
+      ::Process.egid = options[:group] if options[:group]
+      ::Process.euid = options[:user] if options[:user]
+    end
+
+    def shutdown
+      begin
+        STDOUT.puts "Shutting down."
+        @chrono_trigger_process.stop
+        exit(1)
+      rescue Object => e
+        STDERR.puts "There was an error shutting down: #{e}"
+        exit(70)
+      end
+    end
+
+    def setup_signal_traps
+      Signal.trap("INT") { shutdown }
+      Signal.trap("TERM") { shutdown }
+    end
+  end
+
+  class ProcessHelper
+
+    def initialize(log_file = nil, pid_file = nil, user = nil, group = nil)
+      @log_file = log_file
+      @pid_file = pid_file
+      @user = user
+      @group = group
+    end
+
+    def safefork
+      begin
+        if pid = fork
+          return pid
+        end
+      rescue Errno::EWOULDBLOCK
+        sleep 5
+        retry
+      end
+    end
+
+    def daemonize
+      sess_id = detach_from_terminal
+      exit if pid = safefork
+
+      Dir.chdir("/")
+      File.umask 0000
+
+      close_io_handles
+      redirect_io
+
+      return sess_id
+    end
+
+    def detach_from_terminal
+      srand
+      safefork and exit
+
+      unless sess_id = ::Process.setsid
+        raise "Couldn't detach from controlling terminal."
+      end
+
+      trap 'SIGHUP', 'IGNORE'
+
+      sess_id
+    end
+
+    def close_io_handles
+      ObjectSpace.each_object(IO) do |io|
+        unless [STDIN, STDOUT, STDERR].include?(io)
+          begin
+            io.close unless io.closed?
+          rescue Exception
+          end
+        end
+      end
+    end
+
+    def redirect_io
+      begin; STDIN.reopen('/dev/null'); rescue Exception; end
+
+      if @log_file
+        begin
+          STDOUT.reopen(@log_file, "a")
+          STDOUT.sync = true
+        rescue Exception
+          begin; STDOUT.reopen('/dev/null'); rescue Exception; end
+        end
+      else
+        begin; STDOUT.reopen('/dev/null'); rescue Exception; end
+      end
+
+      begin; STDERR.reopen(STDOUT); rescue Exception; end
+      STDERR.sync = true
+    end
+
+    def rescue_exception
+      begin
+        yield
+      rescue Exception
+      end
+    end
+
+    def write_pid_file
+      return unless @pid_file
+      FileUtils.mkdir_p(File.dirname(@pid_file))
+      File.open(@pid_file, "w") { |f| f.write(::Process.pid) }
+      File.chmod(0644, @pid_file)
+    end
+
+    def remove_pid_file
+      return unless @pid_file
+      File.unlink(@pid_file) if File.exists?(@pid_file)
+    end
+
+    def running?
+      return false unless @pid_file
+
+      pid = File.read(@pid_file).chomp.to_i rescue nil
+      pid = nil if pid == 0
+      return false unless pid
+
+      begin
+        ::Process.kill(0, pid)
+        return pid
+      rescue Errno::ESRCH
+        return nil
+      rescue Errno::EPERM
+        return pid
+      end
+    end
+    
+    def kill
+      return false unless @pid_file
+
+      pid = File.read(@pid_file).chomp.to_i rescue nil
+      pid = nil if pid == 0
+      return false unless pid
+
+      begin
+        ::Process.kill("TERM", pid)
+        remove_pid_file
+        return pid
+      rescue Errno::ESRCH
+        return nil
+      rescue Errno::EPERM
+        return pid
+      end
+      
+    end
+  end
+end