queue-bus 0.9.0 → 0.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9002e9de95db1dfd0ed4cc3ba4196dd3d10fd46b3c2e568e12af7b0d0aa75306
-  data.tar.gz: '079f6ce144775b86c7f1e2214595a9e87e984f80f6636a2f9923f8c574d9bb83'
+  metadata.gz: 329cc0a74e428d99421a14c9b2b07e39e14ee98da5c43babceb51376d27006c6
+  data.tar.gz: 2439e577df8ea33e2f959b49ddfc105858844080556c4431a47897667d87fa92
 SHA512:
-  metadata.gz: 1903f31f88bda747999ac8cefc2e2a8f60bafe06225d9fa3ea7b12ffee16c6e09ffcd448494edf15dd8f81d5d9576db97c815dcd78ae6526e94a487a7e3d2e40
-  data.tar.gz: a9b711c88a06812acd66210633cda67e2af46abf8db3960ba184fc54e078de2c07f85e36884317c48eb7820ed9fa66e4b8432b99edbf787e8246f48039f101c4
+  metadata.gz: 2875311c4100923fc00886ac05e2b4053ec6bfff442114faa6cc6bf39698916234866f57ebcbeb09dbcaca85484ca3bb0ce88cdbf8eb5640f6ca3b46d88a5a23
+  data.tar.gz: f7d88adffc92f2635b1068f47c68238787b55eea86d4302bc2579a40bc2c3ff4ce145d62688a7584a2b48fa31b03951b993757a0e3b65eb71a1b3a4715aeb741

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/CHANGELOG.md

@@ -6,6 +6,32 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.12.0]
+
+### Changed
+- Pipelines fetching all queue subscriptions when using `QueueBus::Application.all`
+
+## [0.11.0]
+
+### Added
+
+- Adds `QueueBus.in_context` method. Useful when working with a multithreaded environment to add a description for all events published within this scope.
+
+## [0.10.0]
+
+### Added
+- Ability to unsubscribe from specific queues in an application (`Application#unsubscribe_queue`).
+- `rake queuebus:unsubscribe` can now take two parameters to unsubscribe from specific queues, e.g. `rake queuebus:unsubscribe[my_app_key, my_queue_name]`.
+
+## [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

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,13 +141,16 @@ 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
+#### Thread Safe Options
 
 **!! 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`:
+use the methods `with_local_mode` or `in_context`:
+
+
+With local mode
 
 ```ruby
 QueueBus.with_local_mode(:suppress) do
@@ -155,7 +158,16 @@ QueueBus.with_local_mode(:suppress) do
 end
 ```
 
-The previous value of `local_mode` will be restored after the block exits.
+In context
+
+```ruby
+QueueBus.in_context('some_context') do
+  # Context attribute will be set for all events published within this scope.
+end
+```
+
+
+The previous values will be restored after the block exits.
 
 ### TODO
 

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,26 @@ 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, :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
+                   :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,
+                   :context=, :context, :in_context
 
     def_delegators :_dispatchers, :dispatch, :dispatchers, :dispatcher_by_key, :dispatcher_execute
 

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,36 +1,53 @@
+# 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 do |redis|
+          app_keys = redis.smembers(app_list_key)
+          apps = app_keys.collect { |val| new(val) }
+
+          hashes = redis.pipelined do
+            apps.each do |app|
+              redis.hgetall(app.redis_key)
+            end
+          end
+
+          apps.zip(hashes).each do |app, hash|
+            app._hydrate_redis_hash(hash)
+          end
+
+          apps
+        end
       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
+
         redis_hash.each do |key, hash|
           redis.hset(temp_key, key, QueueBus::Util.encode(hash))
         end
@@ -39,16 +56,23 @@ 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
     end
 
+    def unsubscribe_queue(queue)
+      # Filters out all subscriptions that match the supplied queue name.
+      ::QueueBus.redis do |redis|
+        read_redis_hash.each do |key, hash_details|
+          redis.hdel(redis_key, key) if queue == hash_details["queue_name"]
+        end
+      end
+    end
+
     def unsubscribe
-      # TODO: clean up known queues?
+      # Remove everything.
       ::QueueBus.redis do |redis|
         redis.srem(self.class.app_list_key, app_key)
         redis.del(redis_key)
@@ -68,7 +92,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
@@ -81,18 +105,22 @@ module QueueBus
       out
     end
 
+    def _hydrate_redis_hash(hash)
+      @raw_redis_hash = hash
+    end
+
     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
@@ -105,17 +133,24 @@ module QueueBus
 
     def read_redis_hash
       out = {}
-      ::QueueBus.redis do |redis|
-        redis.hgetall(redis_key).each do |key, val|
-          begin
-            out[key] = ::QueueBus::Util.decode(val)
-          rescue ::QueueBus::Util::DecodeException
-            out[key] = val
-          end
+      raw_redis_hash.each do |key, val|
+        begin
+          out[key] = ::QueueBus::Util.decode(val)
+        rescue ::QueueBus::Util::DecodeException
+          out[key] = val
         end
       end
       out
     end
 
+    private
+
+    def raw_redis_hash
+      return @raw_redis_hash if @raw_redis_hash
+
+      ::QueueBus.redis do |redis|
+        redis.hgetall(redis_key)
+      end
+    end
   end
 end

data/lib/queue_bus/config.rb

@@ -9,7 +9,7 @@ module QueueBus
     attr_accessor :default_queue, :hostname, :incoming_queue, :logger
 
     attr_reader :worker_middleware_stack
-    attr_writer :local_mode
+    attr_writer :local_mode, :context
 
     def initialize
       @worker_middleware_stack = QueueBus::Middleware::Stack.new
@@ -24,6 +24,7 @@ module QueueBus
     Wrap = Struct.new(:value)
 
     LOCAL_MODE_VAR = :queue_bus_local_mode
+    CONTEXT_VAR = :queue_bus_context
 
     # Returns the current local mode of QueueBus
     def local_mode
@@ -34,6 +35,15 @@ module QueueBus
       end
     end
 
+    # Returns the current context of QueueBus
+    def context
+      if Thread.current.thread_variable_get(CONTEXT_VAR).is_a?(Wrap)
+        Thread.current.thread_variable_get(CONTEXT_VAR).value
+      else
+        @context
+      end
+    end
+
     # Overrides the current local mode for the duration of a block. This is a threadsafe
     # implementation. After, the global setting will be resumed.
     #
@@ -46,6 +56,17 @@ module QueueBus
       Thread.current.thread_variable_set(LOCAL_MODE_VAR, previous)
     end
 
+    # Overrides the current bus context (if any) for the duration of a block, adding a
+    # `bus_context` attribute set to this value for all events published in this scope. 
+    # This is a threadsafe implementation. After, the global setting will be resumed.
+    def in_context(context)
+      previous = Thread.current.thread_variable_get(CONTEXT_VAR)
+      Thread.current.thread_variable_set(CONTEXT_VAR, Wrap.new(context))
+      yield if block_given?
+    ensure
+      Thread.current.thread_variable_set(CONTEXT_VAR, previous)
+    end
+
     def adapter=(val)
       raise "Adapter already set to #{@adapter_instance.class.name}" if has_adapter?