Bump 0.8.0

.gitignore

@@ -1,3 +1,4 @@
 pkg/*
 *.gem
 .bundle
+tmp/*.sqlite3

Changes.md

@@ -1,19 +1,35 @@
-0.5.0
+0.8.0
 -----------
 
-- Initial release!
+- Added `on` (day of week) option to cronotab.rb semantic
+- Added job health check and job health indicator to the Web UI
 
-0.5.1
+
+0.7.0
 -----------
 
-- Added -e/--environment ENV option to set the daemon rails environment.
+- Added simple Web UI
+
+
+0.6.1
+-----------
+
+- Persist job state to your database.
+
 
 0.5.2
 -----------
 
 - Fix: Scheduled time now related to the last performing time.
 
-0.6.1
+
+0.5.1
 -----------
 
-- Persist job state to your database.
+- Added -e/--environment ENV option to set the daemon rails environment.
+
+
+0.5.0
+-----------
+
+- Initial release!

Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    crono (0.6.1)
+    crono (0.8.0)
       activejob (~> 4.0)
       activerecord (~> 4.0)
       activesupport (~> 4.0)
@@ -27,12 +27,25 @@ GEM
       tzinfo (~> 1.1)
     arel (6.0.0)
     builder (3.2.2)
+    byebug (3.5.1)
+      columnize (~> 0.8)
+      debugger-linecache (~> 1.2)
+      slop (~> 3.6)
+    columnize (0.9.0)
+    debugger-linecache (1.2.0)
     diff-lcs (1.2.5)
     globalid (0.3.3)
       activesupport (>= 4.1.0)
+    haml (4.0.6)
+      tilt
     i18n (0.7.0)
     json (1.8.2)
     minitest (5.5.1)
+    rack (1.6.0)
+    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)
@@ -47,8 +60,14 @@ GEM
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.2.0)
     rspec-support (3.2.2)
+    sinatra (1.4.5)
+      rack (~> 1.4)
+      rack-protection (~> 1.4)
+      tilt (~> 1.3, >= 1.3.4)
+    slop (3.6.0)
     sqlite3 (1.3.10)
-    thread_safe (0.3.4)
+    thread_safe (0.3.5)
+    tilt (1.4.1)
     timecop (0.7.3)
     tzinfo (1.2.2)
       thread_safe (~> 0.1)
@@ -58,8 +77,12 @@ PLATFORMS
 
 DEPENDENCIES
   bundler (>= 1.0.0)
+  byebug
   crono!
+  haml
+  rack-test
   rake (~> 10.0)
   rspec (~> 3.0)
+  sinatra
   sqlite3
   timecop (~> 0.7)

README.md

@@ -9,9 +9,11 @@ Crono — Job scheduler for Rails
 Crono is a time-based background job scheduler daemon (just like Cron) for Ruby on Rails.
 
 
-## The Idea
+## The Purpose
 
-Currently there is no such thing as Cron in Ruby for Rails. Well, there's [Whenever](https://github.com/javan/whenever) but it works on top of Unix Cron, so you have no total 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 state to your database using Active Record. You have full control of jobs performing process. You have Ruby code, 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 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.
+
+![Web UI](https://github.com/plashchynski/crono/raw/master/examples/crono_web_ui.png)
 
 
 ## Requirements
@@ -24,7 +26,9 @@ Other versions are untested but might work fine.
 
 Add the following line to your application's Gemfile:
 
-    gem 'crono'
+```ruby
+gem 'crono'
+```
 
 Run the `bundle` command to install it.  
 After you install Crono, you can run the generator:
@@ -47,40 +51,49 @@ Crono can use Active Job jobs from `app/jobs/`. The only requirements is that th
 
 Here's an example of a test job:
 
-    # app/jobs/test_job.rb
-    class TestJob < ActiveJob::Base
-      def perform
-        # put you scheduled code here
-        # Comments.deleted.clean_up...
-      end
-    end
+```ruby
+# app/jobs/test_job.rb
+class TestJob < ActiveJob::Base
+  def perform
+    # put you scheduled code here
+    # Comments.deleted.clean_up...
+  end
+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:
 
-    class TestJob # This is not an Active Job job, but pretty legal Crono job.
-      def perform
-        # put you scheduled code here
-        # Comments.deleted.clean_up...
-      end
-    end
-
+```ruby
+class TestJob # This is not an Active Job job, but pretty legal Crono job.
+  def perform
+    # put you scheduled code here
+    # Comments.deleted.clean_up...
+  end
+end
+```
 
 #### Job Schedule
 
-The schedule described in the configuration file `config/cronotab.rb`, that created using `crono:install` or manually. The semantic is pretty straightforward:
+Schedule list is defined in the file `config/cronotab.rb`, that created using `crono:install`. The semantic is pretty straightforward:
 
-    # config/cronotab.rb
-    Crono.perform(TestJob).every 2.days, at: "15:30"
+```ruby
+# config/cronotab.rb
+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 a job to be performed a few times a day:
+You can schedule one job a few times, if you want the job to be performed a few times a day or a week:
 
-    Crono.perform(TestJob).every 1.day, at: "00:00"
-    Crono.perform(TestJob).every 1.day, at: "12:00"
+```ruby
+Crono.perform(TestJob).every 1.week, on: :monday
+Crono.perform(TestJob).every 1.week, on: :thursday
+```
 
 The `at` can be a Hash:
 
-    Crono.perform(TestJob).every 1.day, at: {hour: 12, min: 15}
-
+```ruby
+Crono.perform(TestJob).every 1.day, at: {hour: 12, min: 15}
+```
 
 #### Run daemon
 
@@ -98,6 +111,28 @@ Usage: crono [options]
     -e, --environment ENV            Application environment (Default: development)
 ```
 
+
+## Web UI
+
+Crono comes with a Sinatra application that can display the current state of Crono jobs.  
+Add `sinatra` and `haml` to your Gemfile  
+
+```ruby
+gam 'haml'
+gem 'sinatra', require: nil
+```
+
+Add the following to your `config/routes.rb`:
+
+```ruby
+Rails.application.routes.draw do
+    mount Crono::Web, at: '/crono'
+    ...
+```
+
+Access management and other questions described in the [wiki](https://github.com/plashchynski/crono/wiki/Web-UI).
+
+
 ## Capistrano
 
 Use the `capistrano-crono` gem ([github](https://github.com/plashchynski/capistrano-crono/)).

bin/crono

@@ -1,8 +1,8 @@
 #!/usr/bin/env ruby
 
-$LOAD_PATH.unshift File.expand_path("../../lib", __FILE__)
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
 
-require "crono/cli"
+require 'crono/cli'
 
 begin
   Crono::CLI.instance.run

crono.gemspec

@@ -2,27 +2,31 @@
 require File.expand_path('../lib/crono/version', __FILE__)
 
 Gem::Specification.new do |s|
-  s.name        = "crono"
+  s.name        = 'crono'
   s.version     = Crono::VERSION
-  s.authors     = ["Dzmitry Plashchynski"]
-  s.email       = ["plashchynski@gmail.com"]
-  s.homepage    = "https://github.com/plashchynski/crono"
-  s.description = s.summary = "Job scheduler for Rails"
-  s.license     = "Apache-2.0"
+  s.authors     = ['Dzmitry Plashchynski']
+  s.email       = ['plashchynski@gmail.com']
+  s.homepage    = 'https://github.com/plashchynski/crono'
+  s.description = s.summary = 'Job scheduler for Rails'
+  s.license     = 'Apache-2.0'
 
-  s.required_rubygems_version = ">= 1.3.6"
-  s.rubyforge_project         = "crono"
+  s.required_rubygems_version = '>= 1.3.6'
+  s.rubyforge_project         = 'crono'
 
-  s.add_runtime_dependency      "activejob", "~> 4.0"
-  s.add_runtime_dependency      "activesupport", "~> 4.0"
-  s.add_runtime_dependency      "activerecord", "~> 4.0"
-  s.add_development_dependency  "rake", "~> 10.0"
-  s.add_development_dependency  "bundler", ">= 1.0.0"
-  s.add_development_dependency  "rspec", "~> 3.0"
-  s.add_development_dependency  "timecop", "~> 0.7"
-  s.add_development_dependency  "sqlite3"
+  s.add_runtime_dependency 'activejob', '~> 4.0'
+  s.add_runtime_dependency 'activesupport', '~> 4.0'
+  s.add_runtime_dependency 'activerecord', '~> 4.0'
+  s.add_development_dependency 'rake', '~> 10.0'
+  s.add_development_dependency 'bundler', '>= 1.0.0'
+  s.add_development_dependency 'rspec', '~> 3.0'
+  s.add_development_dependency 'timecop', '~> 0.7'
+  s.add_development_dependency 'sqlite3'
+  s.add_development_dependency 'byebug'
+  s.add_development_dependency 'sinatra'
+  s.add_development_dependency 'haml'
+  s.add_development_dependency 'rack-test'
 
   s.files        = `git ls-files`.split("\n")
-  s.executables  = `git ls-files`.split("\n").map{|f| f =~ /^bin\/(.*)/ ? $1 : nil}.compact
+  s.executables  = ['crono']
   s.require_path = 'lib'
 end

examples/cronotab.rb

@@ -1,15 +1,14 @@
-# cronotab.rb — Crono configuration example file
+# cronotab.rb - Crono configuration file
 #
-# Here you can specify periodic jobs and their schedule.
-# You can specify a periodic job as a ActiveJob class in `app/jobs/`
-# Actually you can use any class. The only requirement is that
-# the class should implement a method `perform` without arguments.
+# Here you can specify periodic jobs and schedule.
+# You can use ActiveJob's jobs from `app/jobs/`
+# You can use any class. The only requirement is that
+# class should have a method `perform` without arguments.
 #
-
 class TestJob
   def perform
-    puts "Test!"
+    puts 'Test!'
   end
 end
 
-Crono.perform(TestJob).every 5.second
+Crono.perform(TestJob).every 2.days, at: '15:30'

lib/crono.rb

@@ -1,12 +1,15 @@
+# Crono main module
 module Crono
 end
 
-require "active_support/all"
-require "crono/version.rb"
-require "crono/logging.rb"
-require "crono/period.rb"
-require "crono/job.rb"
-require "crono/scheduler.rb"
-require "crono/config.rb"
-require "crono/performer_proxy.rb"
-require "crono/orm/active_record/crono_job.rb"
+require 'active_support/all'
+require 'crono/version'
+require 'crono/logging'
+require 'crono/period'
+require 'crono/job'
+require 'crono/scheduler'
+require 'crono/config'
+require 'crono/performer_proxy'
+require 'crono/orm/active_record/crono_job'
+
+Crono.autoload :Web, 'crono/web'

lib/crono/cli.rb

@@ -4,6 +4,7 @@ require 'optparse'
 module Crono
   mattr_accessor :scheduler
 
+  # Crono::CLI - The main class for the crono daemon exacutable `bin/crono`
   class CLI
     include Singleton
     include Logging
@@ -18,12 +19,7 @@ module Crono
     def run
       parse_options(ARGV)
 
-      if config.daemonize
-        set_log_to(config.logfile)
-        daemonize 
-      else
-        set_log_to(STDOUT)
-      end
+      setup_log
 
       write_pid
       load_rails
@@ -33,7 +29,17 @@ module Crono
       start_working_loop
     end
 
-  private
+    private
+
+    def setup_log
+      if config.daemonize
+        self.logifile = config.logfile
+        daemonize
+      else
+        self.logfile = STDOUT
+      end
+    end
+
     def daemonize
       ::Process.daemon(true, true)
 
@@ -42,7 +48,7 @@ module Crono
         io.sync = true
       end
 
-      $stdin.reopen("/dev/null")
+      $stdin.reopen('/dev/null')
     end
 
     def write_pid
@@ -54,29 +60,28 @@ module Crono
       logger.info "Loading Crono #{Crono::VERSION}"
       logger.info "Running in #{RUBY_DESCRIPTION}"
 
-      logger.info "Jobs:"
+      logger.info 'Jobs:'
       Crono.scheduler.jobs.each do |job|
-        logger.info job.description
+        logger.info "'#{job.performer}' with rule '#{job.period.description}'"\
+                    "next time will perform at #{job.next}"
       end
     end
 
     def load_rails
       ENV['RACK_ENV'] = ENV['RAILS_ENV'] = config.environment
       require 'rails'
-      require File.expand_path("config/environment.rb")
+      require File.expand_path('config/environment.rb')
       ::Rails.application.eager_load!
       require File.expand_path(config.cronotab)
     end
 
     def check_jobs
-      if Crono.scheduler.jobs.empty?
-        logger.error "You have no jobs defined in you cronotab file #{config.cronotab}"
-      end
+      return if Crono.scheduler.jobs.present?
+      logger.error "You have no jobs in you cronotab file #{config.cronotab}"
     end
 
     def start_working_loop
-      Thread.abort_on_exception = true
-      while job = Crono.scheduler.next do
+      while (job = Crono.scheduler.next)
         sleep(job.next - Time.now)
         job.perform
       end

lib/crono/config.rb

@@ -1,21 +1,18 @@
 module Crono
+  # Crono::Config stores Crono configuration
   class Config
-    CRONOTAB  = "config/cronotab.rb"
-    LOGFILE   = "log/crono.log"
-    PIDFILE   = "tmp/pids/crono.pid"
+    CRONOTAB  = 'config/cronotab.rb'
+    LOGFILE   = 'log/crono.log'
+    PIDFILE   = 'tmp/pids/crono.pid'
 
-    attr_accessor :cronotab
-    attr_accessor :logfile
-    attr_accessor :pidfile
-    attr_accessor :daemonize
-    attr_accessor :environment
+    attr_accessor :cronotab, :logfile, :pidfile, :daemonize, :environment
 
     def initialize
       self.cronotab = CRONOTAB
       self.logfile  = LOGFILE
       self.pidfile  = PIDFILE
       self.daemonize = false
-      self.environment = ENV['RAILS_ENV'] || ENV['RACK_ENV'] || "development"
+      self.environment = ENV['RAILS_ENV'] || ENV['RACK_ENV'] || 'development'
     end
   end
 end

lib/crono/job.rb

@@ -1,13 +1,19 @@
+require 'stringio'
+require 'logger'
+
 module Crono
+  # Crono::Job represents a Crono job
   class Job
     include Logging
 
-    attr_accessor :performer
-    attr_accessor :period
-    attr_accessor :last_performed_at
+    attr_accessor :performer, :period, :last_performed_at, :job_log,
+                  :job_logger, :healthy
 
     def initialize(performer, period)
       self.performer, self.period = performer, period
+      self.job_log = StringIO.new
+      self.job_logger = Logger.new(job_log)
+      @semaphore = Mutex.new
     end
 
     def next
@@ -24,24 +30,70 @@ module Crono
     end
 
     def perform
-      logger.info "Perform #{performer}"
+      log "Perform #{performer}"
       self.last_performed_at = Time.now
-      save
-      Thread.new do
-        performer.new.perform
-        logger.info "Finished #{performer} in %.2f seconds" % (Time.now - last_performed_at)
-      end
+
+      Thread.new { perform_job }
     end
 
     def save
-      model.update(last_performed_at: last_performed_at)
+      @semaphore.synchronize do
+        update_model
+        clear_job_log
+      end
     end
 
     def load
       self.last_performed_at = model.last_performed_at
     end
 
-  private
+    private
+
+    def clear_job_log
+      job_log.truncate(job_log.rewind)
+    end
+
+    def update_model
+      saved_log = model.reload.log || ''
+      log_to_save = saved_log + job_log.string
+      model.update(last_performed_at: last_performed_at, log: log_to_save,
+                   healthy: healthy)
+    end
+
+    def perform_job
+      performer.new.perform
+      finished_time_sec = format('%.2f', Time.now - last_performed_at)
+    rescue StandardError => e
+      handle_job_fail(e, finished_time_sec)
+    else
+      handle_job_success(finished_time_sec)
+    ensure
+      save
+    end
+
+    def handle_job_fail(exception, finished_time_sec)
+      self.healthy = false
+      log_error "Finished #{performer} in #{finished_time_sec} seconds"\
+                "with error: #{exception.message}"
+      log_error exception.backtrace.join("\n")
+    end
+
+    def handle_job_success(finished_time_sec)
+      self.healthy = true
+      log "Finished #{performer} in #{finished_time_sec} seconds"
+    end
+
+    def log_error(message)
+      log(message, Logger::ERROR)
+    end
+
+    def log(message, severity = Logger::INFO)
+      @semaphore.synchronize do
+        logger.log severity, message
+        job_logger.log severity, message
+      end
+    end
+
     def model
       @model ||= Crono::CronoJob.find_or_create_by(job_id: job_id)
     end

lib/crono/logging.rb

@@ -1,8 +1,9 @@
 module Crono
   mattr_accessor :logger
 
+  # Crono::Logging is a standart Ruby logger wrapper
   module Logging
-    def set_log_to(logfile)
+    def logfile=(logfile)
       Crono.logger = Logger.new(logfile)
     end
 

lib/crono/orm/active_record/crono_job.rb

@@ -1,8 +1,9 @@
 require 'active_record'
 
 module Crono
+  # Crono::CronoJob is a ActiveRecord model to store job state
   class CronoJob < ActiveRecord::Base
-    self.table_name = "crono_jobs"
+    self.table_name = 'crono_jobs'
     validates :job_id, presence: true, uniqueness: true
   end
 end

lib/crono/performer_proxy.rb

@@ -1,4 +1,5 @@
 module Crono
+  # Crono::PerformerProxy is a proxy used in cronotab.rb semantic
   class PerformerProxy
     def initialize(performer, scheduler)
       @performer = performer

lib/crono/period.rb

@@ -1,22 +1,53 @@
 module Crono
+  # Period describe frequency of performing a task
   class Period
-    def initialize(period, at: nil)
+    DAYS = [:monday, :tuesday, :wednesday, :thursday, :friday, :saturday,
+            :sunday]
+
+    def initialize(period, at: nil, on: nil)
       @period = period
       @at_hour, @at_min = parse_at(at) if at
+      @on = parse_on(on) if on
     end
 
     def next(since: nil)
-      since ||= Time.now
-      @period.since(since).change({hour: @at_hour, min: @at_min}.compact)
+      return initial_next unless since
+      @next = @period.since(since)
+      @next = @next.beginning_of_week.advance(days: @on) if @on
+      @next.change(time_atts)
     end
 
     def description
       desc = "every #{@period.inspect}"
-      desc += " at %.2i:%.2i" % [@at_hour, @at_min] if @at_hour && @at_min
+      desc += format(' at %.2i:%.2i', @at_hour, @at_min) if @at_hour && @at_min
+      desc += " on #{DAYS[@on].capitalize}" if @on
       desc
     end
 
+    private
+
+    def initial_next
+      next_time = initial_day.change(time_atts)
+      return next_time if next_time.future?
+      @period.from_now.change(time_atts)
+    end
+
+    def initial_day
+      return Time.now unless @on
+      day = Time.now.beginning_of_week.advance(days: @on)
+      return day if day.future?
+      @period.from_now.beginning_of_week.advance(days: @on)
+    end
+
+    def parse_on(on)
+      day_number = DAYS.index(on)
+      fail "Wrong 'on' day" unless day_number
+      fail "period should be at least 1 week to use 'on'" if @period < 1.week
+      day_number
+    end
+
     def parse_at(at)
+      fail "period should be at least 1 day to use 'at'" if @period < 1.day
       case at
       when String
         time = Time.parse(at)
@@ -24,8 +55,12 @@ module Crono
       when Hash
         return at[:hour], at[:min]
       else
-        raise "Unknown 'at' format"
+        fail "Unknown 'at' format"
       end
     end
+
+    def time_atts
+      { hour: @at_hour, min: @at_min }.compact
+    end
   end
 end

lib/crono/scheduler.rb

@@ -1,4 +1,5 @@
 module Crono
+  # Scheduler is a container for job list and queue
   class Scheduler
     attr_accessor :jobs
 
@@ -15,7 +16,8 @@ module Crono
       queue.first
     end
 
-  private
+    private
+
     def queue
       jobs.sort_by(&:next)
     end

lib/crono/version.rb

@@ -1,3 +1,3 @@
 module Crono
-  VERSION = '0.6.1'
+  VERSION = '0.8.0'
 end

lib/crono/web.rb

@@ -0,0 +1,22 @@
+require 'haml'
+require 'sinatra/base'
+require 'crono'
+
+module Crono
+  # Web is a Web UI Sinatra app
+  class Web < Sinatra::Base
+    set :root, File.expand_path(File.dirname(__FILE__) + '/../../web')
+    set :public_folder, proc { "#{root}/assets" }
+    set :views, proc { "#{root}/views" }
+
+    get '/' do
+      @jobs = Crono::CronoJob.all
+      haml :dashboard, format: :html5
+    end
+
+    get '/job/:id' do
+      @job = Crono::CronoJob.find(params[:id])
+      haml :job
+    end
+  end
+end

lib/generators/crono/install/install_generator.rb

@@ -4,6 +4,7 @@ require 'rails/generators/active_record'
 
 module Crono
   module Generators
+    # rails generate crono:install
     class InstallGenerator < ::Rails::Generators::Base
       include Rails::Generators::Migration
 
@@ -11,15 +12,16 @@ module Crono
         ActiveRecord::Generators::Base.next_migration_number(path)
       end
 
-      desc "Installs crono and generates the necessary configuration files"
-      source_root File.expand_path("../templates", __FILE__)
+      desc 'Installs crono and generates the necessary configuration files'
+      source_root File.expand_path('../templates', __FILE__)
 
       def copy_config
         template 'cronotab.rb.erb', 'config/cronotab.rb'
       end
 
       def create_migrations
-        migration_template 'migrations/create_crono_jobs.rb', 'db/migrate/create_crono_jobs.rb'
+        migration_template 'migrations/create_crono_jobs.rb',
+                           'db/migrate/create_crono_jobs.rb'
       end
     end
   end

lib/generators/crono/install/templates/cronotab.rb.erb

@@ -1,9 +1,15 @@
 # cronotab.rb — Crono configuration file
 #
-# Here you can specify periodic jobs and their schedule.
-# You can specify a periodic job as a ActiveJob class in `app/jobs/`
-# Actually you can use any class. The only requirement is that
-# the class should implement a method `perform` without arguments.
+# Here you can specify periodic jobs and schedule.
+# You can use ActiveJob's jobs from `app/jobs/`
+# You can use any class. The only requirement is that
+# class should have a method `perform` without arguments.
 #
-# Crono.perform(TestJob).every 2.days, at: "15:30"
+# class TestJob
+#   def perform
+#     puts 'Test!'
+#   end
+# end
+#
+# Crono.perform(TestJob).every 2.days, at: '15:30'
 #

lib/generators/crono/install/templates/migrations/create_crono_jobs.rb

@@ -4,7 +4,8 @@ class CreateCronoJobs < ActiveRecord::Migration
       t.string    :job_id, null: false
       t.text      :log
       t.datetime  :last_performed_at
-      t.timestamps
+      t.boolean   :healthy
+      t.timestamps null: false
     end
     add_index :crono_jobs, [:job_id], unique: true
   end

spec/cli_spec.rb

@@ -1,15 +1,16 @@
-require "spec_helper"
+require 'spec_helper'
 require 'crono/cli'
 
 class TestJob
-  def perform;end
+  def perform
+  end
 end
 
 describe Crono::CLI do
   let(:cli) { Crono::CLI.instance }
 
-  describe "#run" do
-    it "should try to initialize rails with #load_rails and start working loop" do
+  describe '#run' do
+    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)
       expect(cli).to receive(:parse_options)
@@ -18,34 +19,30 @@ describe Crono::CLI do
     end
   end
 
-  describe "#start_working_loop" do
-    it "should start working loop"
-  end
-
-  describe "#parse_options" do
-    it "should set cronotab" do
-      cli.send(:parse_options, ["--cronotab", "/tmp/cronotab.rb"])
-      expect(cli.config.cronotab).to be_eql "/tmp/cronotab.rb"
+  describe '#parse_options' do
+    it 'should set cronotab' do
+      cli.send(:parse_options, ['--cronotab', '/tmp/cronotab.rb'])
+      expect(cli.config.cronotab).to be_eql '/tmp/cronotab.rb'
     end
 
-    it "should set logfile" do
-      cli.send(:parse_options, ["--logfile", "log/crono.log"])
-      expect(cli.config.logfile).to be_eql "log/crono.log"
+    it 'should set logfile' do
+      cli.send(:parse_options, ['--logfile', 'log/crono.log'])
+      expect(cli.config.logfile).to be_eql 'log/crono.log'
     end
 
-    it "should set pidfile" do
-      cli.send(:parse_options, ["--pidfile", "tmp/pids/crono.0.log"])
-      expect(cli.config.pidfile).to be_eql "tmp/pids/crono.0.log"
+    it 'should set pidfile' do
+      cli.send(:parse_options, ['--pidfile', 'tmp/pids/crono.0.log'])
+      expect(cli.config.pidfile).to be_eql 'tmp/pids/crono.0.log'
     end
 
-    it "should set daemonize" do
-      cli.send(:parse_options, ["--daemonize"])
+    it 'should set daemonize' do
+      cli.send(:parse_options, ['--daemonize'])
       expect(cli.config.daemonize).to be true
     end
 
-    it "should set environment" do
-      cli.send(:parse_options, ["--environment", "production"])
-      expect(cli.config.environment).to be_eql("production")
+    it 'should set environment' do
+      cli.send(:parse_options, ['--environment', 'production'])
+      expect(cli.config.environment).to be_eql('production')
     end
   end
 end

spec/config_spec.rb

@@ -1,15 +1,15 @@
-require "spec_helper"
+require 'spec_helper'
 
 describe Crono::Config do
-  describe "#initialize" do
-    it "should initialize with default configuration options" do
-      ENV["RAILS_ENV"] = "test"
+  describe '#initialize' do
+    it 'should initialize with default configuration options' do
+      ENV['RAILS_ENV'] = 'test'
       @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 Crono::Config::PIDFILE
       expect(@config.daemonize).to be false
-      expect(@config.environment).to be_eql ENV["RAILS_ENV"]
+      expect(@config.environment).to be_eql ENV['RAILS_ENV']
     end
   end
 end

spec/job_spec.rb

@@ -1,62 +1,117 @@
-require "spec_helper"
+require 'spec_helper'
 
 class TestJob
-  def perform;end
+  def perform
+  end
+end
+
+class TestFailingJob
+  def perform
+    fail 'Some error'
+  end
 end
 
 describe Crono::Job do
   let(:period) { Crono::Period.new(2.day) }
-  let(:job) { Crono::Job.new(TestJob, period) } 
+  let(:job) { Crono::Job.new(TestJob, period) }
+  let(:failing_job) { Crono::Job.new(TestFailingJob, period) }
 
-  it "should contain performer and period" do
+  it 'should contain performer and period' do
     expect(job.performer).to be TestJob
     expect(job.period).to be period
   end
 
-  describe "#perform" do
-    it "should run performer in separate thread" do
+  describe '#perform' do
+    after { job.send(:model).destroy }
+
+    it 'should run performer in separate thread' do
+      expect(job).to receive(:save)
       thread = job.perform.join
       expect(thread).to be_stop
     end
 
-    it "should call Job#save after run" do
-      expect(job).to receive(:save)
+    it 'should save performin errors to log' do
+      thread = failing_job.perform.join
+      expect(thread).to be_stop
+      saved_log = Crono::CronoJob.find_by(job_id: failing_job.job_id).log
+      expect(saved_log).to include 'Some error'
+    end
+
+    it 'should set Job#healthy to true if perform ok' do
       job.perform.join
-      job.send(:model).destroy
+      expect(job.healthy).to be true
+    end
+
+    it 'should set Job#healthy to false if perform with error' do
+      failing_job.perform.join
+      expect(failing_job.healthy).to be false
     end
   end
 
-  describe "#description" do
-    it "should return job identificator" do
-      expect(job.description).to be_eql("Perform TestJob every 2 days")
+  describe '#description' do
+    it 'should return job identificator' do
+      expect(job.description).to be_eql('Perform TestJob every 2 days')
     end
   end
 
-  describe "#save" do
-    it "should save new job to DB" do
+  describe '#save' do
+    it 'should save new job to DB' do
       expect(Crono::CronoJob.where(job_id: job.job_id)).to_not exist
       job.save
       expect(Crono::CronoJob.where(job_id: job.job_id)).to exist
     end
 
-    it "should update saved job" do
+    it 'should update saved job' do
       job.last_performed_at = Time.now
+      job.healthy = true
       job.save
       @crono_job = Crono::CronoJob.find_by(job_id: job.job_id)
-      expect(@crono_job.last_performed_at).to be_eql(job.last_performed_at)
+      expect(@crono_job.last_performed_at.utc.to_s).to be_eql job.last_performed_at.utc.to_s
+      expect(@crono_job.healthy).to be true
+    end
+
+    it 'should save and truncate job log' do
+      message = 'test message'
+      job.send(:log, message)
+      job.save
+      expect(job.send(:model).reload.log).to include message
+      expect(job.job_log.string).to be_empty
     end
   end
 
-  describe "#load" do
+  describe '#load' do
     before do
       @saved_last_performed_at = job.last_performed_at = Time.now
       job.save
     end
 
-    it "should load info from DB" do
+    it 'should load last_performed_at from DB' do
       @job = Crono::Job.new(TestJob, period)
       @job.load
-      expect(@job.last_performed_at).to be_eql @saved_last_performed_at
+      expect(@job.last_performed_at.utc.to_s).to be_eql @saved_last_performed_at.utc.to_s
+    end
+  end
+
+  describe '#log' do
+    it 'should write log messages to both common and job log' do
+      message = 'Test message'
+      expect(job.logger).to receive(:log).with(Logger::INFO, message)
+      expect(job.job_logger).to receive(:log).with(Logger::INFO, message)
+      job.send(:log, message)
+    end
+
+    it 'should write job log to Job#job_log' do
+      message = 'Test message'
+      job.send(:log, message)
+      expect(job.job_log.string).to include(message)
+    end
+  end
+
+  describe '#log_error' do
+    it 'should call log with ERROR severity' do
+      message = 'Test message'
+      expect(job).to receive(:log).with(message, Logger::ERROR)
+      job.send(:log_error, message)
     end
   end
 end

spec/orm/active_record/crono_job_spec.rb

@@ -1,26 +1,26 @@
-require "spec_helper"
+require 'spec_helper'
 
 describe Crono::CronoJob do
   let(:valid_attrs) do
     {
-      job_id: "Perform TestJob every 3 days"
+      job_id: 'Perform TestJob every 3 days'
     }
   end
 
-  it "should validate presence of job_id" do
-    @crono_job = Crono::CronoJob.new()
+  it 'should validate presence of job_id' do
+    @crono_job = Crono::CronoJob.new
     expect(@crono_job).not_to be_valid
     expect(@crono_job.errors.added?(:job_id, :blank)).to be true
   end
 
-  it "should validate uniqueness of job_id" do
-    Crono::CronoJob.create!(job_id: "TestJob every 2 days")
-    @crono_job = Crono::CronoJob.create(job_id: "TestJob every 2 days")
+  it 'should validate uniqueness of job_id' do
+    Crono::CronoJob.create!(job_id: 'TestJob every 2 days')
+    @crono_job = Crono::CronoJob.create(job_id: 'TestJob every 2 days')
     expect(@crono_job).not_to be_valid
     expect(@crono_job.errors.added?(:job_id, :taken)).to be true
   end
 
-  it "should save job_id to DB" do
+  it 'should save job_id to DB' do
     Crono::CronoJob.create!(valid_attrs)
     @crono_job = Crono::CronoJob.find_by(job_id: valid_attrs[:job_id])
     expect(@crono_job).to be_present

spec/performer_proxy_spec.rb

@@ -1,12 +1,13 @@
-require "spec_helper"
+require 'spec_helper'
 
 class TestJob
-  def perform;end
+  def perform
+  end
 end
 
 describe Crono::PerformerProxy do
-  it "should add job to schedule" do
+  it 'should add job to schedule' do
     expect(Crono.scheduler).to receive(:add_job).with(kind_of(Crono::Job))
-    Crono.perform(TestJob).every(2.days, at: "15:30")
+    Crono.perform(TestJob).every(2.days, at: '15:30')
   end
 end

spec/period_spec.rb

@@ -1,4 +1,4 @@
-require "spec_helper"
+require 'spec_helper'
 
 describe Crono::Period do
   around(:each) do |example|
@@ -7,41 +7,94 @@ describe Crono::Period do
     end
   end
 
-  describe "#description" do
-    it "should return period description" do
-      @period = Crono::Period.new(2.day, at: "15:20")
-      expect(@period.description).to be_eql("every 2 days at 15:20")
+  describe '#description' do
+    it 'should return period description' do
+      @period = Crono::Period.new(1.week, on: :monday, at: '15:20')
+      expect(@period.description).to be_eql('every 7 days at 15:20 on Monday')
     end
   end
 
-  describe "#next" do
-    context "in daily basis" do
-      it "should return the time 2 days from now" do
+  describe '#next' do
+    context 'in weakly basis' do
+      it "should raise error if 'on' is wrong" do
+        expect { @period = Crono::Period.new(7.days, on: :bad_day) }
+          .to raise_error("Wrong 'on' day")
+      end
+
+      it 'should raise error when period is less than 1 week' do
+        expect { @period = Crono::Period.new(6.days, on: :monday) }
+          .to raise_error("period should be at least 1 week to use 'on'")
+      end
+
+      it "should return a 'on' day" do
+        @period = Crono::Period.new(1.week, on: :thursday, at: '15:30')
+        current_week = Time.now.beginning_of_week
+        last_run_time = current_week.advance(days: 1) # last run on the tuesday
+        next_run_at = Time.now.next_week.advance(days: 3)
+                      .change(hour: 15, min: 30)
+        expect(@period.next(since: last_run_time)).to be_eql(next_run_at)
+      end
+
+      it "should return a next week day 'on'" do
+        @period = Crono::Period.new(1.week, on: :thursday)
+        Timecop.freeze(Time.now.beginning_of_week.advance(days: 4)) do
+          expect(@period.next).to be_eql(Time.now.next_week.advance(days: 3))
+        end
+      end
+
+      it 'should return a current week day on the first run if not too late' do
+        @period = Crono::Period.new(7.days, on: :tuesday)
+        beginning_of_the_week = Time.now.beginning_of_week
+        tuesday = beginning_of_the_week.advance(days: 1)
+        Timecop.freeze(beginning_of_the_week) do
+          expect(@period.next).to be_eql(tuesday)
+        end
+      end
+    end
+
+    context 'in daily basis' do
+      it 'should return the time 2 days from now' do
         @period = Crono::Period.new(2.day)
         expect(@period.next).to be_eql(2.day.from_now)
       end
 
       it "should set time to 'at' time as a string" do
-        @period = Crono::Period.new(2.day, at: "15:20")
-        expect(@period.next).to be_eql(2.day.from_now.change(hour: 15, min: 20))
+        time = 10.minutes.ago
+        at = [time.hour, time.min].join(':')
+        @period = Crono::Period.new(2.day, at: at)
+        expect(@period.next).to be_eql(2.day.from_now.change(hour: time.hour, min: time.min))
       end
 
       it "should set time to 'at' time as a hash" do
-        at = {hour: 18, min: 45}
+        time = 10.minutes.ago
+        at = { hour: time.hour, min: time.min }
         @period = Crono::Period.new(2.day, at: at)
         expect(@period.next).to be_eql(2.day.from_now.change(at))
       end
 
       it "should raise error when 'at' is wrong" do
         expect {
-          @period = Crono::Period.new(2.day, at: 1)
+          Crono::Period.new(2.day, at: 1)
         }.to raise_error("Unknown 'at' format")
       end
 
-      it "should return time in relation to last time" 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'")
+      end
+
+      it 'should return time in relation to last time' do
         @period = Crono::Period.new(2.day)
         expect(@period.next(since: 1.day.ago)).to be_eql(1.day.from_now)
       end
+
+      it 'should return today time if it is first run and not too late' do
+        time = 10.minutes.from_now
+        at = { hour: time.hour, min: time.min }
+        @period = Crono::Period.new(2.day, at: at)
+        expect(@period.next.utc.to_s).to be_eql(Time.now.change(at).utc.to_s)
+      end
     end
   end
 end

spec/scheduler_spec.rb

@@ -1,35 +1,32 @@
-require "spec_helper"
+require 'spec_helper'
 
 class TestJob
-  def perform;end
+  def perform
+  end
 end
 
 describe Crono::Scheduler do
   before(:each) do
     @scheduler = Crono::Scheduler.new
     @jobs = [
-      Crono::Period.new(3.day, at: "18:55"),
-      Crono::Period.new(1.day, at: "15:30"),
-      Crono::Period.new(7.day, at: "06:05")
+      Crono::Period.new(3.day, 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.day, at: 40.minutes.from_now.strftime('%H:%M'))
     ].map { |period| Crono::Job.new(TestJob, period) }
     @scheduler.jobs = @jobs
   end
 
-  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"))
+  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'))
       expect(@job).to receive(:load)
       @scheduler.add_job(@job)
     end
   end
 
-  describe "#next" do
-    it "should return next job in schedule" do
-      expect(@scheduler.next).to be @jobs[1]
-    end
-
-    it "should return next based on last" do
-      expect(@scheduler.next)
+  describe '#next' do
+    it 'should return next job in schedule' do
+      expect(@scheduler.next).to be @jobs[0]
     end
   end
 end

spec/spec_helper.rb

@@ -2,12 +2,14 @@ require 'bundler/setup'
 Bundler.setup
 
 require 'timecop'
+require 'byebug'
 require 'crono'
 require 'generators/crono/install/templates/migrations/create_crono_jobs.rb'
 
-ActiveRecord::Base.establish_connection(adapter: 'sqlite3', database: ':memory:')
+ActiveRecord::Base.establish_connection(
+  adapter: 'sqlite3',
+  database: 'file::memory:?cache=shared'
+)
+
 ActiveRecord::Base.logger = Logger.new(STDOUT)
 CreateCronoJobs.up
-
-RSpec.configure do |config|
-end

spec/web_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+require 'rack/test'
+include Rack::Test::Methods
+
+describe Crono::Web do
+  let(:app) { Crono::Web }
+
+  before do
+    @test_job_id = 'Perform TestJob every 5 seconds'
+    @test_job_log = 'All runs ok'
+    @test_job = Crono::CronoJob.create!(
+      job_id: @test_job_id,
+      log: @test_job_log
+    )
+  end
+
+  after { @test_job.destroy }
+
+  describe '/' do
+    it 'should show all jobs' do
+      get '/'
+      expect(last_response).to be_ok
+      expect(last_response.body).to include @test_job_id
+    end
+
+    it 'should show a error mark when a job is unhealthy' do
+      @test_job.update(healthy: false)
+      get '/'
+      expect(last_response.body).to include 'Error'
+    end
+  end
+
+  describe '/job/:id' do
+    it 'should show job log' do
+      get "/job/#{@test_job.id}"
+      expect(last_response).to be_ok
+      expect(last_response.body).to include @test_job_id
+      expect(last_response.body).to include @test_job_log
+    end
+
+    it 'should show a message about the unhealthy job' do
+      message = 'An error occurs during the last execution of this job'
+      @test_job.update(healthy: false)
+      get "/job/#{@test_job.id}"
+      expect(last_response.body).to include message
+    end
+  end
+end

web/assets/custom.css

@@ -0,0 +1,20 @@
+.container {
+  background-color: #CFD8DC;
+}
+
+body {
+  background-color: #455A64;
+}
+
+.page-header {
+  border-bottom: 1px solid #B6B6B6;
+}
+
+#job_list td,#job_list th {
+  border-top: 1px solid #B6B6B6;
+  color: #212121;
+}
+
+.breadcrumb {
+  background-color: #FFFFFF;
+}

web/views/dashboard.haml

@@ -0,0 +1,22 @@
+%ol.breadcrumb
+  %li.active Home
+
+%h3 Running Jobs
+%table.table#job_list
+  %tr
+    %th Job
+    %th Last performed at
+    %th
+    %th
+  - @jobs.each do |job|
+    %tr
+      %td= job.job_id
+      %td= job.last_performed_at || '-'
+      %td
+        - if job.healthy == false
+          %a{ href: url("/job/#{job.id}") }
+            %span.label.label-danger Error
+      %td
+        %a{ href: url("/job/#{job.id}") }
+          Log
+          %span.glyphicon.glyphicon-menu-right

web/views/job.haml

@@ -0,0 +1,14 @@
+%ol.breadcrumb
+  %li
+    %a{ href: url('/') } Home
+  %li.active= @job.job_id
+
+%h2
+  "#{@job.job_id}" Log:
+
+- if @job.healthy == false
+  .alert.alert-danger{ role: 'alert' }
+    An error occurs during the last execution of this job.
+    Check the log below for details.
+
+%pre= @job.log

web/views/layout.haml

@@ -0,0 +1,25 @@
+!!! 5
+%html{ lang: 'en' }
+  %head
+    %meta{ charset: 'utf-8' }
+    %meta{ 'http-equiv' => 'X-UA-Compatible', content: 'IE=edge' }
+    %meta{ name: 'viewport', content: 'width=device-width, initial-scale=1' }
+
+    %title Crono Dashboard
+
+    %link{ href: 'https://maxcdn.bootstrapcdn.com/bootstrap/3.3.2/css/bootstrap.min.css', rel: 'stylesheet' }
+    %link{ href: 'https://maxcdn.bootstrapcdn.com/bootstrap/3.3.2/css/bootstrap-theme.min.css', rel: 'stylesheet' }
+    %link{ href: "#{env['SCRIPT_NAME']}/custom.css", rel: 'stylesheet' }
+
+  %body
+    %br
+    %br
+    .container
+      .page-header
+        %h1
+          Crono #{Crono::VERSION}
+          %small Dashboard
+      = yield
+
+    %script{ src: 'https://ajax.googleapis.com/ajax/libs/jquery/1.11.2/jquery.min.js' }
+    %script{ src: 'https://maxcdn.bootstrapcdn.com/bootstrap/3.3.2/js/bootstrap.min.js' }