jobit 0.0.1

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+log
+.idea

data/.rspec

@@ -0,0 +1 @@
+--color

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+## v0.0.1
+
+* initial release

data/Gemfile

@@ -0,0 +1,4 @@
+source 'http://rubygems.org'
+
+# Specify your gem's dependencies in jobit.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Victor Yunevich
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOa AND
+NONINFRINGEMENT. IN NO EVENT SaALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1 @@
+nothing yet

data/Rakefile

@@ -0,0 +1,8 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/app/controllers/jobit/jobs_controller.rb

@@ -0,0 +1,19 @@
+module Jobit
+  class JobsController < ActionController::Base
+
+    def index
+      job = Jobit::Job.find_by_name(params[:id])
+
+      if job.nil?
+        json_response = {:status => 'not_found'}
+      else
+        json_response = job.session
+        if job.status == 'complete'
+          job.destroy if job.status == "complete"
+        end
+      end
+
+      render :json => json_response
+    end
+  end
+end

data/config/routes.rb

@@ -0,0 +1,3 @@
+Jobit::Engine.routes.draw do
+  get '/(:id)', :to => 'jobs#index'
+end

data/init.rb

@@ -0,0 +1,2 @@
+require File.dirname(__FILE__) + '/lib/jobit'
+

data/jobit.gemspec

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/jobit/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Victor Yunevich"]
+  gem.email         = ["v.t.g.m.b.x@gmail.com"]
+  gem.description   = %q{Process background jobs in queue.}
+  gem.summary       = %q{Background jobs processing}
+  gem.homepage      = ""
+
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.name          = "jobit"
+  gem.require_paths = ["lib"]
+  gem.version       = Jobit::VERSION
+  
+  gem.add_dependency "daemons"
+  gem.add_development_dependency "rspec"
+end

data/lib/jobit.rb

@@ -0,0 +1,8 @@
+require "jobit/version"
+require File.dirname(__FILE__) + '/jobit/storage'
+require File.dirname(__FILE__) + '/jobit/jobby'
+require File.dirname(__FILE__) + '/jobit/job'
+require File.dirname(__FILE__) + '/jobit/worker'
+require File.dirname(__FILE__) + '/jobit/engine' if defined?(Rails)
+require File.dirname(__FILE__) + '/jobit/railtie' if defined?(Rails)
+

data/lib/jobit/command.rb

@@ -0,0 +1,88 @@
+require 'rubygems'
+require 'daemons'
+require 'optparse'
+
+module Jobit
+  class Command
+    attr_accessor :worker_count
+
+    def initialize(args)
+      @files_to_reopen = []
+      @options = {
+        :quiet => true,
+        :pid_dir => "#{Rails.root}/tmp/pids"
+      }
+
+      @worker_count = 1
+      @monitor = false
+
+      opts = OptionParser.new do |opts|
+        opts.banner = "Usage: #{File.basename($0)} [options] start|stop|restart|run"
+
+        opts.on('-h', '--help', 'Show this message') do
+          puts opts
+          exit 1
+        end
+        opts.on('-n', '--number_of_workers=workers', "Number of unique workers to spawn") do |worker_count|
+          @worker_count = worker_count.to_i rescue 1
+        end
+      end
+      @args = opts.parse!(args)
+    end
+
+    def daemonize
+      #Jobit::Worker.backend.before_fork
+
+      ObjectSpace.each_object(File) do |file|
+        @files_to_reopen << file unless file.closed?
+      end
+
+      dir = @options[:pid_dir]
+      Dir.mkdir(dir) unless File.exists?(dir)
+
+      if @worker_count > 1 && @options[:identifier]
+        raise ArgumentError, 'Cannot specify both --number-of-workers and --identifier'
+      elsif @worker_count == 1 && @options[:identifier]
+        process_name = "jobit.#{@options[:identifier]}"
+        run_process(process_name, dir)
+      else
+        worker_count.times do |worker_index|
+          process_name = worker_count == 1 ? "jobit" : "jobit.#{worker_index}"
+          run_process(process_name, dir)
+        end
+      end
+    end
+
+    def run_process(process_name, dir)
+      Daemons.run_proc(process_name, :dir => dir, :dir_mode => :normal, :monitor => @monitor, :ARGV => @args) do |*args|
+        $0 = File.join(@options[:prefix], process_name) if @options[:prefix]
+        run process_name
+      end
+    end
+
+    def run(worker_name = nil)
+      Dir.chdir(Rails.root)
+
+      # Re-open file handles
+      @files_to_reopen.each do |file|
+        begin
+          file.reopen file.path, "a+"
+          file.sync = true
+        rescue ::Exception
+        end
+      end
+
+      #Delayed::Worker.logger = Logger.new(File.join(Rails.root, 'log', 'delayed_job.log'))
+      #Delayed::Worker.backend.after_fork
+
+      worker = Jobit::Worker.new(@options)
+      #worker.name_prefix = "#{worker_name} "
+      worker.start
+    rescue => e
+      Rails.logger.fatal e
+      STDERR.puts e.message
+      exit 1
+    end
+
+  end
+end

