sanger_warren 0.1.0 → 0.3.0

data/bin/console

@@ -2,14 +2,11 @@
 # frozen_string_literal: true
 
 require 'bundler/setup'
-require 'Warren'
+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__)
+require 'pry'
+Pry.start

data/bin/warren

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'warren/app/cli'
+
+Warren::App::Cli.start(ARGV)

data/lefthook.yml

@@ -0,0 +1,53 @@
+# https://github.com/Arkweid/lefthook
+# Rubocop globs built based on https://github.com/rubocop-hq/rubocop/blob/master/config/default.yml With globbing support povided by
+# https://pkg.go.dev/github.com/gobwas/glob#section-documentation
+# Has the advantage of quicker commits when no rubocop files
+pre-commit:
+  parallel: true
+  commands:
+    rubocop:
+      glob: '{*.{rb,arb,axlsx,builder,fcgi,gemfile,gemspec,god,jb,jbuilder,mspec,opal,pluginspec,podspec,rabl,rake,rbuild,rbw,rbx,ru,ruby,spec,thor,watchr},.irbrc,.pryrc,.simplecov,buildfile,Appraisals,Berksfile,Brewfile,Buildfile,Capfile,Cheffile,Dangerfile,Deliverfile,Fastfile,*Fastfile,Gemfile,Guardfile,Jarfile,Mavenfile,Podfile,Puppetfile,Rakefile,rakefile,Snapfile,Steepfile,Thorfile,Vagabondfile,Vagrantfile}'
+      run: rubocop --display-style-guide --extra-details --force-exclusion --parallel {staged_files} || (echo 'Run `lefthook run fix` to run autocorrect on staged files only'; exit 1)
+
+fix:
+  parallel: true
+  commands:
+    rubocop:
+      glob: '{*.{rb,arb,axlsx,builder,fcgi,gemfile,gemspec,god,jb,jbuilder,mspec,opal,pluginspec,podspec,rabl,rake,rbuild,rbw,rbx,ru,ruby,spec,thor,watchr},.irbrc,.pryrc,.simplecov,buildfile,Appraisals,Berksfile,Brewfile,Buildfile,Capfile,Cheffile,Dangerfile,Deliverfile,Fastfile,*Fastfile,Gemfile,Guardfile,Jarfile,Mavenfile,Podfile,Puppetfile,Rakefile,rakefile,Snapfile,Steepfile,Thorfile,Vagabondfile,Vagrantfile}'
+      run: rubocop --display-style-guide --extra-details --auto-correct --force-exclusion {staged_files}
+
+
+# EXAMPLE USAGE
+# Refer for explanation to following link:
+# https://github.com/Arkweid/lefthook/blob/master/docs/full_guide.md
+#
+# pre-push:
+#   commands:
+#     packages-audit:
+#       tags: frontend security
+#       run: yarn audit
+#     gems-audit:
+#       tags: backend security
+#       run: bundle audit
+#
+# pre-commit:
+#   parallel: true
+#   commands:
+#     eslint:
+#       glob: "*.{js,ts}"
+#       run: yarn eslint {staged_files}
+#     rubocop:
+#       tags: backend style
+#       glob: "*.rb"
+#       exclude: "application.rb|routes.rb"
+#       run: bundle exec rubocop --force-exclusion {all_files}
+#     govet:
+#       tags: backend style
+#       files: git ls-files -m
+#       glob: "*.go"
+#       run: go vet {files}
+#   scripts:
+#     "hello.js":
+#       runner: node
+#     "any.go":
+#       runner: go run

data/lib/sanger_warren.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# While the gem is sanger_warren we actually namespace under Warren.
+# The gem 'warren' performs a very similar function, but hasn't been updated
+# for ten years.
+# We need to include this file to ensure bundler automatically requires warren,
+# thereby triggering the railties
+require 'warren'

data/lib/warren.rb

@@ -4,26 +4,71 @@ require 'warren/version'
 require 'warren/callback'
 require 'warren/handler'
 require 'warren/message'
+require 'warren/subscriber/base'
+
+# Load railties if rails is available
+require 'warren/railtie' if defined?(Rails::Railtie)
 
 #
 # Module Warren provides connection pooling for RabbitMQ Connections
 #
 module Warren
+  # Environmental variables
+  WARREN_TYPE = 'WARREN_TYPE'
+
+  #
+  # Construct a {Warren::Handler::Base} of the type `type`.
+  # For Rails apps this is usually handled automatically by the initializer.
+  #
+  # @param type ['test','log','broadcast'] The type of warren handler to construct
+  # @param config [Hash] A configuration hash object
+  # @option config [Hash] :server Bunny connection parameters
+  #                               http://rubybunny.info/articles/connecting.html#using_a_map_of_parameters
+  # @option config [String] :exchange The default exchange to receive published messaged
+  # @option config [String] :routing_key_prefix A prefix to apply to all routing keys (Such as the environment)
+  #
+  # @return [Warren::Handler::Base] Exact class determined by the type passed in
+  #
   def self.construct(type:, config: {})
-    case type
+    warren_type = ENV.fetch(WARREN_TYPE, type)
+    case warren_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}"
+    when 'broadcast' then Warren::Handler::Broadcast.new(**config)
+    else raise StandardError, "Unknown type warren: #{warren_type}"
     end
   end
 
+  # Constructs a Warren::Handler of the specified type and sets it as the global handler.
   def self.setup(opts, logger: Rails.logger)
     logger.warn 'Recreating Warren handler when one already exists' if handler.present?
-    @handler = construct(opts.symbolize_keys)
+    @handler = construct(**opts.symbolize_keys)
   end
 
+  #
+  # Returns the global Warren handler
+  #
+  # @return [Warren::Handler::Base] A warren handler for broadcasting messages
+  #
   def self.handler
     @handler
   end
+
+  # When we invoke the warren consumer, we end up loading warren before
+  # rails is loaded, so don't invoke the railtie, and don't get a change to do
+  # so until after the Rails has initialized, and thus run its ties.
+  # I'm sure there is a proper way of handling this, but want to move on for now.
+  def self.load_configuration
+    config = begin
+      Rails.application.config_for(:warren)
+    rescue RuntimeError => e
+      warn <<~WARN
+        🐇 WARREN CONFIGURATION ERROR
+        #{e.message}
+        Use `warren config` to generate a basic configuration file
+      WARN
+      exit 1
+    end
+    Warren.setup(config.deep_symbolize_keys.slice(:type, :config))
+  end
 end

data/lib/warren/app.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Warren
+  # The command line application can be triggered by `bundle exec warren`.
+  # It provides tools for configuring your warren set-up, as well as starting
+  # consumers.
+  module App
+  end
+end

data/lib/warren/app/cli.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'thor'
+require_relative 'config'
+require_relative 'consumer'
+
+module Warren
+  module App
+    # Warren Thor CLI application used to:
+    # - Generate the configuration
+    # - Update the configuration with new consumers
+    # - Start and stop consumers
+    # @see http://whatisthor.com
+    class Cli < Thor
+      # Ensure we exit with an error in the event of failure
+      def self.exit_on_failure?
+        true
+      end
+
+      desc 'config', 'generate a basic warren config file'
+      option :path, type: :string,
+                    default: 'config/warren.yml',
+                    desc: 'The path to the configuration file to generate'
+      option :exchange, type: :string,
+                        desc: 'The RabbitMQ exchange to connect to'
+      # Invoked by `$ warren config` generates a `warren.yml` file.
+      def config
+        Warren::App::Config.invoke(self, path: options['path'], exchange: options['exchange'])
+      end
+
+      desc 'consumer {add|start}', 'add and start queue consumers'
+      subcommand 'consumer', Consumer
+    end
+  end
+end

