backburner 1.7.0 → 1.9.0

data/.gitignore

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

data/.travis.yml

@@ -1,29 +0,0 @@
-# http://about.travis-ci.org/docs/user/build-configuration/
-rvm:
-  - 1.9.3
-  - 2.0.0
-  - 2.1
-  - 2.2
-  - 2.3
-  - 2.4
-  - 2.5
-  - rbx-2
-before_install:
-  - curl -L https://github.com/kr/beanstalkd/archive/v1.9.tar.gz | tar xz -C /tmp
-  - cd /tmp/beanstalkd-1.9/
-  - make
-  - ./beanstalkd &
-  - cd $TRAVIS_BUILD_DIR
-  - gem update --system
-  - gem update bundler
-matrix:
-  allow_failures:
-    - rvm: rbx-2
-    - rvm: 2.0.0
-script:
-  - bundle exec rake test
-gemfile: Gemfile
-notifications:
-  recipients:
-    - nesquena@gmail.com
-    - therealdave.myron@gmail.com

data/CONTRIBUTING.md

@@ -1,37 +0,0 @@
-We love pull requests. Here's a quick guide:
-
-1. Fork the repo.
-
-2. Run the tests. We only take pull requests with passing tests, and it's great
-to know that you have a clean slate: `bundle && rake test`
-
-3. Add a test for your change. Only refactoring and documentation changes
-require no new tests. If you are adding functionality or fixing a bug, we need
-a test!
-
-4. Make the test pass.
-
-5. Push to your fork and submit a pull request.
-
-At this point you're waiting on us. We like to at least comment on, if not
-accept, pull requests within three business days (and, typically, one business
-day). We may suggest some changes or improvements or alternatives.
-
-Some things that will increase the chance that your pull request is accepted:
-
-* Use Rails idioms and helpers
-* Include tests that fail without your code, and pass with it
-* Update the documentation and README for anything affected by your contribution
-
-Syntax:
-
-* Two spaces, no tabs.
-* No trailing whitespace. Blank lines should not have any space.
-* Prefer &&/|| over and/or.
-* MyClass.my_method(my_arg) not my_method( my_arg ) or my_method my_arg.
-* a = b and not a=b.
-* Follow the conventions you see used in the source already.
-
-And in case we didn't emphasize it enough: we love tests!
-
-NOTE: Adapted from https://raw.github.com/thoughtbot/factory_girl_rails/master/CONTRIBUTING.md

data/Gemfile

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

data/Rakefile

@@ -1,17 +0,0 @@
-#!/usr/bin/env rake
-require "bundler/gem_tasks"
-require 'rake/testtask'
-# require 'yard'
-
-task :test do
-  Rake::TestTask.new do |t|
-    t.libs.push "lib"
-    t.test_files = FileList[File.expand_path('../test/**/*_test.rb', __FILE__)]
-    t.verbose = true
-  end
-end
-
-task :default => :test
-
-# task :doc do
-#  YARD::CLI::Yardoc.new.run

data/TODO

@@ -1,4 +0,0 @@
-- Custom front-end in sinatra for viewing beanstalk jobs
-  - Refer to https://github.com/denniskuczynski/beanstalkd_view
-- Fork jobs to control memory
-  - https://github.com/michaeldwan/stalker/commit/386267690a7c03e11d1a8b7b6f08b7c9c7cd2c0d

data/backburner.gemspec