data/lib/jobit/engine.rb

@@ -0,0 +1,5 @@
+module Jobit
+  class Engine < Rails::Engine
+    isolate_namespace Jobit
+  end
+end

data/lib/jobit/job.rb

@@ -0,0 +1,102 @@
+require 'logger'
+require 'benchmark'
+
+module Jobit
+
+  class Job
+
+    def self.jobs_path
+      if defined?(Rails)
+        "#{Rails.root.to_s}/tmp/jobit"
+      else
+        File.dirname(__FILE__) + "/../../tmp/jobit"
+      end
+    end
+
+    def self.worker_name
+      "host:#{Socket.gethostname} pid:#{Process.pid}" rescue "pid:#{Process.pid}"
+    end
+
+    def self.destroy_all
+      Storage.destroy_all
+    end
+
+    def self.destroy_failed
+      failed_jobs = Storage.where({:status => 'failed'})
+      for job in failed_jobs
+        job.destroy
+      end
+      true
+    end
+
+    def self.logger
+      if defined?(Rails)
+        Logger.new("#{Rails.root.to_s}/log/jobit.log", shift_age = 7, shift_size = 1048576)
+      else
+        Logger.new(File.dirname(__FILE__) + "/../../log/jobit.log")
+      end
+    end
+
+    # Jobit::Job.all
+    # returns array of all jobs
+    def self.all
+      Storage.all
+    end
+
+    # Jobit::Job.find(11111.111)
+    # returns job or nil
+    def self.find(id)
+      Storage.find(id)
+    end
+
+    # Jobit::Job.find_by_name('name')
+    # returns job or nil
+    def self.find_by_name(name)
+      Storage.find_by_name(name)
+    end
+
+    # Jobit::Job.where({:name => 'name'})
+    # returns array of found jobs
+    def self.where(search)
+      Storage.where(search)
+    end
+
+    # Jobit::Job.add(name, object, *args) {{options}}
+    # options:
+    #   :priority => the job priority (Integer)
+    #   :run_after => run job after some time from now ex: :run_after => 4.hours
+    #   :schedule => run job at some time. ex: :schedule_at => "16:00"
+    #   :repeat => how many times to repeat the job (Integer)
+    #   :repeat_delay => delay in seconds before next repeat
+    def self.add(name, object, *args, &block)
+      unless JobitItems.method_defined?(object)
+        raise ArgumentError, "Can't add job #{object}. It's not defined in jobs."
+      end
+
+      options = {}
+      options = yield if block_given?
+
+      options[:name] = name
+      options[:object] = object
+      options[:args] = Marshal.dump(args)
+
+      Jobby.new(nil, options)
+    end
+
+    def self.work_off(num = 100)
+      complete, failed, reissued = 0, 0, 0
+      num.times do
+        jobs = self.where({:status => 'new'})
+        break unless jobs.size > 0
+        res = jobs.first.run_job
+        complete += res[0]
+        failed += res[1]
+        reissued += res[2]
+        break if $exit
+      end
+      [complete, failed, reissued]
+    end
+
+  end
+
+end

data/lib/jobit/jobby.rb

@@ -0,0 +1,152 @@
+require File.dirname(__FILE__) + '/jobs/statuses'
+require File.dirname(__FILE__) + '/jobs/commands'
+
+module Jobit
+  class Jobby < Struct.new(
+    :id, :name, :object, :args, :message, :progress, :error, :priority, :run_at,
+    :schedule, :repeat, :repeat_delay, :created_at, :started_at, :stopped_at,
+    :locked_by, :locked_at, :tries, :status, :keep, :failed_at
+  )
+
+    MAX_ATTEMPTS = 25
+    MAX_RUN_TIME = 4 # hours
+
+    include Jobit::Jobs::Statuses
+    include Jobit::Jobs::Commands
+
+    def initialize(job = nil, options = {})
+      if job.nil?
+        create_new
+        if options
+          for key, val in options
+            self[key] = val
+          end
+        end
+        self.id = "#{priority}.#{id}"
+        Jobit::Storage.create(id, self)
+      else
+        job.each_with_index do |val, index|
+          self[index] = val
+        end
+      end
+    end
+
+    def destroy
+      return unless id
+      Jobit::Storage.destroy(id)
+      clear
+    end
+
+    def process_job(args)
+      begin
+        logger.info "* [JOB] aquiring lock on #{name}"
+        runtime = Benchmark.realtime do
+          set_status 'running'
+          set_start_time
+          self.send(object,*args)
+          set_status 'complete'
+          set_stop_time
+        end
+        logger.info "* [JOB] #{name} completed after %.4f" % runtime
+      rescue Exception => e
+        log_exception(e)
+        msg = "#{e.message}\n\n#{e.backtrace.join("\n")}"
+        set_error(msg)
+      end
+    end
+
+    def run_job(worker_name = 'worker')
+      return nil if locked?
+      lock!(worker_name)
+      self.class.send(:include, JobitItems)
+      job_args = Marshal.restore(args)
+      num = repeat.to_i == 0 ? 1 : repeat.to_i
+      delay = repeat_delay.to_i
+      num.times do
+        process_job(job_args)
+        break if failed? # stop loop if job failed
+        increase_tries
+        sleep delay if delay > 0
+      end
+      #p self.class.send(:method_defined?, :perform)
+      #p self.class.send(:undef_method, :perform)
+      cleanup
+    end
+
+
+    def log_exception(error)
+      logger.error "* [JOB:#{name}] failed with #{error.class.name}: #{error.message} - #{tries} failed attempts"
+      logger.error(error)
+    end
+
+    private
+
+    def logger
+      @logger ||= Jobit::Job.logger
+    end
+
+    def create_new
+      self.id = Time.now.to_f
+      self.name = name
+      self.message = ''
+      self.progress = 0
+      self.priority = 0
+      self.run_at = nil
+      self.repeat = 0
+      self.repeat_delay = 0
+      self.created_at = id
+      self.tries = 0
+      self.status = 'new'
+      self.keep = false
+      self
+    end
+
+    def reload
+      reloaded_job = Storage.find(id)
+      reloaded_job.each_with_index do |val, index|
+        self[index] = val
+      end
+    end
+
+    def update
+      Jobit::Storage.update(id, self)
+    end
+
+    def cleanup
+      complete, failed, reissued = 0, 0, 0
+      if failed?
+        if tries < MAX_ATTEMPTS
+          self.tries += 1
+          self.run_at = Time.now + (tries ** 4) + 5
+          self.status = 'new'
+          unlock!
+          update
+          reissued = 1
+        else
+          logger.info "* [JOB:#{name}] Removing... Too many tries."
+          destroy unless keep?
+          failed = 1
+        end
+      elsif complete?
+        if keep?
+          set_progress(100)
+          set_stop_time
+          unlock!
+        else
+          destroy
+        end
+        complete = 1
+      end
+      [complete, failed, reissued]
+    end
+
+    def clear
+      options_size = self.size-1
+
+      for i in (0..options_size)
+        self[i]= nil
+      end
+    end
+
+  end
+end

