queue-bus 0.6.0 → 0.9.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f18ed6e21b956ce928e0c3ede7e1493eb7806413706e92e1f4c991667e9e06b8
-  data.tar.gz: 4043918b7705741e3719d6460b9823367b9e271e6344193c2b616aab063a4d9a
+  metadata.gz: 4f35ec72b2a6256350aabd9f2f6fa6591a1b625f404a3013ea73fb24876fb9e3
+  data.tar.gz: 00eb73580e6160d3932f43110c182832163ab5d3f9db34d44980b831cf4f7fdc
 SHA512:
-  metadata.gz: 6894d383941edf09df6d245eaffc57ecd2ef3185bb3196d89a29c7714cc7b3f849639e285764ee57832158a566538bc2c1b8b6691af2d73ab5a3760d8893ef5e
-  data.tar.gz: 9b08d34ff3309f039640a1c154b5f33cfc186f69f18511a09201e4eeb5553ef8f5b8ad053405fc6f9bf3658d5750543d7fa92d431d88ba72af5c3ab8f0d50e45
+  metadata.gz: 887ddce8443a1c17bc4db578a8d6b51d1a81906287db94ccd1f47681f30032cf485e1ed30e1a0feb56cc05b17162fae8f2ce28d07bad4b943a6dce7b40302c40
+  data.tar.gz: 34394be52205690b867bc2402563a9e970fa899250009481ed460f4b4909b8b8f3782bb4c5915d33eaccf6bebf2eebcedf8961628e539af6cde08646517f792f

data/.circleci/config.yml

@@ -0,0 +1,21 @@
+version: 2.1
+orbs:
+  ruby: circleci/ruby@0.1.2
+
+jobs:
+  build:
+    docker:
+      - image: circleci/ruby:2.6.3-stretch-node
+      - image: circleci/redis:4.0.12-alpine
+    executor: ruby/default
+    steps:
+      - checkout
+      - run:
+          name: Which bundler?
+          command: bundle -v
+      - ruby/bundle-install
+      - run:
+          name: Run tests
+          environment:
+            REDIS_URL: redis://127.0.0.1:6379
+          command: bundle exec rspec spec

data/.rubocop.yml

@@ -0,0 +1,35 @@
+AllCops:
+  TargetRubyVersion: 2.4
+  ExtraDetails: true
+
+# http://rubocop.readthedocs.io/en/latest/cops_style/#stylefrozenstringliteralcomment
+Style/FrozenStringLiteralComment:
+  Enabled: true
+
+# https://rubocop.readthedocs.io/en/latest/cops_style/#styledatetime
+Style/DateTime:
+  Enabled: true
+
+# http://rubocop.readthedocs.io/en/latest/cops_metrics/#metricslinelength
+Metrics/LineLength:
+  Max: 100
+
+Metrics/MethodLength:
+  Max: 15
+
+Metrics/BlockLength:
+  Exclude:
+    - spec/**/*
+
+# https://rubocop.readthedocs.io/en/latest/cops_layout/#layoutdotposition
+Layout/DotPosition:
+  Enabled: true
+  EnforcedStyle: leading
+
+# https://rubocop.readthedocs.io/en/latest/cops_style/#stylehashsyntax
+Style/HashSyntax:
+  Enabled: true
+
+# https://rubocop-rspec.readthedocs.io/en/latest/cops_rspec/#rspecfocus
+RSpec/Focus:
+  Enabled: true

data/CHANGELOG.md

@@ -6,6 +6,44 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.9.1]
+
+### Added
+- Documented some of the major classes and modules
+
+### Fixed
+- Ran the rubocop autocorrect on the entire codebase.
+- Fixed issue that prevented heartbeat events from firing under certain conditions
+
+## [0.9.0]
+
+### Added
+- Adds rake tasks to list scheduled jobs as csv
+
+## [0.8.1]
+
+### Fixed
+- `with_local_mode` breaks subsequent calls to `local_mode` on versions less than 2.6.
+
+## [0.8.0]
+
+### Added
+- Adds `QueueBus.with_local_mode` method. Useful when working with a multithreaded environment.
+
+## [0.7.0]
+
+### Added
+- Adds `QueueBus.has_adapter?` to check whether the adapter is set.
+
+### Changed
+- Now uses `Process.hostname` to determine hostname versus relying on unix shell.
+- Rubocop is now a dev dependency.
+- Accessors to config are now done with actual attrs.
+- Logging with the adapter will use the logger if present.
+
+### Fixed
+- Passing a class to `adapter=` would error on a `NameError`.
+
 ## [0.6.0]
 
 ### Added

data/Gemfile

@@ -1,5 +1,7 @@
-source "http://rubygems.org"
+# frozen_string_literal: true
+
+source 'http://rubygems.org'
 
 gemspec
 
-gem "rake"
+gem 'rake'

data/README.mdown

@@ -141,6 +141,22 @@ event to the appropriate code block.
 You can also say `QueueBus.local_mode = :suppress` to turn off publishing altogether.
 This can be helpful inside some sort of migration, for example.
 
+#### Thread Safe Local Modes
+
+**!! This is important if you are using workers that utilize multiple threads, such as Sidekiq !!**
+
+The above setting is global to the ruby process and modifying it will impact all threads that are
+currently using QueueBus. If you want to isolate a thread or block of code from QueueBus, you can
+use the method `with_local_mode`:
+
+```ruby
+QueueBus.with_local_mode(:suppress) do
+  # QueueBus will be suppressed on this thread, within this block.
+end
+```
+
+The previous value of `local_mode` will be restored after the block exits.
+
 ### TODO
 
 * Replace local modes with adapters

data/Rakefile

@@ -1 +1,3 @@
+# frozen_string_literal: true
+
 $LOAD_PATH.unshift 'lib'

data/lib/queue-bus.rb

@@ -1,8 +1,11 @@
-require "queue_bus/version"
-require "forwardable"
+# frozen_string_literal: true
 
-module QueueBus
+require 'queue_bus/version'
+require 'forwardable'
 
+# The main QueueBus module. Most operations you will need to execute should be executed
+# on this top level domain.
+module QueueBus
   autoload :Application,      'queue_bus/application'
   autoload :Config,           'queue_bus/config'
   autoload :Dispatch,         'queue_bus/dispatch'
@@ -22,25 +25,25 @@ module QueueBus
   autoload :Util,             'queue_bus/util'
   autoload :Worker,           'queue_bus/worker'
 
+  # A module for all adapters, current and future.
   module Adapters
     autoload :Base,           'queue_bus/adapters/base'
     autoload :Data,           'queue_bus/adapters/data'
   end
 
   class << self
-
     include Publishing
     extend Forwardable
 
     def_delegators :config, :default_app_key=, :default_app_key,
-                            :default_queue=, :default_queue,
-                            :local_mode=, :local_mode,
-                            :before_publish=, :before_publish_callback,
-                            :logger=, :logger, :log_application, :log_worker,
-                            :hostname=, :hostname,
-                            :adapter=, :adapter,
-                            :incoming_queue=, :incoming_queue,
-                            :redis, :worker_middleware_stack
+                   :default_queue=, :default_queue,
+                   :local_mode=, :local_mode, :with_local_mode,
+                   :before_publish=, :before_publish_callback,
+                   :logger=, :logger, :log_application, :log_worker,
+                   :hostname=, :hostname,
+                   :adapter=, :adapter, :has_adapter?,
+                   :incoming_queue=, :incoming_queue,
+                   :redis, :worker_middleware_stack
 
     def_delegators :_dispatchers, :dispatch, :dispatchers, :dispatcher_by_key, :dispatcher_execute
 
@@ -60,5 +63,4 @@ module QueueBus
       @_dispatchers ||= ::QueueBus::Dispatchers.new
     end
   end
-
 end

data/lib/queue_bus/adapters/base.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module QueueBus
   module Adapters
     class Base
@@ -19,12 +21,12 @@ module QueueBus
         raise NotImplementedError
       end
 
-      def enqueue(queue_name, klass, json)
+      def enqueue(_queue_name, _klass, _json)
         # enqueue the given class (Driver/Rider) in your queue
         raise NotImplementedError
       end
 
-      def enqueue_at(epoch_seconds, queue_name, klass, json)
+      def enqueue_at(_epoch_seconds, _queue_name, _klass, _json)
         # enqueue the given class (Publisher) in your queue to run at given time
         raise NotImplementedError
       end

data/lib/queue_bus/adapters/data.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # a base adapter just for publishing and redis connection
 module QueueBus
   module Adapters
@@ -6,17 +8,16 @@ module QueueBus
         # nothing to do
       end
 
-      def redis=(client)
-        @redis = client
-      end
+      attr_writer :redis
 
       def redis(&block)
-        raise "no redis instance set" unless @redis
+        raise 'no redis instance set' unless @redis
+
         block.call(@redis)
       end
 
       def enqueue(queue_name, klass, json)
-        push(queue_name, :class => klass.to_s, :args => [json])
+        push(queue_name, class: klass.to_s, args: [json])
       end
 
       def enqueue_at(epoch_seconds, queue_name, klass, json)
@@ -24,7 +25,7 @@ module QueueBus
         delayed_push(epoch_seconds, item)
       end
 
-      def setup_heartbeat!(queue_name)
+      def setup_heartbeat!(_queue_name)
         raise NotImplementedError
       end
 
