harmoniser 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6daf41d7ec196c5f279bca1e4d9ee1339f17a81508fb4432359b32595c364a07
+  data.tar.gz: 1cab012d3c64c10590f032b768e5acd267980980e988d02b3f7297a138d8477a
+SHA512:
+  metadata.gz: 3ec7c8e929076ca5725f91d1755ba5548b99e87e8d7c3b6f9d63d029cf6fd76c8419fef99c25b46a525dc49f0d1af011f71a210bf3602d75787fbba7941c5cb1
+  data.tar.gz: 554b5e2c30444280133ec848124e3b1bb88fbb994b3a2056efdbcfaa5817783530b6d25642217db43eaeb25a5cc80652395e7b1203ebe2c37767e07b8a024578

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "harmoniser"
+
+# 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/harmoniser

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+require "harmoniser/cli"
+
+$stdout.sync = true
+begin
+  Harmoniser::CLI.instance.call
+rescue => e
+  warn(e.message)
+  warn(e.backtrace.join("\n"))
+  exit(1)
+end

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/harmoniser/channelable.rb

@@ -0,0 +1,25 @@
+module Harmoniser
+  module Channelable
+    MUTEX = Mutex.new
+    private_constant :MUTEX
+
+    module ClassMethods
+      def harmoniser_channel
+        MUTEX.synchronize do
+          @harmoniser_channel ||= create_channel
+        end
+      end
+
+      def create_channel
+        connection = Harmoniser.connection
+        connection.create_channel
+      end
+    end
+
+    class << self
+      def included(base)
+        base.extend(ClassMethods)
+      end
+    end
+  end
+end

data/lib/harmoniser/cli.rb

@@ -0,0 +1,70 @@
+require "singleton"
+require "harmoniser"
+require "harmoniser/parser"
+require "harmoniser/launcher"
+
+module Harmoniser
+  class CLI
+    include Singleton
+
+    SIGNAL_HANDLERS = {
+      "INT" => lambda { |cli, signal| raise Interrupt },
+      "TERM" => lambda { |cli, signal| raise Interrupt }
+    }
+    SIGNAL_HANDLERS.default = lambda { |cli, signal| cli.logger.info("Default signal handler executed since there is no handler defined: signal = `#{signal}`") }
+
+    attr_reader :logger
+
+    def initialize
+      @configuration = Harmoniser.default_configuration
+      @logger = Harmoniser.logger
+    end
+
+    def call
+      parse_options
+      define_signals
+      run
+    end
+
+    private
+
+    attr_reader :configuration
+
+    def parse_options
+      options = Parser.new(logger: @logger).call(ARGV)
+      configuration.options_with(**options)
+    end
+
+    def define_signals
+      @read_io, @write_io = IO.pipe
+
+      ["INT", "TERM"].each do |sig|
+        Signal.trap(sig) do
+          @write_io.puts(sig)
+        end
+      end
+    end
+
+    def run
+      launcher = Launcher.new
+      launcher.start
+
+      while @read_io.wait_readable
+        signal = @read_io.gets.strip
+        handle_signal(signal)
+      end
+    rescue Interrupt
+      logger.info("Shutting down!")
+      launcher.stop
+      @write_io.close
+      @read_io.close
+      logger.info("Bye!")
+      exit(0)
+    end
+
+    def handle_signal(signal)
+      logger.info("Signal received: signal = `#{signal}`")
+      SIGNAL_HANDLERS[signal].call(self, signal)
+    end
+  end
+end

data/lib/harmoniser/configurable.rb

@@ -0,0 +1,25 @@
+require "forwardable"
+require "harmoniser/configuration"
+
+module Harmoniser
+  module Configurable
+    extend Forwardable
+
+    def configure
+      @configuration ||= Configuration.new
+      yield(@configuration)
+    end
+
+    def configuration
+      raise NoMethodError.new("Please, configure first") unless @configuration
+
+      @configuration
+    end
+
+    def default_configuration
+      @configuration ||= Configuration.new
+    end
+
+    def_delegators :configuration, :logger, :connection
+  end
+end

