jober 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 658e5f757cdbd193692c730c37853625a6ece891
+  data.tar.gz: 949f6f7ee9ede001aa2ebb14693ee4e537b94737
+SHA512:
+  metadata.gz: 4c5152af3de453ca2f1dd7d0be59f44c52bff556b23dee3204140f18708133223da49f744f2f83acde333ee113c18f99190c65649829a3deee00a5c624a865b6
+  data.tar.gz: 47fa1ca5099ad4294d673cd2ce54b7347432ca75a3ed5e15e9c968b9208e093b5250ebefd0f1b2a80ce949b89b0261094d06a27ad32a31bf51731539b7797472

data/.gitignore

@@ -0,0 +1,17 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+*.log
+*.swp
+todo

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 'Konstantin Makarchev'
+
+MIT License
+
+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 PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL 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/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/bin/jober

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+$:.unshift File.expand_path(File.join(File.dirname(__FILE__), %w[.. lib]))
+require "Jober"
+
+task_name = ARGV[0]
+recursive = true
+
+while true
+  
+end

data/bin/manager

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+$:.unshift File.expand_path(File.join(File.dirname(__FILE__), %w[.. lib]))
+require "jober"
+
+# TODO: require application environment
+# TODO: pass application name
+# TODO: pass logger_path
+
+m = Jober::Manager.new "test"
+m.run

data/examples/classes.rb

@@ -0,0 +1,72 @@
+require 'bundler/setup'
+Bundler.require :default
+
+class A < Jober::Task
+  every 10
+  def perform
+    10.times do |i|
+      info "enqueue to b #{i}"
+      B.enqueue(i)
+    end
+  end
+end
+
+class B < Jober::Queue
+  every 10
+  def perform(x)
+    10.times do |i|
+      info "enqueue to c #{x} #{i}"
+      C.enqueue(x, i)
+    end
+  end
+end
+
+class C < Jober::Queue
+  every 10
+  def perform(x, i)
+    10.times do |j|
+      info "enqueue to d #{x} #{i} #{j}"
+      D.enqueue(x, i, j)
+    end
+  end
+end
+
+class D < Jober::QueueBatch
+  every 10
+  batch_size 200
+
+  def perform(*batch)
+    info "got batch: #{batch.inspect}"
+  end
+end
+
+class E < Jober::Task
+  5.times { every 5 }
+
+  def perform
+    puts "start e :)"
+    sleep 3
+  end
+end
+
+class G < Jober::Task
+  every 10
+
+  def perform
+    "asdfsdf" + 1
+  end
+end
+
+class F < Jober::Task
+  every 5
+  def perform
+    sleep 100
+  end
+end
+
+if $0 == __FILE__
+  require 'irb'
+  require 'irb/completion'
+
+  IRB.start
+end

data/examples/man.rb

@@ -0,0 +1,7 @@
+require 'bundler/setup'
+Bundler.require :default
+require_relative 'classes'
+
+man = Jober::Manager.new "test"
+man.logger_path = File.expand_path(__dir__)
+man.run

data/jober.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'jober/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "jober"
+  spec.version       = Jober::VERSION
+  spec.authors       = ["'Konstantin Makarchev'"]
+  spec.email         = ["'kostya27@gmail.com'"]
+  spec.summary       = %q{Simple background jobs, queues.}
+  spec.description   = %q{Simple background jobs, queues.}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency 'redis'
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec"
+end

data/lib/jober.rb

