scheduled_job 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4e5e1e7a35d0f3d68c2428b653941ccef7161544
+  data.tar.gz: cc91a8c1b338f203665d2c9e4022fcdf421bb761
+SHA512:
+  metadata.gz: bc188dc562bc3871f5bb1da987c834c7e040ef57a57532b1e129f442a1d65b6a46ffe54f0abe4897e92a3d4b1d2ea3299a752a7e1e77ed8406ee8b4dc00aeb2e
+  data.tar.gz: 613e68e70fd21d1d05b27ef8154deea6322bc4d7c60da50452bb793a1dbaada71305b5f35223840de2abf2271ef4f168834c2eb9d41e212721c116d177baa296

data/.gitignore

@@ -0,0 +1,17 @@
+*.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/.ruby-version

@@ -0,0 +1 @@
+2.1.1

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.1.1

data/CHANGELOG.md

@@ -0,0 +1,2 @@
+# 0.0.2
+Initial public release

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 RightScale
+
+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/README.md

@@ -0,0 +1,149 @@
+# ScheduledJob
+
+Scheduled job looks to build on top of the [delayed_job](https://github.com/collectiveidea/delayed_job) project by adding support for jobs that need to recur. Whilst investigating other options we decided that we wanted a very light weight framework that would simply allow us to define worker tasks that need to happen on a regular basis.
+
+In order to achieve this we created the following interface which allows the developer to consisly define what the job is to do as well as when it is to run. This helps keep all the logic in one place which is a huge plus.
+
+In terms of implementation there are only a couple of things we need to do.
+
+Firstly if there are any before or success callbacks you need to define you can do this via the configure block. This passes the instance of DelayedJob that run your job as well as the job itself.
+
+We can also take this opportunity to set up any logging. By default we use the ruby logger but if you are using rails for example you can do something like the following:
+
+```ruby
+ScheduledJob.configure do |config|
+  config.before_callback = -> (job, scheduled_job) do
+    JobRunLogger.update_attributes!(job_name: scheduled_job.class.name, started_at: Time.now.utc)
+  end
+
+  config.success_callback = -> (job, _) do
+    ScheduledJob.logger.info("Hurrah my job #{job.id} has completed")
+  end
+
+  config.logger = Rails.logger
+end
+```
+
+With this in place we can go on to define a job that we want to run regularly. To do this just mix in the scheduled job module in your class, define a perform method and define a time to recur.
+
+```ruby
+class WeeklyMetricJob
+  include ::ScheduledJob
+
+  def perform
+    ScheduledJob.logger.info('I need to do something over and over')
+  end
+
+  def self.time_to_recur(last_run_at)
+    last_run_at.end_of_week + 3.hours
+  end
+end
+```
+
+This allows you so specify what logic you need to run along side how often it needs to run. The time to recur is passed the completion time of the last successful run so you can use whatever logic you like in here to define when the job needs to run again.
+
+Finally you need to kick off the job the first time. Once it has run successfully it will look after itself but to start the cycle you need to run schedule_job on your job. Continuing on the example above:
+
+```ruby
+WeeklyMetricJob.schedule_job
+```
+
+Note currently this implementation is dependant upon using the [delayed_job_active_record](https://github.com/collectiveidea/delayed_job_active_record) backend. This is something that we may be looking to remove in future.
+
+## Running the specs
+
+This is the default rake task so you can run the specs in any of the following ways:
+
+```bash
+bundle exec rake
+bundle exec rake spec
+bundle exec rspec
+```
+
+## Getting a console
+
+The project is currently using pry. In order to get a console in the context of the project just run the pry.rb file in ruby.
+
+```bash
+bundle exec ruby pry.rb
+```
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'scheduled_job'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install scheduled_job
+
+## Usage
+
+First you must include the scheduled job module in any DelayedJob that needs to run on a regular basis.
+
+```ruby
+include ::ScheduledJob
+```
+
+Then you need to say what the job is acutally to do. This is done by implementing the permform method.
+
+```ruby
+def perform
+  puts 'I do work!'
+end
+```
+
+Finaly we need to write the logic for when we want the job to run. This is done by implementing the time_to_recur method which is passed the time the job last completed as its parameter.
+
+```ruby
+def self.time_to_recur(last_run_at)
+  last_run_at + 3.hours
+end
+```
+
+There are also callbacks that are available using ScheduledJob. These allow you to hook into the scheduling life cycle. Also note that as this uses DelayedJob under the hood all of the delayed job callbacks are still available for use.
+
+These can be defined when configuring the gem for you application on the configure block:
+
+```ruby
+ScheduledJob.configure do |config|
+  # configuration code in here
+end
+```
+
+The before_callback is executed before the perform method is called on the scheduled job. This is passed the delayed job object and the scheduled job instance.
+
+```ruby 
+config.before_callback = -> (job, scheduled_job) do
+  JobRunLogger.update_attributes!(job_name: scheduled_job.class.name, started_at: Time.now.utc)
+end
+```
+
+The success_callback is called on sucessful completion of the job and is also passed the delayed job object and the scheduled job instance.
+
+```ruby
+config.success_callback = -> (job, _) do
+  ScheduledJob.logger.info("Hurrah my job #{job.id} has completed")
+end
+```
+
+Then there is the fast mode. This is checked prior to scheduling another run of your job e.g. after a job has completed. This allows you to override the scheduling logic and ask the job to run immediatly. This is passed the scheduled job class. This means you can have state stored elsewhere to change the scheduling without having to modify the code. This could be getting an array from a database for example:
+
+```ruby
+config.fast_mode = -> (job) do
+  Database.get_value('fast_mode_jobs').include?(job.name)
+end
+```
+
+## Contributing
+
+1. Fork it ( http://github.com/rightscale/scheduled_job/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new('spec')
+
+task :default => :spec

data/lib/scheduled_job.rb

@@ -0,0 +1,91 @@
+require "scheduled_job/version"
+require 'logger'
+require 'delayed_job'
+require 'delayed_job_active_record'
+
+module ScheduledJob
+  class << self
+    attr_accessor :config
+  end
+
+  def self.logger
+    self.config.logger
+  end
+
+  def self.configure
+    self.config ||= Config.new
+    yield(config)
+  end
+
+  class Config
+    attr_accessor :logger, :before_callback, :success_callback, :fast_mode
+
+    def initialize
+      @logger = Logger.new(STDOUT)
+    end
+  end
+
+  def self.included(base)
+    base.extend ScheduledJobClassMethods
+  end
+
+  def before(job)
+    callback = ScheduledJob.config.before_callback
+    callback.call(job, self) if callback
+  end
+
+  def success(job)
+    callback = ScheduledJob.config.success_callback
+    callback.call(job, self) if callback
+    GC.start
+    self.class.schedule_job(job)
+  end
+
+  def failure(job)
+    ScheduledJob.logger.error("DelayedJob failed: processing job in queue #{self.class.queue_name} failed")
+    job.update_attributes!(:failed_at => Time.now)
+    self.class.schedule_job
+  end
+
+  def error(job, exception)
+    ScheduledJob.logger.warn("DelayedJob error: Job: #{job.id}, in queue #{self.class.queue_name}, exception: #{exception}")
+    self.class.schedule_job
+  end
+
+  module ScheduledJobClassMethods
+    # This method should be called when scheduling a recurring job as it checks to ensure no
+    # other instances of the job are already running.
+    def schedule_job(job = nil)
+      unless job_exists?(job)
+        callback = ScheduledJob.config.fast_mode
+        in_fast_mode = callback ? callback.call(self) : false
+
+        run_at = in_fast_mode ? Time.now.utc : time_to_recur(Time.now.utc)
+
+        Delayed::Job.enqueue(new, :run_at => run_at, :queue => queue_name)
+      end
+    end
+
+    def queue_name
+      "Default"
+    end
+
+    def random_minutes(base, random_delta)
+      random_delta *= -1 if random_delta < 0
+      (base + Random.new.rand((-1 * random_delta)..random_delta)).minutes
+    end
+
+    def job_exists?(job = nil)
+      conditions = ['handler like ? AND failed_at IS NULL', "%#{self.name}%"]
+      unless job.blank?
+        conditions[0] << " AND id != ?"
+        conditions << job.id
+      end
+      Delayed::Job.exists?(conditions)
+    end
+
+    def run_duration_threshold
+      self.const_defined?(:RUN_DURATION_THRESHOLD) ? self::RUN_DURATION_THRESHOLD : nil
+    end
+  end
+end

data/lib/scheduled_job/version.rb

@@ -0,0 +1,3 @@
+module ScheduledJob
+  VERSION = "0.0.2"
+end

data/pry.rb

@@ -0,0 +1,6 @@
+require 'scheduled_job'
+require 'pry'
+
+ScheduledJob.configure {}
+
+binding.pry

data/scheduled_job.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'scheduled_job/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "scheduled_job"
+  spec.version       = ScheduledJob::VERSION
+  spec.authors       = ["CallumD", "aliscott", "smcgivern", "alikhajeh1"]
+  spec.email         = ["callum.dryden@rightscale.com", "alistair@rightscale.com", "sean.mcgivern@rightscale.com", "ali@rightscale.com"]
+  spec.summary       = %q{Adding support for jobs that need to reccur}
+  spec.description   = %q{By including the scheduled job module in a delayed job you can specify when you would like the job to run again. Currently this is intented to be used with the active record back end this may change in future.}
+  spec.homepage      = "https://github.com/rightscale/scheduled_job"
+  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_runtime_dependency "delayed_job", "3.0.5"
+  spec.add_runtime_dependency "delayed_job_active_record", "0.4.4"
+
+  spec.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "rake", "~> 0.9"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "simplecov"
+end

data/scheduled_job.rconf

@@ -0,0 +1,9 @@
+ruby do
+  version  '2.1.1'
+  gemset   'scheduled_job'
+end
+bundler do
+  version     '1.5.3'
+  exclusions  'deployment'
+  bundle_path File.join(ENV["HOME"], '.rightscale', 'scheduled_job')
+end

data/spec/lib/scheduled_job_spec.rb

@@ -0,0 +1,137 @@
+require 'spec_helper'
+require 'pry'
+
+class UnderTest
+  include ScheduledJob
+
+  def self.queue_name
+    "TESTING"
+  end
+
+  def self.time_to_recur(last_run_time)
+    "time to recur"
+  end
+
+  def perform
+  end
+end
+
+describe ScheduledJob do
+
+  let(:under_test) { UnderTest.new }
+
+  describe 'fast mode' do
+    before { expect(Delayed::Job).to receive(:exists?).and_return(false) }
+
+    context 'when the job is not in run fast mode' do
+      it 'uses the value from time to recur' do
+        Delayed::Job.should_receive(:enqueue).with(anything, {
+          :run_at => UnderTest.time_to_recur(nil),
+          :queue  => UnderTest.queue_name
+        })
+        UnderTest.schedule_job
+      end
+    end
+
+    context 'when the job is in run fast mode' do
+      before do
+        ScheduledJob.configure do |config|
+          config.fast_mode = -> (_) do
+            true
+          end
+        end
+      end
+      it 'uses the current time' do
+        time = Time.now.utc
+        Time.stub_chain(:now, :utc) { time }
+
+        Delayed::Job.should_receive(:enqueue).with(anything, {
+          :run_at => time,
+          :queue  => UnderTest.queue_name
+        })
+        UnderTest.schedule_job
+      end
+    end
+  end
+
+  it "implements the required interface" do
+    expect(UnderTest).to respond_to :queue_name
+    expect(under_test).to respond_to :perform
+    expect(UnderTest).to respond_to :time_to_recur
+    expect(UnderTest).to respond_to :random_minutes
+  end
+
+  it "adds success to the class" do
+    expect(under_test).to respond_to :success
+  end
+
+  it "schedules a new job on success" do
+    expect(UnderTest).to receive(:schedule_job)
+    Delayed::Job.stub(:enqueue)
+    underTestJob = double("UnderTestJob");
+    underTestJob.stub(:run_at) { DateTime.now.utc }
+    underTestJob.stub(:id) { 1 }
+    under_test.before underTestJob
+    under_test.success underTestJob
+  end
+
+  it "adds failure to the class" do
+    expect(under_test).to respond_to :failure
+  end
+
+  it "logs the error and schedules a job on failure" do
+    dummy_job = double("job")
+    dummy_job.stub(:id)
+    expect(dummy_job).to receive(:update_attributes!)
+    expect(ScheduledJob.logger).to receive(:error)
+    expect(UnderTest).to receive(:schedule_job)
+    Delayed::Job.stub(:enqueue)
+    under_test.failure(dummy_job)
+  end
+
+  it "adds error to the class" do
+    expect(under_test).to respond_to :error
+  end
+
+  it "logs on error" do
+    job = double("job")
+    job.stub(:id) { 4 }
+    expect(ScheduledJob.logger).to receive(:warn)
+    UnderTest.stub(:schedule_job)
+    under_test.error job, nil
+  end
+
+    it "wraps delayed job with scheduled_job" do
+      job = double("job")
+      job.stub(:id) { 4 }
+      instance = double("instance")
+      UnderTest.stub(:new) { instance }
+      expect(Delayed::Job).to receive(:exists?).and_return(false)
+      expect(Delayed::Job).to receive(:enqueue).with(instance, run_at: "time to recur", queue: "TESTING")
+      UnderTest.schedule_job job
+    end
+
+    it "scheduled a job even if there is total failure and an existing job" do
+      dummy_job = double("job")
+      dummy_job.stub(:id)
+      expect(dummy_job).to receive(:update_attributes!)
+      expect(Delayed::Job).to receive(:exists?).twice.and_return(false)
+      expect(Delayed::Job).to receive(:enqueue).exactly(2).times
+      UnderTest.schedule_job
+      under_test.failure(dummy_job)
+    end
+
+  describe '#random_minutes' do
+    it 'returns a random number with a base and delta' do
+      expect(UnderTest.random_minutes(60, 10)).to be_within(10 * 60).of(60 * 60)
+    end
+
+    it 'returns a random number when called with a negative delta' do
+      expect(UnderTest.random_minutes(10, -2)).to be_within(2 * 60).of(10 * 60)
+    end
+
+    it 'returns base when called with delta of 0' do
+      expect(UnderTest.random_minutes(5, 0)).to be_within(0).of(5 * 60)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,16 @@
+require 'simplecov'
+SimpleCov.start
+
+require 'bundler/setup'
+Bundler.setup
+
+require 'scheduled_job' # and any other gems you need
+require 'logger'
+
+ScheduledJob.configure do |config|
+  config.logger = Logger.new(nil)
+end
+
+RSpec.configure do |config|
+    # some (optional) config here
+end

metadata

@@ -0,0 +1,168 @@
+--- !ruby/object:Gem::Specification
+name: scheduled_job
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- CallumD
+- aliscott
+- smcgivern
+- alikhajeh1
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-07-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: delayed_job
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.0.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.0.5
+- !ruby/object:Gem::Dependency
+  name: delayed_job_active_record
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.4.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.4.4
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !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'
+- !ruby/object:Gem::Dependency
+  name: pry
+  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'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  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: By including the scheduled job module in a delayed job you can specify
+  when you would like the job to run again. Currently this is intented to be used
+  with the active record back end this may change in future.
+email:
+- callum.dryden@rightscale.com
+- alistair@rightscale.com
+- sean.mcgivern@rightscale.com
+- ali@rightscale.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".ruby-version"
+- ".travis.yml"
+- CHANGELOG.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/scheduled_job.rb
+- lib/scheduled_job/version.rb
+- pry.rb
+- scheduled_job.gemspec
+- scheduled_job.rconf
+- spec/lib/scheduled_job_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/rightscale/scheduled_job
+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: Adding support for jobs that need to reccur
+test_files:
+- spec/lib/scheduled_job_spec.rb
+- spec/spec_helper.rb
+has_rdoc: