clockworkd 0.2.5

data/MIT-LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) 2011 Artem Rufanov
+
+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/README

@@ -0,0 +1,89 @@
+Clockworkd - a clock process to replace cron
+============================================
+
+Cron is non-ideal for running scheduled application tasks, especially in an app
+deployed to multiple machines.  [More details.](http://adam.heroku.com/past/2010/4/13/rethinking_cron/)
+
+Clockworkd is a cron replacement.  It runs as a lightweight, long-running Ruby
+process which sits alongside your web processes (Mongrel/Thin) and your worker
+processes (DJ/Resque/Minion/Stalker) to schedule recurring work at particular
+times or dates.  For example, refreshing feeds on an hourly basis, or send
+reminder emails on a nightly basis, or generating invoices once a month on the
+1st.
+
+Quickstart
+=======
+
+Configure application:
+
+  In your Gemfile gem "clockworkd", ">= 0.2.5"
+  Run generator to generate config yml and script file
+  Use config/initiaizers to configure options for this gem
+
+
+Modify clockworkd.yml:
+
+    # Run job every two minute: */2 * * * *
+    clear_sesssion_job:
+      cron: "59 1 * * *"
+      block: Delayed::Job.enqueue ClearSessionsJob.new
+      description: "This job clear sessions table"
+
+Run it as console or daemon application (rails 3.x):
+
+    $ ruby script/clockworkd run
+    $ ruby script/clockworkd --identifier=0 start
+
+Use clockworkd with capistrano:
+
+    after "deploy:stop",    "clockworkd:stop"
+    after "deploy:start",   "clockworkd:start"
+    after "deploy:restart", "clockworkd:restart"
+
+Use monit script to monitor it:
+
+    check process clockworkd
+      with pidfile /var/www/apps/{app_name}/shared/pids/clockworkd.pid
+      start program = "/usr/bin/env RAILS_ENV=production /var/www/apps/{app_name}/current/script/clockworkd start"
+      stop program = "/usr/bin/env RAILS_ENV=production /var/www/apps/{app_name}/current/script/clockworkd stop"
+
+
+
+In production
+=======
+
+Only one clock process should ever be running across your whole application
+deployment.  For example, if your app is running on three VPS machines (two app
+servers and one database), your app machines might have the following process
+topography:
+
+* App server 1: 3 web (thin start), 3 workers (rake jobs:work), 1 clock (clockwork clock.rb)
+* App server 2: 3 web (thin start), 3 workers (rake jobs:work)
+
+You should use Monit, God, Upstart, or Inittab to keep your clock process
+running the same way you keep your web and workers running.
+
+Meta
+=======
+
+Inspired by
+
+* [clockwork] (http://github.com/adamwiggins/clockwork)
+* [delayed_job] (https://github.com/collectiveidea/delayed_job)
+* [rufus-scheduler](http://rufus.rubyforge.org/rufus-scheduler/)
+* [resque-scehduler] (http://github.com/bvandenbos/resque-scheduler)
+
+
+Installation
+=======
+
+* Type 'gem install --local clockworkd' with root account if you have installed RubyGems.
+
+
+Example
+=======
+
+Example goes here.
+
+Copyright (c) 2011 arufanov, released under the MIT license.
+

data/Rakefile

@@ -0,0 +1,22 @@
+require 'jeweler'
+
+Jeweler::Tasks.new do |s|
+	s.name = "clockworkd"
+	s.summary = "A scheduler process to replace cron."
+	s.description = "A scheduler process to replace cron, using a more flexible Ruby syntax running as a single long-running process.  Inspired by rufus-scheduler and resque-scheduler."
+	s.author = "Adam Wiggins"
+	s.email = "adam@heroku.com"
+	s.homepage = "http://github.com/arufanov/clockworkd"
+	s.executables = [ "clockworkd" ]
+	s.rubyforge_project = "clockworkd"
+
+	s.files = FileList["[A-Z]*", "{bin,lib}/**/*"]
+end
+
+Jeweler::GemcutterTasks.new
+
+task 'test' do
+	sh "ruby spec/lib/clockworkd_spec.rb"
+end
+
+task :build => :test

data/VERSION

@@ -0,0 +1 @@
+0.2.5

data/changelog

@@ -0,0 +1,23 @@
+Introduction:
+To see the latest list of the change log please visit the Change Log page at www.majoron.com.
+
+Legend:
+Follow notation is used at change log, roadmap and known bugs. Each bug begins with a version,
+then follow category of the bug inside {}. It can be bug report, feature request and etc.
+Then follow component inside []. After follow bug number at bug tracking system between // signs.
+And then follow a short description of the bug.
+
+Example:
+For example bug: "1.0 { Feature Request } [ AntHill ] / 380 / STLport support required" means
+that bug was created for 1.0 version of the AntHill component, bug is feature request with
+380 number at bug tracking system. And bug requires STLPort support implementation.
+
+ Version 0.2
+ -----------
+0.2 { Bug Report } [ Clockworkd ] / X / Add before_fork & after fork hook to restore ActiveRecord connection after fork
+0.2 { Bug Report } [ Clockworkd ] / X / Support rails 2.5.x
+0.2 { Bug Report } [ Clockworkd ] / X / Generator that install clockwork to script was added
+0.2 { Bug Report } [ Clockworkd ] / X / Capistrano receips was added
+0.2 { Bug Report } [ Clockworkd ] / X / Monit script was added
+0.2 { Bug Report } [ Clockworkd ] / X / Ability to run as daemons was added
+

data/clockworkd.gemspec

@@ -0,0 +1,36 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{clockworkd}
+  s.version = "0.2.5"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Adam Wiggins"]
+  s.date = %q{2011-07-31}
+  s.description = %q{A scheduler process to replace cron, using a more flexible Ruby syntax running as a single long-running process.  Inspired by rufus-scheduler and resque-scheduler.}
+  s.email = %q{adam@heroku.com}
+  s.extra_rdoc_files = [
+    "README"
+  ]
+  s.files = Dir.glob('**/*') - Dir.glob('distrib/**/*') - Dir.glob('lib/api/**/*') - Dir.glob('doc/*.xpr')
+  s.homepage = %q{http://www.majoron.com/project/rbundle/clockworkd}
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{clockworkd}
+  s.rubygems_version = %q{1.5.0}
+  s.summary = %q{A scheduler process to replace cron.}
+  s.test_files = Dir.glob('spec/**/*')
+  s.add_runtime_dependency 'tzinfo', '>= 0.3.23'
+
+  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/contrib/clockworkd.monitrc

@@ -0,0 +1,14 @@
+# an example Monit configuration file for clockworkd
+# See: http://stackoverflow.com/questions/1226302/how-to-monitor-delayedjob-with-monit/1285611
+#
+# To use:
+# 1. copy to /var/www/apps/{app_name}/shared/clockworkd.monitrc
+# 2. replace {app_name} as appropriate
+# 3. add this to your /etc/monit/monitrc
+#
+#   include /var/www/apps/{app_name}/shared/clockworkd.monitrc
+
+check process clockworkd
+  with pidfile /var/www/apps/{app_name}/shared/pids/clockworkd.pid
+  start program = "/usr/bin/env RAILS_ENV=production /var/www/apps/{app_name}/current/script/clockworkd start"
+  stop program = "/usr/bin/env RAILS_ENV=production /var/www/apps/{app_name}/current/script/clockworkd stop"

data/generators/clockworkd/clockworkd_generator.rb

@@ -0,0 +1,12 @@
+class ClockworkdGenerator < Rails::Generator::Base
+  default_options :skip_migration => false
+  
+  def manifest
+    record do |m|
+      m.template 'script', 'script/clockworkd', :chmod => 0755
+      m.template 'clockworkd.yml', 'config/clockworkd.yml'
+    end
+  end
+  
+  
+end

data/generators/clockworkd/templates/clockworkd.yml

@@ -0,0 +1,14 @@
+
+# Run job every day at 1:59: 59 1 * * *
+# Run job every two minute: */2 * * * *
+clear_sesssion_job:
+  cron: "59 1 * * *"
+  block: Delayed::Job.enqueue ClearSessionsJob.new
+  description: "This job clear sessions table"
+
+# Run job every day at 4:59: 59 4 * * *
+# Run job every two minute: */2 * * * *
+clear_job_reports_job:
+  cron: "59 4 * * *"
+  block: Delayed::Job.enqueue ClearJobReportsJob.new
+  description: "This job clear job report table"

data/generators/clockworkd/templates/script

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'config', 'environment'))
+require 'clockworkd/command'
+Clockworkd::Command.new(ARGV).daemonize

data/knownbugs

@@ -0,0 +1,18 @@
+Introduction:
+To see the latest list of the known bugs please visit the Known bugs page at www.majoron.com.
+
+Legend:
+Follow notation is used at change log, roadmap and known bugs. Each bug begins with a version,
+then follow category of the bug inside {}. It can be bug report, feature request and etc.
+Then follow component inside []. After follow bug number at bug tracking system between // signs.
+And then follow a short description of the bug.
+
+Example:
+For example bug: "1.0 { Feature Request } [ AntHill ] / 380 / STLport support required" means
+that bug was created for 1.0 version of the AntHill component, bug is feature request with
+380 number at bug tracking system. And bug requires STLPort support implementation.
+
+ Version 0.2
+ -----------
+0.2 { Bug Report } [ Clockworkd ] / X / There isn't known bugs
+

data/lib/clockworkd.rb

@@ -0,0 +1,21 @@
+# Include files
+require File.dirname(__FILE__) + '/clockworkd/cronline'
+require File.dirname(__FILE__) + '/clockworkd/event'
+require File.dirname(__FILE__) + '/clockworkd/worker'
+require File.dirname(__FILE__) + '/clockworkd/command'
+
+unless 1.respond_to?(:seconds) 
+  class Numeric
+  	def seconds; self; end
+  	alias :second :seconds
+
+  	def minutes; self * 60; end
+  	alias :minute :minutes
+
+  	def hours; self * 3600; end
+  	alias :hour :hours
+
+  	def days; self * 86400; end
+  	alias :day :days
+  end
+end

data/lib/clockworkd/command.rb

@@ -0,0 +1,90 @@
+require 'rubygems'
+require 'daemons'
+require 'optparse'
+require 'logger'
+
+module Clockworkd
+  class Command
+
+    def initialize(args)
+      @files_to_reopen = []
+      @options = {
+        :quiet => true,
+        :identifier => 0,
+        :pid_dir => "#{Rails.root}/tmp/pids",
+        :clock_file => "#{Rails.root}/config/clockworkd.yml"
+      }
+
+      @monitor = false
+
+      opts = OptionParser.new do |opts|
+        opts.banner = "Usage: #{File.basename($0)} [options] start|stop|restart|run"
+
+        opts.on('-h', '--help', 'Show this message') do
+          puts opts
+          exit 1
+        end
+        opts.on('--clock-file=FILE', 'Specifies an alternate clockwork file with schuduling.') do |file|
+          @options[:clock_file] = file
+        end
+        opts.on('--pid-dir=DIR', 'Specifies an alternate directory in which to store the process ids.') do |dir|
+          @options[:pid_dir] = dir
+        end
+        opts.on('-i', '--identifier=n', 'A numeric identifier for the clockwork process.') do |n|
+          @options[:identifier] = n
+        end
+        opts.on('-m', '--monitor', 'Start monitor process.') do
+          @monitor = true
+        end
+        opts.on('--sleep-delay N', "Amount of time to sleep when no events are found") do |n|
+          @options[:sleep_delay] = n
+        end
+      end
+      @args = opts.parse!(args)
+    end
+
+    def daemonize
+      Clockworkd::Worker.before_fork
+
+      ObjectSpace.each_object(File) do |file|
+        @files_to_reopen << file unless file.closed?
+      end
+
+      dir = @options[:pid_dir]
+      Dir.mkdir(dir) unless File.exists?(dir)
+
+      process_name = "clockworkd.#{@options[:identifier]}"
+      run_process(process_name, dir)
+    end
+
+    def run_process(process_name, dir)
+      Daemons.run_proc(process_name, :multiple => false, :dir => dir, :dir_mode => :normal, :monitor => @monitor, :ARGV => @args) do |*args|
+        run process_name
+      end
+    end
+
+    def run(worker_name = nil)
+      Dir.chdir(Rails.root)
+
+      # Re-open file handles
+      @files_to_reopen.each do |file|
+        begin
+          file.reopen file.path, "a+"
+          file.sync = true
+        rescue ::Exception => e
+          raise e
+        end
+      end
+
+      Clockworkd::Worker.logger = Logger.new(File.join(Rails.root, 'log', 'clockworkd.log'))
+      Clockworkd::Worker.after_fork
+
+      Clockworkd::Worker.new(@options).run
+    rescue => e
+      Rails.logger.fatal e
+      STDERR.puts e.message
+      exit 1
+    end
+
+  end
+end

data/lib/clockworkd/cronline.rb

@@ -0,0 +1,310 @@
+#--
+# Copyright (c) 2006-2011, John Mettraux, jmettraux@gmail.com
+#
+# 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.
+#
+# Made in Japan.
+#++
+
+require 'tzinfo'
+
+
+module Clockworkd
+
+  #
+  # A 'cron line' is a line in the sense of a crontab
+  # (man 5 crontab) file line.
+  #
+  class CronLine
+
+    # The string used for creating this cronline instance.
+    #
+    attr_reader :original
+
+    attr_reader :seconds
+    attr_reader :minutes
+    attr_reader :hours
+    attr_reader :days
+    attr_reader :months
+    attr_reader :weekdays
+    attr_reader :monthdays
+    attr_reader :timezone
+
+    def initialize(line)
+
+      super()
+
+      @original = line
+
+      items = line.split
+
+      @timezone = (TZInfo::Timezone.get(items.last) rescue nil)
+      items.pop if @timezone
+
+      raise ArgumentError.new(
+        "not a valid cronline : '#{line}'"
+      ) unless items.length == 5 or items.length == 6
+
+      offset = items.length - 5
+
+      @seconds = offset == 1 ? parse_item(items[0], 0, 59) : [ 0 ]
+      @minutes = parse_item(items[0 + offset], 0, 59)
+      @hours = parse_item(items[1 + offset], 0, 24)
+      @days = parse_item(items[2 + offset], 1, 31)
+      @months = parse_item(items[3 + offset], 1, 12)
+      @weekdays, @monthdays = parse_weekdays(items[4 + offset])
+    end
+
+    # Returns true if the given time matches this cron line.
+    #
+    def matches?(time)
+
+      time = Time.at(time) unless time.kind_of?(Time)
+
+      time = @timezone.utc_to_local(time.getutc) if @timezone
+
+      return false unless sub_match?(time.sec, @seconds)
+      return false unless sub_match?(time.min, @minutes)
+      return false unless sub_match?(time.hour, @hours)
+      return false unless date_match?(time)
+      true
+    end
+
+    # Returns the next time that this cron line is supposed to 'fire'
+    #
+    # This is raw, 3 secs to iterate over 1 year on my macbook :( brutal.
+    # (Well, I was wrong, takes 0.001 sec on 1.8.7 and 1.9.1)
+    #
+    # This method accepts an optional Time parameter. It's the starting point
+    # for the 'search'. By default, it's Time.now
+    #
+    # Note that the time instance returned will be in the same time zone that
+    # the given start point Time (thus a result in the local time zone will
+    # be passed if no start time is specified (search start time set to
+    # Time.now))
+    #
+    #   Rufus::CronLine.new('30 7 * * *').next_time(
+    #     Time.mktime(2008, 10, 24, 7, 29))
+    #   #=> Fri Oct 24 07:30:00 -0500 2008
+    #
+    #   Rufus::CronLine.new('30 7 * * *').next_time(
+    #     Time.utc(2008, 10, 24, 7, 29))
+    #   #=> Fri Oct 24 07:30:00 UTC 2008
+    #
+    #   Rufus::CronLine.new('30 7 * * *').next_time(
+    #     Time.utc(2008, 10, 24, 7, 29)).localtime
+    #   #=> Fri Oct 24 02:30:00 -0500 2008
+    #
+    # (Thanks to K Liu for the note and the examples)
+    #
+    def next_time(now=Time.now)
+
+      time = @timezone ? @timezone.utc_to_local(now.getutc) : now
+
+      time = time - time.usec * 1e-6 + 1
+        # little adjustment before starting
+
+      loop do
+
+        unless date_match?(time)
+          time += (24 - time.hour) * 3600 - time.min * 60 - time.sec
+          next
+        end
+        unless sub_match?(time.hour, @hours)
+          time += (60 - time.min) * 60 - time.sec
+          next
+        end
+        unless sub_match?(time.min, @minutes)
+          time += 60 - time.sec
+          next
+        end
+        unless sub_match?(time.sec, @seconds)
+          time += 1
+          next
+        end
+
+        break
+      end
+
+      if @timezone
+        time = @timezone.local_to_utc(time)
+        time = time.getlocal unless now.utc?
+      end
+
+      time
+    end
+
+    # Returns an array of 6 arrays (seconds, minutes, hours, days,
+    # months, weekdays).
+    # This method is used by the cronline unit tests.
+    #
+    def to_array
+
+      [
+        @seconds,
+        @minutes,
+        @hours,
+        @days,
+        @months,
+        @weekdays,
+        @monthdays,
+        @timezone ? @timezone.name : nil
+      ]
+    end
+
+    private
+
+    WEEKDAYS = %w[ sun mon tue wed thu fri sat ]
+
+    def parse_weekdays(item)
+
+      return nil if item == '*'
+
+      items = item.downcase.split(',')
+
+      weekdays = nil
+      monthdays = nil
+
+      items.each do |it|
+
+        if it.match(/#[12345]$/)
+
+          raise ArgumentError.new(
+            "ranges are not supported for monthdays (#{it})"
+          ) if it.index('-')
+
+          (monthdays ||= []) << it
+        else
+
+          WEEKDAYS.each_with_index { |a, i| it.gsub!(/#{a}/, i.to_s) }
+
+          its = it.index('-') ? parse_range(it, 0, 7) : [ Integer(it) ]
+          its = its.collect { |i| i == 7 ? 0 : i }
+
+          (weekdays ||= []).concat(its)
+        end
+      end
+
+      weekdays = weekdays.uniq if weekdays
+
+      [ weekdays, monthdays ]
+    end
+
+    def parse_item(item, min, max)
+
+      return nil if item == '*'
+      return parse_list(item, min, max) if item.index(',')
+      return parse_range(item, min, max) if item.index('*') or item.index('-')
+
+      i = Integer(item)
+
+      i = min if i < min
+      i = max if i > max
+
+      [ i ]
+    end
+
+    def parse_list(item, min, max)
+
+      item.split(',').inject([]) { |r, i|
+        r.push(parse_range(i, min, max))
+      }.flatten
+    end
+
+    def parse_range(item, min, max)
+
+      i = item.index('-')
+      j = item.index('/')
+
+      return item.to_i if (not i and not j)
+
+      inc = j ? Integer(item[j+1..-1]) : 1
+
+      istart = -1
+      iend = -1
+
+      if i
+
+        istart = Integer(item[0..i - 1])
+
+        if j
+          iend = Integer(item[i + 1..j - 1])
+        else
+          iend = Integer(item[i + 1..-1])
+        end
+
+      else # case */x
+
+        istart = min
+        iend = max
+      end
+
+      istart = min if istart < min
+      iend = max if iend > max
+
+      result = []
+
+      value = istart
+      loop do
+        result << value
+        value = value + inc
+        break if value > iend
+      end
+
+      result
+    end
+
+    def sub_match?(value, values)
+
+      values.nil? || values.include?(value)
+    end
+
+    def monthday_match(monthday, monthdays)
+
+      return true if monthdays == nil
+      return true if monthdays.include?(monthday)
+    end
+
+    def date_match?(date)
+
+      return false unless sub_match?(date.day, @days)
+      return false unless sub_match?(date.month, @months)
+      return false unless sub_match?(date.wday, @weekdays)
+      return false unless sub_match?(CronLine.monthday(date), @monthdays)
+      true
+    end
+
+    DAY_IN_SECONDS = 7 * 24 * 3600
+
+    def self.monthday(date)
+
+      count = 1
+      date2 = date.dup
+
+      loop do
+        date2 = date2 - DAY_IN_SECONDS
+        break if date2.month != date.month
+        count = count + 1
+      end
+
+      "#{WEEKDAYS[date.wday]}##{count}"
+    end
+  end
+end
+

data/lib/clockworkd/event.rb

@@ -0,0 +1,33 @@
+module Clockworkd
+  class Event
+   attr_accessor :job, :block, :cronline, :cron_time, :next_time
+
+    def initialize(job, block, cronline)
+      @job = job
+      @block = block
+      @cronline = cronline
+      @cron_time = CronLine.new(@cronline)
+      @next_time = @cron_time.next_time
+    end
+
+    def to_s
+      @job = job
+    end
+
+    def time?(t)
+      if (t.to_i - @next_time.to_i) > 0
+        @next_time = @cron_time.next_time
+        return true
+      end
+      false
+    end
+
+    def run(t)
+      eval(@block)
+    rescue Exception => e
+      raise e
+    end
+
+  end
+end
+

data/lib/clockworkd/recipes.rb

@@ -0,0 +1,50 @@
+# Capistrano Recipes for managing clockworkd
+#
+# Add these callbacks to have the clockworkd process restart when the server
+# is restarted:
+#
+#   after "deploy:stop",    "clockworkd:stop"
+#   after "deploy:start",   "clockworkd:start"
+#   after "deploy:restart", "clockworkd:restart"
+#
+# If you want to use command line options, for example to start multiple workers,
+# define a Capistrano variable clockworkd_args:
+#
+#   set :clockworkd_args, "-n 2"
+#
+# If you've got clockworkd workers running on a servers, you can also specify
+# which servers have clockworkd running and should be restarted after deploy.
+#
+#   set :clockworkd_server_role, :worker
+#
+
+Capistrano::Configuration.instance.load do
+  namespace :clockworkd do
+    def rails_env
+      fetch(:rails_env, false) ? "RAILS_ENV=#{fetch(:rails_env)}" : ''
+    end
+
+    def args
+      fetch(:clockworkd_args, "")
+    end
+
+    def roles
+      fetch(:clockworkd_server_role, :app)
+    end
+
+    desc "Stop the clockworkd process"
+    task :stop, :roles => lambda { roles } do
+      run "cd #{current_path};#{rails_env} script/clockworkd stop"
+    end
+
+    desc "Start the clockworkd process"
+    task :start, :roles => lambda { roles } do
+      run "cd #{current_path};#{rails_env} script/clockworkd start #{args}"
+    end
+
+    desc "Restart the clockworkd process"
+    task :restart, :roles => lambda { roles } do
+      run "cd #{current_path};#{rails_env} script/clockworkd restart #{args}"
+    end
+  end
+end

data/lib/clockworkd/worker.rb

@@ -0,0 +1,102 @@
+require 'logger'
+
+module Clockworkd
+  class Worker
+    cattr_accessor :clock_file, :sleep_delay, :logger
+    self.clock_file = "#{::Rails.root}/config/clockworkd.yml"
+    self.sleep_delay = 5
+
+    self.logger = if defined?(::Rails)
+      ::Rails.logger
+    elsif defined?(RAILS_DEFAULT_LOGGER)
+      RAILS_DEFAULT_LOGGER
+    end
+
+    # name_prefix is ignored if name is set directly
+    attr_accessor :events
+
+    def initialize(options={})
+      self.events = []
+
+      @quiet = options.has_key?(:quiet) ? options[:quiet] : true
+      self.class.clock_file = options[:clock_file] if options.has_key?(:clock_file)
+      self.class.sleep_delay = options[:sleep_delay] if options.has_key?(:sleep_delay)
+    end
+
+    # Hook method that is called before a new worker is forked
+    def self.before_fork
+      ::ActiveRecord::Base.clear_all_connections!
+    end
+
+    # Hook method that is called after a new worker is forked
+    def self.after_fork
+      ::ActiveRecord::Base.establish_connection
+    end
+
+    # Every worker has a unique name which by default is the pid of the process. There are some
+    # advantages to overriding this with something which survives worker retarts:  Workers can#
+    # safely resume working on tasks which are locked by themselves. The worker will assume that
+    # it crashed before.
+    def name
+      return @name unless @name.nil?
+      "host:#{Socket.gethostname} pid:#{Process.pid}" rescue "pid:#{Process.pid}"
+    end
+
+    # Sets the name of the worker.
+    # Setting the name to nil will reset the default worker name
+    def name=(val)
+      @name = val
+    end
+
+
+    def run
+      trap('TERM') { log 'Exiting...'; $exit = true }
+      trap('INT')  { log 'Exiting...'; $exit = true }
+
+      # Load scheduling
+      log "Load file with scheduling #{self.class.clock_file.to_s}"
+      yml_file = YAML::load(File.open(self.class.clock_file))
+      yml_file.each do |key, value|
+        job = key
+        block = value["block"]
+        cronline = value["cron"]
+        self.events << Event.new(job, block, cronline)
+      end
+
+      # Start a processing
+      log "Starting clock for #{self.events.size} events: [ " + self.events.map { |e| e.to_s }.join(' ') + " ]"
+      loop do
+        tick
+        break if $exit
+        sleep(self.class.sleep_delay)
+        break if $exit
+      end
+    end
+
+    def tick(t=Time.now)
+      to_run = self.events.select do |event|
+        event.time?(t)
+      end
+
+      to_run.each do |event|
+        log "Triggering #{event} with cronline #{event.cronline} and next time: #{event.next_time}"
+        begin
+          event.run(t)
+        rescue Exception => e
+          log "Unable to execute #{event} with error: #{e.to_s}", Logger::ERROR
+          raise e
+        end
+      end
+
+      to_run
+    end
+
+    def log(text, level = Logger::INFO)
+      text = "[Worker(#{name})] #{text}"
+      puts text unless @quiet
+      logger.add level, "#{Time.now.strftime('%FT%T%z')}: #{text}" if logger
+    end
+
+
+  end
+end

data/lib/generators/clockworkd/clockworkd_generator.rb

@@ -0,0 +1,21 @@
+require 'rails/generators'
+require 'rails/generators/migration'
+
+class ClockworkdGenerator < Rails::Generators::Base
+
+  include Rails::Generators::Migration
+  
+  def self.source_root
+     @source_root ||= File.join(File.dirname(__FILE__), 'templates')
+  end
+
+  def create_script_file
+    template 'script', 'script/clockworkd'
+    chmod 'script/clockworkd', 0755
+  end
+
+  def create_clockworkd_file
+    template 'clockworkd.yml', 'config/clockworkd.yml'
+  end
+
+end

data/lib/generators/clockworkd/templates/clockworkd.yml

@@ -0,0 +1,14 @@
+
+# Run job every day at 1:59: 59 1 * * *
+# Run job every two minute: */2 * * * *
+clear_sesssion_job:
+  cron: "59 1 * * *"
+  block: Delayed::Job.enqueue ClearSessionsJob.new
+  description: "This job clear sessions table"
+
+# Run job every day at 4:59: 59 4 * * *
+# Run job every two minute: */2 * * * *
+clear_job_reports_job:
+  cron: "59 4 * * *"
+  block: Delayed::Job.enqueue ClearJobReportsJob.new
+  description: "This job clear job report table"

data/lib/generators/clockworkd/templates/script

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'config', 'environment'))
+require 'clockworkd/command'
+Clockworkd::Command.new(ARGV).daemonize

data/recipes/clockworkd.rb

@@ -0,0 +1 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib', 'clockworkd', 'recipes'))

data/roadmap

@@ -0,0 +1,17 @@
+Introduction:
+To see the latest list of the roadmap please visit the Roadmap page at www.majoron.com.
+
+Legend:
+Follow notation is used at change log, roadmap and known bugs. Each bug begins with a version,
+then follow category of the bug inside {}. It can be bug report, feature request and etc.
+Then follow component inside []. After follow bug number at bug tracking system between // signs.
+And then follow a short description of the bug.
+
+Example:
+For example bug: "1.0 { Feature Request } [ AntHill ] / 380 / STLport support required" means
+that bug was created for 1.0 version of the AntHill component, bug is feature request with
+380 number at bug tracking system. And bug requires STLPort support implementation.
+
+ Version 0.2
+ -----------
+0.2 { Feature Request } [ Clockworkd ] / X / Add tests

data/spec/lib/clockworkd/command_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe Clockworkd::Command do
+  it "should define class Command" do
+    ::Clockworkd::Command.should be
+  end
+end

data/spec/lib/clockworkd/cronline_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe Clockworkd::CronLine do
+  it "should define class CronLine" do
+    ::Clockworkd::CronLine.should be
+  end
+end

data/spec/lib/clockworkd/event_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe Clockworkd::Event do
+  it "should define class Event" do
+    ::Clockworkd::Event.should be
+  end
+end

data/spec/lib/clockworkd/worker_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe Clockworkd::Worker do
+  it "should define class Worker" do
+    ::Clockworkd::Worker.should be
+  end
+end

data/spec/lib/clockworkd_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+
+describe Clockworkd do
+  it "should define rails" do
+    ::Rails::VERSION::MAJOR.should be
+  end
+
+end

data/spec/spec.opts

@@ -0,0 +1,2 @@
+--color
+--backtrace

data/spec/spec_helper.rb

@@ -0,0 +1,26 @@
+$:.unshift File.dirname(__FILE__)
+$:.unshift File.join(File.dirname(__FILE__), '../lib')
+
+ENV["RAILS_ENV"] = "test"
+require 'rubygems'
+require 'bundler/setup'
+require 'rspec'
+require 'logger'
+require 'rails'
+require 'action_controller'
+require 'clockworkd'
+
+module Rails
+  module VERSION
+    MAJOR = 3
+  end
+end unless defined? Rails
+
+# Clockworkd.root = './'
+RAILS_ROOT = './' unless defined?(RAILS_ROOT)
+RAILS_ENV = 'test' unless defined?(RAILS_ENV)
+
+RSpec.configure do |config|
+  config.mock_with :rspec
+end
+

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification
+name: clockworkd
+version: !ruby/object:Gem::Version
+  version: 0.2.5
+  prerelease: 
+platform: ruby
+authors:
+- Adam Wiggins
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-07-31 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: tzinfo
+  requirement: &30906132 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.3.23
+  type: :runtime
+  prerelease: false
+  version_requirements: *30906132
+description: A scheduler process to replace cron, using a more flexible Ruby syntax
+  running as a single long-running process.  Inspired by rufus-scheduler and resque-scheduler.
+email: adam@heroku.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README
+files:
+- changelog
+- clockworkd.gemspec
+- contrib/clockworkd.monitrc
+- generators/clockworkd/clockworkd_generator.rb
+- generators/clockworkd/templates/clockworkd.yml
+- generators/clockworkd/templates/script
+- knownbugs
+- lib/clockworkd/command.rb
+- lib/clockworkd/cronline.rb
+- lib/clockworkd/event.rb
+- lib/clockworkd/recipes.rb
+- lib/clockworkd/worker.rb
+- lib/clockworkd.rb
+- lib/generators/clockworkd/clockworkd_generator.rb
+- lib/generators/clockworkd/templates/clockworkd.yml
+- lib/generators/clockworkd/templates/script
+- MIT-LICENSE
+- Rakefile
+- README
+- recipes/clockworkd.rb
+- roadmap
+- spec/lib/clockworkd/command_spec.rb
+- spec/lib/clockworkd/cronline_spec.rb
+- spec/lib/clockworkd/event_spec.rb
+- spec/lib/clockworkd/worker_spec.rb
+- spec/lib/clockworkd_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+- VERSION
+homepage: http://www.majoron.com/project/rbundle/clockworkd
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: clockworkd
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: A scheduler process to replace cron.
+test_files:
+- spec/lib/clockworkd/command_spec.rb
+- spec/lib/clockworkd/cronline_spec.rb
+- spec/lib/clockworkd/event_spec.rb
+- spec/lib/clockworkd/worker_spec.rb
+- spec/lib/clockworkd_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb