bellbro 0.0.10 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 41861361bc83b68a51bc52e215bc4807abf67d6a
-  data.tar.gz: b29769f4efc8e9735bdef5901a95a8b530e080a3
+  metadata.gz: 2b9a986f01ee5802f9a0de0140f43326ebc03bdf
+  data.tar.gz: 9523ec14d089eecce4b14ec9a193cd8f42ddfe01
 SHA512:
-  metadata.gz: 5dafcf250ba4889ba5167b9aa75889c733873a25617f88e1eb6ba7c2afa786547c2490fae1a72f48b92e84cf1eda16d60f1eeceb24a8728b27348376dd1eb9b1
-  data.tar.gz: 23b14ea36b6a74aa2522fb98f79fecff069172dfa8b5dd4acbab297f473c0c8239850e80daf9ed8a26d24e8182c4069543aacbd6e5e6427beb14ce70fbdb9e60
+  metadata.gz: ab2080b1e3e50445ddcdcb2ad95d6ffc74f71cd35e5e85bfba8fc388c971da3d246312cd2a223ff1df1b7dab310cf4e936511114839d9943ec85dc1ae4f6b756
+  data.tar.gz: dd48e8a909e52659a22a55100c694b59b90354fe0c536b39c6b9247b7e8d6bbbeb6911b3815870f6555b61fc8dc0e0de3446b1ee297c28169cba62498e6f4cf1

data/lib/bellbro/hooks.rb

@@ -0,0 +1,264 @@
+module Bellbro
+  # Internal: Methods relating to supporting hooks around Sidekiq worker invocation.
+  module Hooks
+    def self.included(base)
+      base.class_eval do
+        extend ClassMethods
+      end
+    end
+
+    module ClassMethods
+      # Public: Declare hooks to run around worker invocation. The around
+      # method may be called multiple times; subsequent calls append declared
+      # hooks to existing around hooks.
+      #
+      # hooks - Zero or more Symbol method names representing instance methods
+      #         to be called around worker invocation. Each instance method
+      #         invocation receives an argument representing the next link in
+      #         the around hook chain.
+      # block - An optional block to be executed as a hook. If given, the block
+      #         is executed after methods corresponding to any given Symbols.
+      #
+      # Examples
+      #
+      #   class MyWorker
+      #     include Worker
+      #
+      #     around :time_execution
+      #
+      #     around do |worker|
+      #       puts "started"
+      #       worker.call
+      #       puts "finished"
+      #     end
+      #
+      #     def call
+      #       puts "called"
+      #     end
+      #
+      #     private
+      #
+      #     def time_execution(worker)
+      #       context.start_time = Time.now
+      #       worker.call
+      #       context.finish_time = Time.now
+      #     end
+      #   end
+      #
+      # Returns nothing.
+      def around(*hooks, &block)
+        hooks << block if block
+        hooks.each { |hook| around_hooks.push(hook) }
+      end
+
+      # Public: Declare hooks to run before Worker invocation. The before
+      # method may be called multiple times; subsequent calls append declared
+      # hooks to existing before hooks.
+      #
+      # hooks - Zero or more Symbol method names representing instance methods
+      #         to be called before worker invocation.
+      # block - An optional block to be executed as a hook. If given, the block
+      #         is executed after methods corresponding to any given Symbols.
+      #
+      # Examples
+      #
+      #   class MyWorker
+      #     include Worker
+      #
+      #     before :set_start_time
+      #
+      #     before do
+      #       puts "started"
+      #     end
+      #
+      #     def call
+      #       puts "called"
+      #     end
+      #
+      #     private
+      #
+      #     def set_start_time
+      #       context.start_time = Time.now
+      #     end
+      #   end
+      #
+      # Returns nothing.
+      def before(*hooks, &block)
+        hooks << block if block
+        hooks.each { |hook| before_hooks.push(hook) }
+      end
+
+      # Public: Declare hooks to run after Worker invocation. The after
+      # method may be called multiple times; subsequent calls prepend declared
+      # hooks to existing after hooks.
+      #
+      # hooks - Zero or more Symbol method names representing instance methods
+      #         to be called after worker invocation.
+      # block - An optional block to be executed as a hook. If given, the block
+      #         is executed before methods corresponding to any given Symbols.
+      #
+      # Examples
+      #
+      #   class MyWorker
+      #     include Worker
+      #
+      #     after :set_finish_time
+      #
+      #     after do
+      #       puts "finished"
+      #     end
+      #
+      #     def call
+      #       puts "called"
+      #     end
+      #
+      #     private
+      #
+      #     def set_finish_time
+      #       context.finish_time = Time.now
+      #     end
+      #   end
+      #
+      # Returns nothing.
+      def after(*hooks, &block)
+        hooks << block if block
+        hooks.each { |hook| after_hooks.unshift(hook) }
+      end
+
+      # Internal: An Array of declared hooks to run around Worker
+      # invocation. The hooks appear in the order in which they will be run.
+      #
+      # Examples
+      #
+      #   class MyWorker
+      #     include Worker
+      #
+      #     around :time_execution, :use_transaction
+      #   end
+      #
+      #   MyWorker.around_hooks
+      #   # => [:time_execution, :use_transaction]
+      #
+      # Returns an Array of Symbols and Procs.
+      def around_hooks
+        @around_hooks ||= []
+      end
+
+      # Internal: An Array of declared hooks to run before Worker
+      # invocation. The hooks appear in the order in which they will be run.
+      #
+      # Examples
+      #
+      #   class MyWorker
+      #     include Sidekiq::Worker
+      #
+      #     before :set_start_time, :say_hello
+      #   end
+      #
+      #   MyWorker.before_hooks
+      #   # => [:set_start_time, :say_hello]
+      #
+      # Returns an Array of Symbols and Procs.
+      def before_hooks
+        @before_hooks ||= []
+      end
+
+      # Internal: An Array of declared hooks to run before Worker
+      # invocation. The hooks appear in the order in which they will be run.
+      #
+      # Examples
+      #
+      #   class MyWorker
+      #     include Sidekiq::Worker
+      #
+      #     after :set_finish_time, :say_goodbye
+      #   end
+      #
+      #   MyWorker.after_hooks
+      #   # => [:say_goodbye, :set_finish_time]
+      #
+      # Returns an Array of Symbols and Procs.
+      def after_hooks
+        @after_hooks ||= []
+      end
+    end
+
+    private
+
+    # Internal: Run around, before and after hooks around yielded execution. The
+    # required block is surrounded with hooks and executed.
+    #
+    # Examples
+    #
+    #   class MyProcessor
+    #     include Bellbro::Hooks
+    #
+    #     def process_with_hooks
+    #       with_hooks do
+    #         process
+    #       end
+    #     end
+    #
+    #     def process
+    #       puts "processed!"
+    #     end
+    #   end
+    #
+    # Returns nothing.
+    def with_hooks
+      run_around_hooks do
+        run_before_hooks
+        yield
+        run_after_hooks
+      end
+    end
+
+    # Internal: Run around hooks.
+    #
+    # Returns nothing.
+    def run_around_hooks(&block)
+      self.class.around_hooks.reverse.inject(block) { |chain, hook|
+        proc { run_hook(hook, chain) }
+      }.call
+    end
+
+    # Internal: Run before hooks.
+    #
+    # Returns nothing.
+    def run_before_hooks
+      run_hooks(self.class.before_hooks)
+    end
+
+    # Internal: Run after hooks.
+    #
+    # Returns nothing.
+    def run_after_hooks
+      run_hooks(self.class.after_hooks)
+    end
+
+    # Internal: Run a colection of hooks. The "run_hooks" method is the common
+    # interface by which collections of either before or after hooks are run.
+    #
+    # hooks - An Array of Symbol and Proc hooks.
+    #
+    # Returns nothing.
+    def run_hooks(hooks)
+      hooks.each { |hook| run_hook(hook) }
+    end
+
+    # Internal: Run an individual hook. The "run_hook" method is the common
+    # interface by which an individual hook is run. If the given hook is a
+    # symbol, the method is invoked whether public or private. If the hook is a
+    # proc, the proc is evaluated in the context of the current instance.
+    #
+    # hook - A Symbol or Proc hook.
+    # args - Zero or more arguments to be passed as block arguments into the
+    #        given block or as arguments into the method described by the given
+    #        Symbol method name.
+    #
+    # Returns nothing.
+    def run_hook(hook, *args)
+      hook.is_a?(Symbol) ? send(hook, *args) : instance_exec(*args, &hook)
+    end
+  end
+end

data/lib/bellbro/service.rb

@@ -5,11 +5,27 @@ module Bellbro
     include Bellbro::SidekiqUtils
     include Bellbro::Trackable
 
-    SLEEP_INTERVAL = defined?(Rails) && Rails.env.test? ? 1 : 3600
-    track_with_schema jobs_started: Integer
-
     attr_reader :thread, :thread_error, :jid
 
+    def self.poll_interval(arg)
+      if defined?(Rails) && Rails.env.test?
+        @sleep_interval = 0.5
+      else
+        @sleep_interval = arg
+      end
+    end
+
+    def self.worker_class(arg)
+      @worker_class = arg
+    end
+
+    def self.get_worker_class
+      @worker_class
+    end
+
+    poll_interval defined?(Rails) && Rails.env.test? ? 1 : 3600
+    track_with_schema jobs_started: Integer
+
     def initialize
       @done = false
       @jid = Digest::MD5.hexdigest(Time.now.utc.to_s + Thread.current.object_id.to_s)
@@ -40,20 +56,23 @@ module Bellbro
       begin
         start_jobs
         Service.mutex.synchronize { status_update }
-        sleep self.class::SLEEP_INTERVAL
+        sleep
       end until @done
       Service.mutex.synchronize { stop_tracking }
     end
 
     def start_jobs
       each_job do |job|
-        klass = job[:klass].constantize
-        jid = klass.perform_async(job[:arguments])
-        ring "Starting job #{jid} #{job[:klass]} with #{job[:arguments]}."
+        jid = worker_class.perform_async(job)
+        ring "Starting job #{jid} #{worker_class.name} with #{job.inspect}."
         record_incr(:jobs_started)
       end
     end
 
+    def sleep
+      super(self.class.sleep_interval)
+    end
+
     def each_job
       # Override
       []
@@ -63,9 +82,18 @@ module Bellbro
       !@done
     end
 
+    def worker_class
+      @worker_class ||= self.class.get_worker_class
+    end
+
     def self.mutex
       $mutex ||= Mutex.new
     end
+
+    def self.sleep_interval
+      @sleep_interval
+    end
+
   end
 
 end

data/lib/bellbro/sidekiq_utils.rb

@@ -1,6 +1,44 @@
 module Bellbro
   module SidekiqUtils
 
+    def _workers
+      retryable(on: Redis::TimeoutError) do
+        workers_for_class("#{self.name}")
+      end
+    end
+
+    def _jobs
+      retryable(on: Redis::TimeoutError) do
+        jobs_for_class("#{self.name}")
+      end
+    end
+
+    def active_workers
+      _workers.map do |w|
+        {
+            :domain => worker_domain(w),
+            :jid => worker_jid(w),
+            :time => worker_time(w)
+        }
+      end
+    end
+
+    def queued_jobs
+      _jobs.map { |j| {:domain => job_domain(j), :jid => job_jid(j)} }
+    end
+
+    def workers_with_domain(domain)
+      active_workers.select { |w| w[:domain] == domain }
+    end
+
+    def jobs_with_domain(domain)
+      queued_jobs.select { |j| j[:domain] == domain }
+    end
+
+    def jobs_in_flight_with_domain(domain)
+      jobs_with_domain(domain) + workers_with_domain(domain)
+    end
+
     def workers
       Sidekiq::Workers.new.map do |process_id, thread_id, worker|
         worker

data/lib/bellbro/trackable.rb

@@ -4,17 +4,19 @@ module Bellbro
 
     attr_reader :record
 
-    def self.included(klass)
-      class << klass
-        def track_with_schema(hash)
-          self.class_eval do
-            @log_record_schema = hash
-          end
-        end
+    def self.included(base)
+      base.class_eval do
+        extend ClassMethods
+      end
+    end
 
-        def log_record_schema
-          @log_record_schema
-        end
+    module ClassMethods
+      def track_with_schema(hash)
+        @log_record_schema = hash
+      end
+
+      def log_record_schema
+        @log_record_schema
       end
     end
 
