jobbr 1.0.1

data/app/helpers/jobbr/application_helper.rb

@@ -0,0 +1,36 @@
+module Jobbr
+  module ApplicationHelper
+
+    def delayed_job_creation_path(delayed_job_class, params = {})
+      delayed_jobs_path(params.merge(job_name: delayed_job_class.name.underscore))
+    end
+
+    def delayed_job_polling_path(id = ':job_id')
+      delayed_job_path(id)
+    end
+
+    def status_icon_class(job_status)
+      if job_status == :waiting
+        "job-status #{job_status} icon-circle-blank"
+      elsif job_status == :running
+        "job-status #{job_status} icon-refresh icon-spin"
+      elsif job_status == :success
+        "job-status #{job_status} icon-certificate"
+      else
+        "job-status #{job_status} icon-exclamation-sign"
+      end
+    end
+
+    def display_scheduling(job)
+      every = job.class.every
+      if every
+        scheduling = ChronicDuration.output(every[0])
+        if every[1] && !every[1].empty?
+          scheduling = "#{scheduling} at #{every[1][:at]}"
+        end
+        scheduling
+      end
+    end
+
+  end
+end

data/app/models/jobbr/delayed_job.rb

@@ -0,0 +1,38 @@
+module Jobbr
+
+  class DelayedJob < Jobbr::Job
+
+    field :delayed, type: Boolean, default: true
+
+    # hack to work around multiple inheritance issue with Mongoid
+    default_scope ->{ Job.where(delayed: true, :_type.ne => nil) }
+
+    def perform(params, run)
+      raise NotImplementedError.new :message => 'Must be implemented'
+    end
+
+    def self.run_delayed(params, delayed = true)
+      job = instance
+      job_run = Run.create(status: :waiting, started_at: Time.now, job: job)
+      if delayed
+        job.delay.run(job_run, params)
+      else
+        job.run(job_run, params)
+      end
+      job_run
+    end
+
+    def self.run_delayed_by_name(job_class_name, params, delayed = true)
+      job = instance(job_class_name)
+      job_run = Run.create(status: :waiting, started_at: Time.now, job: job)
+      if delayed
+        job.delay.run(job_run, params)
+      else
+        job.run(job_run, params)
+      end
+      job_run
+    end
+
+  end
+
+end

data/app/models/jobbr/job.rb