data/lib/warren/app/config.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module Warren
+  module App
+    # Handles the initial creation of the configuration object
+    class Config
+      # We keep the template as plain text as it allows us to add comments
+      TEMPLATE = <<~TEMPLATE
+        # By default the development environment just logs the message and
+        # payload. If you wish to enable broadcasting in development mode,
+        # the easiest way to do so is to set the ENV WARREN_TYPE.
+        # For example
+        # `WARREN_TYPE=broadcast bundle exec rails s`
+        # This will override the setting in warren.yml
+        development:
+          type: log
+          # Log mode does not actually use this configuration, but
+          # it is provided for convenience when broadcast mode is enabled.
+          # The provided settings are the default options of RabbitMQ
+          # DO NOT commit sensitive information in this file. Instead you may
+          # use the WARREN_CONNECTION_URI environmental variable
+          config:
+            server:
+              host: localhost
+              port: 5672
+              username: guest
+              password: guest
+              vhost: %<vhost>s
+              frame_max: 0
+              heartbeat: 30
+            exchange: %<exchange>s
+            routing_key_prefix: development
+        # The test environment sets up a test message handler, which lets
+        # you make assertions about which messages have been sent.
+        # See: https://rubydoc.info/gems/sanger_warren/Warren/Handler/Test
+        test:
+          type: test
+          config:
+            routing_key_prefix: test
+        # You are encouraged to use the WARREN_CONNECTION_URI environmental
+        # variable to configure your production environment. Under no
+        # circumstances should you commit sensitive information in the file.
+      TEMPLATE
+
+      # Triggers the configuration task. Primarily called by the Thor CLI.
+      # Will either use arguments passed in from the command line, or prompt the
+      # user for them if missing.
+      #
+      # @param shell [Thor::Shell::Basic] Thor shell instance for feedback
+      # @param path [String] Path to the `warren.yml` file
+      # @param exchange [String, nil] Name of the exchange to use, if passed in from CLI
+      #
+      # @return [Void]
+      #
+      def self.invoke(shell, path:, exchange: nil)
+        new(shell, path: path, exchange: exchange).invoke
+      end
+
+      #
+      # Generates a new warren.yml file at {#path}. Usually invoked via the
+      # `warren config` cli command
+      #
+      # @param shell [Thor::Shell::Basic] Thor shell instance for user interaction
+      # @param path [String] The path to the warren.yml file.
+      # @param exchange [String] The exchange to connect to
+      #
+      def initialize(shell, path:, exchange: nil)
+        @shell = shell
+        @path = path
+        @exchange = exchange
+      end
+
+      #
+      # Create a new configuration yaml file at {#path} using sensible defaults
+      # and the provided {#exchange}. If {#exchange} is nil, prompts the user
+      #
+      # @return [Void]
+      #
+      def invoke
+        return unless check_file?
+
+        @exchange ||= ask_exchange # Update our exchange before we do anything
+        File.open(@path, 'w') do |file|
+          file.write payload
+        end
+      end
+
+      private
+
+      # The path to the config file
+      attr_reader :path
+      # The exchange to connect to
+      attr_reader :exchange
+
+      def payload
+        format(TEMPLATE, exchange: @exchange, vhost: '/')
+      end
+
+      def check_file?
+        return true unless File.exist?(@path)
+
+        @shell.yes? "#{@path} exists. Overwrite (Y/N)? "
+      end
+
+      def ask_exchange
+        @shell.ask 'Specify an exchange: '
+      end
+    end
+  end
+end

data/lib/warren/app/consumer.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require 'thor'
+require_relative 'consumer_add'
+require_relative 'consumer_start'
+require 'warren/config/consumers'
+
+module Warren
+  module App
+    # Warren Thor CLI subcommand used to:
+    # - Add new consumer configurations
+    # - Start consumers
+    # @see http://whatisthor.com
+    class Consumer < Thor
+      include Thor::Actions
+
+      source_root("#{File.dirname(__FILE__)}/templates")
+
+      # Ensure we exit with an error in the event of failure
+      def self.exit_on_failure?
+        true
+      end
+
+      desc 'add NAME', 'generate a new warren consumer'
+      option :desc, type: :string,
+                    desc: 'Brief description of consumer'
+      option :queue, type: :string,
+                     desc: 'The RabbitMQ queue to create / connect to'
+      option :bindings, type: :array,
+                        desc: 'bindings between the queue and exchange',
+                        banner: '{direct|fanout|topic|headers}:EXCHANGE[:ROUTING_KEY_A[,ROUTING_KEY_B]]'
+      option :path, type: :string,
+                    default: Warren::Config::Consumers::DEFAULT_PATH,
+                    desc: 'The path to the consumer configuration file to generate'
+      option :delay, type: :numeric,
+                     desc: 'The delay (ms) on the delay queue. 0 to skip queue creation.'
+      # Invoked by `$ warren consumer add` adds a consumer to the `warren_consumers.yml`
+      #
+      # @param name [String, nil] Optional: Passed in from Command. The name of the consumer to create.
+      #
+      # @return [Void]
+      #
+      def add(name = nil)
+        say 'Adding a consumer'
+        Warren::App::ConsumerAdd.invoke(self, name, options)
+      end
+
+      desc 'start', 'start registered consumers'
+      option :path, type: :string,
+                    default: Warren::Config::Consumers::DEFAULT_PATH,
+                    desc: 'The path to the consumer configuration file to use'
+      option :consumers, type: :array,
+                         desc: 'The consumers to start. Defaults to all consumers',
+                         banner: 'consumer_name other_consumer'
+      # Invoked by `$ warren consumer start`. Starts up the configured consumers
+      #
+      # @return [Void]
+      #
+      def start
+        say 'Starting consumers'
+        Warren::App::ConsumerStart.invoke(self, options)
+      end
+    end
+  end
+end