@@ -0,0 +1,91 @@
+require "Jober/version"
+
+require 'redis'
+require 'logger'
+
+module Jober
+  autoload :Manager,      'Jober/manager'
+  autoload :AbstractTask, 'Jober/abstract_task'
+  autoload :Task,         'Jober/task'
+  autoload :Queue,        'Jober/queue'
+  autoload :QueueBatch,   'Jober/queue_batch'
+  autoload :UniqueQueue,  'Jober/unique_queue'
+  autoload :Logger,       'Jober/logger'
+  autoload :SharedObject, 'Jober/shared_object'
+
+  class << self
+    attr_accessor :redis_config
+    attr_reader :classes
+
+    def logger
+      ::Logger.new(STDOUT)
+    end
+
+    def redis
+      Thread.current[:__redis__] ||= Redis.new(redis_config || {})
+    end
+
+    def reset_redis
+      Thread.current[:__redis__] = nil
+    end
+
+    def add_class(klass)
+      unless klass.to_s.start_with?('Jober::')
+        @classes ||= []
+        @classes << klass
+      end
+    end
+
+    def after_fork(&block)
+      @after_fork = block
+    end
+
+    def call_after_fork
+      @after_fork.call if @after_fork
+    end
+
+    def dump(obj)
+      Marshal.dump(obj)
+    end
+
+    def load(obj)
+      Marshal.load(obj)
+    end
+
+    def exception(ex)
+      # redefine me
+    end
+
+    def underscore(str)
+      word = str.dup
+      word.gsub!('::', '/')
+      word.gsub!(/(?:([A-Za-z\d])|^)((?=a)b)(?=\b|[^a-z])/) { "#{$1}#{$1 && '_'}#{$2.downcase}" }
+      word.gsub!(/([A-Z\d]+)([A-Z][a-z])/,'\1_\2')
+      word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+      word.tr!("-", "_")
+      word.downcase!
+      word
+    end
+
+    def llens
+      h = {}
+      @classes.each do |klass|
+        next unless klass.ancestors.include?(Jober::Queue)
+        h[klass.short_name] = klass.len
+      end
+      h
+    end
+
+    def stats
+      h = {}
+      @classes.each do |klass|
+        start = Jober.redis.get("Jober:stats:#{klass.short_name}:start")
+        start = Time.at(start.to_i) if start
+        _end = Jober.redis.get("Jober:stats:#{klass.short_name}:end")
+        _end = Time.at(_end.to_i) if _end
+        h[klass.short_name] = {:start => start, :end => _end, :duration => (_end && start && _end >= start) ? (_end - start) : nil }
+      end
+      h
+    end
+  end
+end

data/lib/jober/abstract_task.rb

@@ -0,0 +1,46 @@
+class Jober::AbstractTask
+  include Jober::Logger
+
+  class << self
+    def every(interval, method = :perform)
+      workers << [interval, method]
+    end
+
+    def workers
+      @workers ||= []
+    end
+
+    attr_accessor :short_name
+  end
+
+  attr_accessor :stopped
+
+  def self.inherited(base)
+    Jober.add_class(base)
+  end
+
+  def initialize
+    @stopped = false
+    trap("QUIT") { @stopped = true }
+    trap("INT")  { @stopped = true }
+  end
+
+  def execute(method = :perform)
+    info "=> starting"
+    @start_at = Time.now
+    write_timestamp(:start)
+    run(method)
+    write_timestamp(:end)
+    info "<= end of #{method} in #{Time.now - @start_at}"
+    self
+  end
+
+private
+
+  def write_timestamp(type)
+    Jober.redis.set("Jober:stats:#{self.class.short_name}:#{type}", Time.now.to_i.to_s)
+  rescue Object => ex
+    error "#{ex.inspect} #{ex.backtrace}"
+  end
+
+end

data/lib/jober/logger.rb

@@ -0,0 +1,18 @@
+require 'logger'
+
+module Jober::Logger
+  def logger
+    @logger ||= Jober.logger
+  end
+
+  def logger=(logger)
+    @logger = logger
+  end
+
+  Logger::Severity.constants.each do |level|
+    method_name = level.to_s.downcase
+    define_method method_name do |msg = nil, &block|
+      logger.send(method_name, msg, &block)
+    end
+  end
+end

data/lib/jober/manager.rb

