activejob-scheduler 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d82e4890ae35e31690712e645bf35ed17563f411
+  data.tar.gz: 22080545aa6fd5a349d583f974e19674ddbadc3e
+SHA512:
+  metadata.gz: 67873b9ceb54a39466f027030123de2e09d4015afb9ac9e6fbb3bfb89e89bff8b1926ae26f94e9b9a20aee55e44296166539c6740f8e2a96a2e27dd088c6f7a5
+  data.tar.gz: bbf7cb9b2dd1484d271e78ef6d8967c74cbc7194cc59d99853b84538c0c6517c124d197c5d1b8635a6395ffdc51250a4b328b17bdb1b47040abaa44549d07bd0

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/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Tom Scott
+
+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,90 @@
+# ActiveJob::Scheduler
+
+An extension to [ActiveJob][aj] for running background jobs
+periodically, according to a schedule. Inspired by its predecessors,
+[resque-scheduler][resque] and [sidekiq-scheduler][sidekiq],
+`ActiveJob::Scheduler` hopes to bring the power of scheduled jobs into
+everyone's hands, by way of the pre-defined ActiveJob API which most
+popular queueing backend choices already support.
+
+Like its predecessors, `ActiveJob::Scheduler` is built with
+[Rufus::Scheduler][rufus], an immensely powerful task scheduling library
+to make sure your jobs get kicked off at *exactly* the right time.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'activejob-scheduler'
+
+And then execute:
+
+    $ bundle
+
+## Usage
+
+Run the following command to generate a YAML-based schedule:
+
+```bash
+$ rails generate activejob:schedule
+```
+
+Edit this YAML file the same way you would with resque-scheduler or
+sidekiq-scheduler (they define the same parameters). Then, it's your
+choice as to how you wish to run it, either by the binary:
+
+```bash
+$ bundle exec ajs
+```
+
+Or, with a Rake task:
+
+```bash
+$ bundle exec rake activejob:schedule
+```
+
+The schedule must run as a separate process, but it's very light...it
+delegates all the real processing to your queue workers, and simply
+enqueues jobs as the specified time rolls around.
+
+## Development
+
+Please use GitHub pull requests to contribute bug fixes or features, and
+make sure to include tests with all your work.
+
+### License
+
+[University of Illinois/NCSA Open Source License][license]
+
+    Copyright (c) 2014 Tom Scott
+    All rights reserved.
+
+    Permission is hereby granted, free of charge, to any person obtaining
+    a copy of this software and associated documentation files (the "Software"),
+    to deal with 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:
+
+    Redistributions of source code must retain the above copyright notice,
+    this list of conditions and the following disclaimers.
+
+    Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimers in the documentation
+    and/or other materials provided with the distribution.
+
+    None of the names of its contributors may be used to endorse or promote
+    products derived from this Software without specific prior written permission.
+
+    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 CONTRIBUTORS 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 WITH THE SOFTWARE.
+
+[aj]: https://github.com/rails/activejob
+[resque]: https://github.com/resque/resque-scheduler
+[sidekiq]: https://github.com/Moove-it/sidekiq-scheduler
+[rufus]: https://github.com/jmettraux/rufus-scheduler
+[license]: http://opensource.org/licenses/NCSA

data/Rakefile

@@ -0,0 +1,5 @@
+require "bundler/setup"
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new :test

data/activejob-scheduler.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'active_job/scheduler/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "activejob-scheduler"
+  spec.version       = ActiveJob::Scheduler::VERSION
+  spec.authors       = ["Tom Scott"]
+  spec.email         = ["tscott@telvue.com"]
+  spec.summary       = %q{A scheduling apparatus for ActiveJob based on Rufus.}
+  spec.description   = %q{A scheduling apparatus for ActiveJob based on Rufus. Resque::Scheduler for everyone!}
+  spec.homepage      = "http://github.com/tubbo/activejob-scheduler"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(spec)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+
+  spec.add_dependency 'activejob'
+  spec.add_dependency 'rufus-scheduler'
+  spec.add_dependency 'activemodel'
+end

data/bin/ajs

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+#
+# Easy-peasy binary goodness for the ActiveJob::Scheduler
+
+require 'active_job/scheduler'
+
+ActiveJob::Scheduler::CLI.run ARGV, ENV

data/lib/active_job/scheduler.rb

@@ -0,0 +1,7 @@
+require "active_job/scheduler/version"
+
+module ActiveJob
+  module Scheduler
+    # Your code goes here...
+  end
+end

data/lib/active_job/scheduler/cli.rb

@@ -0,0 +1,113 @@
+require 'optparse'
+
+module ActiveJob::Scheduler
+  # Controller for the schedule via the CLI.
+  class Cli
+    attr_reader :env, :options
+
+    # A short doc explaining the CLI.
+    USAGE = <<-EOF.gsub(/ {6}/, '')
+      Usage: activejob-scheduler [options]
+
+      Runs an active_job scheduler process directly (rather than via rake).
+
+    EOF
+
+    # The various options our CLI takes.
+    OPTIONS = [
+      {
+        args: ['-n', '--app-name [APP_NAME]',
+               'Application name for procline'],
+        callback: ->(options) { ->(n) { options[:app_name] = n } }
+      },
+      {
+        args: ['-B', '--background', 'Run in the background [BACKGROUND]'],
+        callback: ->(options) { ->(b) { options[:background] = b } }
+      },
+      {
+        args: ['-D', '--dynamic-schedule',
+               'Enable dynamic scheduling [DYNAMIC_SCHEDULE]'],
+        callback: ->(options) { ->(d) { options[:dynamic] = d } }
+      },
+      {
+        args: ['-E', '--environment [RAILS_ENV]', 'Environment name'],
+        callback: ->(options) { ->(e) { options[:env] = e } }
+      },
+      {
+        args: ['-I', '--initializer-path [INITIALIZER_PATH]',
+               'Path to optional initializer ruby file'],
+        callback: ->(options) { ->(i) { options[:initializer_path] = i } }
+      },
+      {
+        args: ['-i', '--interval [RESQUE_SCHEDULER_INTERVAL]',
+               'Interval for checking if a scheduled job must run'],
+        callback: ->(options) { ->(i) { options[:poll_sleep_amount] = i } }
+      },
+      {
+        args: ['-l', '--logfile [LOGFILE]', 'Log file name'],
+        callback: ->(options) { ->(l) { options[:logfile] = l } }
+      },
+      {
+        args: ['-F', '--logformat [LOGFORMAT]', 'Log output format'],
+        callback: ->(options) { ->(f) { options[:logformat] = f } }
+      },
+      {
+        args: ['-P', '--pidfile [PIDFILE]', 'PID file name'],
+        callback: ->(options) { ->(p) { options[:pidfile] = p } }
+      },
+      {
+        args: ['-q', '--quiet', 'Run with minimal output [QUIET]'],
+        callback: ->(options) { ->(q) { options[:quiet] = q } }
+      },
+      {
+        args: ['-v', '--verbose', 'Run with verbose output [VERBOSE]'],
+        callback: ->(options) { ->(v) { options[:verbose] = v } }
+      }
+    ].freeze
+
+    # Instantiate a new CLI handler with the given args.
+    def initialize(argv, env)
+      @env = env
+      @args = argv
+      @options = option_parser.parse! argv
+    end
+
+    # Start the scheduler CLI immediately from given command-line
+    # arguments.
+    def self.run(argv, env)
+      new(argv, env).run
+    end
+
+    # Now that we have args, actually begin running the schedule by
+    # loading each Job into Rufus::Scheduler. Rufus uses methods like
+    # `every` and `cron` to determine what kind of job you're pushing
+    # into it, so we use send() to give the Job object the power to make
+    # that choice.
+    def run
+      jobs.each do |job|
+        rufus.send job.interval, *job.rufus_params
+      end
+
+      rufus.start
+    end
+
+    private
+    def option_parser
+      OptionParser.new do |parser|
+        parser.banner = USAGE
+
+        OPTIONS.each do |opt|
+          parser.on(*opt[:args], &(opt[:callback].call(options)))
+        end
+      end
+    end
+
+    def jobs
+      @jobs ||= Jobs.from_yaml
+    end
+
+    def rufus
+      @rufus ||= Rufus::Scheduler.new
+    end
+  end
+end