@@ -0,0 +1,110 @@
+require 'jobbr/logger'
+
+module Jobbr
+
+  class Job
+
+    include Mongoid::Document
+    include Mongoid::Timestamps
+
+    MAX_RUN_PER_JOB = 50
+
+    has_many :runs, class_name: 'Jobbr::Run', dependent: :destroy
+
+    scope :by_name, ->(name) { where(_type: /.*#{name.underscore.camelize}/) }
+
+    def self.instance(instance_type = nil)
+      if instance_type
+        job_class = instance_type.camelize.constantize
+      else
+        job_class = self
+      end
+      job_class.find_or_create_by(_type: job_class.name)
+    end
+
+    def self.run
+      instance.run
+    end
+
+    def self.description(desc = nil)
+      @description = desc if desc
+      @description
+    end
+
+    def run(job_run = nil, params = {})
+      if job_run
+        job_run.status = :running
+        job_run.save!
+      else
+        job_run = Run.create(status: :running, started_at: Time.now, job: self)
+      end
+
+      # prevent Run collection to grow beyond max_run_per_job
+      job_runs = Run.where(job: self).order_by(started_at: 1)
+      runs_count = job_runs.count
+      if runs_count > max_run_per_job
+        job_runs.limit(runs_count - max_run_per_job).each(&:destroy)
+      end
+
+      # overidding Rails.logger
+      old_logger = Rails.logger
+      Rails.logger = Jobbr::Logger.new(Rails.logger, job_run)
+
+      begin
+        if self.delayed?
+          perform(params, job_run)
+        else
+          perform
+        end
+        job_run.status = :success
+      rescue Exception => e
+        job_run.status = :failure
+        logger.error(e.message)
+        logger.error(e.backtrace)
+        raise e
+      ensure
+        Rails.logger = old_logger
+        job_run.finished_at = Time.now
+        job_run.save!
+      end
+    end
+
+    def last_run
+      @last_run ||= Run.for_job(self).first
+    end
+
+    def average_run_time
+      return 0 if runs.empty?
+      (runs.map { |run| run.run_time }.compact.inject { |sum, el| sum + el }.to_f / runs.length).round(2)
+    end
+
+    def to_param
+      name.parameterize
+    end
+
+    def name
+      self._type.demodulize.underscore.humanize
+    end
+
+    def scheduled?
+      self.is_a? Jobbr::ScheduledJob
+    end
+
+    def delayed?
+      self.is_a? Jobbr::DelayedJob
+    end
+
+    protected
+
+    # mocking purpose
+    def max_run_per_job
+      MAX_RUN_PER_JOB
+    end
+
+    def logger
+      Rails.logger
+    end
+
+  end
+
+end

data/app/models/jobbr/log_message.rb

@@ -0,0 +1,15 @@
+module Jobbr
+
+  class LogMessage
+
+    include Mongoid::Document
+
+    field :message,  type: String
+    field :kind,     type: Symbol
+    field :date,     type: Time
+
+    embedded_in :run
+
+  end
+
+end

data/app/models/jobbr/run.rb

@@ -0,0 +1,61 @@
+module Jobbr
+
+  class Run
+
+    include Mongoid::Document
+    include Mongoid::Timestamps
+
+    field :status,      type: Symbol
+    field :started_at,  type: Time
+    field :finished_at, type: Time
+    field :progress,    type: Integer, default: 0
+    field :result
+
+    belongs_to   :job
+    embeds_many  :log_messages, class_name: 'Jobbr::LogMessage'
+
+    index(job_id: 1, started_at: -1)
+
+    scope :for_job, ->(job) { Run.where(job_id: job.id).order_by(started_at: -1) }
+
+    def run_time
+      @run_time ||= if finished_at && started_at
+        finished_at - started_at
+      else
+        nil
+      end
+    end
+
+    def next
+      return nil if index == 0
+      @next ||= Run.for_job(job).all[index - 1]
+    end
+
+    def previous
+      @previous ||= Run.for_job(job).all[index + 1]
+    end
+
+    def messages(limit = 1000)
+      limit = [log_messages.length, limit].min
+      log_messages[-limit..-1]
+    end
+
+    def result=(result)
+      write_attribute(:result, result)
+      save!
+    end
+
+    def progress=(progress)
+      write_attribute(:progress, progress)
+      save!
+    end
+
+    protected
+
+    def index
+      @index ||= job.runs.index(self)
+    end
+
+  end
+
+end

data/app/models/jobbr/scheduled_job.rb

@@ -0,0 +1,29 @@
+module Jobbr
+
+  class ScheduledJob < Job
+
+    field :scheduled, type: Boolean, default: true
+
+    default_scope ->{ Job.where(scheduled: true, :_type.ne => nil) }
+
+    def perform
+      raise NotImplementedError.new :message => 'Must be implemented'
+    end
+
+    def self.every(every = nil, options = {})
+      @every = [every, options] if every
+      @every
+    end
+
+    def self.task_name(with_namespace = false)
+      task_name = name.demodulize.underscore
+      if with_namespace
+        "jobbr:#{task_name}"
+      else
+        task_name
+      end
+    end
+
+  end
+
+end

data/app/models/jobbr/standalone_tasks.rb

@@ -0,0 +1,56 @@
+module Jobbr
+  module StandaloneTasks
+
+    # Build the information about the crontab jobs which
+    # will used to generate the corresponding rake tasks.
+    # If a block is passed, then it will iterate over each information.
+    #
+    # @params [ String ] name Name of the kind of jobs (scheduled_job)
+    #
+    def self.all(name, &block)
+      self.mock_job
+      require File.join(File.dirname(__FILE__), "#{name}.rb")
+
+      dependencies = ['Jobbr::Job', "Jobbr::#{name.to_s.camelize}"]
+
+      # load all the classes for the specific kind
+      list = Dir[Rails.root.join('app', 'models', name.to_s.pluralize, '*.rb')].map do |file|
+        require file
+        klass = "#{name.to_s.pluralize.camelize}::#{File.basename(file, '.rb').camelize}".constantize
+        dependencies << klass.name
+        {
+          name:         klass.task_name.to_sym,
+          desc:         klass.description,
+          klass_name:   klass.name,
+          dependencies: (dependencies[0..1] + [klass.name]).map { |n| "#{n.underscore}.rb" }
+        }
+      end
+
+      # clean our Job mock and make sure to unload its children as well
+      dependencies.reverse.each do |name|
+        module_name, klass_name = name.split('::')
+        module_name.constantize.send(:remove_const, klass_name.to_sym)
+      end
+
+      list.each(&block)
+    end
+
+    protected
+
+    # Mock Jobbr::Job which avoids to load the Mongoid stack
+    #
+    def self.mock_job
+      c = Class.new do
+        def self.field(*args); end
+        def self.default_scope(*args); end
+        def self.description(desc = nil)
+          @description = desc if desc
+          @description
+        end
+      end
+
+      ::Jobbr.const_set 'Job', c
+    end
+
+  end
+end

data/app/views/jobbr/jobs/_job_list.html.haml

@@ -0,0 +1,23 @@
+%h5= title
+
+%table.table.table-striped.table-hover
+  %thead
+    %tr
+      %th= t('.status')
+      %th= t('.job_name')
+      %th= t('.last_run')
+      %th= t('.average_run_time')
+  - jobs.each do |job|
+    %tr
+      %td
+        %i{'class' => status_icon_class(job.last_run.status)}
+      %td= job.name.humanize
+      %td= l job.last_run.started_at.localtime
+      %td= ChronicDuration.output(job.average_run_time)
+      %td
+        .btn-toolbar
+          .btn-group
+            = link_to job_path(job), class: 'btn', title: t('.see_all_runs') do
+              %i.icon-list
+            = link_to job_run_path(job, job.last_run), class: 'btn', title: t('.see_last_run') do
+              %i.icon-download

data/app/views/jobbr/jobs/index.html.haml

@@ -0,0 +1,6 @@
+%ul.breadcrumb
+  %li.active= t('.title')
+
+= render 'job_list', title: t('.scheduled_jobs'), jobs: @scheduled_jobs
+%br
+= render 'job_list', title: t('.delayed_jobs'), jobs: @delayed_jobs

data/app/views/jobbr/jobs/show.html.haml

@@ -0,0 +1,30 @@
+%ul.breadcrumb
+  %li
+    = link_to t('jobbr.jobs.index.title'), jobs_path
+    %span.divider /
+  %li.active= @job.name.humanize
+
+.well
+  - if @job.scheduled? && @job.class.every
+    %p= raw t('.scheduling', scheduling: display_scheduling(@job))
+  = raw t('.average_run_time', run_time: ChronicDuration.output(@job.average_run_time, format: :long))
+
+= render 'jobbr/runs/logs', run: @job.last_run, title: t('.last_run_logs'), size: 'small'
+
+%table.table.table-striped.table-hover
+  %thead
+    %tr
+      %th= t('.status')
+      %th= t('.last_run')
+      %th= t('.duration')
+  - @runs.each do |run|
+    %tr
+      %td
+        %i{'class' => status_icon_class(run.status)}
+      %td= l run.started_at.localtime
+      %td= ChronicDuration.output((run.finished_at - run.started_at).round(2)) rescue 'N/A'
+      %td
+        .btn-toolbar
+          .btn-group
+            = link_to job_run_path(@job, run), class: 'btn', title: t('.see_run') do
+              %i.icon-download

data/app/views/jobbr/runs/_logs.html.haml

@@ -0,0 +1,7 @@
+%h5= title
+.well.logs{class: size}
+  - run.messages.each do |msg|
+    %span.date{class: msg.kind}= "[#{msg.date.localtime.strftime('%H:%M:%S')}]"
+    %span.kind{class: msg.kind}= "[#{msg.kind}]"
+    %span.message= raw(msg.message)
+    %br

data/app/views/jobbr/runs/show.html.haml

@@ -0,0 +1,31 @@
+%ul.breadcrumb
+  %li
+    = link_to t('jobbr.jobs.index.title'), jobs_path
+    %span.divider /
+  %li
+    = link_to @job.name.humanize, job_path(@job)
+    %span.divider /
+  %li.active
+    = l @run.started_at
+    %i{'class' => status_icon_class(@run.status)}
+  .btn-toolbar
+    .btn-group
+      - if @run.previous
+        = link_to job_run_path(@job, @run.previous), class: 'btn', title: t('.previous_run') do
+          %i.icon-step-backward
+      - else
+        = link_to '#', class: 'btn disabled' do
+          %i.icon-step-backward
+      - if @run.next
+        = link_to job_run_path(@job, @run.next), class: 'btn', title: t('.next_run') do
+          %i.icon-step-forward
+      - else
+        = link_to '#', class: 'btn disabled' do
+          %i.icon-step-forward
+
+- if @run.run_time
+  .well
+    = t('.run_time', run_time: ChronicDuration.output(@run.run_time.round(2), format: :long))
+
+= render 'logs', run: @run, title: t('.logs'), size: 'large'
+