sqeduler 0.1.4

data/lib/sqeduler/worker/callbacks.rb

@@ -0,0 +1,38 @@
+# encoding: utf-8
+require "benchmark"
+module Sqeduler
+  module Worker
+    # Basic callbacks for worker events.
+    module Callbacks
+      def perform(*args)
+        before_start
+        duration = Benchmark.realtime { super }
+        on_success(duration)
+      rescue StandardError => e
+        on_failure(e)
+        raise
+      end
+
+      private
+
+      # provides an oppurtunity to log when the job has started (maybe create a
+      # stateful db record for this job run?)
+      def before_start
+        Service.logger.info "Starting #{self.class.name} at #{Time.new.utc} in process ID #{Process.pid}"
+        super if defined?(super)
+      end
+
+      # callback for successful run of this job
+      def on_success(total_time)
+        Service.logger.info "#{self.class.name} completed at #{Time.new.utc}. Total time #{total_time}"
+        super if defined?(super)
+      end
+
+      # callback for when failues in this job occur
+      def on_failure(e)
+        Service.logger.error "#{self.class.name} failed with exception #{e}"
+        super if defined?(super)
+      end
+    end
+  end
+end

data/lib/sqeduler/worker/everything.rb

@@ -0,0 +1,13 @@
+module Sqeduler
+  module Worker
+    # convenience module for including everything
+    module Everything
+      def self.included(mod)
+        mod.prepend Sqeduler::Worker::Synchronization
+        mod.prepend Sqeduler::Worker::KillSwitch
+        # needs to be the last one
+        mod.prepend Sqeduler::Worker::Callbacks
+      end
+    end
+  end
+end

data/lib/sqeduler/worker/kill_switch.rb

@@ -0,0 +1,52 @@
+# encoding: utf-8
+module Sqeduler
+  module Worker
+    # Uses Redis hashes to enabled and disable workers across multiple hosts.
+    module KillSwitch
+      SIDEKIQ_DISABLED_WORKERS = "sidekiq.disabled-workers"
+
+      def self.prepended(base)
+        if base.ancestors.include?(Sqeduler::Worker::Callbacks)
+          fail "Sqeduler::Worker::Callbacks must be the last module that you prepend."
+        end
+        base.extend(ClassMethods)
+      end
+
+      # rubocop:disable Style/Documentation
+      module ClassMethods
+        def enable
+          Service.redis_pool.with do |redis|
+            redis.hdel(SIDEKIQ_DISABLED_WORKERS, name)
+            Service.logger.warn "#{name} has been enabled"
+          end
+        end
+
+        def disable
+          Service.redis_pool.with do |redis|
+            redis.hset(SIDEKIQ_DISABLED_WORKERS, name, Time.now)
+            Service.logger.warn "#{name} has been disabled"
+          end
+        end
+
+        def disabled?
+          Service.redis_pool.with do |redis|
+            redis.hexists(SIDEKIQ_DISABLED_WORKERS, name)
+          end
+        end
+
+        def enabled?
+          !disabled?
+        end
+      end
+      # rubocop:enable Style/Documentation
+
+      def perform(*args)
+        if self.class.disabled?
+          Service.logger.warn "#{self.class.name} is currently disabled."
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/sqeduler/worker/synchronization.rb

@@ -0,0 +1,110 @@
+# encoding: utf-8
+require "benchmark"
+require "active_support/core_ext/class/attribute"
+
+module Sqeduler
+  module Worker
+    # Module that provides common synchronization infrastructure
+    # of workers across multiple hosts `Sqeduler::BaseWorker.synchronize_jobs`.
+    module Synchronization
+      def self.prepended(base)
+        if base.ancestors.include?(Sqeduler::Worker::Callbacks)
+          fail "Sqeduler::Worker::Callbacks must be the last module that you prepend."
+        end
+
+        base.extend(ClassMethods)
+        base.class_attribute :synchronize_jobs_mode
+        base.class_attribute :synchronize_jobs_expiration
+        base.class_attribute :synchronize_jobs_timeout
+      end
+
+      # rubocop:disable Style/Documentation
+      module ClassMethods
+        def synchronize(mode, opts = {})
+          self.synchronize_jobs_mode = mode
+          self.synchronize_jobs_timeout = opts[:timeout] || 5
+          self.synchronize_jobs_expiration = opts[:expiration]
+          return if synchronize_jobs_expiration
+          fail ArgumentError, ":expiration is required!"
+        end
+      end
+      # rubocop:enable Style/Documentation
+
+      def perform(*args)
+        if self.class.synchronize_jobs_mode == :one_at_a_time
+          perform_locked(sync_lock_key(*args)) do
+            perform_timed do
+              super
+            end
+          end
+        else
+          super
+        end
+      end
+
+      private
+
+      def sync_lock_key(*args)
+        if args.empty?
+          self.class.name
+        else
+          "#{self.class.name}-#{args.join}"
+        end
+      end
+
+      # callback for when a lock cannot be obtained
+      def on_lock_timeout(key)
+        Service.logger.warn(
+          "#{self.class.name} unable to acquire lock '#{key}'. Aborting."
+        )
+        super if defined?(super)
+      end
+
+      # callback for when the job expiration is too short, less < time it took
+      # perform the actual work
+      SCHEDULE_COLLISION_MARKER = "%s took %s but has an expiration of %p sec. Beware of race conditions!".freeze
+      def on_schedule_collision(duration)
+        Service.logger.warn(
+          format(
+            SCHEDULE_COLLISION_MARKER,
+            self.class.name,
+            time_duration(duration),
+            self.class.synchronize_jobs_expiration
+          )
+        )
+        super if defined?(super)
+      end
+
+      def perform_timed(&block)
+        duration = Benchmark.realtime(&block)
+        on_schedule_collision(duration) if duration > self.class.synchronize_jobs_expiration
+      end
+
+      def perform_locked(sync_lock_key, &work)
+        RedisLock.with_lock(
+          sync_lock_key,
+          :expiration => self.class.synchronize_jobs_expiration,
+          :timeout => self.class.synchronize_jobs_timeout,
+          &work
+        )
+      rescue RedisLock::LockTimeoutError
+        on_lock_timeout(sync_lock_key)
+      end
+
+      # rubocop:disable Metrics/AbcSize
+      def time_duration(timespan)
+        rest, secs = timespan.divmod(60)  # self is the time difference t2 - t1
+        rest, mins = rest.divmod(60)
+        days, hours = rest.divmod(24)
+
+        result = []
+        result << "#{days} Days" if days > 0
+        result << "#{hours} Hours" if hours > 0
+        result << "#{mins} Minutes" if mins > 0
+        result << "#{secs.round(2)} Seconds" if secs > 0
+        result.join(" ")
+      end
+      # rubocop:enable Metrics/AbcSize
+    end
+  end
+end

data/lib/sqeduler.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+require "sqeduler/version"
+require "sqeduler/config"
+require "sqeduler/redis_scripts"
+require "sqeduler/lock_value"
+require "sqeduler/redis_lock"
+require "sqeduler/trigger_lock"
+require "sqeduler/service"
+require "sqeduler/worker/callbacks"
+require "sqeduler/worker/synchronization"
+require "sqeduler/worker/kill_switch"
+require "sqeduler/worker/everything"

data/spec/config_spec.rb

@@ -0,0 +1,41 @@
+# encoding: utf-8
+require "spec_helper"
+
+RSpec.describe Sqeduler::Config do
+  describe "#initialize" do
+    subject do
+      described_class.new(options)
+    end
+
+    let(:options) do
+      {
+        :logger => double,
+        :schedule_path => "/tmp/schedule.yaml",
+        :redis_hash => {
+          :host => "localhost",
+          :db => 1
+        }
+      }.merge(extras)
+    end
+
+    let(:extras) { {} }
+
+    describe "redis_hash" do
+      it "should set the redis_hash" do
+        expect(subject.redis_hash).to eq(options[:redis_hash])
+      end
+    end
+
+    describe "schedule_path" do
+      it "should set the schedule_path" do
+        expect(subject.schedule_path).to eq(options[:schedule_path])
+      end
+    end
+
+    describe "logger" do
+      it "should set the logger" do
+        expect(subject.logger).to eq(options[:logger])
+      end
+    end
+  end
+end

data/spec/fixtures/env.rb

@@ -0,0 +1,21 @@
+require "sqeduler"
+require_relative "fake_worker"
+
+REDIS_CONFIG = {
+  :host => "localhost",
+  :db => 1
+}
+Sidekiq.logger = Logger.new(STDOUT).tap { |l| l.level = Logger::DEBUG }
+
+Sqeduler::Service.config = Sqeduler::Config.new(
+  :redis_hash => REDIS_CONFIG,
+  :logger => Sidekiq.logger,
+  :schedule_path => File.expand_path(File.dirname(__FILE__)) + "/schedule.yaml",
+  :on_server_start => proc do |_config|
+    Sqeduler::Service.logger.info "Received on_server_start callback"
+  end,
+  :on_client_start => proc do |_config|
+    Sqeduler::Service.logger.info "Received on_client_start callback"
+  end
+)
+Sqeduler::Service.start

data/spec/fixtures/fake_worker.rb

@@ -0,0 +1,47 @@
+# encoding: utf-8
+# Sample worker for specs
+class FakeWorker
+  JOB_RUN_PATH =            "/tmp/job_run"
+  JOB_BEFORE_START_PATH =   "/tmp/job_before_start"
+  JOB_SUCCESS_PATH =        "/tmp/job_success"
+  JOB_FAILURE_PATH =        "/tmp/job_failure"
+  JOB_LOCK_FAILURE_PATH =   "/tmp/lock_failure"
+  SCHEDULE_COLLISION_PATH = "/tmp/schedule_collision"
+  include Sidekiq::Worker
+  include Sqeduler::Worker::Everything
+
+  def perform(sleep_time = 0.1)
+    long_process(sleep_time)
+  end
+
+  private
+
+  def long_process(sleep_time)
+    sleep sleep_time
+    log_event(JOB_RUN_PATH)
+  end
+
+  def log_event(file_path)
+    File.open(file_path, "a+") { |f| f.write "1" }
+  end
+
+  def on_success(_total_duration)
+    log_event(JOB_SUCCESS_PATH)
+  end
+
+  def on_failure(_e)
+    log_event(JOB_FAILURE_PATH)
+  end
+
+  def before_start
+    log_event(JOB_BEFORE_START_PATH)
+  end
+
+  def on_lock_timeout(_key)
+    log_event(JOB_LOCK_FAILURE_PATH)
+  end
+
+  def on_schedule_collision(_duration)
+    log_event(SCHEDULE_COLLISION_PATH)
+  end
+end

data/spec/fixtures/schedule.yaml

@@ -0,0 +1,2 @@
+FakeWorker:
+  every: 5s

data/spec/integration_spec.rb

@@ -0,0 +1,32 @@
+require "spec_helper"
+require "./spec/fixtures/fake_worker"
+
+def maybe_cleanup_file(file_path)
+  File.delete(file_path) if File.exist?(file_path)
+end
+
+RSpec.describe "Sidekiq integration" do
+  before do
+    maybe_cleanup_file(FakeWorker::JOB_RUN_PATH)
+    maybe_cleanup_file(FakeWorker::JOB_SUCCESS_PATH)
+    maybe_cleanup_file(FakeWorker::JOB_FAILURE_PATH)
+    maybe_cleanup_file(FakeWorker::JOB_LOCK_FAILURE_PATH)
+    maybe_cleanup_file(FakeWorker::JOB_BEFORE_START_PATH)
+    maybe_cleanup_file(FakeWorker::SCHEDULE_COLLISION_PATH)
+  end
+
+  it "should start sidekiq, schedule FakeWorker, and verify that it ran" do
+    path = File.expand_path(File.dirname(__FILE__)) + "/fixtures/env.rb"
+    pid = Process.spawn "bundle exec sidekiq -r #{path}"
+    puts "Spawned process #{pid}"
+    timeout = 30
+    start = Time.new
+    while (Time.new - start) < timeout
+      break if File.exist?(FakeWorker::JOB_RUN_PATH)
+      sleep 0.5
+    end
+    Process.kill("INT", pid)
+    Process.wait(pid, 0)
+    expect(File).to exist(FakeWorker::JOB_RUN_PATH)
+  end
+end

data/spec/service_spec.rb

@@ -0,0 +1,172 @@
+# encoding: utf-8
+require "spec_helper"
+
+RSpec.describe Sqeduler::Service do
+  let(:logger) do
+    Logger.new(STDOUT).tap { |l| l.level = Logger::DEBUG }
+  end
+
+  describe ".start" do
+    subject { described_class.start }
+
+    context "no config provided" do
+      it "should raise" do
+        expect { subject }.to raise_error
+      end
+    end
+
+    context "config provided" do
+      let(:schedule_filepath) { Pathname.new("./spec/fixtures/schedule.yaml") }
+      let(:server_receiver) { double }
+      let(:client_receiver) { double }
+      before do
+        allow(server_receiver).to receive(:call)
+        allow(client_receiver).to receive(:call)
+
+        described_class.config = Sqeduler::Config.new(
+          :redis_hash => REDIS_CONFIG,
+          :logger => logger,
+          :schedule_path => schedule_filepath,
+          :on_server_start => proc { |config| server_receiver.call(config) },
+          :on_client_start => proc { |config| client_receiver.call(config) }
+        )
+      end
+
+      it "starts the server" do
+        expect(Sidekiq).to receive(:configure_server)
+        subject
+      end
+
+      it "starts the client" do
+        expect(Sidekiq).to receive(:configure_client)
+        subject
+      end
+
+      it "calls the appropriate on_server_start callbacks" do
+        allow(Sidekiq).to receive(:server?).and_return(true)
+        expect(server_receiver).to receive(:call)
+        subject
+      end
+
+      it "calls the appropriate on_client_start callbacks" do
+        expect(client_receiver).to receive(:call)
+        subject
+      end
+
+      context "a schedule_path is provided" do
+        it "starts the scheduler" do
+          expect(Sidekiq).to receive(:"schedule=").with(YAML.load_file(schedule_filepath))
+          subject
+          expect(Sidekiq::Scheduler.rufus_scheduler_options).to have_key(:trigger_lock)
+          expect(Sidekiq::Scheduler.rufus_scheduler_options[:trigger_lock]).to be_kind_of(
+            Sqeduler::TriggerLock
+          )
+        end
+
+        context "a schedule_path is a string" do
+          let(:schedule_filepath) { "./spec/fixtures/schedule.yaml" }
+
+          it "starts the scheduler" do
+            expect(Sidekiq).to receive(:"schedule=").with(YAML.load_file(schedule_filepath))
+            subject
+            expect(Sidekiq::Scheduler.rufus_scheduler_options).to have_key(:trigger_lock)
+            expect(Sidekiq::Scheduler.rufus_scheduler_options[:trigger_lock]).to be_kind_of(
+              Sqeduler::TriggerLock
+            )
+          end
+        end
+      end
+
+      context "a schedule_path is not provided" do
+        let(:schedule_filepath) { nil }
+
+        it "does not start the scheduler" do
+          expect(Sidekiq).to_not receive(:"schedule=")
+          subject
+        end
+      end
+    end
+  end
+
+  describe ".redis_pool" do
+    subject { described_class.redis_pool }
+
+    before do
+      described_class.config = Sqeduler::Config.new.tap do |config|
+        config.redis_hash = REDIS_CONFIG
+        config.logger = logger
+      end
+    end
+
+    it "creates a connection pool" do
+      expect(subject).to be_kind_of(ConnectionPool)
+    end
+
+    it "is memoized" do
+      pool_1 = described_class.redis_pool
+      pool_2 = described_class.redis_pool
+      expect(pool_1.object_id).to eq(pool_2.object_id)
+    end
+
+    it "is not Sidekiq.redis" do
+      described_class.start
+      expect(Sidekiq.redis_pool.object_id).to_not eq(subject.object_id)
+    end
+
+    context "redis version is too low" do
+      before do
+        allow_any_instance_of(Redis).to receive(:info).and_return(
+          "redis_version" => "2.6.11"
+        )
+        if described_class.instance_variable_defined?(:@redis_pool)
+          described_class.remove_instance_variable(:@redis_pool)
+        end
+
+        if described_class.instance_variable_defined?(:@verified)
+          described_class.remove_instance_variable(:@verified)
+        end
+      end
+
+      it "should raise" do
+        expect { described_class.redis_pool }.to raise_error
+      end
+    end
+  end
+
+  describe ".logger" do
+    subject { described_class.logger }
+
+    before do
+      described_class.config = Sqeduler::Config.new.tap do |config|
+        config.logger = logger
+      end
+    end
+
+    context "provided in config" do
+      it "return the config value" do
+        expect(subject).to eq(logger)
+      end
+    end
+
+    context "no config provided" do
+      let(:logger) { nil }
+
+      it "should raise ArgumentError" do
+        expect { subject }.to raise_error(ArgumentError)
+      end
+
+      context "in a Rails app" do
+        let(:logger) { double }
+        before do
+          rails = double
+          stub_const("Rails", rails)
+          allow(rails).to receive(:logger).and_return(logger)
+        end
+
+        it "should use the Rails logger" do
+          expect(subject).to eq(logger)
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+require "pry"
+require "rspec"
+require "sqeduler"
+require "timecop"
+
+REDIS_CONFIG = {
+  :host => "localhost",
+  :db => 1
+}
+TEST_REDIS = Redis.new(REDIS_CONFIG)
+
+Timecop.safe_mode = true
+
+RSpec.configure do |config|
+  config.before(:each) do
+    TEST_REDIS.flushdb
+  end
+
+  config.disable_monkey_patching!
+end

data/spec/sqeduler_spec.rb

@@ -0,0 +1,10 @@
+# encoding: utf-8
+
+require "spec_helper"
+require "sqeduler"
+
+RSpec.describe Sqeduler do
+  it "should have a VERSION constant" do
+    expect(subject.const_get("VERSION")).not_to be_empty
+  end
+end