@@ -1,28 +0,0 @@
-# -*- encoding: utf-8 -*-
-require File.expand_path('../lib/backburner/version', __FILE__)
-
-Gem::Specification.new do |s|
-  s.authors       = ["Nathan Esquenazi"]
-  s.email         = ["nesquena@gmail.com"]
-  s.description   = %q{Beanstalk background job processing made easy}
-  s.summary       = %q{Reliable beanstalk background job processing made easy for Ruby and Sinatra}
-  s.homepage      = "http://github.com/nesquena/backburner"
-
-  s.files         = `git ls-files`.split($\)
-  s.executables   = s.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
-  s.test_files    = s.files.grep(%r{^(test|spec|features)/})
-  s.name          = "backburner"
-  s.require_paths = ["lib"]
-  s.version       = Backburner::VERSION
-  s.license       = 'MIT'
-
-  s.add_runtime_dependency 'beaneater', '~> 1.0'
-  s.add_runtime_dependency 'dante', '> 0.1.5'
-  s.add_runtime_dependency 'concurrent-ruby', '~> 1.0', '>= 1.0.1'
-
-  s.add_development_dependency 'rake'
-  s.add_development_dependency 'minitest', '5.1.0'
-  s.add_development_dependency 'mocha'
-  s.add_development_dependency 'activejob', '>= 6.0'
-  s.add_development_dependency 'activesupport', '>= 6.0'
-end

data/circle.yml

@@ -1,3 +0,0 @@
-machine:
-  services:
-    - beanstalkd

data/examples/custom.rb

@@ -1,25 +0,0 @@
-$:.unshift "lib"
-require 'backburner'
-
-# Define ruby job
-class TestJob
-  include Backburner::Queue
-  # queue "test-job"
-
-  def self.perform(value, user)
-    puts "[TestJob] Running perform with args: [#{value}, #{user}]"
-  end
-end
-
-# Configure Backburner
-Backburner.configure do |config|
-  config.beanstalk_url = "beanstalk://127.0.0.1"
-  config.tube_namespace = "demo.production"
-end
-
-# Enqueue tasks
-Backburner.enqueue TestJob, 5, 3
-Backburner.enqueue TestJob, 10, 6
-
-# Work tasks using threaded worker
-Backburner.work("test-job", :worker => Backburner::Workers::ThreadsOnFork)

data/examples/demo.rb

@@ -1,60 +0,0 @@
-$:.unshift "lib"
-require 'backburner'
-
-module Tester
-  class TestJob
-    include Backburner::Queue
-    queue "test.job"
-
-    def self.perform(value, user)
-      p [value, user]
-    end
-  end
-
-  class UserModel
-    include Backburner::Performable
-
-    attr_accessor :id, :name
-
-    def self.first
-      self.find(3, "John")
-    end
-
-    def self.find(id, name="Fetched")
-      self.new(id, name)
-    end
-
-    def initialize(id, name)
-      @id, @name = id, name
-    end
-
-    def hello(x, y)
-      puts "Instance #{x} and #{y} and my id is #{id}"
-    end
-
-    def self.foo(x, y)
-      puts "Class #{x} and #{y}"
-    end
-  end
-end
-
-# connection = Backburner::Connection.new("beanstalk://127.0.0.1")
-
-Backburner.configure do |config|
-  config.beanstalk_url = "beanstalk://127.0.0.1"
-  config.tube_namespace = "myblog.production"
-end
-
-# p Backburner.configuration.beanstalk_url
-# p Backburner::Worker.connection
-
-Backburner.enqueue Tester::TestJob, 5, 3
-Backburner.enqueue Tester::TestJob, 10, 6
-@user = Tester::UserModel.first
-@user.async.hello("foo", "bar")
-Tester::UserModel.async.foo("bar", "baz")
-
-Backburner.default_queues.concat([Tester::TestJob.queue, Tester::UserModel.queue])
-Backburner.work
-# Backburner.work("test.job")
-# Backburner.work("tester/user-model")

data/examples/god.rb

