Handle a few jobs scheduled at the same time

.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.1)
       activejob (~> 4.0)
       activerecord (~> 4.0)
       activesupport (~> 4.0)
@@ -9,17 +9,17 @@ PATH
 GEM
   remote: https://rubygems.org/
   specs:
-    activejob (4.2.0)
+    activejob (4.2.1)
-      activesupport (= 4.2.0)
+      activesupport (= 4.2.1)
       globalid (>= 0.3.0)
-    activemodel (4.2.0)
+    activemodel (4.2.1)
-      activesupport (= 4.2.0)
+      activesupport (= 4.2.1)
       builder (~> 3.1)
-    activerecord (4.2.0)
+    activerecord (4.2.1)
-      activemodel (= 4.2.0)
+      activemodel (= 4.2.1)
-      activesupport (= 4.2.0)
+      activesupport (= 4.2.1)
       arel (~> 6.0)
-    activesupport (4.2.0)
+    activesupport (4.2.1)
       i18n (~> 0.7)
       json (~> 1.7, >= 1.7.7)
       minitest (~> 5.1)
@@ -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:
@@ -45,42 +49,53 @@ Now you are ready to move forward to create a job and schedule it.
 
 Crono can use Active Job jobs from `app/jobs/`. The only requirements is that the `perform` method should take no arguments.
 
-Here's an example of a test job:
+Here's an example of a job:
 
-    # app/jobs/test_job.rb
+```ruby
-    class TestJob < ActiveJob::Base
+# app/jobs/test_job.rb
-      def perform
+class TestJob < ActiveJob::Base
-        # put you scheduled code here
+  def perform
-        # Comments.deleted.clean_up...
+    # put you scheduled code here
-      end
+    # Comments.deleted.clean_up...
-    end
+  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.
+```ruby
-      def perform
+class TestJob # This is not an Active Job job, but pretty legal Crono job.
-        # put you scheduled code here
+  def perform
-        # Comments.deleted.clean_up...
+    # put you scheduled code here
-      end
+    # Comments.deleted.clean_up...
-    end
+  end
+end
+```
 
+_Please note that crono uses threads, so your code should be thread-safe_
 
 #### 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
+```ruby
-    Crono.perform(TestJob).every 2.days, at: "15:30"
+# 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"
+```ruby
-    Crono.perform(TestJob).every 1.day, at: "12:00"
+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 +113,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.authors     = ['Dzmitry Plashchynski']
-  s.email       = ["plashchynski@gmail.com"]
+  s.email       = ['plashchynski@gmail.com']
-  s.homepage    = "https://github.com/plashchynski/crono"
+  s.homepage    = 'https://github.com/plashchynski/crono'
-  s.description = s.summary = "Job scheduler for Rails"
+  s.description = s.summary = 'Job scheduler for Rails'
-  s.license     = "Apache-2.0"
+  s.license     = 'Apache-2.0'
 
-  s.required_rubygems_version = ">= 1.3.6"
+  s.required_rubygems_version = '>= 1.3.6'
-  s.rubyforge_project         = "crono"
+  s.rubyforge_project         = 'crono'
 
-  s.add_runtime_dependency      "activejob", "~> 4.0"
+  s.add_runtime_dependency 'activejob', '~> 4.0'
-  s.add_runtime_dependency      "activesupport", "~> 4.0"
+  s.add_runtime_dependency 'activesupport', '~> 4.0'
-  s.add_runtime_dependency      "activerecord", "~> 4.0"
+  s.add_runtime_dependency 'activerecord', '~> 4.0'
-  s.add_development_dependency  "rake", "~> 10.0"
+  s.add_development_dependency 'rake', '~> 10.0'
-  s.add_development_dependency  "bundler", ">= 1.0.0"
+  s.add_development_dependency 'bundler', '>= 1.0.0'
-  s.add_development_dependency  "rspec", "~> 3.0"
+  s.add_development_dependency 'rspec', '~> 3.0'
-  s.add_development_dependency  "timecop", "~> 0.7"
+  s.add_development_dependency 'timecop', '~> 0.7'
-  s.add_development_dependency  "sqlite3"
+  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.
+# Here you can specify periodic jobs and schedule.
-# You can specify a periodic job as a ActiveJob class in `app/jobs/`
+# You can use ActiveJob's jobs from `app/jobs/`
-# Actually you can use any class. The only requirement is that
+# You can use any class. The only requirement is that
-# the class should implement a method `perform` without arguments.
+# 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,16 @@
+# Crono main module
 module Crono
 end
 
-require "active_support/all"
+require 'active_support/all'
-require "crono/version.rb"
+require 'crono/version'
-require "crono/logging.rb"
+require 'crono/logging'
-require "crono/period.rb"
+require 'crono/period'
-require "crono/job.rb"
+require 'crono/job'
-require "crono/scheduler.rb"
+require 'crono/scheduler'
-require "crono/config.rb"
+require 'crono/config'
-require "crono/performer_proxy.rb"
+require 'crono/performer_proxy'
-require "crono/orm/active_record/crono_job.rb"
+require 'crono/orm/active_record/crono_job'
+require 'crono/railtie' if defined?(Rails)
+
+Crono.autoload :Web, 'crono/web'

lib/crono/cli.rb

@@ -2,8 +2,7 @@ require 'crono'
 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 +17,7 @@ module Crono
     def run
       parse_options(ARGV)
 
-      if config.daemonize
+      setup_log
-        set_log_to(config.logfile)
-        daemonize 
-      else
-        set_log_to(STDOUT)
-      end
 
       write_pid
       load_rails
@@ -33,7 +27,17 @@ module Crono
       start_working_loop
     end
 
-  private
+    private
+
+    def setup_log
+      if config.daemonize
+        self.logfile = config.logfile
+        daemonize
+      else
+        self.logfile = STDOUT
+      end
+    end
+
     def daemonize
       ::Process.daemon(true, true)
 
@@ -42,7 +46,7 @@ module Crono
         io.sync = true
       end
 
-      $stdin.reopen("/dev/null")
+      $stdin.reopen('/dev/null')
     end
 
     def write_pid
@@ -54,31 +58,31 @@ 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?
+      return if Crono.scheduler.jobs.present?
-        logger.error "You have no jobs defined in you cronotab file #{config.cronotab}"
+      logger.error "You have no jobs in you cronotab file #{config.cronotab}"
-      end
     end
 
     def start_working_loop
-      Thread.abort_on_exception = true
+      while true
-      while job = Crono.scheduler.next do
+        next_time, jobs = Crono.scheduler.next_jobs
-        sleep(job.next - Time.now)
+        sleep(next_time - Time.now)
-        job.perform
+        jobs.each(&:perform)
       end
     end
 

lib/crono/config.rb

@@ -1,21 +1,18 @@
 module Crono
+  # Crono::Config stores Crono configuration
   class Config
-    CRONOTAB  = "config/cronotab.rb"
+    CRONOTAB  = 'config/cronotab.rb'
-    LOGFILE   = "log/crono.log"
+    LOGFILE   = 'log/crono.log'
-    PIDFILE   = "tmp/pids/crono.pid"
+    PIDFILE   = 'tmp/pids/crono.pid'
 
-    attr_accessor :cronotab
+    attr_accessor :cronotab, :logfile, :pidfile, :daemonize, :environment
-    attr_accessor :logfile
-    attr_accessor :pidfile
-    attr_accessor :daemonize
-    attr_accessor :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,18 +1,23 @@
+require 'stringio'
+require 'logger'
+
 module Crono
+  # Crono::Job represents a Crono job
   class Job
     include Logging
 
-    attr_accessor :performer
+    attr_accessor :performer, :period, :last_performed_at, :job_log,
-    attr_accessor :period
+                  :job_logger, :healthy
-    attr_accessor :last_performed_at
 
     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
-      next_time = period.next(since: last_performed_at)
+      period.next(since: last_performed_at)
-      next_time.past? ? period.next : next_time
     end
 
     def description
@@ -24,24 +29,72 @@ module Crono
     end
 
     def perform
-      logger.info "Perform #{performer}"
+      log "Perform #{performer}"
       self.last_performed_at = Time.now
-      save
+
-      Thread.new do
+      Thread.new { perform_job }
-        performer.new.perform
-        logger.info "Finished #{performer} in %.2f seconds" % (Time.now - last_performed_at)
-      end
     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_instance = performer.new
+      performer_instance.instance_variable_set(:@_crono_job, self)
+      performer_instance.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,13 @@
 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
+
+    def self.outdated
+      self
+    end
   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
+      return initial_next unless since
-      @period.since(since).change({hour: @at_hour, min: @at_min}.compact)
+      @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/railtie.rb

@@ -0,0 +1,9 @@
+module Crono
+  class Railtie < ::Rails::Railtie
+    rake_tasks do
+      Dir[File.join(File.dirname(__FILE__), '../tasks/*.rake')].each do |file|
+        load file
+      end
+    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
 
@@ -11,13 +12,10 @@ module Crono
       jobs << job
     end
 
-    def next
+    def next_jobs
-      queue.first
+      jobs.group_by(&:next).sort_by {|time,_| time }.first
-    end
-
-  private
-    def queue
-      jobs.sort_by(&:next)
     end
   end
+
+  mattr_accessor :scheduler
 end

lib/crono/version.rb

@@ -1,3 +1,3 @@
 module Crono
-  VERSION = '0.6.1'
+  VERSION = '0.8.1'
 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"
+      desc 'Installs crono and generates the necessary configuration files'
-      source_root File.expand_path("../templates", __FILE__)
+      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.
+# Here you can specify periodic jobs and schedule.
-# You can specify a periodic job as a ActiveJob class in `app/jobs/`
+# You can use ActiveJob's jobs from `app/jobs/`
-# Actually you can use any class. The only requirement is that
+# You can use any class. The only requirement is that
-# the class should implement a method `perform` without arguments.
+# 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

lib/tasks/crono_tasks.rake

@@ -0,0 +1,26 @@
+module Crono
+  def self.load_cronotab
+    cronotab_path = ENV['CRONOTAB'] || (defined?(Rails) &&
+                      File.join(Rails.root, cronotab_path))
+    fail 'No cronotab defined' unless cronotab_path
+    puts "Load cronotab #{cronotab_path}"
+    require cronotab_path
+  end
+end
+
+namespace :crono do
+  desc 'Clean unused job stats from DB'
+  task clean: :environment do
+    Crono.scheduler = Crono::Scheduler.new
+    Crono.load_cronotab
+    current_job_ids = Crono.scheduler.jobs.map(&:job_id)
+    Crono::CronoJob.where.not(job_id: current_job_ids).destroy_all
+  end
+
+  desc 'Check cronotab.rb syntax'
+  task check: :environment do
+    Crono.scheduler = Crono::Scheduler.new
+    Crono.load_cronotab
+    puts 'Syntax ok'
+  end
+end

spec/assets/bad_cronotab.rb

@@ -0,0 +1,12 @@
+# This is an example of a bad cronotab for tests
+
+class TestJob
+  def perform
+    puts 'Test!'
+  end
+end
+
+# This is an error, because you can use `on` options with
+# a period less than 7 days.
+
+Crono.perform(TestJob).every 5.days, on: :sunday

spec/assets/good_cronotab.rb

@@ -0,0 +1,9 @@
+# This is an example of a good cronotab for tests
+
+class TestJob
+  def perform
+    puts 'Test!'
+  end
+end
+
+Crono.perform(TestJob).every 5.seconds

spec/cli_spec.rb

@@ -1,15 +1,11 @@
-require "spec_helper"
+require 'spec_helper'
 require 'crono/cli'
 
-class TestJob
-  def perform;end
-end
-
 describe Crono::CLI do
   let(:cli) { Crono::CLI.instance }
 
-  describe "#run" do
+  describe '#run' do
-    it "should try to initialize rails with #load_rails and start working loop" 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 +14,30 @@ describe Crono::CLI do
     end
   end
 
-  describe "#start_working_loop" do
+  describe '#parse_options' do
-    it "should start working loop"
+    it 'should set cronotab' do
-  end
+      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
+    it 'should set logfile' do
-      cli.send(:parse_options, ["--logfile", "log/crono.log"])
+      cli.send(:parse_options, ['--logfile', 'log/crono.log'])
-      expect(cli.config.logfile).to be_eql "log/crono.log"
+      expect(cli.config.logfile).to be_eql 'log/crono.log'
     end
 
-    it "should set pidfile" do
+    it 'should set pidfile' do
-      cli.send(:parse_options, ["--pidfile", "tmp/pids/crono.0.log"])
+      cli.send(:parse_options, ['--pidfile', 'tmp/pids/crono.0.log'])
-      expect(cli.config.pidfile).to be_eql "tmp/pids/crono.0.log"
+      expect(cli.config.pidfile).to be_eql 'tmp/pids/crono.0.log'
     end
 
-    it "should set daemonize" do
+    it 'should set daemonize' do
-      cli.send(:parse_options, ["--daemonize"])
+      cli.send(:parse_options, ['--daemonize'])
       expect(cli.config.daemonize).to be true
     end
 
-    it "should set environment" do
+    it 'should set environment' do
-      cli.send(:parse_options, ["--environment", "production"])
+      cli.send(:parse_options, ['--environment', 'production'])
-      expect(cli.config.environment).to be_eql("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
+  describe '#initialize' do
-    it "should initialize with default configuration options" do
+    it 'should initialize with default configuration options' do
-      ENV["RAILS_ENV"] = "test"
+      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,120 @@
-require "spec_helper"
+require 'spec_helper'
-
-class TestJob
-  def perform;end
-end
 
 describe Crono::Job do
-  let(:period) { Crono::Period.new(2.day) }
+  let(:period) { Crono::Period.new(2.day, at: '15:00') }
-  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
+  describe '#next' do
-    it "should run performer in separate thread" do
+    it 'should return next performing time according to period' do
+      expect(job.next).to be_eql period.next
+    end
+  end
+
+  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
+    it 'should save performin errors to log' do
-      expect(job).to receive(:save)
+      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
+
+    xit 'should set Job#healthy to true if perform ok' do
+      class TestJob
+        def perform
+          @_crono_job
+        end
+      end
       job.perform.join
-      job.send(:model).destroy
+    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
+
+    xit 'should set @_crono_job variable to instance' do
+      job.perform
     end
   end
 
-  describe "#description" do
+  describe '#description' do
-    it "should return job identificator" do
+    it 'should return job identificator' do
-      expect(job.description).to be_eql("Perform TestJob every 2 days")
+      expect(job.description).to be_eql('Perform TestJob every 2 days at 15:00')
     end
   end
 
-  describe "#save" do
+  describe '#save' do
-    it "should save new job to DB" 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
+  it 'should validate presence of job_id' do
-    @crono_job = Crono::CronoJob.new()
+    @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
+  it 'should validate uniqueness of job_id' do
-    Crono::CronoJob.create!(job_id: "TestJob every 2 days")
+    Crono::CronoJob.create!(job_id: 'TestJob every 2 days')
-    @crono_job = 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,8 @@
-require "spec_helper"
+require 'spec_helper'
-
-class TestJob
-  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
+  describe '#description' do
-    it "should return period description" do
+    it 'should return period description' do
-      @period = Crono::Period.new(2.day, at: "15:20")
+      @period = Crono::Period.new(1.week, on: :monday, at: '15:20')
-      expect(@period.description).to be_eql("every 2 days at 15:20")
+      expect(@period.description).to be_eql('every 7 days at 15:20 on Monday')
     end
   end
 
-  describe "#next" do
+  describe '#next' do
-    context "in daily basis" do
+    context 'in weakly basis' do
-      it "should return the time 2 days from now" 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")
+        time = 10.minutes.ago
-        expect(@period.next).to be_eql(2.day.from_now.change(hour: 15, min: 20))
+        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,38 @@
-require "spec_helper"
+require 'spec_helper'
-
-class TestJob
-  def perform;end
-end
 
 describe Crono::Scheduler do
-  before(:each) do
+  let(:scheduler) { Crono::Scheduler.new }
-    @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")
-    ].map { |period| Crono::Job.new(TestJob, period) }
-    @scheduler.jobs = @jobs
-  end
 
-  describe "#add_job" do
+  describe '#add_job' do
-    it "should call Job#load on 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)
+      scheduler.add_job(@job)
     end
   end
 
-  describe "#next" do
+  describe '#next_jobs' do
-    it "should return next job in schedule" do
+    it 'should return next job in schedule' do
-      expect(@scheduler.next).to be @jobs[1]
+      scheduler.jobs = jobs = [
+        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) }
+
+      time, jobs = scheduler.next_jobs
+      expect(jobs).to be_eql [jobs[0]]
     end
 
-    it "should return next based on last" do
+    it 'should return an array of jobs scheduled at same time' do
-      expect(@scheduler.next)
+      time = 5.minutes.from_now
+      scheduler.jobs = jobs = [
+        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) }
+
+      time, jobs = scheduler.next_jobs
+      expect(jobs).to be_eql [jobs[0], jobs[1]]
     end
   end
 end

spec/spec_helper.rb

@@ -2,12 +2,25 @@ 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|
+class TestJob
+  def perform
+  end
+end
+
+class TestFailingJob
+  def perform
+    fail 'Some error'
+  end
 end

spec/tasks/crono_tasks_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+require 'rake'
+
+load 'tasks/crono_tasks.rake'
+Rake::Task.define_task(:environment)
+
+describe 'rake' do
+  describe 'crono:clean' do
+    it 'should clean unused tasks from DB' do
+      Crono::CronoJob.create!(job_id: 'used_job')
+      ENV['CRONOTAB'] = File.expand_path('../../assets/good_cronotab.rb', __FILE__)
+      Rake::Task['crono:clean'].invoke
+      expect(Crono::CronoJob.where(job_id: 'used_job')).not_to exist
+    end
+  end
+
+  describe 'crono:check' do
+    it 'should check cronotab syntax' do
+      ENV['CRONOTAB'] = File.expand_path('../../assets/bad_cronotab.rb', __FILE__)
+      expect { Rake::Task['crono:check'].invoke }.to raise_error
+    end
+  end
+end

spec/web_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+require 'rack/test'
+include Rack::Test::Methods
+
+describe Crono::Web do
+  let(:app) { Crono::Web }
+
+  before do
+    Crono::CronoJob.destroy_all
+    @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' }