data/spec/trigger_lock_spec.rb

@@ -0,0 +1,80 @@
+# encoding: utf-8
+require "spec_helper"
+
+RSpec.describe Sqeduler::TriggerLock do
+  context "#lock" do
+    subject { described_class.new.lock }
+
+    before do
+      Sqeduler::Service.config = Sqeduler::Config.new(
+        :redis_hash => REDIS_CONFIG,
+        :logger     => Logger.new(STDOUT).tap { |l| l.level = Logger::DEBUG }
+      )
+    end
+
+    let(:trigger_lock_1) { described_class.new }
+    let(:trigger_lock_2) { described_class.new }
+
+    it "should get the lock" do
+      lock_successes = [trigger_lock_1, trigger_lock_2].map do |trigger_lock|
+        Thread.new { trigger_lock.lock }
+      end.map(&:value)
+
+      expect(lock_successes).to match_array([true, false])
+    end
+
+    it "should not be the owner if the lock has expired" do
+      allow(trigger_lock_1).to receive(:expiration_milliseconds).and_return(1000)
+      expect(trigger_lock_1.lock).to be true
+      expect(trigger_lock_1.locked?).to be true
+      sleep 1
+      expect(trigger_lock_1.locked?).to be false
+    end
+
+    it "should refresh the lock expiration time when it is the owner" do
+      allow(trigger_lock_1).to receive(:expiration_milliseconds).and_return(1000)
+      expect(trigger_lock_1.lock).to be true
+      sleep 1.1
+      expect(trigger_lock_1.locked?).to be false
+      expect(trigger_lock_1.refresh).to be true
+    end
+
+    it "should not refresh the lock when it is not owner" do
+      threads = []
+      threads << Thread.new do
+        allow(trigger_lock_1).to receive(:expiration_milliseconds).and_return(1000)
+        trigger_lock_1.lock
+        sleep 1
+      end
+      threads << Thread.new do
+        sleep 1.1
+        trigger_lock_2.lock
+      end
+      threads.each(&:join)
+      expect(trigger_lock_2.locked?).to be(true)
+      expect(trigger_lock_1.refresh).to be(false)
+    end
+
+    it "should release the lock when it is the owner" do
+      expect(trigger_lock_1.lock).to be true
+      expect(trigger_lock_1.unlock).to be true
+      expect(trigger_lock_1.locked?).to be false
+    end
+
+    it "should not release the lock when it is not the owner" do
+      threads = []
+      threads << Thread.new do
+        allow(trigger_lock_1).to receive(:expiration_milliseconds).and_return(1000)
+        trigger_lock_1.lock
+        sleep 1
+      end
+      threads << Thread.new do
+        sleep 1.1
+        trigger_lock_2.lock
+      end
+      threads.each(&:join)
+      expect(trigger_lock_2.locked?).to be(true)
+      expect(trigger_lock_1.unlock).to be(false)
+    end
+  end
+end

data/spec/worker/synchronization_spec.rb

@@ -0,0 +1,33 @@
+require "spec_helper"
+
+RSpec.describe Sqeduler::Worker::Synchronization do
+  describe ".synchronize" do
+    before do
+      stub_const(
+        "ParentWorker",
+        Class.new do
+          prepend Sqeduler::Worker::Synchronization
+          synchronize :one_at_a_time, :expiration => 10, :timeout => 1
+        end
+      )
+
+      stub_const("ChildWorker", Class.new(ParentWorker))
+    end
+
+    it "should preserve the synchronize attributes" do
+      expect(ChildWorker.synchronize_jobs_mode).to eq(:one_at_a_time)
+      expect(ChildWorker.synchronize_jobs_expiration).to eq(10)
+      expect(ChildWorker.synchronize_jobs_timeout).to eq(1)
+    end
+
+    it "should allow the child class to update the synchronize attributes" do
+      ChildWorker.synchronize :one_at_a_time, :expiration => 20, :timeout => 2
+      expect(ChildWorker.synchronize_jobs_mode).to eq(:one_at_a_time)
+      expect(ChildWorker.synchronize_jobs_expiration).to eq(20)
+      expect(ChildWorker.synchronize_jobs_timeout).to eq(2)
+      expect(ParentWorker.synchronize_jobs_mode).to eq(:one_at_a_time)
+      expect(ParentWorker.synchronize_jobs_expiration).to eq(10)
+      expect(ParentWorker.synchronize_jobs_timeout).to eq(1)
+    end
+  end
+end