zhong 0.1.4 → 0.1.5

data/lib/zhong/every.rb

@@ -3,16 +3,39 @@ module Zhong
     class FailedToParse < StandardError; end
 
     EVERY_KEYWORDS = {
+      minute: 1.minute,
+      hour: 1.hour,
       day: 1.day,
       week: 1.week,
       month: 1.month,
-      semiannual: 6.months, # enterprise!
       year: 1.year,
       decade: 10.years
     }.freeze
 
     def initialize(period)
       @period = period
+
+      fail "`every` must be >= 1 second" unless valid?
+    end
+
+    def to_s
+      EVERY_KEYWORDS.to_a.reverse.each do |friendly, period|
+        if @period % period == 0
+          rem = @period / period
+
+          if rem == 1
+            return "#{rem} #{friendly}"
+          else
+            return "#{rem} #{friendly}s"
+          end
+        end
+      end
+
+      "#{@period.to_i} second#{@period.to_i == 1 ? '' : 's'}"
+    end
+
+    private def valid?
+      @period.to_f >= 1
     end
 
     def next_at(last = Time.now)
@@ -20,8 +43,6 @@ module Zhong
     end
 
     def self.parse(every)
-      return unless every
-
       case every
       when Numeric, ActiveSupport::Duration
         new(every)

data/lib/zhong/job.rb

@@ -1,95 +1,90 @@
 module Zhong
   class Job
-    attr_reader :name, :category
+    attr_reader :name, :category, :last_ran, :logger, :at, :every, :id
 
-    def initialize(name, config = {}, &block)
-      @name = name
+    def initialize(job_name, config = {}, &block)
+      @name = job_name
       @category = config[:category]
+      @logger = config[:logger]
+      @config = config
 
-      @at = At.parse(config[:at], grace: config.fetch(:grace, 15.minutes))
-      @every = Every.parse(config[:every])
-
-      if @at && !@every
-        @logger.error "warning: #{self} has `at` but no `every`; could run far more often than expected!"
-      end
+      @at = config[:at] ? At.parse(config[:at], grace: config.fetch(:grace, 15.minutes)) : nil
+      @every = config[:every] ? Every.parse(config[:every]) : nil
 
       fail "must specific either `at` or `every` for job: #{self}" unless @at || @every
 
       @block = block
 
       @redis = config[:redis]
-      @logger = config[:logger]
       @tz = config[:tz]
       @if = config[:if]
-      @lock = Suo::Client::Redis.new(lock_key, client: @redis, stale_lock_expiration: config[:long_running_timeout])
-      @timeout = 5
-
-      refresh_last_ran
+      @long_running_timeout = config[:long_running_timeout]
+      @running = false
+      @first_run = true
+      @id = Digest::SHA256.hexdigest(@name)
     end
 
     def run?(time = Time.now)
+      if @first_run
+        clear_last_ran_if_at_changed if @at
+        refresh_last_ran
+        @first_run = false
+      end
+
       run_every?(time) && run_at?(time) && run_if?(time)
     end
 
     def run(time = Time.now, error_handler = nil)
       return unless run?(time)
 
-      if running?
-        @logger.info "already running: #{self}"
-        return
-      end
-
-      @thread = nil
       locked = false
+      errored = false
 
-      @lock.lock do
-        locked = true
+      begin
+        redis_lock.lock do
+          locked = true
+          @running = true
 
-        refresh_last_ran
+          refresh_last_ran
 
-        # we need to check again, as another process might have acquired
-        # the lock right before us and obviated our need to do anything
-        break unless run?(time)
+          # we need to check again, as another process might have acquired
+          # the lock right before us and obviated our need to do anything
+          break unless run?(time)
 
-        if disabled?
-          @logger.info "disabled: #{self}"
-          break
-        end
+          if disabled?
+            logger.info "not running, disabled: #{self}"
+            break
+          end
 
-        @logger.info "running: #{self}"
+          logger.info "running: #{self}"
 
-        if @block
-          @thread = Thread.new do
+          if @block
             begin
               @block.call
             rescue => boom
-              @logger.error "#{self} failed: #{boom}"
+              logger.error "#{self} failed: #{boom}"
               error_handler.call(boom, self) if error_handler
             end
-
-            nil # do not retain thread return value
           end
-        end
 
-        ran!(time)
+          ran!(time)
+        end
+      rescue Suo::LockClientError => boom
+        logger.error "unable to run due to client error: #{boom}"
+        errored = true
       end
 
-      @logger.info "unable to acquire exclusive run lock: #{self}" unless locked
-    end
+      @running = false
 
-    def stop
-      return unless running?
-      Thread.new { @logger.error "killing #{self} due to stop" } # thread necessary due to trap context
-      @thread.join(@timeout)
-      @thread.kill
+      logger.info "unable to acquire exclusive run lock: #{self}" if !locked && !errored
     end
 
     def running?