@@ -1,46 +0,0 @@
-God.watch do |w|
-  w.name   = "backburner-worker-1"
-  w.dir    = '/path/to/app/dir'
-  w.env = { 'PADRINO_ENV' => 'production', 'QUEUES' => 'newsletter-sender,push-message' }
-  w.group    = 'backburner-workers'
-  w.interval = 30.seconds
-  w.start = "bundle exec rake -f Rakefile backburner:work"
-  w.log   = "/var/log/god/backburner-worker-1.log"
-
-  # restart if memory gets too high
-  w.transition(:up, :restart) do |on|
-    on.condition(:memory_usage) do |c|
-      c.above = 50.megabytes
-      c.times = 3
-    end
-  end
-
-  # determine the state on startup
-  w.transition(:init, { true => :up, false => :start }) do |on|
-    on.condition(:process_running) do |c|
-      c.running = true
-    end
-  end
-
-  # determine when process has finished starting
-  w.transition([:start, :restart], :up) do |on|
-    on.condition(:process_running) do |c|
-      c.running = true
-      c.interval = 5.seconds
-    end
-
-    # failsafe
-    on.condition(:tries) do |c|
-      c.times = 5
-      c.transition = :start
-      c.interval = 5.seconds
-    end
-  end
-
-  # start if process is not running
-  w.transition(:up, :start) do |on|
-    on.condition(:process_running) do |c|
-      c.running = false
-    end
-  end
-end

data/examples/hooked.rb

@@ -1,87 +0,0 @@
-$:.unshift "lib"
-require 'backburner'
-
-$fail = 0
-class User
-  include Backburner::Performable
-
-  # Called with the job args before a job is placed on the queue.
-  # !! If the hook returns `false`, the job will not be placed on the queue.
-  def self.before_enqueue_foo(*args)
-    puts "[before_enqueue] Just about to enqueue #{self} with #{args.inspect}"
-  end
-
-  # Called with the job args after a job is placed on the queue.
-  # !! Any exception raised propagates up to the code which queued the job.
-  def self.after_enqueue_foo(*args)
-    puts "[after_enqueue] Finished enqueuing #{self} with #{args.inspect}"
-  end
-
-  # Called with the job args before perform. If it raises
-  #  `Backburner::Job::DontPerform`, the job is aborted. Other exceptions
-  #  are treated like regular job exceptions.
-  def self.before_perform_foo(*args)
-    puts "[before_perform] Just about to perform #{self} with #{args.inspect}"
-  end
-
-  # Called with the job args after it performs. Uncaught
-  #   exceptions will be treated like regular job exceptions.
-  def self.after_perform_foo(*args)
-    puts "[after_perform] Just finished performing #{self} with #{args.inspect}"
-  end
-
-  # Called with the job args. It is expected to yield in order
-  #   to perform the job (but is not required to do so). It may handle exceptions
-  #   thrown by perform, but uncaught exceptions will be treated like regular job exceptions.
-  def self.around_perform_bar(*args)
-    puts "[around_perform_bar before] About to perform #{self} with #{args.inspect}"
-    yield
-    puts "[around_perform_bar after] Just after performing #{self} with #{args.inspect}"
-  end
-
-  # Called with the job args. It is expected to yield in order
-  #   to perform the job (but is not required to do so). It may handle exceptions
-  #   thrown by perform, but uncaught exceptions will be treated like regular job exceptions.
-  def self.around_perform_cat(*args)
-    puts "[around_perform_cat before] About to perform #{self} with #{args.inspect}"
-    yield
-    puts "[around_perform_cat after] Just after performing #{self} with #{args.inspect}"
-  end
-
-  # Called with the job args. It is expected to yield in order
-  #   to perform the job (but is not required to do so). It may handle exceptions
-  #   thrown by perform, but uncaught exceptions will be treated like regular job exceptions.
-  def self.around_perform_foo(*args)
-    puts "[around_perform_foo before] About to perform #{self} with #{args.inspect}"
-    yield
-    puts "[around_perform_foo after] Just after performing #{self} with #{args.inspect}"
-  end
-
-  # Called with the exception and job args if any exception occurs
-  #  while performing the job (or hooks).
-  def self.on_failure_foo(ex, *args)
-    puts "[on_failure] Failure #{ex.inspect} occurred for job #{self} with #{args.inspect}"
-  end
-
-  def self.foo
-    $fail += 1
-    raise "Fail!" if $fail == 1
-    puts "This is the job running successfully!!"
-  end
-end
-
-# Configure Backburner
-Backburner.configure do |config|
-  config.beanstalk_url = "beanstalk://127.0.0.1"
-  config.tube_namespace = "demo.production"
-  config.on_error = lambda { |e| puts "HEY!!! #{e.class}" }
-  config.max_job_retries = 1
-  config.retry_delay     = 0
-end
-
-# Enqueue tasks
-User.async.foo
-
-# Run work
-# Backburner.default_queues << "user"
-Backburner.work