@@ -0,0 +1,136 @@
+require 'thread'
+
+class Jober::Manager
+  include Jober::Logger
+
+  attr_accessor :logger_path, :stopped
+
+  def initialize(name, allowed_classes = nil)
+    @name = name
+    @stopped = false
+    @mutex = Mutex.new
+    @pids = []
+    @allowed_classes = allowed_classes ? (Jober.classes & allowed_classes) : Jober.classes
+
+    $0 = "#{@name} manager"
+    if @logger_path
+      self.logger = ::Logger.new(File.join(@logger_path, "manager.log"))
+    end
+    info "starting manager #{@name}"
+  end
+
+  def run!
+    @allowed_classes.each do |klass|
+      workers = klass.workers
+      workers = [[5 * 60, :perform]] if workers.empty?
+
+      workers.each do |interval, method|
+        Thread.new { start_worker(klass, interval, method) }
+      end
+    end
+  end
+
+  def run
+    run!
+
+    trap("TERM") { stop }
+
+    loop do
+      sleep 1
+      break if @stopped
+    end
+  end
+
+  def stop!
+    @stopped = true
+    @pids.each { |pid| ::Process.kill("QUIT", pid) }
+    info "stopping manager..."
+  end
+
+  def stop(timeout = 2.5)
+    stop!
+    return if @pids.empty?
+
+    sum = 0
+    while true
+      sleep(0.1)
+      sum += 0.1
+      break if sum >= timeout
+      break if @pids.empty?
+    end
+
+    return if @pids.empty?
+
+    info { "still alive pids: #{@pids}, killing" }
+    @pids.each { |pid| ::Process.kill("KILL", pid) }
+
+    @pids = []
+  end
+
+  def catch
+    yield
+    true
+  rescue Object => ex
+    p "exception #{ex.inspect} #{ex.backtrace}"
+    Jober.exception(ex)
+    nil
+  end
+
+  def start_worker(klass, interval, method)
+    debug { "start worker for #{klass.to_s} #{method}" }
+    loop do
+      pid = nil
+      res = catch do
+        pid = run_task_fork(klass, method)
+        add_pid(pid)
+        Process.wait(pid)
+        del_pid(pid)
+        sleep interval unless stopped
+      end
+      del_pid(pid)
+      break if stopped
+      sleep 0.5 unless res
+      break if stopped
+    end
+  end
+
+  def run_task_fork(klass, method)
+    info "invoke #{klass} #{method}"
+    fork do
+      $0 = "#{@name} manager #{klass}"
+      #$0 += " #{index}" if index > 0
+      Jober.call_after_fork
+      Jober.reset_redis
+
+      inst = klass.new # class_name parent of Jober::Task
+
+      if @logger_path
+        logger_path = File.join(@logger_path, "#{klass.short_name}.log")
+
+        STDOUT.reopen(File.open(logger_path, 'a'))
+        STDERR.reopen(File.open(logger_path, 'a'))
+        inst.logger = ::Logger.new(logger_path)
+      end
+
+      inst.execute(method)
+    end
+  end
+
+  def pids
+    @mutex.synchronize { @pids }
+  end
+
+private
+
+  def add_pid(pid)
+    @mutex.synchronize { @pids << pid }
+  end
+
+  def del_pid(pid)
+    @mutex.synchronize { @pids -= [pid] }
+  end
+
+  def clear_pids
+    @mutex.synchronize { @pids = [] }
+  end
+end

data/lib/jober/queue.rb

@@ -0,0 +1,47 @@
+class Jober::Queue < Jober::Task
+
+  def self.inherited(base)
+    super
+    base.set_queue_name(base.short_name)
+  end
+
+  class << self
+    attr_accessor :queue_name
+
+    def set_queue_name(q)
+      @queue_name = "Jober:queue:#{q}"
+    end
+  end
+
+  def queue_name
+    self.class.queue_name
+  end
+
+  def self.enqueue(*args)
+    Jober.redis.rpush(queue_name, Jober.dump(args))
+  end
+
+  def self.len
+    Jober.redis.llen(self.queue_name)
+  end
+
+  def pop
+    res = Jober.redis.lpop(queue_name)
+    Jober.load(res) if res
+  end
+
+  def run(method)
+    cnt = 0
+    while args = pop
+      send(method, *args)
+      cnt += 1
+
+      if stopped
+        break
+      end
+
+      info { "processed #{cnt}" } if cnt % 1000 == 0
+    end
+    info { "processed #{cnt}" }
+  end
+end