data/lib/active_job/scheduler/job.rb

@@ -0,0 +1,59 @@
+require 'active_model'
+
+module ActiveJob::Scheduler
+  # A model for use in the scheduler itself that wraps an existing
+  # ActiveJob::Base and enqueues it at some point. This is pretty much
+  # the holder for each stanza of YAML information as expressed in
+  # `config/jobs.yml`.
+  class Job
+    include ActiveModel::Model
+
+    # Attributes this object supports...
+    #
+    # - name: the name of the job in YAML
+    # - description: A short String description for shell docs
+    # - class: The class name of the job, by default derived from name.
+    # - interval: How we are describing the interval of passed time
+    #   between runs (can be 'every', 'at', 'cron', or 'in')
+    #
+    # These are all specified in the YAML.
+    attr_accessor :name, :description, :job_class, :interval, :interval_value
+    attr_reader :attributes
+
+    # Interval types supported by the scheduler.
+    INTERVALS = %w(at in cron every)
+
+    validates :name, presence: true
+    validates :interval, presence: true
+    validates :interval_value, presence: true
+
+    # Set up and instantiate this Job object for use with the scheduler.
+    # Basically, this wraps the enqueued execution of an `ActiveJob::Base`.
+    def initialize(from_attrs={})
+      @interval, @interval_value = from_attrs.select { |attr, value|
+        INTERVALS.include? "#{attr}"
+      }.first.to_a.flatten
+      from_attrs.delete @interval
+      @attributes = from_attrs
+      super
+    end
+
+    # Description is the humanized name of the task by default.
+    def description
+      @description ||= name.titleize
+    end
+
+    # Enqueue this job with ActiveJob.
+    def enqueue
+      return false unless valid?
+      jobject.enqueue
+    end
+
+    private
+    def jobject
+      job_class.constantize
+    rescue StandardError
+      errors.add :job_class, "'#{job_class}' was not found"
+    end
+  end
+end

data/lib/active_job/scheduler/jobs.rb

@@ -0,0 +1,32 @@
+require 'yaml'
+
+module ActiveJob::Scheduler
+  class Jobs
+    include Enumerable
+
+    attr_reader :path
+
+    def initialize(from_path)
+      @path = from_path
+    end
+
+    def self.from_yaml
+      new "config/jobs.yml"
+    end
+
+    def each
+      collection.each { |job| yield job }
+    end
+
+    private
+    def collection
+      params.keys.map do |name|
+        Job.new params[name].merge name: name
+      end
+    end
+
+    def params
+      @collection ||= YAML::load_file path
+    end
+  end
+end

data/lib/active_job/scheduler/task.rb

@@ -0,0 +1,38 @@
+require 'active_job/scheduler/cli'
+require 'rake/tasklib'
+
+module ActiveJob::Scheduler
+  # Run the scheduler as a Rake task, and preload the Rails environment.
+  #
+  # Example Task:
+  #
+  #   ActiveJob::Scheduler::Task.new :schedule
+  #
+  # Example Shell Command:
+  #
+  #   rake schedule
+  #
+  # The task can also be pre-loaded with a task called `schedule:setup`.
+  class Task < Rake::TaskLib
+    attr_reader :name
+
+    def initialize(with_name=:schedule)
+      @name = with_name
+      yield self if block_given?
+      define
+    end
+
+    def define
+      namespace name do
+        task :setup
+
+        task :run do
+          ActiveJob::Scheduler::Cli.run ARGV, ENV
+        end
+      end
+
+      desc "Run the ActiveJob::Scheduler"
+      task name => ["#{name}:setup", "#{name}:run"]
+    end
+  end
+end

