Fix table_name_suffix/prefix issue. Closes #33

Fix for Rails 5

.gitignore

@@ -6,3 +6,4 @@
 /pkg/
 /spec/reports/
 /tmp/
+log/*.log

.travis.yml

@@ -4,12 +4,17 @@ os:
   - osx
 rvm:
   - 2.0.0
-  - 2.1
-  - 2.2
+  - 2.1.7
+  - 2.2.3
+  - 2.3.1
+matrix:
+  exclude:
+    - rvm: 2.3.1
+      os: osx
 notifications:
   webhooks:
     urls:
       - https://webhooks.gitter.im/e/907e95dada362be2a13c
     on_success: change  # options: [always|never|change] default: always
     on_failure: always  # options: [always|never|change] default: always
-    on_start: false     # default: false
+    on_start: never     # options: [always|never|change] default: always

Changes.md

@@ -1,3 +1,20 @@
+0.9.1
+-----------
+- Add ability to define minimal time between job executions to support multiple corno nodes, so two different nodes will not execute the same job
+
+
+0.8.9
+-----------
+
+- We moved Web UI to materializecss.com CSS framework
+- We moved from CDN to local assets for Web UI
+- We show current state of a job in Web UI (thanks to @michaelachrisco) https://github.com/plashchynski/crono/issues/16
+- We won't write a pidfile unless daemonized (thanks to @thomasfedb) https://github.com/plashchynski/crono/pull/13
+- Fixed `rake crono:clean` task error
+- Fixed issue when jobs scheduled at same time exclude each other https://github.com/plashchynski/crono/issues/19
+- Fixed issue with a daemon crash due to `time interval must be positive` error
+
+
 0.8.0
 -----------
 

Gemfile.lock

@@ -1,70 +1,63 @@
 PATH
   remote: .
   specs:
-    crono (0.8.9.pre)
-      activejob (~> 4.0)
-      activerecord (~> 4.0)
-      activesupport (~> 4.0)
+    crono (1.0.2)
+      activerecord (>= 4.0)
+      activesupport (>= 4.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    activejob (4.2.1)
-      activesupport (= 4.2.1)
-      globalid (>= 0.3.0)
-    activemodel (4.2.1)
-      activesupport (= 4.2.1)
+    activemodel (4.2.6)
+      activesupport (= 4.2.6)
       builder (~> 3.1)
-    activerecord (4.2.1)
-      activemodel (= 4.2.1)
-      activesupport (= 4.2.1)
+    activerecord (4.2.6)
+      activemodel (= 4.2.6)
+      activesupport (= 4.2.6)
       arel (~> 6.0)
-    activesupport (4.2.1)
+    activesupport (4.2.6)
       i18n (~> 0.7)
       json (~> 1.7, >= 1.7.7)
       minitest (~> 5.1)
       thread_safe (~> 0.3, >= 0.3.4)
       tzinfo (~> 1.1)
-    arel (6.0.0)
+    arel (6.0.3)
     builder (3.2.2)
-    byebug (4.0.5)
-      columnize (= 0.9.0)
-    columnize (0.9.0)
+    byebug (9.0.5)
+    daemons (1.2.3)
     diff-lcs (1.2.5)
-    globalid (0.3.5)
-      activesupport (>= 4.1.0)
-    haml (4.0.6)
+    haml (4.0.7)
       tilt
     i18n (0.7.0)
-    json (1.8.2)
-    minitest (5.5.1)
-    rack (1.6.0)
+    json (1.8.3)
+    minitest (5.9.0)
+    rack (1.6.4)
     rack-protection (1.5.3)
       rack
     rack-test (0.6.3)
       rack (>= 1.0)
-    rake (10.4.2)
-    rspec (3.2.0)
-      rspec-core (~> 3.2.0)
-      rspec-expectations (~> 3.2.0)
-      rspec-mocks (~> 3.2.0)
-    rspec-core (3.2.2)
-      rspec-support (~> 3.2.0)
-    rspec-expectations (3.2.0)
+    rake (10.5.0)
+    rspec (3.4.0)
+      rspec-core (~> 3.4.0)
+      rspec-expectations (~> 3.4.0)
+      rspec-mocks (~> 3.4.0)
+    rspec-core (3.4.4)
+      rspec-support (~> 3.4.0)
+    rspec-expectations (3.4.0)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.2.0)
-    rspec-mocks (3.2.1)
+      rspec-support (~> 3.4.0)
+    rspec-mocks (3.4.1)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.2.0)
-    rspec-support (3.2.2)
-    sinatra (1.4.5)
-      rack (~> 1.4)
+      rspec-support (~> 3.4.0)
+    rspec-support (3.4.1)
+    sinatra (1.4.7)
+      rack (~> 1.5)
       rack-protection (~> 1.4)
-      tilt (~> 1.3, >= 1.3.4)
-    sqlite3 (1.3.10)
+      tilt (>= 1.3, < 3)
+    sqlite3 (1.3.11)
     thread_safe (0.3.5)
-    tilt (1.4.1)
-    timecop (0.7.3)
+    tilt (2.0.2)
+    timecop (0.8.1)
     tzinfo (1.2.2)
       thread_safe (~> 0.1)
 
@@ -75,6 +68,7 @@ DEPENDENCIES
   bundler (>= 1.0.0)
   byebug
   crono!
+  daemons
   haml
   rack-test
   rake (~> 10.0)
@@ -82,3 +76,6 @@ DEPENDENCIES
   sinatra
   sqlite3
   timecop (~> 0.7)
+
+BUNDLED WITH
+   1.11.2

README.md

@@ -11,14 +11,14 @@ Crono is a time-based background job scheduler daemon (just like Cron) for Ruby
 
 ## The Purpose
 
-Currently there is no such thing as Ruby Cron for Rails. Well, there's [Whenever](https://github.com/javan/whenever) but it works on top of Unix Cron, so you haven't control of it from Ruby. Crono is pure Ruby. It doesn't use Unix Cron and other platform-dependent things. So you can use it on all platforms supported by Ruby. It persists job states to your database using Active Record. You have full control of jobs performing process. It's Ruby, so you can understand and modify it to fit your needs.
+Currently, there is no such thing as Ruby Cron for Rails. Well, there's [Whenever](https://github.com/javan/whenever) but it works on top of Unix Cron, so you can't manage it from Ruby. Crono is pure Ruby. It doesn't use Unix Cron and other platform-dependent things. So you can use it on all platforms supported by Ruby. It persists job states to your database using Active Record. You have full control of jobs performing process. It's Ruby, so you can understand and modify it to fit your needs.
 
 ![Web UI](https://github.com/plashchynski/crono/raw/master/examples/crono_web_ui.png)
 
 
 ## Requirements
 
-Tested with latest MRI Ruby (2.2, 2.1 and 2.0) and Rails 3.2+  
+Tested with latest MRI Ruby (2.3, 2.2, 2.1 and 2.0) and Rails 3.2+
 Other versions are untested but might work fine.
 
 
@@ -47,7 +47,7 @@ Now you are ready to move forward to create a job and schedule it.
 
 #### Create Job
 
-Crono can use Active Job jobs from `app/jobs/`. The only requirements is that the `perform` method should take no arguments.
+Crono can use Active Job jobs from `app/jobs/`. The only requirement is that the `perform` method should take no arguments.
 
 Here's an example of a job:
 
@@ -61,11 +61,11 @@ class TestJob < ActiveJob::Base
 end
 ```
 
-The ActiveJob jobs is convenient because you can use one job in both periodic and enqueued ways. But Active Job is not required. Any class can be used as a crono job if it implements a method `perform` without arguments:
+The ActiveJob jobs are convenient because you can use one job in both periodic and enqueued ways. But Active Job is not required. Any class can be used as a crono job if it implements a method `perform`:
 
 ```ruby
 class TestJob # This is not an Active Job job, but pretty legal Crono job.
-  def perform
+  def perform(*args)
     # put you scheduled code here
     # Comments.deleted.clean_up...
   end
@@ -111,7 +111,7 @@ Crono.perform(TestJob).every 2.days, at: {hour: 15, min: 30}
 Crono.perform(TestJob).every 1.week, on: :monday, at: "15:30"
 ```
 
-You can schedule one job a few times, if you want the job to be performed a few times a day or a week:
+You can schedule one job a few times if you want the job to be performed a few times a day or a week:
 
 ```ruby
 Crono.perform(TestJob).every 1.week, on: :monday
@@ -124,22 +124,45 @@ The `at` can be a Hash:
 Crono.perform(TestJob).every 1.day, at: {hour: 12, min: 15}
 ```
 
-#### Run daemon
+You can schedule a job with arguments, which can contain objects that can be
+serialized using JSON.generate
 
-To run Crono daemon, in your Rails project root directory:
+```ruby
+Crono.perform(TestJob, 'some', 'args').every 1.day, at: {hour: 12, min: 15}
+```
+
+#### Run
+
+To run Crono, in your Rails project root directory:
 
     bundle exec crono RAILS_ENV=development
 
 crono usage:
 ```
-Usage: crono [options]
+Usage: crono [options] [start|stop|restart|run]
     -C, --cronotab PATH              Path to cronotab file (Default: config/cronotab.rb)
     -L, --logfile PATH               Path to writable logfile (Default: log/crono.log)
-    -P, --pidfile PATH               Path to pidfile (Default: tmp/pids/crono.pid)
-    -d, --[no-]daemonize             Daemonize process (Default: false)
+    -P, --pidfile PATH               Deprecated! use --piddir with --process_name; Path to pidfile (Default: )
+    -D, --piddir PATH                Path to piddir (Default: tmp/pids)
+    -N, --process_name NAME          Name of the process (Default: crono)
+    -d, --[no-]daemonize             Deprecated! Instead use crono [start|stop|restart] without this option; Daemonize process (Default: false)
+    -m, --monitor                    Start monitor process for a deamon (Default false)
     -e, --environment ENV            Application environment (Default: development)
 ```
 
+#### Run as a daemon
+
+To run Crono as a daemon, please add to your Gemfile:
+
+```ruby
+gem 'daemons'
+```
+
+Then:
+
+    bundle install; bundle exec crono start RAILS_ENV=development
+
+There are "start", "stop", and "restart" commands.
 
 ## Web UI
 

crono.gemspec

@@ -19,9 +19,8 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
 
-  spec.add_runtime_dependency 'activejob', '~> 4.0'
-  spec.add_runtime_dependency 'activesupport', '~> 4.0'
-  spec.add_runtime_dependency 'activerecord', '~> 4.0'
+  spec.add_runtime_dependency 'activesupport', '>= 4.0'
+  spec.add_runtime_dependency 'activerecord', '>= 4.0'
   spec.add_development_dependency 'rake', '~> 10.0'
   spec.add_development_dependency 'bundler', '>= 1.0.0'
   spec.add_development_dependency 'rspec', '~> 3.0'
@@ -31,4 +30,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'sinatra'
   spec.add_development_dependency 'haml'
   spec.add_development_dependency 'rack-test'
+  spec.add_development_dependency 'daemons'
 end

lib/crono.rb

@@ -6,6 +6,8 @@ require 'active_support/all'
 require 'crono/version'
 require 'crono/logging'
 require 'crono/period'
+require 'crono/time_of_day'
+require 'crono/interval'
 require 'crono/job'
 require 'crono/scheduler'
 require 'crono/config'

lib/crono/cli.rb

@@ -1,3 +1,5 @@
+Thread.abort_on_exception = true
+
 require 'crono'
 require 'optparse'
 
@@ -7,6 +9,8 @@ module Crono
     include Singleton
     include Logging
 
+    COMMANDS = %w(start stop restart run zap reload status)
+
     attr_accessor :config
 
     def initialize
@@ -16,16 +20,21 @@ module Crono
 
     def run
       parse_options(ARGV)
+      parse_command(ARGV)
 
-      setup_log
+      setup_log 
 
-      write_pid
+      write_pid unless config.daemonize
       load_rails
       Cronotab.process(File.expand_path(config.cronotab))
       print_banner
 
       check_jobs
-      start_working_loop
+      if config.daemonize
+        start_working_loop_in_daemon
+      else
+        start_working_loop
+      end
     end
 
     private
@@ -33,13 +42,15 @@ module Crono
     def setup_log
       if config.daemonize
         self.logfile = config.logfile
-        daemonize
+      elsif config.deprecated_daemonize
+        self.logfile = config.logfile
+        deprecated_daemonize
       else
         self.logfile = STDOUT
       end
     end
 
-    def daemonize
+    def deprecated_daemonize
       ::Process.daemon(true, true)
 
       [$stdout, $stderr].each do |io|
@@ -79,6 +90,30 @@ module Crono
       logger.error "You have no jobs in you cronotab file #{config.cronotab}"
     end
 
+    def start_working_loop_in_daemon
+      unless ENV['RAILS_ENV'] == 'test'
+        begin
+          require 'daemons'
+        rescue LoadError
+          raise "You need to add gem 'daemons' to your Gemfile if you wish to use it."
+        end
+      end
+      Daemons.run_proc(config.process_name, dir: config.piddir, dir_mode: :normal, monitor: config.monitor, ARGV: @argv) do |*_argv|
+        Dir.chdir(root)
+        Crono.logger = Logger.new(config.logfile)
+
+        start_working_loop
+      end
+    end
+
+    def root
+      @root ||= rails_root_defined? ? ::Rails.root : DIR_PWD
+    end
+
+    def rails_root_defined?
+      defined?(::Rails.root)
+    end
+
     def start_working_loop
       loop do
         next_time, jobs = Crono.scheduler.next_jobs
@@ -88,8 +123,8 @@ module Crono
     end
 
     def parse_options(argv)
-      OptionParser.new do |opts|
-        opts.banner = "Usage: crono [options]"
+      @argv = OptionParser.new do |opts|
+        opts.banner = "Usage: crono [options] [start|stop|restart|run]"
 
         opts.on("-C", "--cronotab PATH", "Path to cronotab file (Default: #{config.cronotab})") do |cronotab|
           config.cronotab = cronotab
@@ -99,12 +134,24 @@ module Crono
           config.logfile = logfile
         end
 
-        opts.on("-P", "--pidfile PATH", "Path to pidfile (Default: #{config.pidfile})") do |pidfile|
+        opts.on("-P", "--pidfile PATH", "Deprecated! use --piddir with --process_name; Path to pidfile (Default: #{config.pidfile})") do |pidfile|
           config.pidfile = pidfile
         end
 
-        opts.on("-d", "--[no-]daemonize", "Daemonize process (Default: #{config.daemonize})") do |daemonize|
-          config.daemonize = daemonize
+        opts.on("-D", "--piddir PATH", "Path to piddir (Default: #{config.piddir})") do |piddir|
+          config.piddir = piddir
+        end
+
+        opts.on("-N", "--process_name NAME", "Name of the process (Default: #{config.process_name})") do |process_name|
+          config.process_name = process_name
+        end
+
+        opts.on("-d", "--[no-]daemonize", "Deprecated! Instead use crono [start|stop|restart] without this option; Daemonize process (Default: #{config.daemonize})") do |daemonize|
+          config.deprecated_daemonize = daemonize
+        end
+
+        opts.on("-m", "--monitor", "Start monitor process for a deamon (Default #{config.monitor})") do
+          config.monitor = true
         end
 
         opts.on '-e', '--environment ENV', "Application environment (Default: #{config.environment})" do |env|
@@ -112,5 +159,12 @@ module Crono
         end
       end.parse!(argv)
     end
+
+    def parse_command(argv)
+      if COMMANDS.include? argv[0]
+        config.daemonize = true
+      end
+    end
+
   end
 end

lib/crono/config.rb

@@ -4,18 +4,31 @@ module Crono
     CRONOTAB  = 'config/cronotab.rb'
     LOGFILE   = 'log/crono.log'
     PIDFILE   = 'tmp/pids/crono.pid'
+    PIDDIR    = 'tmp/pids'
+    PROCESS_NAME = 'crono'
 
-    attr_accessor :cronotab, :logfile, :pidfile, :daemonize, :environment
+    attr_accessor :cronotab, :logfile, :pidfile, :piddir, :process_name,
+                  :monitor, :daemonize, :deprecated_daemonize, :environment
 
     def initialize
       self.cronotab = CRONOTAB
       self.logfile  = LOGFILE
+      self.piddir = PIDDIR
+      self.process_name = PROCESS_NAME
       self.daemonize = false
+      self.deprecated_daemonize = false
+      self.monitor = false
       self.environment = ENV['RAILS_ENV'] || ENV['RACK_ENV'] || 'development'
     end
 
+    def pidfile=(pidfile)
+      @pidfile = pidfile
+      self.process_name = Pathname.new(pidfile).basename(".*").to_s
+      self.piddir = Pathname.new(pidfile).dirname.to_s 
+    end
+
     def pidfile
-      @pidfile || (daemonize ? PIDFILE : nil)
+      @pidfile || (deprecated_daemonize ? PIDFILE : nil)
     end
   end
 end

lib/crono/interval.rb

@@ -0,0 +1,43 @@
+module Crono
+  # Interval describes a period between two specific times of day
+  class Interval
+    attr_accessor :from, :to
+
+    def self.parse(value)
+      from_to =
+        case value
+        when Array  then value
+        when Hash   then value.values_at(:from, :to)
+        when String then value.split('-')
+        else
+          fail "Unknown interval format: #{value.inspect}"
+        end
+      from, to = from_to.map { |v| TimeOfDay.parse(v) }
+      new from, to
+    end
+
+    def initialize(from, to)
+      @from, @to = from, to
+    end
+
+    def within?(value)
+      tod = ((value.is_a? TimeOfDay) ? value : TimeOfDay.parse(value))
+      if @from <= @to
+        tod >= @from && tod < @to
+      else
+        tod >= @from || tod < @to
+      end
+    end
+
+    def next_within(time, period)
+      begin
+        time = period.since(time)
+      end until within? TimeOfDay.parse(time)
+      time
+    end
+
+    def to_s
+      "#{@from}-#{@to}"
+    end
+  end
+end

lib/crono/job.rb

@@ -6,11 +6,13 @@ module Crono
   class Job
     include Logging
 
-    attr_accessor :performer, :period, :last_performed_at,
-                  :next_performed_at, :job_log, :job_logger, :healthy
+    attr_accessor :performer, :period, :job_args, :last_performed_at,
+                  :next_performed_at, :job_log, :job_logger, :healthy, :execution_interval
 
-    def initialize(performer, period)
+    def initialize(performer, period, job_args)
+      self.execution_interval = 0.minutes
       self.performer, self.period = performer, period
+      self.job_args = JSON.generate(job_args) 
       self.job_log = StringIO.new
       self.job_logger = Logger.new(job_log)
       self.next_performed_at = period.next
@@ -31,6 +33,8 @@ module Crono
     end
 
     def perform
+      return Thread.new {} if perform_before_interval?
+
       log "Perform #{performer}"
       self.last_performed_at = Time.now
       self.next_performed_at = period.next(since: last_performed_at)
@@ -42,6 +46,7 @@ module Crono
       @semaphore.synchronize do
         update_model
         clear_job_log
+        ActiveRecord::Base.clear_active_connections!
       end
     end
 
@@ -64,7 +69,7 @@ module Crono
     end
 
     def perform_job
-      performer.new.perform
+      performer.new.perform *JSON.parse(job_args)
     rescue StandardError => e
       handle_job_fail(e)
     else
@@ -101,5 +106,27 @@ module Crono
     def model
       @model ||= Crono::CronoJob.find_or_create_by(job_id: job_id)
     end
+
+    def perform_before_interval?
+      return false if execution_interval == 0.minutes
+
+      return true if self.last_performed_at.present? && self.last_performed_at > execution_interval.ago
+      return true if model.updated_at.present? && model.created_at != model.updated_at && model.updated_at > execution_interval.ago
+
+      Crono::CronoJob.transaction do
+        job_record = Crono::CronoJob.where(job_id: job_id).lock(true).first
+
+        return true if  job_record.updated_at.present? &&
+                        job_record.updated_at != job_record.created_at &&
+                        job_record.updated_at > execution_interval.ago
+
+        job_record.touch
+
+        return true unless job_record.save
+      end
+
+      # Means that this node is permit to perform the job.
+      return false
+    end
   end
 end

lib/crono/orm/active_record/crono_job.rb

@@ -3,7 +3,6 @@ require 'active_record'
 module Crono
   # Crono::CronoJob is a ActiveRecord model to store job state
   class CronoJob < ActiveRecord::Base
-    self.table_name = 'crono_jobs'
     validates :job_id, presence: true, uniqueness: true
 
     def self.outdated

lib/crono/performer_proxy.rb

@@ -1,18 +1,25 @@
 module Crono
   # Crono::PerformerProxy is a proxy used in cronotab.rb semantic
   class PerformerProxy
-    def initialize(performer, scheduler)
+    def initialize(performer, scheduler, job_args)
       @performer = performer
       @scheduler = scheduler
+      @job_args = job_args
     end
 
     def every(period, *args)
-      job = Job.new(@performer, Period.new(period, *args))
-      @scheduler.add_job(job)
+      @job = Job.new(@performer, Period.new(period, *args), @job_args)
+      @scheduler.add_job(@job)
+      self
+    end
+
+    def once_per(execution_interval)
+      @job.execution_interval = execution_interval if @job
+      self
     end
   end
 
-  def self.perform(performer)
-    PerformerProxy.new(performer, Crono.scheduler)
+  def self.perform(performer, *job_args)
+    PerformerProxy.new(performer, Crono.scheduler, job_args)
   end
 end

lib/crono/period.rb

@@ -4,15 +4,25 @@ module Crono
     DAYS = [:monday, :tuesday, :wednesday, :thursday, :friday, :saturday,
             :sunday]
 
-    def initialize(period, at: nil, on: nil)
+    def initialize(period, at: nil, on: nil, within: nil)
       @period = period
       @at_hour, @at_min = parse_at(at) if at
+      @interval = Interval.parse(within) if within
       @on = parse_on(on) if on
     end
 
     def next(since: nil)
-      return initial_next unless since
-      @next = @period.since(since)
+      if @interval
+        if since
+          @next = @interval.next_within(since, @period)
+        else
+          return initial_next if @interval.within?(initial_next)
+          @next = @interval.next_within(initial_next, @period)
+        end
+      else
+        return initial_next unless since
+        @next = @period.since(since)
+      end
       @next = @next.beginning_of_week.advance(days: @on) if @on
       @next = @next.change(time_atts)
       return @next if @next.future?
@@ -21,6 +31,7 @@ module Crono
 
     def description
       desc = "every #{@period.inspect}"
+      desc += " between #{@interval.from} and #{@interval.to} UTC" if @interval
       desc += format(' at %.2i:%.2i', @at_hour, @at_min) if @at_hour && @at_min
       desc += " on #{DAYS[@on].capitalize}" if @on
       desc
@@ -49,7 +60,10 @@ module Crono
     end
 
     def parse_at(at)
-      fail "period should be at least 1 day to use 'at'" if @period < 1.day
+      if @period < 1.day && (at.is_a? String || at[:hour])
+        fail "period should be at least 1 day to use 'at' with specified hour"
+      end
+
       case at
       when String
         time = Time.parse(at)

lib/crono/time_of_day.rb

@@ -0,0 +1,36 @@
+module Crono
+  # TimeOfDay describes a certain hour and minute (on any day)
+  class TimeOfDay
+    include Comparable
+
+    attr_accessor :hour, :min
+
+    def self.parse(value)
+      time =
+        case value
+        when String then Time.parse(value).utc
+        when Hash   then Time.now.change(value).utc
+        when Time   then value.utc
+        else
+          fail "Unknown TimeOfDay format: #{value.inspect}"
+        end
+      new time.hour, time.min
+    end
+
+    def initialize(hour, min)
+      @hour, @min = hour, min
+    end
+
+    def to_i
+      @hour * 60 + @min
+    end
+
+    def to_s
+      '%02d:%02d' % [@hour, @min]
+    end
+
+    def <=>(other)
+      to_i <=> other.to_i
+    end
+  end
+end

lib/crono/version.rb

@@ -1,3 +1,3 @@
 module Crono
-  VERSION = '0.8.9.pre'
+  VERSION = '1.0.2'
 end

spec/cli_spec.rb

@@ -9,10 +9,25 @@ describe Crono::CLI do
       expect(cli).to receive(:load_rails)
       expect(cli).to receive(:start_working_loop)
       expect(cli).to receive(:parse_options)
+      expect(cli).to receive(:parse_command)
       expect(cli).to receive(:write_pid)
       expect(Crono::Cronotab).to receive(:process)
       cli.run
     end
+    context 'should run as daemon' do
+
+      before {cli.config.daemonize = true}
+
+      it 'should initialize rails with #load_rails and start working loop' do
+        expect(cli).to receive(:load_rails)
+        expect(cli).to receive(:start_working_loop_in_daemon)
+        expect(cli).to receive(:parse_options)
+        expect(cli).to receive(:parse_command)
+        expect(cli).not_to receive(:write_pid)
+        expect(Crono::Cronotab).to receive(:process)
+        cli.run
+      end
+    end
   end
 
   describe '#parse_options' do
@@ -31,9 +46,24 @@ describe Crono::CLI do
       expect(cli.config.pidfile).to be_eql 'tmp/pids/crono.0.log'
     end
 
-    it 'should set daemonize' do
+    it 'should set piddir' do
+      cli.send(:parse_options, ['--piddir', 'tmp/pids'])
+      expect(cli.config.piddir).to be_eql 'tmp/pids'
+    end
+
+    it 'should set process_name' do
+      cli.send(:parse_options, ['--process_name', 'crono0'])
+      expect(cli.config.process_name).to be_eql 'crono0'
+    end
+
+    it 'should set monitor' do
+      cli.send(:parse_options, ['--monitor'])
+      expect(cli.config.monitor).to be true
+    end
+
+    it 'should set deprecated_daemonize' do
       cli.send(:parse_options, ['--daemonize'])
-      expect(cli.config.daemonize).to be true
+      expect(cli.config.deprecated_daemonize).to be true
     end
 
     it 'should set environment' do
@@ -41,4 +71,42 @@ describe Crono::CLI do
       expect(cli.config.environment).to be_eql('production')
     end
   end
+
+  describe '#parse_command' do
+
+    it 'should set daemonize on start' do
+      cli.send(:parse_command, ['start'])
+      expect(cli.config.daemonize).to be true
+    end
+
+    it 'should set daemonize on stop' do
+      cli.send(:parse_command, ['stop'])
+      expect(cli.config.daemonize).to be true
+    end
+
+    it 'should set daemonize on restart' do
+      cli.send(:parse_command, ['restart'])
+      expect(cli.config.daemonize).to be true
+    end
+
+    it 'should set daemonize on run' do
+      cli.send(:parse_command, ['run'])
+      expect(cli.config.daemonize).to be true
+    end
+
+    it 'should set daemonize on zap' do
+      cli.send(:parse_command, ['zap'])
+      expect(cli.config.daemonize).to be true
+    end
+
+    it 'should set daemonize on reload' do
+      cli.send(:parse_command, ['reload'])
+      expect(cli.config.daemonize).to be true
+    end
+
+    it 'should set daemonize on status' do
+      cli.send(:parse_command, ['status'])
+      expect(cli.config.daemonize).to be true
+    end
+  end
 end

spec/config_spec.rb

@@ -8,8 +8,11 @@ describe Crono::Config do
       @config = Crono::Config.new
       expect(@config.cronotab).to be Crono::Config::CRONOTAB
       expect(@config.logfile).to be Crono::Config::LOGFILE
-      expect(@config.pidfile).to be nil
+      expect(@config.piddir).to be Crono::Config::PIDDIR
+      expect(@config.process_name).to be Crono::Config::PROCESS_NAME
       expect(@config.daemonize).to be false
+      expect(@config.deprecated_daemonize).to be false
+      expect(@config.monitor).to be false
       expect(@config.environment).to be_eql ENV['RAILS_ENV']
     end
 
@@ -23,8 +26,8 @@ describe Crono::Config do
           specify { expect(pidfile).to be_nil }
         end
 
-        context "daemonize is true" do
-          before { config.daemonize = true }
+        context "deprecated_daemonize is true" do
+          before { config.deprecated_daemonize = true }
 
           specify { expect(pidfile).to eq Crono::Config::PIDFILE }
         end
@@ -36,7 +39,16 @@ describe Crono::Config do
         before { config.pidfile = path }
 
         specify { expect(pidfile).to eq path }
+
+        it "trys to set piddir" do
+          expect(config.piddir).to eq "foo/bar"
+        end
+
+        it "trys to set process_name" do
+          expect(config.process_name).to eq "pid"
+        end
       end
+
     end
   end
 end

spec/job_spec.rb

@@ -2,14 +2,20 @@ require 'spec_helper'
 
 describe Crono::Job do
   let(:period) { Crono::Period.new(2.day, at: '15:00') }
-  let(:job) { Crono::Job.new(TestJob, period) }
-  let(:failing_job) { Crono::Job.new(TestFailingJob, period) }
+  let(:job_args) {[{some: 'data'}]}
+  let(:job) { Crono::Job.new(TestJob, period, []) }
+  let(:job_with_args) { Crono::Job.new(TestJob, period, job_args) }
+  let(:failing_job) { Crono::Job.new(TestFailingJob, period, []) }
 
   it 'should contain performer and period' do
     expect(job.performer).to be TestJob
     expect(job.period).to be period
   end
 
+  it 'should contain data as JSON String' do
+    expect(job_with_args.job_args).to eq '[{"some":"data"}]'
+  end
+
   describe '#next' do
     it 'should return next performing time according to period' do
       expect(job.next).to be_eql period.next
@@ -36,6 +42,46 @@ describe Crono::Job do
       failing_job.perform.join
       expect(failing_job.healthy).to be false
     end
+
+    it 'should execute one' do
+      job.execution_interval = 5.minutes
+
+      expect(job).to receive(:perform_job).once
+      job.perform.join
+      thread = job.perform.join
+      expect(thread).to be_stop
+    end
+
+    it 'should execute twice' do
+      job.execution_interval = 0.minutes
+
+      test_preform_job_twice
+    end
+
+    it 'should execute twice without initialize execution_interval' do
+      test_preform_job_twice
+    end
+
+    it 'should call perform of performer' do
+      expect(TestJob).to receive(:new).with(no_args)
+      thread = job.perform.join
+      expect(thread).to be_stop
+    end
+
+    it 'should call perform of performer with data' do
+      test_job = double()
+      expect(TestJob).to receive(:new).and_return(test_job)
+      expect(test_job).to receive(:perform).with({'some' => 'data'})
+      thread = job_with_args.perform.join
+      expect(thread).to be_stop
+    end
+
+    def test_preform_job_twice
+      expect(job).to receive(:perform_job).twice
+      job.perform.join
+      thread = job.perform.join
+      expect(thread).to be_stop
+    end
   end
 
   describe '#description' do
@@ -54,6 +100,7 @@ describe Crono::Job do
     it 'should update saved job' do
       job.last_performed_at = Time.now
       job.healthy = true
+      job.job_args = JSON.generate([{some: 'data'}])
       job.save
       @crono_job = Crono::CronoJob.find_by(job_id: job.job_id)
       expect(@crono_job.last_performed_at.utc.to_s).to be_eql job.last_performed_at.utc.to_s
@@ -76,7 +123,7 @@ describe Crono::Job do
     end
 
     it 'should load last_performed_at from DB' do
-      @job = Crono::Job.new(TestJob, period)
+      @job = Crono::Job.new(TestJob, period, job_args)
       @job.load
       expect(@job.last_performed_at.utc.to_s).to be_eql @saved_last_performed_at.utc.to_s
     end

spec/performer_proxy_spec.rb

@@ -5,4 +5,23 @@ describe Crono::PerformerProxy do
     expect(Crono.scheduler).to receive(:add_job).with(kind_of(Crono::Job))
     Crono.perform(TestJob).every(2.days, at: '15:30')
   end
+
+  it 'should set execution interval' do
+    allow(Crono).to receive(:scheduler).and_return(Crono::Scheduler.new)
+    expect_any_instance_of(Crono::Job).to receive(:execution_interval=).with(0.minutes).once
+    expect_any_instance_of(Crono::Job).to receive(:execution_interval=).with(10.minutes).once
+    Crono.perform(TestJob).every(2.days, at: '15:30').once_per 10.minutes
+  end
+
+  it 'do nothing when job not initalized' do
+    expect_any_instance_of(Crono::Job).not_to receive(:execution_interval=)
+    expect_any_instance_of(described_class).to receive(:once_per)
+    Crono.perform(TestJob).once_per 10.minutes
+  end
+
+  it 'should add job with args to schedule' do
+    expect(Crono::Job).to receive(:new).with(TestJob, kind_of(Crono::Period), [:some, {some: 'data'}])
+    allow(Crono.scheduler).to receive(:add_job)
+    Crono.perform(TestJob, :some, {some: 'data'}).every(2.days, at: '15:30')
+  end
 end

spec/period_spec.rb

@@ -52,7 +52,7 @@ describe Crono::Period do
         expect(@period.next(since: 2.days.ago).to_s).to be_eql(Time.now.to_s)
       end
 
-      it 'should return the time 2 days from now' do
+      it 'should return time 2 days from now' do
         @period = Crono::Period.new(2.day)
         expect(@period.next.to_s).to be_eql(2.days.from_now.to_s)
       end
@@ -61,14 +61,14 @@ describe Crono::Period do
         time = 10.minutes.ago
         at = [time.hour, time.min].join(':')
         @period = Crono::Period.new(2.days, at: at)
-        expect(@period.next).to be_eql(2.days.from_now.change(hour: time.hour, min: time.min))
+        expect(@period.next.to_s).to be_eql(2.days.from_now.change(hour: time.hour, min: time.min).to_s)
       end
 
       it "should set time to 'at' time as a hash" do
         time = 10.minutes.ago
         at = { hour: time.hour, min: time.min }
         @period = Crono::Period.new(2.days, at: at)
-        expect(@period.next).to be_eql(2.days.from_now.change(at))
+        expect(@period.next.to_s).to be_eql(2.days.from_now.change(at).to_s)
       end
 
       it "should raise error when 'at' is wrong" do
@@ -80,7 +80,7 @@ describe Crono::Period do
       it 'should raise error when period is less than 1 day' do
         expect {
           Crono::Period.new(5.hours, at: '15:30')
-        }.to raise_error("period should be at least 1 day to use 'at'")
+        }.to raise_error("period should be at least 1 day to use 'at' with specified hour")
       end
 
       it 'should return time in relation to last time' do
@@ -95,5 +95,32 @@ describe Crono::Period do
         expect(@period.next.utc.to_s).to be_eql(Time.now.change(at).utc.to_s)
       end
     end
+
+    context 'in hourly basis' do
+      it 'should return next hour minutes if current hour minutes passed' do
+        Timecop.freeze(Time.now.beginning_of_hour.advance(minutes: 20)) do
+          @period = Crono::Period.new(1.hour, at: { min: 15 })
+          expect(@period.next.utc.to_s).to be_eql 1.hour.from_now.beginning_of_hour.advance(minutes: 15).utc.to_s
+        end
+      end
+
+      it 'should return current hour minutes if current hour minutes not passed yet' do
+        Timecop.freeze(Time.now.beginning_of_hour.advance(minutes: 10)) do
+          @period = Crono::Period.new(1.hour, at: { min: 15 })
+          expect(@period.next.utc.to_s).to be_eql Time.now.beginning_of_hour.advance(minutes: 15).utc.to_s
+        end
+      end
+
+      it 'should return next hour minutes within the given interval' do
+        Timecop.freeze(Time.now.change(hour: 16, min: 10)) do
+          @period = Crono::Period.new(1.hour, at: { min: 15 }, within: '08:00-16:00')
+          expect(@period.next.utc.to_s).to be_eql Time.now.tomorrow.change(hour: 8, min: 15).utc.to_s
+        end
+        Timecop.freeze(Time.now.change(hour: 16, min: 10)) do
+          @period = Crono::Period.new(1.hour, at: { min: 15 }, within: '23:00-07:00')
+          expect(@period.next.utc.to_s).to be_eql Time.now.change(hour: 23, min: 15).utc.to_s
+        end
+      end
+    end
   end
 end

spec/scheduler_spec.rb

@@ -5,7 +5,7 @@ describe Crono::Scheduler do
 
   describe '#add_job' do
     it 'should call Job#load on Job' do
-      @job = Crono::Job.new(TestJob, Crono::Period.new(10.day, at: '04:05'))
+      @job = Crono::Job.new(TestJob, Crono::Period.new(10.day, at: '04:05'), [])
       expect(@job).to receive(:load)
       scheduler.add_job(@job)
     end
@@ -17,7 +17,7 @@ describe Crono::Scheduler do
         Crono::Period.new(3.days, at: 10.minutes.from_now.strftime('%H:%M')),
         Crono::Period.new(1.day, at: 20.minutes.from_now.strftime('%H:%M')),
         Crono::Period.new(7.days, at: 40.minutes.from_now.strftime('%H:%M'))
-      ].map { |period| Crono::Job.new(TestJob, period) }
+      ].map { |period| Crono::Job.new(TestJob, period, []) }
 
       time, jobs = scheduler.next_jobs
       expect(jobs).to be_eql [jobs[0]]
@@ -29,7 +29,7 @@ describe Crono::Scheduler do
         Crono::Period.new(1.day, at: time.strftime('%H:%M')),
         Crono::Period.new(1.day, at: time.strftime('%H:%M')),
         Crono::Period.new(1.day, at: 10.minutes.from_now.strftime('%H:%M'))
-      ].map { |period| Crono::Job.new(TestJob, period) }
+      ].map { |period| Crono::Job.new(TestJob, period, []) }
 
       time, jobs = scheduler.next_jobs
       expect(jobs).to be_eql [jobs[0], jobs[1]]
@@ -40,7 +40,7 @@ describe Crono::Scheduler do
         Crono::Period.new(10.seconds),
         Crono::Period.new(10.seconds),
         Crono::Period.new(1.day, at: 10.minutes.from_now.strftime('%H:%M'))
-      ].map { |period| Crono::Job.new(TestJob, period) }
+      ].map { |period| Crono::Job.new(TestJob, period, []) }
 
       _, next_jobs = scheduler.next_jobs
       expect(next_jobs).to be_eql [jobs[0]]