data/lib/jobit/jobs/commands.rb

@@ -0,0 +1,64 @@
+module Jobit
+  module Jobs
+    module Commands
+      def set_start_time
+        self.started_at = Time.now.to_f
+        update
+      end
+
+      def set_stop_time
+        self.stopped_at = Time.now.to_f
+        update
+      end
+
+      def set_status(new_status)
+        self.status = new_status
+        update
+      end
+
+      def set_error(text)
+        self.error = text
+        self.status = 'failed'
+        self.stopped_at = Time.now.to_f
+        self.failed_at = stopped_at
+        update
+      end
+
+      def set_tries(num)
+        self.tries = num
+        update
+      end
+
+      def increase_tries
+        self.tries += 1
+        update
+      end
+
+      def set_progress(num)
+        self.progress = num
+        update
+      end
+
+      def add_message(text, force = false)
+        if self.keep? || force
+          self.message += text
+          update
+        end
+      end
+
+      def unlock!
+        self.locked_at= nil
+        self.locked_by= nil
+        update
+      end
+
+      def lock!(worker_name)
+        self.run_at= Time.now.to_f
+        self.locked_at= Time.now.to_f
+        self.locked_by= worker_name
+        update
+      end
+
+    end
+  end
+end

data/lib/jobit/jobs/statuses.rb

@@ -0,0 +1,53 @@
+module Jobit
+  module Jobs
+    module Statuses
+      def running?
+        status == 'running'
+      end
+
+      def failed?
+        status == 'failed'
+      end
+
+      def complete?
+        status == 'complete'
+      end
+
+      def stopped?
+        status == 'stopped'
+      end
+
+      def new?
+        status == 'new'
+      end
+
+      def keep?
+        keep
+      end
+
+      def locked?
+        locked_at != nil
+      end
+
+      def current_job
+        self
+      end
+
+      def session
+        {
+          :name => name,
+          :message => message,
+          :progress => progress,
+          :error => error,
+          :run_at => run_at,
+          :created_at => created_at,
+          :started_at => started_at,
+          :stopped_at =>stopped_at,
+          :tries => tries,
+          :status => status,
+          :failed_at => failed_at
+        }
+      end
+    end
+  end
+end

data/lib/jobit/railtie.rb

@@ -0,0 +1,11 @@
+require 'jobit'
+require 'rails'
+module Jobit
+  class Railtie < Rails::Railtie
+    railtie_name :jobit
+
+    rake_tasks do
+      load "tasks/jobit.rake"
+    end
+  end
+end

data/lib/jobit/storage.rb