@@ -32,13 +33,13 @@ module QueueBus
 
       def push(queue, item)
         watch_queue(queue)
-        self.redis { |redis| redis.rpush "queue:#{queue}", ::QueueBus::Util.encode(item) }
+        redis { |redis| redis.rpush "queue:#{queue}", ::QueueBus::Util.encode(item) }
       end
 
       # Used internally to keep track of which queues we've created.
       # Don't call this directly.
       def watch_queue(queue)
-        self.redis { |redis| redis.sadd(:queues, queue.to_s) }
+        redis { |redis| redis.sadd(:queues, queue.to_s) }
       end
 
       # Used internally to stuff the item into the schedule sorted list.
@@ -46,7 +47,7 @@ module QueueBus
       # Insertion if O(log(n)).
       # Returns true if it's the first job to be scheduled at that time, else false
       def delayed_push(timestamp, item)
-        self.redis do |redis|
+        redis do |redis|
           # First add this item to the list for this timestamp
           redis.rpush("delayed:#{timestamp.to_i}", ::QueueBus::Util.encode(item))
 
@@ -56,9 +57,9 @@ module QueueBus
           redis.zadd :delayed_queue_schedule, timestamp.to_i, timestamp.to_i
         end
       end
-      
+
       def delayed_job_to_hash_with_queue(queue, klass, args)
-        {:class => klass.to_s, :args => args, :queue => queue}
+        { class: klass.to_s, args: args, queue: queue }
       end
     end
   end

data/lib/queue_bus/application.rb

@@ -1,33 +1,34 @@
+# frozen_string_literal: true
+
 module QueueBus
+  # An Application is the top level unifier for a number of subscriptions. It allows for
+  # the toggling of an entire applications subscriptions.
   class Application
-
     class << self
-
       def all
         # note the names arent the same as we started with
-        ::QueueBus.redis { |redis| redis.smembers(app_list_key).collect{ |val| new(val) } }
+        ::QueueBus.redis { |redis| redis.smembers(app_list_key).collect { |val| new(val) } }
       end
     end
 
     attr_reader :app_key, :redis_key
 
-
     def initialize(app_key)
       @app_key = self.class.normalize(app_key)
       @redis_key = "#{self.class.app_single_key}:#{@app_key}"
       # raise error if only other chars
-      raise "Invalid application name" if @app_key.gsub("_", "").size == 0
+      raise 'Invalid application name' if @app_key.gsub('_', '').empty?
     end
 
     def subscribe(subscription_list, log = false)
       @subscriptions = nil
 
-      if subscription_list == nil || subscription_list.size == 0
+      if subscription_list.nil? || subscription_list.empty?
         unsubscribe
         return true
       end
 
-      temp_key = "temp_#{redis_key}:#{rand(999999999)}"
+      temp_key = "temp_#{redis_key}:#{rand(999_999_999)}"
 
       ::QueueBus.redis do |redis|
         redis_hash = subscription_list.to_redis
@@ -39,9 +40,7 @@ module QueueBus
         redis.rename(temp_key, redis_key)
         redis.sadd(self.class.app_list_key, app_key)
 
-        if log
-          redis.hgetall(redis_key).inspect
-        end
+        redis.hgetall(redis_key).inspect if log
       end
 
       true
@@ -68,7 +67,7 @@ module QueueBus
     def subscription_matches(attributes)
       out = subscriptions.matches(attributes)
       out.each do |sub|
-        sub.app_key = self.app_key
+        sub.app_key = app_key
       end
       out
     end
@@ -84,15 +83,15 @@ module QueueBus
     protected
 
     def self.normalize(val)
-      val.to_s.gsub(/\W/, "_").downcase
+      val.to_s.gsub(/\W/, '_').downcase
     end
 
     def self.app_list_key
-      "bus_apps"
+      'bus_apps'
     end
 
     def self.app_single_key
-      "bus_app"
+      'bus_app'
     end
 
     def event_queues
@@ -116,6 +115,5 @@ module QueueBus
       end
       out
     end
-
   end
 end

data/lib/queue_bus/config.rb

@@ -1,102 +1,100 @@
+# frozen_string_literal: true
+
+require 'socket'
+require 'logger'
+
 module QueueBus
+  # This class contains all the configuration for a running queue bus application.
   class Config
-    def adapter=val
-      raise "Adapter already set to #{@adapter_instance.class.name}" if @adapter_instance
-      if val.is_a?(Class)
-        @adapter_instance = name_or_klass.new
-      elsif val.is_a?(::QueueBus::Adapters::Base)
-        @adapter_instance = val
-      else
-        class_name = ::QueueBus::Util.classify(val)
-        @adapter_instance = ::QueueBus::Util.constantize("::QueueBus::Adapters::#{class_name}").new
-      end
-      @adapter_instance
-    end
+    attr_accessor :default_queue, :hostname, :incoming_queue, :logger
 
-    def adapter
-      return @adapter_instance if @adapter_instance
-      raise "no adapter has been set"
-    end
+    attr_reader :worker_middleware_stack
+    attr_writer :local_mode
 
-    def redis(&block)
-      # TODO: could allow setting for non-redis adapters
-      adapter.redis(&block)
+    def initialize
+      @worker_middleware_stack = QueueBus::Middleware::Stack.new
+      @incoming_queue = 'bus_incoming'
+      @hostname = Socket.gethostname
     end
 
-    def default_app_key=val
-      @default_app_key = Application.normalize(val)
-    end
+    # A wrapper that is always "truthy" but can contain an inner value. This is useful for
+    # checking that a thread local variable is set to a value, even if that value happens to
+    # be nil. This is important because setting a thread local value to nil will cause it to
+    # be deleted.
+    Wrap = Struct.new(:value)
 
-    def default_app_key
-      @default_app_key
-    end
+    LOCAL_MODE_VAR = :queue_bus_local_mode
 
-    def default_queue=val
-      @default_queue = val
+    # Returns the current local mode of QueueBus
+    def local_mode
+      if Thread.current.thread_variable_get(LOCAL_MODE_VAR).is_a?(Wrap)
+        Thread.current.thread_variable_get(LOCAL_MODE_VAR).value
+      else
+        @local_mode
+      end
     end
 
-    def default_queue
-      @default_queue
+    # Overrides the current local mode for the duration of a block. This is a threadsafe
+    # implementation. After, the global setting will be resumed.
+    #
+    # @param mode [Symbol] the mode to switch to
+    def with_local_mode(mode)
+      previous = Thread.current.thread_variable_get(LOCAL_MODE_VAR)
+      Thread.current.thread_variable_set(LOCAL_MODE_VAR, Wrap.new(mode))
+      yield if block_given?
+    ensure
+      Thread.current.thread_variable_set(LOCAL_MODE_VAR, previous)
     end
 
-    def local_mode=value
-      @local_mode = value
-    end
+    def adapter=(val)
+      raise "Adapter already set to #{@adapter_instance.class.name}" if has_adapter?
 
-    def local_mode
-      @local_mode
+      @adapter_instance =
+        if val.is_a?(Class)
+          val.new
+        elsif val.is_a?(::QueueBus::Adapters::Base)
+          val
+        else
+          class_name = ::QueueBus::Util.classify(val)
+          ::QueueBus::Util.constantize("::QueueBus::Adapters::#{class_name}").new
+        end
     end
 
-    def incoming_queue=val
-      @incoming_queue = val
-    end
+    def adapter
+      return @adapter_instance if has_adapter?
 
-    def incoming_queue
-      @incoming_queue ||= "bus_incoming"
+      raise 'no adapter has been set'
     end
 
-    def worker_middleware_stack
-      @worker_middleware_stack ||= QueueBus::Middleware::Stack.new
+    # Checks whether an adapter is set and returns true if it is.
+    def has_adapter? # rubocop:disable Naming/PredicateName
+      !@adapter_instance.nil?
     end
 
-    def hostname
-      @hostname ||= `hostname 2>&1`.strip.sub(/.local/,'')
+    def redis(&block)
+      # TODO: could allow setting for non-redis adapters
+      adapter.redis(&block)
     end
 
-    def hostname=val
-      @hostname = val
+    attr_reader :default_app_key
+    def default_app_key=(val)
+      @default_app_key = Application.normalize(val)
     end
 
-    def before_publish=(proc)
-      @before_publish_callback = proc
+    def before_publish=(callback)
+      @before_publish_callback = callback
     end
 
     def before_publish_callback(attributes)
-      if @before_publish_callback
-        @before_publish_callback.call(attributes)
-      end
-    end
-
-    def logger
-      @logger
-    end
-
-    def logger=val
-      @logger = val
+      @before_publish_callback&.call(attributes)
     end
 
     def log_application(message)
-      if logger
-        time = Time.now.strftime('%H:%M:%S %Y-%m-%d')
-        logger.info("** [#{time}] #$$: QueueBus #{message}")
-      end
+      logger&.info(message)
     end
 
     def log_worker(message)
-      if ENV['LOGGING'] || ENV['VERBOSE'] || ENV['VVERBOSE']
-        time = Time.now.strftime('%H:%M:%S %Y-%m-%d')
-        puts "** [#{time}] #$$: #{message}"
-      end
+      logger&.debug(message)
     end
   end
 end