sanger_warren 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: '08237db3ed2d846148e3e1b127b737d660cb48f755489ced7fbda20d582fb3c2'
+  data.tar.gz: 41dc24f4262cc1b641e985058d7ef6b1cb294ef9e26c42775ac68bd21182c8e3
+SHA512:
+  metadata.gz: e60a34f8902db181b06978f0b554485c8f69148e9111b2a325ad6b37b13dc4abef93f5e8d010ad4e2d2d7dab4dcdfddfa51f6b5fe5866e037d9d437e85095af2
+  data.tar.gz: 98a52f7cdfaf2815f6b83a5166791bb83ab84aaa37e87ed9b4d68534fccb7a9efe14ec0c618467bd24f8c67deecd2124833245b0e3bc7b156ca48ff2a4762bb6

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,21 @@
+# The behavior of RuboCop can be controlled via the .rubocop.yml
+# configuration file. It makes it possible to enable/disable
+# certain cops (checks) and to alter their behavior if they accept
+# any parameters. The file can be placed either in your home
+# directory or in some project directory.
+#
+# RuboCop will start looking for the configuration file in the directory
+# where the inspected file is and continue its way up to the root directory.
+#
+# See https://docs.rubocop.org/rubocop/configuration
+AllCops:
+  TargetRubyVersion: 2.6
+# Blocks are used to structure tests and are part of the shoulda dsl.
+# The standard BlockLength limits are too stringent for this purpose.
+# Block DSL is also used in routes
+# We should be careful keeping rake tasks here, as large tasks are still an issue.
+# Not sure if we need to split namespaces across several files though.
+# We exclude builders, as they are concerned with rendering xml
+Metrics/BlockLength:
+  ExcludedMethods:
+   - describe

data/.travis.yml

@@ -0,0 +1,6 @@
+---
+language: ruby
+cache: bundler
+rvm:
+  - 2.7.1
+before_install: gem install bundler -v 2.1.4

data/CHANGELOG.md

@@ -0,0 +1,10 @@
+# Changelog
+
+Keeps track of notable changes. Please remember to add new behaviours to the
+Unreleased section to make new releases easy.
+
+## [Unreleased]
+
+Initial release
+
+- Import of lib/warren from sequencescape

data/Gemfile

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in Warren.gemspec
+gemspec
+
+gem 'pry'
+gem 'rake', '~> 12.0'
+gem 'rspec', '~> 3.0'
+gem 'rubocop'
+gem 'simplecov'
+gem 'yard'

data/Gemfile.lock

@@ -0,0 +1,77 @@
+PATH
+  remote: .
+  specs:
+    sanger_warren (0.1.0)
+      bunny (~> 2.17.0)
+      connection_pool (~> 2.2.0)
+      multi_json (~> 1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    amq-protocol (2.3.2)
+    ast (2.4.1)
+    bunny (2.17.0)
+      amq-protocol (~> 2.3, >= 2.3.1)
+    coderay (1.1.2)
+    connection_pool (2.2.3)
+    diff-lcs (1.4.4)
+    docile (1.3.2)
+    method_source (0.9.2)
+    multi_json (1.13.1)
+    parallel (1.19.2)
+    parser (2.7.2.0)
+      ast (~> 2.4.1)
+    pry (0.12.2)
+      coderay (~> 1.1.0)
+      method_source (~> 0.9.0)
+    rainbow (3.0.0)
+    rake (12.3.3)
+    regexp_parser (1.8.2)
+    rexml (3.2.4)
+    rspec (3.9.0)
+      rspec-core (~> 3.9.0)
+      rspec-expectations (~> 3.9.0)
+      rspec-mocks (~> 3.9.0)
+    rspec-core (3.9.3)
+      rspec-support (~> 3.9.3)
+    rspec-expectations (3.9.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.9.0)
+    rspec-mocks (3.9.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.9.0)
+    rspec-support (3.9.3)
+    rubocop (1.0.0)
+      parallel (~> 1.10)
+      parser (>= 2.7.1.5)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 1.8)
+      rexml
+      rubocop-ast (>= 0.6.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 1.4.0, < 2.0)
+    rubocop-ast (1.0.0)
+      parser (>= 2.7.1.5)
+    ruby-progressbar (1.10.1)
+    simplecov (0.19.0)
+      docile (~> 1.1)
+      simplecov-html (~> 0.11)
+    simplecov-html (0.12.3)
+    unicode-display_width (1.7.0)
+    yard (0.9.25)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  pry
+  rake (~> 12.0)
+  rspec (~> 3.0)
+  rubocop
+  sanger_warren!
+  simplecov
+  yard
+
+BUNDLED WITH
+   2.1.4

data/LICENSE.txt

@@ -0,0 +1,27 @@
+
+Authors:
+James Glover <james.glover@sanger.ac.uk>
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 1, or (at your option)
+any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, see <http://www.gnu.org/licenses/>.
+
+
+The usage of a range of years within a copyright statement contained within
+this distribution should be interpreted as being equivalent to a list of years
+including the first and last year specified and all consecutive years between
+them. For example, a copyright statement that reads "Copyright (c) 2005, 2007-
+2009, 2011-2012" should be interpreted as being identical to a statement that
+reads "Copyright (c) 2005, 2007, 2008, 2009, 2011, 2012" and a copyright
+statement that reads "Copyright (c) 2005-2012" should be interpreted as being
+identical to a statement that reads "Copyright (c) 2005, 2006, 2007, 2008, 2009
+, 2010 , 2011 , 2012".

data/README.md

@@ -0,0 +1,81 @@
+# Warren
+
+Warren extracts the connection pooling behaviour originally in Sequencescape
+in order to provide a common interface for our Rails app interaction with
+RabbitMQ via the bunny gem.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'sanger-warren'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install sanger-warren
+
+## Usage
+
+If using with a Rails app, here's an example to get you started:
+
+```ruby
+# config/initializers/warren.rb
+require 'warren'
+
+Warren.setup(Rails.application.config.warren.deep_symbolize_keys.slice(:type, :config))
+```
+
+```ruby
+# config/application.rb
+# ...
+config.warren = config_for(:warren)
+# ...
+```
+
+```yaml
+# config/warren.yml
+development:
+  type: log
+  config: # Useful to allow easy switching to broadcast in development
+    routing_key_prefix: 'dev'
+    server:
+      host: localhost
+      port: 5672
+      username: guest
+      password: guest
+      vhost: /
+      frame_max: 0
+      heartbeat: 30
+    exchange: exchange_to_use
+test:
+  type: test
+production: # In practice keep this out of your source control
+  type: broadcast
+  config: # Useful to allow easy switching to broadcast
+    routing_key_prefix: 'production'
+    server:
+      host: localhost # Or a remote host
+      port: 5672
+      username: ...
+      password: ...
+      vhost: /
+      frame_max: 0
+      heartbeat: 30
+    exchange: exchange_to_use
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/Warren.

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'Warren'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require 'irb'
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/warren.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'warren/version'
+require 'warren/callback'
+require 'warren/handler'
+require 'warren/message'
+
+#
+# Module Warren provides connection pooling for RabbitMQ Connections
+#
+module Warren
+  def self.construct(type:, config: {})
+    case type
+    when 'test' then Warren::Handler::Test.new
+    when 'log' then Warren::Handler::Log.new(logger: config.fetch(:logger) { Rails.logger })
+    when 'broadcast' then Warren::Handler::Broadcast.new(config)
+    else raise StandardError, "Unknown type warren: #{type}"
+    end
+  end
+
+  def self.setup(opts, logger: Rails.logger)
+    logger.warn 'Recreating Warren handler when one already exists' if handler.present?
+    @handler = construct(opts.symbolize_keys)
+  end
+
+  def self.handler
+    @handler
+  end
+end

data/lib/warren/callback.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require_relative 'message/full'
+require 'connection_pool'
+
+require_relative 'callback/broadcast_with_warren'
+require_relative 'callback/broadcast_associated_with_warren'
+#
+# Module Warren::Callback provides methods to assist with
+# setting up message broadcast
+#
+module Warren
+  #
+  # Module Warren::BroadcastMessages provides methods to assist with
+  # setting up message broadcast
+  #
+  module Callback
+    # Provides the broadcast_with_warren and broadcasts_associated_with_warren to
+    # ActiveRecord::Base classes to configure broadcast
+    module ClassMethods
+      attr_reader :associated_to_broadcast, :warren
+
+      #
+      # Records of this type are broadcast via RabbitMQ when a transaction is closed.
+      #
+      # @return [void]
+      #
+      def broadcast_with_warren(handler: Warren.handler)
+        after_commit BroadcastWithWarren.new(handler: handler)
+      end
+
+      #
+      # When records of this type are saved, broadcast the associated records once
+      # the transaction is closed. (Requires that associated record is broadcast_with_warren)
+      #
+      # @param [Symbol,Array<Symbol>] associated One or more symbols indicating the associations to broadcast.
+      #
+      # @return [void]
+      #
+      def broadcasts_associated_with_warren(*associated, handler: Warren.handler)
+        after_save BroadcastAssociatedWithWarren.new(associated, handler: handler)
+      end
+    end
+
+    def self.included(base)
+      base.class_eval do
+        extend ClassMethods
+      end
+    end
+
+    def broadcast
+      # This results in borrowing a connection from the pool
+      # per-message. Which isn't ideal. Ideally we'd either
+      # check out a connection per thread or per transaction.
+      # Any checked out connections will need to be checked back
+      # in once the thread/transaction ends with high reliability.
+      # So we're doing things the easy way until:
+      # 1) Performance requires something more complicated
+      # 2) We find a way to achieve the above without monkey-patching
+      #    or other complexity (Its probably possible)
+      Warren.handler << Warren::Message::Full.new(self)
+    end
+  end
+end

data/lib/warren/callback/broadcast_associated_with_warren.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Warren
+  module Callback
+    # Warren::Callback::BroadcastWithWarren is a Callback class
+    # which is used to handle message broadcast of records associated with
+    # ActiveRecord::Base objects on save. Associated records will be queued for
+    # broadcast when the transaction is closed.
+    # @see https://guides.rubyonrails.org/active_record_callbacks.html#callback-classes
+    class BroadcastAssociatedWithWarren
+      attr_reader :handler, :associations
+
+      #
+      # Creates the callback object
+      #
+      # @param handler [Warren::Handler] The handler to take the messaged (unused)
+      # @param associations [Array<Symbol>] An array of symbols reflecting the
+      #                                     names of associations
+      #
+      def initialize(associations, handler:)
+        @associations = associations
+        @handler = handler
+      end
+
+      #
+      # After save callback: configured via broadcasts_associated_with_warren
+      # Adds any associated records to the transaction, ensuring their after commit
+      # methods will fire.
+      #
+      # @return [void]
+      #
+      def after_save(record)
+        associations.each do |association|
+          record.send(association).try(:add_to_transaction)
+        end
+      end
+    end
+  end
+end

data/lib/warren/callback/broadcast_with_warren.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'warren/message/short'
+
+module Warren
+  module Callback
+    # Warren::Callback::BroadcastWithWarren is a Callback class
+    # which is used to handle message broadcast of ActiveRecord::Base objects
+    # on commit
+    # @see https://guides.rubyonrails.org/active_record_callbacks.html#callback-classes
+    class BroadcastWithWarren
+      attr_reader :handler, :message_class
+
+      #
+      # Creates the callback object
+      #
+      # @param handler [Warren::Handler] The handler to take the messaged
+      # @param message_class [Warren::Message] The adpater to render the messages
+      #
+      def initialize(handler:, message_class: Warren::Message::Short)
+        @handler = handler
+        @message_class = message_class
+      end
+
+      def after_commit(record)
+        # Message rendering is slow in some cases. This broadcasts an initial
+        # lightweight message which can be picked up and rendered asynchronously
+        # Borrows connection as per #broadcast
+        handler << message_class.new(record)
+      end
+    end
+  end
+end

data/lib/warren/handler.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative 'handler/broadcast'
+require_relative 'handler/log'
+require_relative 'handler/test'
+module Warren
+  # A {Warren::Handler} provides an interface for sending messages to either
+  # a message queue, a log, or an internal store for testing purposes.
+  module Handler
+    def self.routing_key_template(prefix)
+      prefix ? "#{prefix}.%s" : '%s'
+    end
+  end
+end

data/lib/warren/handler/broadcast.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require 'bunny'
+
+module Warren
+  module Handler
+    #
+    # Class Warren::Broadcast provides a connection pool of
+    # threadsafe RabbitMQ channels for broadcasting messages
+    #
+    class Broadcast
+      # Wraps a {Bunny::Channel}
+      class Channel
+        def initialize(bun_channel, routing_key_template:, exchange: nil)
+          @bun_channel = bun_channel
+          @exchange_name = exchange
+          @routing_key_template = routing_key_template
+        end
+
+        def <<(message)
+          exchange.publish(message.payload, routing_key: key_for(message))
+          self
+        end
+
+        def close
+          @bun_channel.close
+        end
+
+        private
+
+        def exchange
+          raise StandardError, 'No exchange configured' if @exchange_name.nil?
+
+          @exchange ||= @bun_channel.topic(@exchange_name, auto_delete: false, durable: true)
+        end
+
+        def key_for(message)
+          @routing_key_template % message.routing_key
+        end
+      end
+      #
+      # Creates a warren but does not connect.
+      #
+      # @param [Hash] server Server config options passes straight to Bunny
+      # @param [String] exchange The name of the exchange to connect to
+      # @param [Integer] pool_size The connection pool size
+      # @param [String,nil] routing_key_prefix The prefix to pass before the routing key.
+      #                                        Can be used to ensure environments remain distinct.
+      def initialize(exchange:, routing_key_prefix:, server: {}, pool_size: 14)
+        @server = server
+        @exchange_name = exchange
+        @pool_size = pool_size
+        @routing_key_template = Handler.routing_key_template(routing_key_prefix)
+      end
+
+      #
+      # Opens a connection to the RabbitMQ server. Will need to be re-initialized after forking.
+      #
+      # @return [true] We've connected!
+      #
+      def connect
+        reset_pool
+        start_session
+      end
+
+      #
+      # Closes the connection. Call before forking to avoid leaking connections
+      #
+      #
+      # @return [true] We've disconnected
+      #
+      def disconnect
+        close_session
+      end
+
+      #
+      # Yields an exchange which gets returned to the pool on block closure
+      #
+      #
+      # @return [void]
+      #
+      # @yieldreturn [Warren::Broadcast::Channel] A rabbitMQ channel that sends messages to the configured exchange
+      def with_channel(&block)
+        connection_pool.with(&block)
+      end
+
+      #
+      # Borrows a RabbitMQ channel, sends a message, and immediately returns it again.
+      # Useful if you only need to send one message.
+      #
+      # @param [Warren::Message] message The message to broadcast. Must respond to #routing_key and #payload
+      #
+      # @return [Warren::Broadcast] Returns itself to allow chaining. But you're
+      #                             probably better off using #with_channel
+      #                             in that case
+      #
+      def <<(message)
+        with_channel { |channel| channel << message }
+        self
+      end
+
+      private
+
+      def session
+        @session ||= Bunny.new(@server)
+      end
+
+      def connection_pool
+        @connection_pool ||= start_session && ConnectionPool.new(size: @pool_size, timeout: 5) do
+          Channel.new(session.create_channel, exchange: @exchange_name,
+                                              routing_key_template: @routing_key_template)
+        end
+      end
+
+      def start_session
+        session.start
+        true
+      end
+
+      def close_session
+        reset_pool
+        @session&.close
+        @session = nil
+      end
+
+      def reset_pool
+        @connection_pool&.shutdown { |ch| ch.close }
+        @connection_pool = nil
+      end
+    end
+  end
+end

data/lib/warren/handler/log.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Warren
+  module Handler
+    # Class Warren::Log provides a dummy RabbitMQ
+    # connection pool for use during development
+    class Log
+      # Mimics a {Bunny::Channel} but instead passes out to a logger
+      class Channel
+        def initialize(logger, routing_key_template: '%s')
+          @logger = logger
+          @routing_key_template = routing_key_template
+        end
+
+        def <<(message)
+          @logger.info "Published: #{key_for(message)}"
+          @logger.debug "Payload: #{message.payload}"
+          self
+        end
+
+        private
+
+        def key_for(message)
+          @routing_key_template % message.routing_key
+        end
+      end
+
+      attr_reader :logger
+
+      def initialize(logger:, routing_key_prefix: nil)
+        @logger = logger
+        @routing_key_template = Handler.routing_key_template(routing_key_prefix)
+      end
+
+      #
+      # Provide API compatibility with the RabbitMQ versions
+      # Do nothing in this case
+      #
+      def connect; end
+
+      def disconnect; end
+
+      #
+      # Yields a Warren::Log::Channel
+      #
+      #
+      # @return [void]
+      #
+      # @yieldreturn [Warren::Log::Channel] A rabbitMQ channel that logs messaged to the test warren
+      def with_channel
+        yield Channel.new(@logger, routing_key_template: @routing_key_template)
+      end
+
+      #
+      # Sends a message to the log channel.
+      # Useful if you only need to send one message.
+      #
+      # @param [Warren::Message] message The message to broadcast. Must respond to #routing_key and #payload
+      #
+      # @return [Warren::Log] Returns itself to allow chaining. But you're
+      #                       probably better off using #with_channel
+      #                       in that case
+      #
+      def <<(message)
+        with_channel { |c| c << message }
+      end
+    end
+  end
+end

data/lib/warren/handler/test.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module Warren
+  module Handler
+    # Class Warren::Test provides provides a dummy RabbitMQ
+    # connection pool for use during testing
+    class Test
+      DISABLED_WARNING = <<~DISABLED_WARREN
+        Test made against a disabled warren.
+        Warren::Handler::Test must be explicitly enabled to track messages,
+        it is a good idea to disable it again after testing the relevant
+        behaviour. This ensures we track messages on a per-test basis, and
+        avoids unnecessary message storage.
+
+        If using rspec it is suggested that you add the following to your
+        spec_helper.rb
+
+        config.around(:each, warren: true) do |ex|
+          Warren.handler.enable!
+          ex.run
+          Warren.handler.disable!
+        end
+
+        You can then tag tests with warren: true to enable warren testing.
+      DISABLED_WARREN
+      # Stand in for {Bunny::Channel}, provides a store of messages to use
+      # in test assertions
+      class Channel
+        def initialize(warren)
+          @warren = warren
+        end
+
+        def <<(message)
+          @warren << message
+        end
+      end
+      #
+      # Creates a test warren with no messages.
+      # Test warrens are shared across all threads.
+      #
+      # @param [_] _args Configuration arguments are ignored.
+      #
+      def initialize(*_args)
+        @messages = []
+        @enabled = false
+      end
+
+      #
+      # Provide API compatibility with the RabbitMQ versions
+      # Do nothing in this case
+      #
+      def connect; end
+
+      def disconnect; end
+
+      #
+      # Yields an exchange which gets returned to the pool on block closure
+      #
+      #
+      # @return [void]
+      #
+      # @yieldreturn [Warren::Test::Channel] A rabbitMQ channel that logs messaged to the test warren
+      def with_channel
+        yield Channel.new(self)
+      end
+
+      def clear_messages
+        @messages = []
+      end
+
+      def last_message
+        messages.last
+      end
+
+      def message_count
+        messages.length
+      end
+
+      def messages_matching(routing_key)
+        messages.count { |message| message.routing_key == routing_key }
+      end
+
+      def enable!
+        @enabled = true
+        clear_messages
+      end
+
+      # Clean up after ourselves to avoid memory leaks
+      def disable!
+        @enabled = false
+        clear_messages
+      end
+
+      def messages
+        raise_if_not_tracking
+        @messages
+      end
+
+      # Disable message logging if not required
+      def <<(message)
+        @messages << message if @enabled
+      end
+
+      private
+
+      def raise_if_not_tracking
+        raise StandardError, DISABLED_WARNING unless @enabled
+      end
+    end
+  end
+end

data/lib/warren/message.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+# Namespace to collect message formats
+# A Warren compatible message must implement:
+# routing_key: returns the routing_key for the message
+# payloadL returns the message payload
+
+require_relative 'message/short'
+require_relative 'message/full'
+
+# Additionally, if you wish to use the Message with the ActiveRecord
+# helpers, then the initialize should take the ActiveRecord::Base object
+# as a single argument
+module Message
+end

data/lib/warren/message/full.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Warren
+  module Message
+    # Generates a payload of an active_record object
+    class Full
+      attr_reader :record
+
+      def initialize(record)
+        @record = record
+      end
+
+      def routing_key
+        if record.respond_to?(:routing_key)
+          record.routing_key
+        else
+          "saved.#{record.class.name.underscore}.#{record.id}"
+        end
+      end
+
+      def payload
+        MultiJson.dump(record)
+      end
+    end
+  end
+end

data/lib/warren/message/short.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Warren
+  module Message
+    # Light-weight interim message which can be expanded to a full payload later.
+    class Short
+      attr_reader :record
+
+      def initialize(record)
+        @record = record
+      end
+
+      def routing_key
+        "queue_broadcast.#{record.class.name.underscore}.#{record.id}"
+      end
+
+      def payload
+        [record.class.name, record.id].to_json
+      end
+    end
+  end
+end

data/lib/warren/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Warren
+  VERSION = '0.1.0'
+end

data/sanger-warren.gemspec

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative 'lib/warren/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'sanger_warren'
+  spec.version       = Warren::VERSION
+  spec.authors       = ['James Glover']
+  spec.email         = ['james.glover@sanger.ac.uk']
+
+  spec.summary       = 'Configuring and managing bunny RabbitMQ connections'
+  spec.description   = <<~DESCRIPTION
+    Warren provides connection pooling for RabbitMQ connections. It also adds
+    the ability to switch in different adapters during testing and development.
+  DESCRIPTION
+  spec.homepage = 'https://github.com/sanger/warren'
+  spec.required_ruby_version = Gem::Requirement.new('>= 2.6.0')
+
+  # spec.metadata["allowed_push_host"] = "TODO: Set to 'http://mygemserver.com'"
+
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = 'https://github.com/sanger/warren'
+  spec.metadata['changelog_uri'] = 'https://github.com/sanger/warren/blob/master/CHANGELOG.md'
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  # Dependencies
+  spec.add_runtime_dependency 'bunny', '~> 2.17.0'
+  spec.add_runtime_dependency 'connection_pool', '~> 2.2.0'
+  spec.add_runtime_dependency 'multi_json', '~> 1.0'
+end

metadata

@@ -0,0 +1,119 @@
+--- !ruby/object:Gem::Specification
+name: sanger_warren
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- James Glover
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2020-10-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bunny
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.17.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.17.0
+- !ruby/object:Gem::Dependency
+  name: connection_pool
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.2.0
+- !ruby/object:Gem::Dependency
+  name: multi_json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: |
+  Warren provides connection pooling for RabbitMQ connections. It also adds
+  the ability to switch in different adapters during testing and development.
+email:
+- james.glover@sanger.ac.uk
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- ".travis.yml"
+- CHANGELOG.md
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- checksums
+- complete
+- lib/warren.rb
+- lib/warren/callback.rb
+- lib/warren/callback/broadcast_associated_with_warren.rb
+- lib/warren/callback/broadcast_with_warren.rb
+- lib/warren/handler.rb
+- lib/warren/handler/broadcast.rb
+- lib/warren/handler/log.rb
+- lib/warren/handler/test.rb
+- lib/warren/message.rb
+- lib/warren/message/full.rb
+- lib/warren/message/short.rb
+- lib/warren/version.rb
+- object_types
+- objects/root.dat
+- proxy_types
+- sanger-warren.gemspec
+homepage: https://github.com/sanger/warren
+licenses: []
+metadata:
+  homepage_uri: https://github.com/sanger/warren
+  source_code_uri: https://github.com/sanger/warren
+  changelog_uri: https://github.com/sanger/warren/blob/master/CHANGELOG.md
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.4
+signing_key: 
+specification_version: 4
+summary: Configuring and managing bunny RabbitMQ connections
+test_files: []