@@ -0,0 +1,123 @@
+# encoding: utf-8
+module Jobit
+  class Storage
+
+    def self.all_files
+      Dir.mkdir(Jobit::Job.jobs_path) unless Dir.exist?(Jobit::Job.jobs_path)
+      Dir.glob("#{Jobit::Job.jobs_path}/*").find_all { |x| File.file? x }
+    end
+
+    def self.destroy_all
+      for file_name in self.all_files
+        File.delete(file_name)
+      end
+    end
+
+    def self.all
+      result = []
+
+      for file_name in self.all_files
+        obj = get_data_from_file(file_name)
+        result << Jobby.new(obj)
+      end
+
+      result
+    end
+
+    def self.find(id)
+      file_name = self.make_file_name(id)
+      return nil unless File.exist?(file_name)
+
+      obj = get_data_from_file(file_name)
+      Jobby.new(obj)
+    end
+
+
+    def self.find_by_name(name)
+
+      result = nil
+
+      for file_name in self.all_files
+        obj = get_data_from_file(file_name)
+        next if obj.nil?
+        if obj.name == name
+          result = Jobby.new(obj)
+          break
+        end
+      end
+
+      result
+    end
+
+    def self.where(search)
+      search_hash = {:name => search}
+      search_hash = search if search.is_a?(Hash)
+
+      result = []
+
+      for file_name in self.all_files
+        obj = get_data_from_file(file_name)
+        for key, val in search_hash
+          next unless obj.respond_to?(key)
+          result << Jobby.new(obj) if obj[key] == val
+        end
+      end
+
+      result
+    end
+
+    def self.destroy(file)
+      file_name = self.make_file_name(file)
+      return false unless File.exist?(file_name)
+      File.delete(file_name)
+    end
+
+    def self.create(file, content)
+      Dir.mkdir(Jobit::Job.jobs_path) unless Dir.exist?(Jobit::Job.jobs_path)
+      file_name = self.make_file_name(file)
+      data = Marshal.dump(content.to_hash)
+      File.open(file_name, 'w+b') { |f| f.write(data) }
+      true
+    end
+
+
+    def self.update(file, content)
+      file_name = self.make_file_name(file)
+      return false unless File.exist?(file_name)
+      File.open(file_name, 'w+b') { |f| f.write(Marshal.dump(content.to_hash)) }
+      true
+    end
+
+    private
+
+    def self.get_data_from_file(file_name)
+      begin
+        file = File.open(file_name)
+        obj = Marshal.load(file).to_struct
+      rescue
+        return nil
+      ensure
+        file.close
+      end
+      obj
+    end
+
+    def self.make_file_name(file)
+      File.join(Jobit::Job.jobs_path, file.to_s)
+    end
+
+
+  end
+end
+
+class Hash
+  def to_struct
+    Struct.new(*keys).new(*values)
+  end
+end
+
+class Struct
+  def to_hash
+    Hash[*members.zip(values).flatten]
+  end
+end

data/lib/jobit/version.rb

@@ -0,0 +1,3 @@
+module Jobit
+  VERSION = "0.0.1"
+end

data/lib/jobit/worker.rb

@@ -0,0 +1,49 @@
+module Jobit
+  class Worker
+    SLEEP = 5
+
+    def logger
+      @logger ||= Jobit::Job.logger
+    end
+
+    def initialize(options={})
+      @quiet = options[:quiet]
+      #Delayed::Job.min_priority = options[:min_priority] if options.has_key?(:min_priority)
+      #Delayed::Job.max_priority = options[:max_priority] if options.has_key?(:max_priority)
+    end
+
+    def start
+      #say "*** Starting job worker #{Jobit::Job.worker_name}"
+      say "*** Starting job worker #{Jobit::Job.worker_name}"
+
+      trap('TERM') { say 'Exiting...'; $exit = true }
+      trap('INT') { say 'Exiting...'; $exit = true }
+
+      loop do
+        result = nil
+
+        realtime = Benchmark.realtime do
+          result = Jobit::Job.work_off
+        end
+
+        count = result.sum
+
+        break if $exit
+
+        if count.zero?
+          sleep(SLEEP)
+        else
+          say "#{count} jobs processed at %.4f j/s, %d failed ..." % [count / realtime, result[1]]
+        end
+
+        break if $exit
+      end
+    end
+
+    def say(text)
+      puts text unless @quiet
+      logger.info text if logger
+    end
+
+  end
+end

data/lib/tasks/jobit.rake

@@ -0,0 +1 @@
+require File.join(File.dirname(__FILE__), 'tasks')

data/lib/tasks/tasks.rb