data/lib/harmoniser/configuration.rb

@@ -0,0 +1,77 @@
+require "forwardable"
+require "logger"
+require "harmoniser/connection"
+require "harmoniser/topology"
+require "harmoniser/options"
+
+module Harmoniser
+  class Configuration
+    extend Forwardable
+
+    DEFAULT_CONNECTION_OPTS = {
+      connection_name: "harmoniser@#{VERSION}",
+      host: "127.0.0.1",
+      password: "guest",
+      port: 5672,
+      tls_silence_warnings: true,
+      username: "guest",
+      verify_peer: false,
+      vhost: "/"
+    }
+    MUTEX = Mutex.new
+
+    attr_reader :connection, :connection_opts, :logger, :options
+    def_delegators :options, :environment, :require, :verbose
+
+    def initialize
+      @logger = Logger.new($stdout, progname: "harmoniser@#{VERSION}")
+      @options = Options.new(**default_options)
+      set_logger_severity
+      @connection_opts = DEFAULT_CONNECTION_OPTS.merge({ logger: @logger })
+      @topology = Topology.new
+    end
+
+    def define_topology
+      raise LocalJumpError, "A block is required for this method" unless block_given?
+
+      yield(@topology)
+    end
+
+    def connection
+      MUTEX.synchronize do
+        @connection = Connection.new(connection_opts) unless @connection
+        @connection.start unless @connection.open?
+        @connection
+      end
+    end
+
+    def connection_opts=(opts)
+      raise TypeError, "opts must be a Hash object" unless opts.is_a?(Hash)
+
+      @connection_opts = connection_opts.merge(opts)
+    end
+
+    def options_with(**kwargs)
+      @options = options.with(**kwargs)
+      set_logger_severity
+    end
+
+    private
+
+    def default_options
+      {
+        environment: ENV.fetch("RAILS_ENV", ENV.fetch("RACK_ENV", "production")),
+        require: ".",
+        verbose: false
+      }
+    end
+
+    def set_logger_severity
+      if @options.production?
+        @logger.level = @options.verbose? ? Logger::DEBUG : Logger::INFO
+      else
+        @logger.level = Logger::DEBUG
+      end
+    end
+  end
+end

data/lib/harmoniser/connection.rb

@@ -0,0 +1,35 @@
+require "forwardable"
+require "bunny"
+
+module Harmoniser
+  class Connection
+    extend Forwardable
+    def_delegators :@bunny, :close, :create_channel, :open?, :start
+
+    def initialize(opts)
+      @bunny = Bunny.new(opts)
+    end
+
+    def to_s
+      "<#{self.class.name}>: #{user}@#{host}:#{port}, vhost = #{vhost}"
+    end
+
+    private
+
+    def host
+      @bunny.transport.host
+    end
+
+    def port
+      @bunny.transport.port
+    end
+
+    def user
+      @bunny.user
+    end
+
+    def vhost
+      @bunny.vhost
+    end
+  end
+end

data/lib/harmoniser/definition.rb

@@ -0,0 +1,35 @@
+module Harmoniser
+  module Definition
+    Binding = Data.define(:exchange_name, :destination_name, :destination_type, :opts) do
+      def queue?
+        [:queue, "queue"].include?(destination_type)
+      end
+
+      def exchange?
+        [:exchange, "exchange"].include?(destination_type)
+      end
+    end
+
+    Consumer = Data.define(:queue_name, :consumer_tag, :no_ack, :exclusive, :arguments)
+
+    Exchange = Data.define(:name, :type, :opts) do
+      def hash
+        [self.class, name].hash
+      end
+
+      def eql?(other)
+        self.class == other.class && name == other.name
+      end
+    end
+
+    Queue = Data.define(:name, :opts) do
+      def hash
+        [self.class, name].hash
+      end
+
+      def eql?(other)
+        self.class == other.class && name == other.name
+      end
+    end
+  end
+end

data/lib/harmoniser/includable.rb