data/lib/jober/queue_batch.rb

@@ -0,0 +1,47 @@
+class Jober::QueueBatch < Jober::Queue
+  class << self
+    def batch_size(bs)
+      @batch_size = bs
+    end
+
+    def get_batch_size
+      @batch_size ||= 100
+    end
+  end
+
+  def execute(method = :perform)
+    cnt = 0
+    batch = []
+    while args = pop
+      batch << args
+      if batch.length >= self.class.get_batch_size
+        execute_batch(method, batch)
+        batch = []
+      end
+      break if stopped
+      cnt += 1
+    end
+    if batch.length > 0
+      if stopped
+      	reschedule_batch(batch)
+      else
+        execute_batch(method, batch)
+      end
+    end
+    self
+  end
+
+  def execute_batch(method, batch)
+    send(method, batch)
+  rescue Object => ex
+    reschedule_batch(batch)
+    Jober.exception(ex)
+  end
+
+private
+
+  def reschedule_batch(batch)
+  	batch.reverse_each { |ev| Jober.redis.lpush(queue_name, Jober.dump(ev)) }
+  end
+
+end

data/lib/jober/shared_object.rb

@@ -0,0 +1,48 @@
+class Jober::SharedObject
+  class << self
+    def set(name, obj, conn = Jober.redis)
+      conn.set(key(name), Marshal.dump(obj))
+    end
+
+    def get(name, conn = Jober.redis)
+      r = conn.get(key(name))
+      Marshal.load(r) if r
+    end
+
+    def raw_get(name)
+      Jober.redis.get(key(name))
+    end
+
+    def [](name)
+      get(name)
+    end
+
+    def []=(name, obj)
+      set name, obj
+    end
+
+    def inc(name, by = 1)
+      Jober.redis.incrby(key(name), by)
+    end
+
+    def del(name)
+      Jober.redis.del key(name)
+    end
+
+    def clear
+      Jober.redis.keys(key('*')).each { |k| del(k) }
+    end
+
+    def values(mask)
+      Jober.redis.keys(key(mask)).map { |key| get(key) }
+    end
+
+    def key(name)
+      if name.start_with?('shared:')
+        name
+      else
+        "shared:#{name}"
+      end
+    end
+  end
+end

data/lib/jober/task.rb

@@ -0,0 +1,20 @@
+class Jober::Task < Jober::AbstractTask
+
+  def self.extract_name(name)
+    Jober.underscore(name).gsub(/_?queue_?/, '').gsub(/_?fk_?/, '').gsub(/_?task_?/, '').split('::').last.gsub('/', '-')
+  end
+
+  def self.inherited(base)
+    super
+    base.short_name = extract_name(base.name)
+  end
+
+  def perform
+    raise "implement me"
+  end
+
+  def run(method)
+    send(method)
+  end
+
+end

data/lib/jober/unique_queue.rb

@@ -0,0 +1,16 @@
+class Jober::UniqueQueue < Jober::Queue
+
+  def self.len
+    Jober.redis.scard(queue_name)
+  end
+
+  def self.enqueue(*args)
+    Jober.redis.sadd(queue_name, Jober.dump(args))
+  end
+
+  def pop
+    res = Jober.redis.spop(queue_name)
+    Jober.load(res) if res
+  end
+
+end

data/lib/jober/version.rb

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

data/spec/chain_spec.rb