@@ -0,0 +1,20 @@
+# Re-definitions are appended to existing tasks
+task :environment
+
+namespace :jobit do
+  desc "Clear the Jobit job queue."
+  task :clear => :environment do
+    Jobit::Job.destroy_all
+  end
+
+  desc "Clear the Jobit filed jobs."
+  task :clear_failed => :environment do
+    Jobit::Job.destroy_failed
+  end
+
+  desc "Start a Jobit worker."
+  task :work => :environment do
+    p Rails.root
+    Jobit::Worker.new().start
+  end
+end

data/spec/jobit/storage_spec.rb

@@ -0,0 +1,93 @@
+# encoding: utf-8
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Jobit::Storage do
+
+  def struct
+    struct = Struct.new(:id, :name)
+    struct.new(@file_name, @job_name)
+  end
+
+  before(:each) do
+    @file_name = Time.now.to_f
+    @job_name = "job#1"
+    @total_files = Jobit::Storage.all_files.size
+    Jobit::Storage.create(@file_name, struct).should eq(true)
+  end
+
+  after(:each) do
+    Jobit::Storage.destroy(@file_name)
+  end
+
+  after(:all) do
+    begin
+      Dir.delete(Jobit.jobs_path)
+    rescue
+      nil
+    end
+  end
+
+  it "creates file with struct id equal to filename" do
+    job = Jobit::Storage.find(@file_name)
+    job.should be_a(Struct)
+    job.id.should eq(@file_name)
+  end
+
+  it ".find returns file value" do
+    job = Jobit::Storage.find(@file_name)
+    job.should be_a(Struct)
+    job.name.should eq(@job_name)
+  end
+
+  it ".all retrieves list of jobs" do
+    jobs = Jobit::Storage.all
+    jobs.should be_a(Array)
+    jobs.size.should eq(@total_files+1)
+  end
+
+
+  it ".find_by_name returns file value" do
+    job = Jobit::Storage.find_by_name(@job_name)
+    job.should be_a(Struct)
+    job.name.should eq(@job_name)
+  end
+
+  it ".find_by_name with wrong name returns nil" do
+    job = Jobit::Storage.find_by_name('wrong_name')
+    job.should eq(nil)
+  end
+
+  it ".where(name) returns file value" do
+    jobs = Jobit::Storage.where(@job_name)
+    jobs.should be_a(Array)
+    jobs.first.name.should eq(@job_name)
+  end
+
+  it ".where(hash) returns file value" do
+    jobs = Jobit::Storage.where({:name => @job_name})
+    jobs.should be_a(Array)
+    jobs.first.name.should eq(@job_name)
+  end
+
+  it ".where(wrong hash key) returns empty array" do
+    jobs = Jobit::Storage.where({:name1 => @job_name})
+    jobs.should be_a(Array)
+    jobs.size.should eq(0)
+  end
+
+  it ".where(wrong hash value) returns empty array" do
+    jobs = Jobit::Storage.where({:name => 'wrong_name'})
+    jobs.should be_a(Array)
+    jobs.size.should eq(0)
+  end
+
+  it "find by name and update" do
+    job = Jobit::Storage.find_by_name(@job_name)
+    job.name = "new name"
+    Jobit::Storage.update(job.id, job)
+    job = Jobit::Storage.find(job.id)
+    job.should be_a(Struct)
+    job.name.should eq('new name')
+  end
+
+end

data/spec/jobit_spec.rb