data/lib/warren/app/consumer_add.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+require_relative 'exchange_config'
+require 'warren/config/consumers'
+
+module Warren
+  module App
+    # Handles the initial creation of the configuration object
+    class ConsumerAdd
+      # Default namespace for new Subscribers
+      SUBSCRIBER_NAMESPACE = %w[Warren Subscriber].freeze
+
+      attr_reader :name, :desc, :queue
+
+      #
+      # Add a consumer to the configuration file located at `options.path`
+      # Will prompt the user for input on the `shell` if information not
+      # provided upfront
+      #
+      # @param shell [Thor::Shell::Basic] Thor shell instance for feedback
+      # @param name [String] The name of the consumer
+      # @param options [Hash] Hash of command line arguments from Thor
+      # @option options [String] :desc Short description of consumer (for documentation)
+      # @option options [String] :queue Then name of the queue to bind to
+      # @option options [Array<String>] :bindings Array of binding in the format
+      #                                 '<exchange_type>:<exchange_name>:<outing_key>,<routing_key>'
+      #
+      # @return [ConsumerAdd] The ConsumerAdd
+      #
+      def self.invoke(shell, name, options)
+        new(shell, name, options).invoke
+      end
+
+      # Create a consumer configuration object. Use {#invoke} to gather information and
+      # generate the config
+      #
+      # @param shell [Thor::Shell::Basic] Thor shell instance for feedback
+      # @param name [String] The name of the consumer
+      # @param options [Hash] Hash of command line arguments from Thor
+      # @option options [String] :desc Short description of consumer (for documentation)
+      # @option options [String] :queue Then name of the queue to bind to
+      # @option options [Array<String>] :bindings Array of binding in the format
+      #                                 '<exchange_type>:<exchange_name>:<outing_key>,<routing_key>'
+      #
+      def initialize(shell, name, options)
+        @shell = shell
+        @name = name
+        @desc = options[:desc]
+        @queue = options[:queue]
+        @delay = options[:delay]
+        @config = Warren::Config::Consumers.new(options[:path])
+        @bindings = Warren::App::ExchangeConfig.parse(shell, options[:bindings])
+      end
+
+      #
+      # Create a new configuration yaml file at `@path` using sensible defaults
+      # and the provided exchange. If exchange is nil, prompts the user
+      #
+      # @return [Void]
+      #
+      def invoke
+        check_name if @name # Check name before we gather facts, as its better to know we
+        # might have an issue early.
+        gather_facts
+        write_configuration
+        write_subscriber
+      end
+
+      private
+
+      def subscribed_class
+        class_name = name.split(/[\s\-_]/).map(&:capitalize).join
+
+        [*SUBSCRIBER_NAMESPACE, class_name].join('::')
+      end
+
+      def check_name
+        while @config.consumer_exist?(@name)
+          @name = @shell.ask(
+            "Consumer named '#{@name}' already exists. Specify a alternative " \
+            'consumer name: '
+          )
+        end
+      end
+
+      #
+      # Loads the configuration, should be a hash
+      #
+      # @return [Hash] A hash of consumer configurations indexed by name
+      #
+      def load_config
+        YAML.load_file(@path)
+      rescue Errno::ENOENT
+        {}
+      end
+
+      def gather_facts
+        @name ||= @shell.ask 'Specify a consumer name: '
+        check_name
+        @desc ||= @shell.ask 'Provide an optional description: '
+        @queue ||= @shell.ask 'Provide the name of the queue to connect to: '
+        @bindings ||= gather_bindings
+        @delay ||= @shell.ask(
+          'Create a delay queue? Specify delay in milliseconds to create; set to 0 or leave blank to skip.'
+        ).to_i
+        nil
+      end
+
+      def gather_bindings
+        Warren::App::ExchangeConfig.ask(@shell)
+      end
+
+      def write_configuration
+        @config.add_consumer(
+          @name, desc: @desc, queue: @queue,
+                 bindings: @bindings, subscribed_class: subscribed_class,
+                 delay: @delay
+        )
+        @config.save
+      end
+
+      def write_subscriber
+        @shell.template('subscriber.tt', subscriber_path, context: binding)
+      end
+
+      def subscriber_path
+        "#{['app', *SUBSCRIBER_NAMESPACE, @name.tr(' -', '_')].map(&:downcase).join('/')}.rb"
+      end
+    end
+  end
+end