@@ -0,0 +1,25 @@
+module Harmoniser
+  module Includable
+    MUTEX = Mutex.new
+    private_constant :MUTEX
+
+    module ClassMethods
+      def harmoniser_register_included(klass)
+        MUTEX.synchronize do
+          @harmoniser_included ||= Set.new
+          @harmoniser_included << klass
+        end
+      end
+
+      def harmoniser_included
+        @harmoniser_included.to_a
+      end
+    end
+
+    class << self
+      def included(base)
+        base.extend(ClassMethods)
+      end
+    end
+  end
+end

data/lib/harmoniser/launcher.rb

@@ -0,0 +1,56 @@
+module Harmoniser
+  class Launcher
+    def initialize(configuration: Harmoniser.configuration, logger: Harmoniser.logger)
+      @configuration = configuration
+      @logger = logger
+    end
+
+    def start
+      boot_app
+      start_subscribers
+    end
+
+    def stop
+      stop_subscribers
+    end
+
+    private
+
+    def boot_app
+      if File.directory?(@configuration.require)
+        load_rails
+      else
+        load_file
+      end
+    end
+
+    # TODO - Frameworks like Rails which have autoload for development/test will not start any subscriber unless the files where subscribers are located are required explicitly. Since we premier production and the eager load ensures that every file is loaded, this approach works
+    def start_subscribers
+      klasses = Subscriber.harmoniser_included
+      klasses.each do |klass|
+        klass.harmoniser_subscriber_start
+      end
+      @logger.info("Subscribers registered to consume messages from queues: klasses = `#{klasses}`")
+    end
+
+    def stop_subscribers
+      @logger.info("Connection will be closed: connection = `#{@configuration.connection.to_s}`")
+      @configuration.connection.close
+    end
+
+    private
+
+    def load_rails
+      filepath = File.expand_path("#{@configuration.require}/config/environment.rb")
+      require filepath
+    rescue LoadError
+      @logger.warn("Error while requiring file within directory. No subscribers will run for this process: require = `#{@configuration.require}`, filepath = `#{filepath}`")
+    end
+
+    def load_file
+      require @configuration.require
+    rescue LoadError
+      @logger.warn("Error while requiring file. No subscribers will run for this process: require = `#{@configuration.require}`")
+    end
+  end
+end

data/lib/harmoniser/options.rb

@@ -0,0 +1,11 @@
+module Harmoniser
+  Options = Data.define(:environment, :require, :verbose) do
+    def production?
+      environment == "production"
+    end
+
+    def verbose?
+      !!verbose
+    end
+  end
+end

data/lib/harmoniser/parser.rb

@@ -0,0 +1,36 @@
+require "optparse"
+require_relative "version"
+
+module Harmoniser
+  class Parser
+    def initialize(logger:)
+      @logger = logger
+      @options = {}
+      @option_parser = OptionParser.new do |opts|
+        opts.banner = "harmoniser [options]"
+        opts.on "-e", "--environment ENV", "Application environment" do |arg|
+          @options[:environment] = arg
+        end
+        opts.on "-r", "--require [PATH|DIR]", "File to require or location of Rails application" do |arg|
+          @options[:require] = arg
+        end
+        opts.on("-v", "--[no-]verbose", "Run verbosely") do |arg|
+          @options[:verbose] = arg
+        end
+        opts.on "-V", "--version", "Print version and exit" do
+          puts "Harmoniser #{Harmoniser::VERSION}"
+          exit(0)
+        end
+        opts.on_tail "-h", "--help", "Show help" do
+          puts @option_parser
+          exit(0)
+        end
+      end
+    end
+
+    def call(argv = [])
+      @option_parser.parse!(argv)
+      @options
+    end
+  end
+end

data/lib/harmoniser/publisher.rb