@@ -0,0 +1,236 @@
+# encoding: utf-8
+require File.dirname(__FILE__) + '/spec_helper'
+
+module JobitItems
+
+  def good_job(opt1, opt2)
+    set_progress(10)
+    unless opt1 == 'val1'
+      raise(NoMethodError, 'wrong arguments 0')
+    end
+    unless opt2 == 'val2'
+      raise(NoMethodError, 'wrong arguments 1')
+    end
+    set_progress(100)
+  end
+
+  def bad_job(text)
+    add_message "start"
+    set_progress(10)
+    add_message "end"
+    raise(NoMethodError, "Some dumb error #{text}")
+  end
+end
+
+describe Jobit do
+  describe "Job" do
+
+    before(:each) do
+      @job_name = 'job-1'
+      @total_jobs = Jobit::Job.all.size
+      @new_job = Jobit::Job.add(@job_name, :good_job, 'val1', 'val2') {
+        {:priority => 1}
+      }
+    end
+
+    after(:each) do
+      @new_job.destroy
+    end
+
+    after(:all) do
+      begin
+        Dir.delete(Jobit::JOBS_PATH)
+      rescue
+        nil
+      end
+    end
+
+    it "creates new job" do
+      @new_job.name.should eq(@job_name)
+    end
+
+    it 'returns nil if not found' do
+      job = Jobit::Job.find('123')
+      job.should eq(nil)
+    end
+
+    it 'returns job if found by id' do
+      job = Jobit::Job.find(@new_job.id)
+      job.name.should eq(@job_name)
+    end
+
+    it 'returns job if found_by_name' do
+      job = Jobit::Job.find_by_name(@job_name)
+      job.name.should eq(@job_name)
+    end
+
+    it 'returns array of all jobs' do
+      jobs = Jobit::Job.all
+      jobs.should be_a(Array)
+      jobs.size.should eq(@total_jobs+1)
+      jobs.first.name.should be_a(String)
+    end
+
+    it 'returns array of found jobs' do
+      jobs = Jobit::Job.where(:name => @job_name)
+      jobs.should be_a(Array)
+      jobs.size.should eq(1)
+      jobs.first.name.should eq(@job_name)
+    end
+
+    it 'returns empty array if wrong key' do
+      jobs = Jobit::Job.where(:name1 => @job_name)
+      jobs.should be_a(Array)
+      jobs.size.should eq(0)
+    end
+
+    it 'returns empty array if wrong value' do
+      jobs = Jobit::Job.where(:name => 'wrong name')
+      jobs.should be_a(Array)
+      jobs.size.should eq(0)
+    end
+
+    it 'destroys job' do
+      @new_job.destroy
+      job = Jobit::Job.find_by_name(@job_name)
+      job.should eq(nil)
+    end
+
+    it 'update status' do
+      @new_job.status.should eq('new')
+      @new_job.set_status 'running'
+      @new_job.status.should eq('running')
+      job = Jobit::Job.find_by_name(@job_name)
+      job.status.should eq('running')
+    end
+
+    it 'update error' do
+      @new_job.error.should eq(nil)
+      @new_job.set_error 'my error'
+      @new_job.error.should eq('my error')
+      job = Jobit::Job.find_by_name(@job_name)
+      job.error.should eq('my error')
+    end
+
+    it 'update error' do
+      @new_job.tries.should eq(0)
+      @new_job.set_tries 1
+      @new_job.tries.should eq(1)
+      job = Jobit::Job.find_by_name(@job_name)
+      job.tries.should eq(1)
+    end
+
+    it 'update progress' do
+      @new_job.progress.should eq(0)
+      @new_job.set_progress 10
+      @new_job.progress.should eq(10)
+      job = Jobit::Job.find_by_name(@job_name)
+      job.progress.should eq(10)
+    end
+
+    it 'adds message' do
+      @new_job.message.should eq('')
+      @new_job.add_message('hello',true)
+      @new_job.message.should eq('hello')
+      job = Jobit::Job.find_by_name(@job_name)
+      job.message.should eq('hello')
+      @new_job.add_message(' there',true)
+      @new_job.message.should eq('hello there')
+      job = Jobit::Job.find_by_name(@job_name)
+      job.message.should eq('hello there')
+    end
+
+    it 'running good job' do
+      @new_job.run_job
+      job = Jobit::Job.find_by_name(@job_name)
+      job.should eq(nil)
+    end
+
+    it 'running good job 5 times' do
+      job = Jobit::Job.add('good_job', :good_job, 'val1', 'val2') { {
+        :priority => 0,
+        :repeat => 5
+      } }
+      job.keep?.should eq(false)
+      job.run_job
+      job = Jobit::Job.find_by_name('good_job')
+      job.should eq(nil)
+    end
+
+    it 'running good job 5 times and keep file' do
+      job = Jobit::Job.add('good_job_keep', :good_job, 'val1', 'val2') { {
+        :priority => 0,
+        :repeat => 5,
+        :keep => true
+      } }
+      job.run_job
+      job = Jobit::Job.find_by_name('good_job_keep')
+      job.tries.should eq(5)
+      job.run_at.should_not eq(nil)
+      job.destroy
+    end
+
+    it 'running bad job' do
+      job = Jobit::Job.add('bad_job', :bad_job, 'val1') {
+        {
+          :priority => 0,
+          :keep => true
+        }
+      }
+
+      job.run_job
+      job = Jobit::Job.find_by_name('bad_job')
+      job.tries.should eq(1)
+      job.message.should eq('startend')
+      job.status.should eq('new')
+      job.progress.should eq(10)
+      job.destroy
+    end
+
+    it 'running bad job 5 times should run it just once' do
+      job = Jobit::Job.add('bad_job_5', :bad_job, 'val1') {
+        {
+          :priority => 0,
+          :repeat => 5
+        }
+      }
+
+      job.run_job
+      job = Jobit::Job.find_by_name('bad_job_5')
+      job.tries.should eq(1)
+      job.status.should eq('new')
+      job.progress.should eq(10)
+      job.destroy
+    end
+
+    it 'work_off test' do
+      @new_job.destroy
+      for i in (0..5)
+        Jobit::Job.add("work_off_#{i}", :good_job, 'val1', 'val2') { {
+          :priority => rand(6),
+          :keep => true
+        } }
+      end
+      Jobit::Job.add('work_off_bad', :bad_job, 'val1') { {
+        :priority => 2,
+        :keep => true
+      } }
+
+      Jobit::Job.work_off
+      jobs = []
+      for i in (0..5)
+        job = Jobit::Job.find_by_name("work_off_#{i}")
+        job.status.should eq('complete'), " #{job}"
+        job.destroy
+        job.id.should eq(nil)
+      end
+
+      job_failed = Jobit::Job.find_by_name('work_off_bad')
+      job_failed.tries.should eq(25)
+      job_failed.status.should eq('failed')
+      job_failed.destroy
+
+    end
+
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require 'jobit'

metadata

@@ -0,0 +1,97 @@
+--- !ruby/object:Gem::Specification
+name: jobit
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Victor Yunevich
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-12-03 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: daemons
+  requirement: &2162428060 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *2162428060
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &2162427640 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2162427640
+description: Process background jobs in queue.
+email:
+- v.t.g.m.b.x@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- CHANGELOG.md
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- app/controllers/jobit/jobs_controller.rb
+- config/routes.rb
+- init.rb
+- jobit.gemspec
+- lib/jobit.rb
+- lib/jobit/command.rb
+- lib/jobit/engine.rb
+- lib/jobit/job.rb
+- lib/jobit/jobby.rb
+- lib/jobit/jobs/commands.rb
+- lib/jobit/jobs/statuses.rb
+- lib/jobit/railtie.rb
+- lib/jobit/storage.rb
+- lib/jobit/version.rb
+- lib/jobit/worker.rb
+- lib/tasks/jobit.rake
+- lib/tasks/tasks.rb
+- spec/jobit/storage_spec.rb
+- spec/jobit_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.6
+signing_key: 
+specification_version: 3
+summary: Background jobs processing
+test_files:
+- spec/jobit/storage_spec.rb
+- spec/jobit_spec.rb
+- spec/spec_helper.rb