activejob-scheduler 0.0.1 → 1.0.0.pre

data/bin/ajs

@@ -1,7 +0,0 @@
-#!/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/cli.rb

@@ -1,113 +0,0 @@
-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/jobs.rb

@@ -1,32 +0,0 @@
-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

@@ -1,38 +0,0 @@
-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/spec/active_job/scheduler/job_spec.rb

@@ -1,44 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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

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

data/spec/spec_helper.rb

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