@@ -0,0 +1,55 @@
+require "harmoniser/channelable"
+require "harmoniser/definition"
+
+module Harmoniser
+  module Publisher
+    class MissingExchangeDefinition < StandardError ; end
+    include Channelable
+    MUTEX = Mutex.new
+    private_constant :MUTEX
+
+    module ClassMethods
+      def harmoniser_publisher(exchange_name:)
+        @harmoniser_exchange_definition = Definition::Exchange.new(
+          name: exchange_name,
+          type: nil,
+          opts: { passive: true }
+        )
+      end
+
+      def publish(payload, opts = {})
+        raise_missing_exchange_definition unless @harmoniser_exchange_definition
+
+        MUTEX.synchronize do
+          harmoniser_exchange.publish(payload, opts)
+        end
+        Harmoniser.logger.debug { "Message published: payload = `#{payload}`, opts = `#{opts}`" }
+
+        harmoniser_exchange
+      end
+
+      private
+
+      def harmoniser_exchange
+        return @harmoniser_exchange if @harmoniser_exchange
+
+        @harmoniser_exchange ||= Bunny::Exchange.new(
+          Publisher.harmoniser_channel,
+          @harmoniser_exchange_definition.type,
+          @harmoniser_exchange_definition.name,
+          @harmoniser_exchange_definition.opts
+        )
+      end
+
+      def raise_missing_exchange_definition
+        raise MissingExchangeDefinition, "Please, call harmoniser_publisher class method first with the exchange_name that will be used for publications"
+      end
+    end
+
+    class << self
+      def included(base)
+        base.extend(ClassMethods)
+      end
+    end
+  end
+end

data/lib/harmoniser/subscriber.rb

@@ -0,0 +1,85 @@
+require "harmoniser/channelable"
+require "harmoniser/definition"
+require "harmoniser/includable"
+
+module Harmoniser
+  module Subscriber
+    class MissingConsumerDefinition < StandardError ; end
+    include Channelable
+    include Includable
+    MUTEX = Mutex.new
+    private_constant :MUTEX
+
+    module ClassMethods
+      def harmoniser_subscriber(queue_name:, consumer_tag: nil, no_ack: true, exclusive: false, arguments: {})
+        @harmoniser_consumer_definition = Definition::Consumer.new(
+          queue_name: queue_name,
+          consumer_tag: consumer_tag,
+          no_ack: no_ack,
+          exclusive: exclusive,
+          arguments: arguments
+        )
+      end
+
+      def harmoniser_subscriber_start
+        MUTEX.synchronize do
+          @harmoniser_consumer ||= create_consumer
+        end
+      end
+
+      private
+
+      def create_consumer
+        raise_missing_consumer_definition unless @harmoniser_consumer_definition
+
+        consumer = Bunny::Consumer.new(
+          Subscriber.harmoniser_channel,
+          @harmoniser_consumer_definition.queue_name,
+          @harmoniser_consumer_definition.consumer_tag || Subscriber.harmoniser_channel.generate_consumer_tag,
+          @harmoniser_consumer_definition.no_ack,
+          @harmoniser_consumer_definition.exclusive,
+          @harmoniser_consumer_definition.arguments
+        )
+        handle_cancellation(consumer)
+        handle_delivery(consumer)
+        register_consumer(consumer)
+        consumer
+      end
+
+      def handle_cancellation(consumer)
+        consumer.on_cancellation do |basic_cancel|
+          if respond_to?(:on_cancellation)
+            on_cancellation(basic_cancel)
+          else
+            Harmoniser.logger.info("Default on_cancellation handler executed for consumer: consumer_tag = `#{consumer.consumer_tag}`, queue = `#{consumer.queue}`")
+          end
+        end
+      end
+
+      def handle_delivery(consumer)
+        consumer.on_delivery do |delivery_info, properties, payload|
+          if respond_to?(:on_delivery)
+            on_delivery(delivery_info, properties, payload)
+          else
+            Harmoniser.logger.info("Default on_delivery handler executed for consumer: consumer_tag = `#{consumer.consumer_tag}`, queue = `#{consumer.queue}`")
+          end
+        end
+      end
+
+      def register_consumer(consumer)
+        consumer.channel.basic_consume_with(consumer)
+      end
+
+      def raise_missing_consumer_definition
+        raise MissingConsumerDefinition, "Please, call harmoniser_subscriber class method first with the queue_name that will be used for subscribing"
+      end
+    end
+
+    class << self
+      def included(base)
+        base.extend(ClassMethods)
+        harmoniser_register_included(base)
+      end
+    end
+  end
+end