data/examples/retried.rb

@@ -1,31 +0,0 @@
-$:.unshift "lib"
-require 'backburner'
-
-$error = 0
-
-class User
-  include Backburner::Performable
-  attr_accessor :id, :name
-
-  def self.foo(x, y)
-    $error += 1
-    raise "fail #{$error}" unless $error > 3
-    puts "User #foo args [#{x}, #{y}] Success!!"
-  end
-end
-
-# Configure Backburner
-Backburner.configure do |config|
-  config.beanstalk_url = "beanstalk://127.0.0.1"
-  config.tube_namespace = "demo.production"
-  config.on_error = lambda { |e| puts "HEY!!! #{e.class}" }
-  config.max_job_retries = 3
-  config.retry_delay     = 0
-end
-
-# Enqueue tasks
-User.async(:queue => "retried").foo("bar", "baz")
-
-# Run work
-# Backburner.default_queues << "user"
-Backburner.work

data/examples/simple.rb

@@ -1,43 +0,0 @@
-$:.unshift "lib"
-require 'backburner'
-
-class User
-  include Backburner::Performable
-  attr_accessor :id, :name
-
-  def self.first
-    User.find(3, "John")
-  end
-
-  def self.find(id, name="Fetched")
-    User.new(id, name)
-  end
-
-  def initialize(id, name)
-    @id, @name = id, name
-  end
-
-  def hello(x, y)
-    puts "User(id=#{id}) #hello args: [#{x}, #{y}] (Instance method)"
-  end
-
-  def self.foo(x, y)
-    puts "User #foo args [#{x}, #{y}] (Class method)"
-  end
-end
-
-# Configure Backburner
-Backburner.configure do |config|
-  config.beanstalk_url = "beanstalk://127.0.0.1"
-  config.tube_namespace = "demo.production"
-  config.on_error = lambda { |e| puts "HEY!!! #{e.class}" }
-end
-
-# Enqueue tasks
-@user = User.first
-@user.async(:pri => 1000).hello("foo", "bar")
-User.async.foo("bar", "baz")
-
-# Run work
-# Backburner.default_queues << "user"
-Backburner.work

data/examples/stress.rb

@@ -1,31 +0,0 @@
-$:.unshift "lib"
-require 'backburner'
-
-$values = []
-
-# Define ruby job
-class TestJob
-  include Backburner::Queue
-  queue "test-job"
-
-  def self.perform(value)
-    puts "[TestJob] Running perform with args: [#{value}]"
-    $values << value
-    puts "#{$values.size} total jobs processed"
-  end
-end
-
-# Configure Backburner
-Backburner.configure do |config|
-  config.beanstalk_url = "beanstalk://127.0.0.1"
-  config.tube_namespace = "demo.production"
-end
-
-# Enqueue tasks
-1.upto(1000) do |i|
-  Backburner.enqueue TestJob, i
-end
-
-# Work tasks using threads_on_fork worker
-# twitter tube will have 10 threads, garbage after 1000 executions and retry jobs 1 times.
-Backburner.work("test-job:10:100:1", :worker => Backburner::Workers::ThreadsOnFork)

data/test/async_proxy_test.rb