@@ -0,0 +1,18 @@
+require_relative "spec_helper"
+
+class MyChain < Jober::Task
+  every 3
+
+  def perform
+    sleep 5
+    SO["chain"] += 1
+  end
+end
+
+describe "Queue" do
+  it "should work" do
+    SO["chain"] = 0
+    run_manager_for(7, [MyChain])
+    SO["chain"].should == 1
+  end
+end

data/spec/integration_spec.rb

@@ -0,0 +1,37 @@
+require_relative "spec_helper"
+
+class A < Jober::Task
+  every 3000
+
+  def perform
+    10.times do |i|
+      B.enqueue(i)
+      C.enqueue(i)
+    end
+  end
+end
+
+class B < Jober::Queue
+  every 3
+
+  def perform(x)
+    SO["b"] += x
+  end
+end
+
+class C < Jober::QueueBatch
+  every 3
+
+  def perform(batch)
+    SO["c"] = batch.flatten
+  end
+end
+
+describe "integration" do
+  it "should work" do
+    SO["b"] = 0
+    run_manager_for(5, [A, B, C])
+    SO["b"].should == 45
+    SO["c"].should == [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+  end
+end

data/spec/kill_task_spec.rb

@@ -0,0 +1,39 @@
+require_relative "spec_helper"
+
+class LongTask1 < Jober::Task
+  def perform
+    sleep 100
+  end
+end
+
+class LongTask11 < Jober::Task
+  def perform
+    while true
+      sleep 1
+      break if stopped
+    end
+    SO["11"] = true
+  end
+end
+
+class LongTask2 < Jober::Queue
+  def perform
+    sleep 1
+    SO["a"] += 1
+  end
+end
+
+describe "should kill long tasks" do
+  it "kill" do
+    t = Time.now
+    SO["a"] = 0
+    100.times { LongTask2.enqueue }
+
+    m = run_manager_for(3, [LongTask1, LongTask11, LongTask2])
+
+    SO["a"].should == 3
+    m.pids.should == []
+    (Time.now - t).should < (3.2 + 2.5)
+    SO["11"].should == true
+  end
+end

data/spec/pids_spec.rb

@@ -0,0 +1,39 @@
+require_relative "spec_helper"
+
+class Man1 < Jober::Task
+  every 2
+
+  def perform
+    sleep 3
+  end
+end
+
+class Man2 < Jober::Task
+  every 2
+
+  def perform
+    sleep 2
+    raise "jopa"
+  end
+end
+
+describe "manage pids" do
+  it "should work" do
+    run_manager_for(nil, [Man1, Man2]) do |m|
+      sleep 1
+      m.pids.size.should == 2
+
+      sleep 1.5
+      m.pids.size.should == 1
+
+      sleep 1
+      m.pids.size.should == 0
+
+      sleep 1
+      m.pids.size.should == 1
+
+      sleep 1.1
+      m.pids.size.should == 2
+    end
+  end
+end

data/spec/queue_batch_spec.rb

@@ -0,0 +1,28 @@
+require_relative "spec_helper"
+
+class MyBatchQueue < Jober::QueueBatch
+  batch_size 6
+
+  attr_reader :res
+
+  def perform(batch)
+    @res ||= []
+    @res << batch
+  end
+end
+
+describe "QueueBatch" do
+  it "should set internals" do
+    w = MyBatchQueue.new
+    w.queue_name.should == 'Jober:queue:my_batch'
+  end
+
+  it "should execute" do
+    10.times { |i| MyBatchQueue.enqueue(i) }
+    MyBatchQueue.new.execute.res.should == [[[0], [1], [2], [3], [4], [5]], [[6], [7], [8], [9]]]
+  end
+
+  it "should register class" do
+    Jober.classes.should include(MyBatchQueue)
+  end
+end

data/spec/queue_parallel_spec.rb

@@ -0,0 +1,24 @@
+require_relative "spec_helper"
+
+class FkMyParallel < Jober::Queue
+  5.times { |i| every 3 }
+
+  def perform(arg)
+    SO["fork:#{$$}"] ||= 0
+    SO["fork:#{$$}"] += 1
+    SO.inc("count", arg)
+  end
+end
+
+describe "Queue" do
+  it "should work" do
+    1000.times { |i| FkMyParallel.enqueue(i) }
+    run_manager_for(2, [FkMyParallel])
+    SO.raw_get("count").to_i.should == 499500
+
+    vals = SO.values("fork*")
+    vals.size.should == 5
+    vals.all? { |el| el > 20 }.should == true
+    vals.inject(0, :+).should == 1000
+  end
+end

data/spec/queue_spec.rb

@@ -0,0 +1,45 @@
+require_relative "spec_helper"
+
+class MyQueue < Jober::Queue
+  def initialize(*args)
+    super
+    @counter = 0
+  end
+
+  attr_reader :counter
+
+  def perform(x)
+    @counter += x
+  end
+end
+
+class Jasdfoadsfjaf < Jober::Queue
+  set_queue_name 'human_name'
+
+  def perform
+  end
+end
+
+describe "Queue" do
+  it "should set internals" do
+    w = MyQueue.new
+    w.queue_name.should == 'Jober:queue:my'
+  end
+
+  it "should execute" do
+    MyQueue.enqueue(1)
+    MyQueue.enqueue(2)
+    MyQueue.enqueue(3)
+    MyQueue.new.execute.counter.should == 6
+  end
+
+  it "should register class" do
+    Jober.classes.should include(MyQueue)
+  end
+
+  it "custom queue name" do
+    10.times { Jasdfoadsfjaf.enqueue }
+    p Jober.llens
+    Jober.llens['human_name'].should == 10
+  end
+end

data/spec/shared_object_spec.rb

@@ -0,0 +1,25 @@
+require_relative "spec_helper"
+
+describe "SO" do
+  it "should work" do
+    SO["a"].should == nil
+    SO["a"] = 0
+    SO["a"].should == 0
+    SO["a"] += 1
+    SO["a"].should == 1
+
+    SO["b"].should == nil
+    SO["b"] = [1, 2, 3, :bla, {"a" => 2.5}]
+    SO["b"].should == [1, 2, 3, :bla, {"a" => 2.5}]
+
+    SO.del("a")
+    SO["a"].should == nil
+
+    SO.clear
+    SO["b"].should == nil
+
+    SO["c"] ||= 0
+    SO["c"] += 1
+    SO["c"].should == 1
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,33 @@
+require "bundler/setup"
+Bundler.require :default
+
+Jober::SharedObject
+SO = Jober::SharedObject
+
+RSpec.configure do |config|
+  config.expect_with(:rspec) { |c| c.syntax = :should }
+
+  config.before(:each) do
+    SO.clear
+    Jober.redis.keys("Jober*").each { |k| Jober.redis.del(k) }
+  end
+
+  config.after(:all) do
+    SO.clear
+  end
+end
+
+def run_manager_for(timeout, classes, &block)
+  m = Jober::Manager.new "test", classes
+  m.run!
+
+  if block
+    block.call(m)
+  else
+    sleep timeout
+  end
+
+  m.stop
+  sleep 0.1
+  m
+end

data/spec/stats_spec.rb

@@ -0,0 +1,33 @@
+require_relative "spec_helper"
+
+class MyQueue1 < Jober::Queue
+  def perform
+    sleep 2
+  end
+end
+
+class MyQueue2 < Jober::QueueBatch
+  def perform
+  end
+end
+
+describe "Stats" do
+  it "llens" do
+    10.times { MyQueue1.enqueue }
+    99.times { MyQueue2.enqueue }
+
+    h = Jober.llens
+    h['my1'].should == 10
+    h['my2'].should == 99
+  end
+
+  it "stats" do
+    MyQueue1.enqueue
+    run_manager_for(3, [MyQueue1, MyQueue2])
+    h = Jober.stats
+    h['my1'][:start].should be
+    h['my1'][:end].should be
+    h['my1'][:duration].should be_within(0.1).of(2.0)
+    h['my2'].should == {:start=>nil, :end=>nil, :duration=>nil}
+  end
+end

data/spec/task_spec.rb

@@ -0,0 +1,44 @@
+require_relative "spec_helper"
+
+class WorkerTask < Jober::Task
+  def initialize(*args)
+    super
+    @counter = 0
+  end
+
+  attr_reader :counter
+
+  def perform
+    10.times { @counter += 1 }
+  end
+end
+
+class Task2 < Jober::Task
+  every 3, :bla
+  every 5
+
+  def bla
+  end
+
+  def perform
+  end
+end
+
+describe "Task" do
+  it "should execute" do
+    w = WorkerTask.new
+    w.execute.counter.should == 10
+  end
+
+  it "should set short_name" do
+    WorkerTask.short_name.should == 'worker'
+  end
+
+  it "should register class" do
+    Jober.classes.should include(WorkerTask)
+  end
+
+  it "set some schedulers" do
+    Task2.workers.should == [[3, :bla], [5, :perform]]
+  end
+end

data/spec/unique_queue_spec.rb

@@ -0,0 +1,34 @@
+require_relative "spec_helper"
+
+class MyUniqueQueue < Jober::UniqueQueue
+  def initialize(*args)
+    super
+    @counter = 0
+  end
+
+  attr_reader :counter
+
+  def perform(x)
+    @counter += x
+  end
+end
+
+describe "Queue" do
+  it "should set internals" do
+    w = MyUniqueQueue.new
+    w.queue_name.should == 'Jober:queue:my_unique'
+  end
+
+  it "should execute Only for unique values" do
+    MyUniqueQueue.enqueue(1)
+    MyUniqueQueue.enqueue(2)
+    MyUniqueQueue.enqueue(2)
+    MyUniqueQueue.enqueue(2)
+    MyUniqueQueue.enqueue(3)
+    MyUniqueQueue.enqueue(3)
+    MyUniqueQueue.enqueue(3)
+    MyUniqueQueue.len.should == 3
+    MyUniqueQueue.new.execute.counter.should == 6
+  end
+
+end

metadata

@@ -0,0 +1,145 @@
+--- !ruby/object:Gem::Specification
+name: jober
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- "'Konstantin Makarchev'"
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-04-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Simple background jobs, queues.
+email:
+- "'kostya27@gmail.com'"
+executables:
+- jober
+- manager
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- Rakefile
+- bin/jober
+- bin/manager
+- examples/classes.rb
+- examples/man.rb
+- jober.gemspec
+- lib/jober.rb
+- lib/jober/abstract_task.rb
+- lib/jober/logger.rb
+- lib/jober/manager.rb
+- lib/jober/queue.rb
+- lib/jober/queue_batch.rb
+- lib/jober/shared_object.rb
+- lib/jober/task.rb
+- lib/jober/unique_queue.rb
+- lib/jober/version.rb
+- spec/chain_spec.rb
+- spec/integration_spec.rb
+- spec/kill_task_spec.rb
+- spec/pids_spec.rb
+- spec/queue_batch_spec.rb
+- spec/queue_parallel_spec.rb
+- spec/queue_spec.rb
+- spec/shared_object_spec.rb
+- spec/spec_helper.rb
+- spec/stats_spec.rb
+- spec/task_spec.rb
+- spec/unique_queue_spec.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Simple background jobs, queues.
+test_files:
+- spec/chain_spec.rb
+- spec/integration_spec.rb
+- spec/kill_task_spec.rb
+- spec/pids_spec.rb
+- spec/queue_batch_spec.rb
+- spec/queue_parallel_spec.rb
+- spec/queue_spec.rb
+- spec/shared_object_spec.rb
+- spec/spec_helper.rb
+- spec/stats_spec.rb
+- spec/task_spec.rb
+- spec/unique_queue_spec.rb