-      @thread && @thread.alive?
+      @running
     end
 
     def refresh_last_ran
-      last_ran_val = @redis.get(run_time_key)
+      last_ran_val = @redis.get(last_ran_key)
       @last_ran = last_ran_val ? Time.at(last_ran_val.to_i) : nil
     end
 
@@ -106,7 +101,7 @@ module Zhong
     end
 
     def to_s
-      [@category, @name].compact.join(".").freeze
+      @to_s ||= [@category, @name].compact.join(".").freeze
     end
 
     def next_at
@@ -115,8 +110,45 @@ module Zhong
       [every_time, at_time, Time.now].compact.max || "now"
     end
 
+    def clear
+      @redis.del(last_ran_key)
+    end
+
+    def last_ran_key
+      "zhong:last_ran:#{self}"
+    end
+
+    def desired_at_key
+      "zhong:at:#{self}"
+    end
+
+    def disabled_key
+      "zhong:disabled:#{self}"
+    end
+
+    def lock_key
+      "zhong:lock:#{self}"
+    end
+
     private
 
+    # if the @at value is changed across runs, the last_run becomes invalid
+    # so clear it
+    def clear_last_ran_if_at_changed
+      previous_at_msgpack = @redis.get(desired_at_key)
+
+      if previous_at_msgpack
+        previous_at = At.deserialize(previous_at_msgpack)
+
+        if previous_at != @at
+          logger.error "#{self} period changed (from #{previous_at} to #{@at}), clearing last run"
+          clear
+        end
+      end
+
+      @redis.set(desired_at_key, @at.serialize)
+    end
+
     def run_every?(time)
       !@last_ran || !@every || @every.next_at(@last_ran) <= time
     end
@@ -131,19 +163,11 @@ module Zhong
 
     def ran!(time)
       @last_ran = time
-      @redis.set(run_time_key, @last_ran.to_i)
-    end
-
-    def run_time_key
-      "zhong:last_ran:#{self}"
+      @redis.set(last_ran_key, @last_ran.to_i)
     end
 
-    def disabled_key
-      "zhong:disabled:#{self}"
-    end
-
-    def lock_key
-      "zhong:lock:#{self}"
+    def redis_lock
+      @lock ||= Suo::Client::Redis.new(lock_key, client: @redis, stale_lock_expiration: @long_running_timeout)
     end
   end
 end

data/lib/zhong/scheduler.rb

@@ -5,17 +5,20 @@ module Zhong
     DEFAULT_CONFIG = {
       timeout: 0.5,
       grace: 15.minutes,
-      long_running_timeout: 5.minutes
+      long_running_timeout: 5.minutes,
+      tz: nil
     }.freeze
 
-    TRAPPED_SIGNALS = %w(QUIT INT TERM).freeze
-
     def initialize(config = {})
       @jobs = {}
       @callbacks = {}
       @config = DEFAULT_CONFIG.merge(config)
-      @logger = @config[:logger] ||= Util.default_logger
-      @redis = @config[:redis] ||= Redis.new(ENV["REDIS_URL"])
+
+      @logger = @config[:logger]
+      @redis = @config[:redis]
+      @tz = @config[:tz]
+      @category = nil
+      @error_handler = nil
     end
 
     def category(name)
@@ -30,8 +33,15 @@ module Zhong
 
     def every(period, name, opts = {}, &block)
       fail "must specify a period for #{name} (#{caller.first})" unless period
+
       job = Job.new(name, opts.merge(@config).merge(every: period, category: @category), &block)
-      add(job)
+
+      if jobs.key?(job.id)
+        @logger.error "duplicate job #{job}, skipping"
+        return
+      end
+
+      @jobs[job.id] = job
     end
 
     def error_handler(&block)
@@ -45,64 +55,86 @@ module Zhong
     end
 
     def start
-      TRAPPED_SIGNALS.each do |sig|
-        Signal.trap(sig) { stop }
-      end
-
       @logger.info "starting at #{redis_time}"
 
+      @stop = false
+
+      trap_signals
+
       loop do
         if fire_callbacks(:before_tick)
           now = redis_time
 
-          jobs.each do |_, job|
-            if fire_callbacks(:before_run, job, now)
-              job.run(now, error_handler)
-              fire_callbacks(:after_run, job, now)
-            end
+          jobs_to_run(now).each do |_, job|
+            break if @stop
+            run_job(job, now)
           end
 
+          break if @stop
+
           fire_callbacks(:after_tick)
 
-          GC.start
+          heartbeat(now)
 
-          sleep(interval)
+          break if @stop
+          sleep_until_next_second
         end
 
         break if @stop
       end
+
+      Thread.new { @logger.info "stopped" }.join
     end
 
     def stop
       Thread.new { @logger.error "stopping" } # thread necessary due to trap context
       @stop = true
-      jobs.values.each(&:stop)
-      Thread.new { @logger.info "stopped" }
     end
 
+    private
+
+    TRAPPED_SIGNALS = %w(QUIT INT TERM).freeze
+    private_constant :TRAPPED_SIGNALS
+
     def fire_callbacks(event, *args)
       @callbacks[event].to_a.all? { |h| h.call(*args) }
     end
 
-    private
+    def jobs_to_run(time = redis_time)
+      jobs.select { |_, job| job.run?(time) }
+    end
 
-    def add(job)
-      if @jobs.key?(job.to_s)
-        @logger.error "duplicate job #{job}, skipping"
-        return
-      end
+    def run_job(job, time = redis_time)
+      return unless fire_callbacks(:before_run, job, time)
+
+      job.run(time, error_handler)
 
-      @jobs[job.to_s] = job
+      fire_callbacks(:after_run, job, time)
+    end
+
+    def heartbeat(time)
+      @redis.setex(heartbeat_key, @config[:grace].to_i, time.to_i)
+    end
+
+    def heartbeat_key
+      @heartbeat_key ||= "zhong:heartbeat:#{`hostname`.strip}##{Process.pid}"
+    end
+
+    def trap_signals
+      TRAPPED_SIGNALS.each do |sig|
+        Signal.trap(sig) { stop }
+      end
     end
 
-    def interval
-      1.0 - Time.now.subsec + 0.001
+    def sleep_until_next_second
+      GC.start
+      sleep(1.0 - Time.now.subsec + 0.0001)
     end
 
     def redis_time
       s, ms = @redis.time # returns [seconds since epoch, microseconds]
       now = Time.at(s + ms / (10**6))
-      config[:tz] ? now.in_time_zone(config[:tz]) : now
+      @tz ? now.in_time_zone(@tz) : now
     end
   end
 end

data/lib/zhong/version.rb

@@ -1,3 +1,3 @@
 module Zhong
-  VERSION = "0.1.4"
+  VERSION = "0.1.5"
 end

data/lib/zhong/web.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+require "tilt/erubis"
+require "erb"
+require "sinatra/base"
+
+require "zhong"
+require "zhong/web_helpers"
+
+module Zhong
+  class Web < Sinatra::Base
+    enable :sessions
+    use ::Rack::Protection, use: :authenticity_token unless ENV["RACK_ENV"] == "test"
+
+    if ENV["ZHONG_WEB_USERNAME"] && ENV["ZHONG_WEB_PASSWORD"]
+      use Rack::Auth::Basic, "Sorry." do |username, password|
+        username == ENV["ZHONG_WEB_USERNAME"] and password == ENV["ZHONG_WEB_PASSWORD"]
+      end
+    end
+
+    if ENV["RACK_ENV"] == "development"
+      before do
+        STDERR.puts "[params] #{params}" unless params.empty?
+      end
+    end
+
+    set :root, File.expand_path(File.dirname(__FILE__) + "/../../web")
+    set :public_folder, proc { "#{root}/assets" }
+    set :views, proc { "#{root}/views" }
+
+    helpers WebHelpers
+
+    get '/' do
+      index
+
+      erb :index
+    end
+
+    post '/' do
+      if params['disable']
+        if job = Zhong.jobs[params['disable']]
+          job.disable
+        end
+      elsif params['enable']
+        if job = Zhong.jobs[params['enable']]
+          job.enable
+        end
+      end
+
+      index
+
+      erb :index
+    end
+
+    def index
+      @jobs = Zhong.jobs.values
+      @last_runs = zhong_mget(@jobs, "last_ran")
+      @disabled = zhong_mget(@jobs, "disabled")
+      @hosts = safe_mget(Zhong.redis.scan_each(match: "zhong:heartbeat:*").to_a).map do |k, v|
+        host, pid = k.split("zhong:heartbeat:", 2)[1].split("#", 2)
+        {host: host, pid: pid, last_seen: Time.at(v.to_i)}
+      end
+    end
+
+    def zhong_mget(jobs, key)
+      keys = jobs.map(&:to_s)
+      ret = safe_mget(keys.map { |j| "zhong:#{key}:#{j}" })
+      Hash[keys.map { |j| [j, ret["zhong:#{key}:#{j}"]] }]
+    end
+
+    def safe_mget(keys)
+      if keys.length > 0
+        Zhong.redis.mapped_mget(*keys)
+      else
+        {}
+      end
+    end
+  end
+end
+
+if defined?(::ActionDispatch::Request::Session) &&
+    !::ActionDispatch::Request::Session.respond_to?(:each)
+  # mperham/sidekiq#2460
+  # Rack apps can't reuse the Rails session store without
+  # this monkeypatch
+  class ActionDispatch::Request::Session
+    def each(&block)
+      hash = self.to_hash
+      hash.each(&block)
+    end
+  end
+end