@@ -1,36 +0,0 @@
-require File.expand_path('../test_helper', __FILE__)
-
-class AsyncUser; end
-
-describe "Backburner::AsyncProxy class" do
-  before do
-    Backburner.default_queues.clear
-    clear_jobs!(Backburner.configuration.primary_queue)
-  end
-
-  describe "for method_missing enqueue" do
-    should "enqueue job onto worker with no args" do
-      @async = Backburner::AsyncProxy.new(AsyncUser, 10, :pri => 1000, :ttr => 100)
-      @async.foo
-      pop_one_job do |job, body|
-        assert_equal "AsyncUser", body["class"]
-        assert_equal [10, "foo"], body["args"]
-        assert_equal 100, job.ttr
-        assert_equal 1000, job.pri
-        job.delete
-      end
-    end
-
-    should "enqueue job onto worker with args" do
-      @async = Backburner::AsyncProxy.new(AsyncUser, 10, :pri => 1000, :ttr => 100)
-      @async.bar(1, 2, 3)
-      pop_one_job do |job, body|
-        assert_equal "AsyncUser", body["class"]
-        assert_equal [10, "bar", 1, 2, 3], body["args"]
-        assert_equal 100, job.ttr
-        assert_equal 1000, job.pri
-        job.delete
-      end
-    end
-  end # method_missing
-end # AsyncProxy

data/test/back_burner_test.rb

@@ -1,88 +0,0 @@
-require File.expand_path('../test_helper', __FILE__)
-
-$backburner_sum = 0
-$backburner_numbers = []
-
-class TestBackburnerJob
-  include Backburner::Queue
-  queue "test.jobber"
-
-  def self.perform(value, number)
-    $backburner_sum += value
-    $backburner_numbers << number
-  end
-end
-
-class TestWorker < Backburner::Worker; end
-
-describe "Backburner module" do
-  before { Backburner.default_queues.clear }
-
-  describe "for enqueue method" do
-    before do
-      Backburner.enqueue TestBackburnerJob, 5, 6
-      Backburner.enqueue TestBackburnerJob, 15, 10
-      silenced(2) do
-        worker = Backburner::Workers::Simple.new('test.jobber')
-        worker.prepare
-        2.times { worker.work_one_job }
-      end
-    end
-
-    it "can run jobs using #run method" do
-      assert_equal 20, $backburner_sum
-      assert_same_elements [6, 10], $backburner_numbers
-    end
-  end # enqueue
-
-  describe "for work method" do
-    it "invokes worker simple start" do
-      Backburner::Workers::Simple.expects(:start).with(["foo", "bar"])
-      Backburner.work("foo", "bar")
-    end
-
-    it "invokes other worker if specified in configuration" do
-      Backburner.configure { |config| config.default_worker = TestWorker }
-      TestWorker.expects(:start).with(["foo", "bar"])
-      Backburner.work("foo", "bar")
-    end
-
-    it "invokes other worker if specified in work method as options" do
-      TestWorker.expects(:start).with(["foo", "bar"])
-      Backburner.work("foo", "bar", :worker => TestWorker)
-    end
-
-    it "invokes worker start with no args" do
-      Backburner::Workers::Simple.expects(:start).with([])
-      Backburner.work
-    end
-  end # work!
-
-  describe "for configuration" do
-    it "remembers the tube_namespace" do
-      assert_equal "demo.test", Backburner.configuration.tube_namespace
-    end
-
-    it "remembers the namespace_separator" do
-      assert_equal ".", Backburner.configuration.namespace_separator
-    end
-
-    it "disallows a reserved separator" do
-      assert_raises RuntimeError do
-        Backburner.configuration.namespace_separator = ':'
-      end
-    end
-  end # configuration
-
-  describe "for default_queues" do
-    it "supports assignment" do
-      Backburner.default_queues << "foo"
-      Backburner.default_queues << "bar"
-      assert_same_elements ["foo", "bar"], Backburner.default_queues
-    end
-  end
-
-  after do
-    Backburner.configure { |config| config.default_worker = Backburner::Workers::Simple }
-  end
-end # Backburner