data/lib/active_job/scheduler/version.rb

@@ -0,0 +1,5 @@
+module ActiveJob
+  module Scheduler
+    VERSION = "0.0.1"
+  end
+end

data/spec/active_job/scheduler/job_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+require 'active_job/scheduler/job'
+
+class Worker
+  def perform(record)
+    # do nothing
+  end
+end
+
+module ActiveJob::Scheduler
+  describe Job do
+    subject do
+      Job.new \
+        name: 'testing',
+        every: '30s',
+        job_class: 'Worker'
+    end
+
+    before do
+      allow(subject.send(:jobject)).to receive(:enqueue).and_return true
+    end
+
+    it "finds the interval" do
+      expect(subject.interval).to eq(:every)
+    end
+
+    it "finds the interval value" do
+      expect(subject.interval_value).to eq('30s')
+    end
+
+    it "finds the job class name" do
+      expect(subject.job_class).to eq('Worker')
+    end
+
+    it "it finds the description or gets one set" do
+      expect(subject.description).to eq('Testing')
+    end
+
+    it "enqueues the job with active_job" do
+      expect(subject).to be_valid
+      expect(subject.enqueue).to be_true
+    end
+  end
+end

data/spec/active_job/scheduler/jobs_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+require 'active_job/scheduler/jobs'
+
+module ActiveJob::Scheduler
+  describe Jobs do
+    let :fixture_config do
+      File.expand_path('../../../fixtures/jobs.yml', __FILE__)
+    end
+
+    subject { Jobs.new fixture_config }
+
+    it "reads from a yaml file on disk" do
+      expect(subject.path).to eq(fixture_config)
+    end
+
+    it "defines jobs from each params stanza it sees" do
+      expect(subject.send(:collection).first).to be_a Job
+    end
+
+    it "iterates over the collection as an enumerable" do
+      expect(subject).to respond_to :each
+    end
+  end
+end

data/spec/fixtures/jobs.yml

@@ -0,0 +1,3 @@
+example:
+  every: '1m'
+  job_class: 'ExampleJob'

data/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+$LOAD_PATH << File.expand_path('../../lib', __FILE__)
+
+require 'bundler/setup'
+require 'rspec'

metadata

@@ -0,0 +1,151 @@
+--- !ruby/object:Gem::Specification
+name: activejob-scheduler
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Tom Scott
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-06-10 00:00:00.000000000 Z
+dependencies:
+- !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'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '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'
+- !ruby/object:Gem::Dependency
+  name: activejob
+  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: rufus-scheduler
+  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: activemodel
+  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'
+description: A scheduling apparatus for ActiveJob based on Rufus. Resque::Scheduler
+  for everyone!
+email:
+- tscott@telvue.com
+executables:
+- ajs
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- activejob-scheduler.gemspec
+- bin/ajs
+- lib/active_job/scheduler.rb
+- lib/active_job/scheduler/cli.rb
+- lib/active_job/scheduler/job.rb
+- lib/active_job/scheduler/jobs.rb
+- lib/active_job/scheduler/task.rb
+- lib/active_job/scheduler/version.rb
+- spec/active_job/scheduler/job_spec.rb
+- spec/active_job/scheduler/jobs_spec.rb
+- spec/fixtures/jobs.yml
+- spec/spec_helper.rb
+homepage: http://github.com/tubbo/activejob-scheduler
+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.0.3
+signing_key: 
+specification_version: 4
+summary: A scheduling apparatus for ActiveJob based on Rufus.
+test_files:
+- spec/active_job/scheduler/job_spec.rb
+- spec/active_job/scheduler/jobs_spec.rb
+- spec/fixtures/jobs.yml
+- spec/spec_helper.rb