data/lib/harmoniser/topology.rb

@@ -0,0 +1,72 @@
+require "harmoniser/channelable"
+require "harmoniser/definition"
+
+module Harmoniser
+  class Topology
+    include Channelable
+
+    attr_reader :bindings, :exchanges, :queues
+
+    def initialize
+      @bindings = Set.new
+      @exchanges = Set.new
+      @queues = Set.new
+    end
+
+    def add_exchange(type, name, **opts)
+      @exchanges << Definition::Exchange.new(
+        type: type,
+        name: name,
+        opts: opts
+      )
+    end
+
+    def add_queue(name, **opts)
+      @queues << Definition::Queue.new(
+        name: name,
+        opts: opts
+      )
+    end
+
+    def add_binding(exchange_name, destination_name, destination_type = :queue, **opts)
+      @bindings << Definition::Binding.new(
+        exchange_name: exchange_name,
+        destination_name: destination_name,
+        destination_type: destination_type,
+        opts: opts
+      )
+    end
+
+    def declare
+      channel = self.class.create_channel
+      declare_exchanges(channel)
+      declare_queues(channel)
+      declare_bindings(channel)
+      Harmoniser.connection.close
+    end
+
+    private
+
+    def declare_exchanges(channel)
+      exchanges.each do |exchange|
+        Bunny::Exchange.new(channel, exchange.type, exchange.name, exchange.opts)
+      end
+    end
+
+    def declare_queues(channel)
+      queues.each do |queue|
+        Bunny::Queue.new(channel, queue.name, queue.opts)
+      end
+    end
+
+    def declare_bindings(channel)
+      bindings.each do |binding|
+        if binding.queue?
+          channel.queue_bind(binding.destination_name, binding.exchange_name, binding.opts)
+        elsif binding.exchange?
+          ;
+        end
+      end
+    end
+  end
+end

data/lib/harmoniser/version.rb

@@ -0,0 +1,3 @@
+module Harmoniser
+  VERSION = "0.1.0"
+end

data/lib/harmoniser.rb

@@ -0,0 +1,8 @@
+require "harmoniser/version"
+require "harmoniser/configurable"
+require "harmoniser/publisher"
+require "harmoniser/subscriber"
+
+module Harmoniser
+  extend Configurable
+end

metadata

@@ -0,0 +1,121 @@
+--- !ruby/object:Gem::Specification
+name: harmoniser
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Jose Lloret
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2023-11-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bunny
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.22'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.22'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: standardrb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: A declarative tool to communicate with RabbitMQ
+email:
+- jollopre@gmail.com
+executables:
+- harmoniser
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/console
+- bin/harmoniser
+- bin/setup
+- lib/harmoniser.rb
+- lib/harmoniser/channelable.rb
+- lib/harmoniser/cli.rb
+- lib/harmoniser/configurable.rb
+- lib/harmoniser/configuration.rb
+- lib/harmoniser/connection.rb
+- lib/harmoniser/definition.rb
+- lib/harmoniser/includable.rb
+- lib/harmoniser/launcher.rb
+- lib/harmoniser/options.rb
+- lib/harmoniser/parser.rb
+- lib/harmoniser/publisher.rb
+- lib/harmoniser/subscriber.rb
+- lib/harmoniser/topology.rb
+- lib/harmoniser/version.rb
+homepage: https://github.com/jollopre/harmoniser
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/jollopre/harmoniser
+  source_code_uri: https://github.com/jollopre/harmoniser
+  changelog_uri: https://github.com/jollopre/harmoniser/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.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.10
+signing_key: 
+specification_version: 4
+summary: A declarative tool to communicate with RabbitMQ
+test_files: []