@@ -25,11 +27,12 @@ module Bellbro
       @write_interval = opts[:write_interval] || 500
       @count = 0
       @tracking = true
-      initialize_log_record
+      initialize_log_record if @log_record_schema
       status_update(true)
     end
 
     def status_update(force = false)
+      return unless @log_record_schema && Bellbro.logger
       return unless force || ((@count += 1) % @write_interval) == 0
       retryable { write_log(@record.to_json) }
     end

data/lib/bellbro/version.rb

@@ -1,3 +1,3 @@
 module Bellbro
-  VERSION = '0.0.10'
+  VERSION = '0.1.0'
 end

data/lib/bellbro/worker.rb

@@ -2,68 +2,46 @@ module Bellbro
   class Worker < Bellbro::Bell
     include Sidekiq::Worker
     include Bellbro::Trackable
+    include Bellbro::Hooks
     extend Bellbro::SidekiqUtils
 
-    attr_reader :domain
+    attr_reader :context
 
-    def init(opts)
-      # override
+    def perform(args)
+      return unless args.present?
+      set_context(args)
+      run_before_hooks
+      return unless should_run?
+      call
+      run_after_hooks
     end
 
-    def perform(opts)
+    def call
       # override
     end
 
-    def clean_up
+    def should_run?
       # override
+      self.class.should_run?
     end
 
-    def transition
-      # override
+    def debug?
+      @debug ||= !!context[:debug] rescue false
     end
 
-    def i_am_alone_with_this_domain?
-      self.class.jobs_with_domain(@domain).select { |j| jid != j[:jid] }.empty? &&
-          self.class.workers_with_domain(@domain).select { |j| jid != j[:jid] }.empty?
-    end
-
-    def self._workers
-      retryable(on: Redis::TimeoutError) do
-        workers_for_class("#{self.name}")
-      end
+    def self.should_run?
+      # override
+      true
     end
 
-    def self._jobs
-      retryable(on: Redis::TimeoutError) do
-        jobs_for_class("#{self.name}")
-      end
-    end
+    private
 
-    def self.active_workers
-      _workers.map do |w|
-        {
-            :domain => worker_domain(w),
-            :jid => worker_jid(w),
-            :time => worker_time(w)
-        }
+    def set_context(args)
+      if args.is_a?(Hash)
+        @context = args.symbolize_keys
+      else
+        @context = args
       end
     end
-
-    def self.queued_jobs
-      _jobs.map { |j| {:domain => job_domain(j), :jid => job_jid(j)} }
-    end
-
-    def self.workers_with_domain(domain)
-      active_workers.select { |w| w[:domain] == domain }
-    end
-
-    def self.jobs_with_domain(domain)
-      queued_jobs.select { |j| j[:domain] == domain }
-    end
-
-    def self.jobs_in_flight_with_domain(domain)
-      jobs_with_domain(domain) + workers_with_domain(domain)
-    end
   end
-
 end

data/lib/bellbro.rb

@@ -9,6 +9,7 @@ require 'airbrake'
 
 %w(
     bellbro/settings.rb
+    bellbro/hooks.rb
     bellbro/retryable.rb
     bellbro/ringable.rb
     bellbro/trackable.rb

data/spec/trackable_spec.rb

@@ -10,10 +10,6 @@ class TrackWorker < Bellbro::Worker
     status:           String
   )
 
-  def initialize(domain)
-    @domain = domain
-  end
-
   def jid
     "abc123"
   end
@@ -21,7 +17,7 @@ end
 
 describe Bellbro::Trackable do
   before :each do
-    @worker = TrackWorker.new('www.retailer.com')
+    @worker = TrackWorker.new
     Sidekiq::Worker.clear_all
   end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bellbro
 version: !ruby/object:Gem::Version
-  version: 0.0.10
+  version: 0.1.0
 platform: ruby
 authors:
 - Jon Stokes
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2015-02-07 00:00:00.000000000 Z
+date: 2015-02-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
@@ -137,6 +137,7 @@ files:
 - bellbro.gemspec
 - lib/bellbro.rb
 - lib/bellbro/bell.rb
+- lib/bellbro/hooks.rb
 - lib/bellbro/pool.rb
 - lib/bellbro/retryable.rb
 - lib/bellbro/ringable.rb