happn 1.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 06b2f20b019373ac23f020f1b5c060f5f5185dddba551ace75ef4fc9a129d8ec
+  data.tar.gz: b7b767f5e7abb62eb33661afaea52b7a2695674ddd2b18255002c18ad4923fed
+SHA512:
+  metadata.gz: 94cf0746e1fac94dfde7da681c1abe4c4632411d79d46123d546b41bc84a87ece483e5a9e5b0094fba1e98518fc15d9aa202ea65cb8e05accce59176122059a0
+  data.tar.gz: c63c774536d302c301b33ba1d37e828abddf2eae9e9783b8e60ae44ea45601a3f221df5ecc13265381c00ac3ae5b25078e54e1782855b604889a06f2d38515ca

data/CHANGELOG.md

@@ -0,0 +1,42 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+### [1.1.0] - 2026-07-30
+
+* Remove the `activesupport` dependency: `Happn::Configuration` no longer relies on `ActiveSupport::Configurable`, and `Happn::Event` no longer relies on `String#to_datetime` / `Object#try`
+* Relax the `bundler` development dependency from a pinned `1.12.5` to `>=1.17`
+
+### [1.0.3] - 2024-12-04
+
+* Replace the use of `to_time` to `to_datetime`
+
+### [1.0.2] - 2021-11-06
+
+* Breaking change : force every `port` to be an integer
+* Add `management_options`
+
+### [1.0.0] - 2021-11-05
+
+* Add `bunny_options`
+* Add `rabbitmq_management_scheme`
+* MIT License
+
+### [0.1.4]
+
+* Add convenient method `Event.request_metadata`
+
+### [0.1.3]
+
+* Use of `rabbitmq_http_api_client >= 2.0.0` and `bunny >= 2.19.0`
+
+### [0.1.2]
+
+* Use of `rabbitmq_http_api_client:1.14.0`, which supports `faraday >= 1`
+
+### [0.1.1]
+
+* Happn now raise an exception instead of exiting the process when the consumption of an event fails, allowing the gem user to decide how to handle it.

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2018 
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,129 @@
+# Gem for happn
+
+Happn connects a RabbitMQ exchange and listens for CREPE events (possibly generated using `flu-rails`) sequentially.
+Happn helps developers to create _"Projectors"_ that define how to match and consume events.
+
+This gem connects a single RabbitMQ queue and bind it automatically to its exchange. These bindings are defined by developers through "matchers" when loading projectors.
+
+## Requirements
+
+* Ruby 2.2
+* Tested with RabbitMQ 3.5.8
+* `happn-ruby` works with or without Rails (tested with Rails 4 and 5).
+
+## Installation
+
+Add the gem to your project's Gemfile:
+
+  ```ruby
+  gem "happn", git: "https://github.com/crepesourcing/happn-ruby.git"
+  ```
+
+Then, configure `Happn`. If you use Rails, you can create an initializer into your Rails app (`config/initializers/happn.rb`). This code can be called anywhere before starting `Happn.init`.
+  ```ruby
+  Happn.configure do |config|
+    config.logger                     = Rails.logger
+    config.rabbitmq_host              = ENV["RABBITMQ_HOST"]
+    config.rabbitmq_port              = ENV["RABBITMQ_PORT"]
+    config.rabbitmq_management_port   = ENV["RABBITMQ_MANAGEMENT_PORT"]
+    config.rabbitmq_user              = ENV["RABBITMQ_USER"]
+    config.rabbitmq_password          = ENV["RABBITMQ_PASSWORD"]
+    config.rabbitmq_queue_name        = ENV["CONSUMER_QUEUE_NAME"]
+    config.rabbitmq_exchange_name     = ENV["RABBITMQ_EXCHANGE_NAME"]
+    config.rabbitmq_exchange_durable  = ENV["RABBITMQ_EXCHANGE_DURABLE"] == "true"
+    config.projector_classes          = [LoggerProjector]
+    config.bunny_options              = {}
+  end
+  ```
+
+Each configuration is detailed below.
+
+## About queues
+
+* `Happn` consumes a single queue through the RabbitMQ's [Topic Exchange Model](https://www.rabbitmq.com/tutorials/amqp-concepts.html#exchange-topic).
+* If the queue does not exist when `Happn` starts, it is created automatically.
+* When connecting a queue, please be careful that each connection parameter must match the existing queue's parameters. For instance, the value of `x-queue-mode` must match to avoid a `PRECONDITION FAILED` error.
+* All bindings between queues and their exchange are reset when starting `Happn`. Based on all the projectors that have been registered (option `projector_classes`), `Happn` detects which events must be consumed and binds its queue to the exchange depending on these event matchers.
+
+## About projectors
+
+A projector:
+* defines one or multiple matchers to detect which events must be consumed. Matchers can be declared using 4 event properties
+  * `emitter`: _e.g._ `Facebook` or `MyInternalApi` (`:all` or no value mean "all emitters")
+  * `kind`: _e.g._ `entity_change` or `kind` (`:all` or no value mean "all kinds")
+  * `name`: _e.g._ `create country` or `request to destroy bunnies` (`:all` or no value mean "all names")
+  * `status`: _e.g._ `:new` or `:replayed` (`:all` or no value mean "all statuses")
+* defines how to consume these events.
+
+When a projector raises an Error, `Happn` stops.
+
+## Usage
+
+### Start Up
+
+Starting `Happn` consumes events sequentially. For instance, it can be started from a `Rake` tasks:
+  ```ruby
+  namespace :events do
+    desc "Listen all events and consume them."
+    task consume: :environment do
+      Happn.init
+      Happn.start
+    end
+  end
+  ```
+
+### Define a Projector
+
+A projector is a class that defines how to consume one or multiple types of events. This class must:
+
+* extend `Happn::Projector`.
+* use its `on` method to declare _which_ events to match and _how_ to consume them. This must be done in a `define_handlers` method.
+
+```ruby
+class LoggerProjector < Happn::Projector
+  def define_handlers
+    on emitter: "MyApplication", name: "create country" do |event|
+      Rails.logger("A country has been created and generated an event with id #{event.id}")
+    end
+
+    on kind: "request", status: :new do |event|
+      Rails.logger("This is a new request to the controller: #{event.data["controller_name"]}")
+    end
+  end
+end
+```
+
+### Registering all projectors automatically
+
+If all subclass of `Happn::Projector` should be registered seamlessly, the configuration can declare the following code (using Rails):
+```ruby
+Happn.configure do |config|
+  Rails.application.eager_load!
+  config.projector_classes = Happn::Projector.descendants
+end
+```
+
+When Zeitwerk is defined and when `Rails.application.eager_load!` returns `false`, you should call `Zeitwerk::Loader.eager_load_all`. 
+
+## Overall configuration options
+
+All options have a default value. However, all of them can be changed in your `Happn.configure` block.
+
+| Option | Default Value | Type | Required? | Description  | Example |
+| ---- | ----- | ------ | ----- | ------ | ----- |
+| `logger` | `Logger.new(STDOUT)`| Logger | Optional | The logger used by `happn` | `Rails.logger` | 
+| `rabbitmq_host` | `"localhost"` | String | Required | RabbitMQ exchange's host. | `"192.168.42.42"` |
+| `rabbitmq_port` | `5672` | Integer | Required | RabbitMQ exchange's port. | `1234` |
+| `rabbitmq_user` | `""` | String | Required | RabbitMQ exchange's username. | `"root"` |
+| `rabbitmq_password` | `""` | String | Required | RabbitMQ exchange's password. | `"pouet"` |
+| `rabbitmq_exchange_name` | `"events"` | String | Required | RabbitMQ exchange's name. | `"myproject"` |
+| `rabbitmq_management_scheme` | `"http"` | String | Required | RabbitMQ exchange's management scheme. This scheme is used when `happn` must access metadata information about queues, messages, etc. This port is used to create/delete bindings between the queue and its exchange. | `"https"` |
+| `rabbitmq_management_port` | `15672` | Integer | Required | RabbitMQ exchange's management port. This port is used when `happn` must access metadata information about queues, messages, etc. This port is used to create/delete bindings between the queue and its exchange. | `15671` |
+| `rabbitmq_queue_name` | `"happn-queue"` | String | Required | The RabbitMQ queue to create, bind and consume. If the queue does not exist, it will be created at startup. | `"my-queue"` |
+| `rabbitmq_exchange_durable` | `true` | Boolean | Optional | Make the RabbitMQ's exchange durable or not. From RabbitMQ's [documentation](https://www.rabbitmq.com/tutorials/amqp-concepts.html#exchanges): _"Durable exchanges survive broker restart whereas transient exchanges do not (they have to be redeclared when broker comes back online)."_ | `false` |
+| `rabbitmq_queue_mode` | `nil` | String | Optional | When creating the queue, this option can be passed to set `x-queue-mode`. For instance, a queue can be made _"lazy"_ by passing `"lazy"` as a value. See [RabbitMQ's documentation](https://www.rabbitmq.com/lazy-queues.html) for more details.  | `lazy` |
+| `rabbitmq_prefetch_size` | `10` | Integer | Optional | Also known as RabbitMQ's QOS. From the [RabbitMQ's documentation](http://www.rabbitmq.com/consumer-prefetch.html): _"AMQP specifies the basic.qos method to allow you to limit the number of unacknowledged messages on a channel (or connection) when consuming (aka "prefetch count")."_ | `1000` |
+| `projector_classes` | `[]` | Array of constants | Required | All Projector classes to register. This value can be generated by reading all descendant classes from `Happn::Projector`. | `[MyProjector]` |
+| `bunny_options` | `{}` | Hash of symbols | Optional | Additional options to add when connecting the RabbitMQ broker. This overrides the existing options with the same name. | `{ verify_peer: true }` |
+| `management_options` | `{}` | Hash of symbols | Optional | Additional options to add when accessing the RabbitMQ Managmement. This overrides the existing options with the same name. The options are defined at https://github.com/ruby-amqp/rabbitmq_http_api_client | `{ verify: false }` |
+| `on_error` | `nil` | `block` with an argument `exception` | false | When the consumption of an event raises an Error, the consumption exits. However, this block can be called before exiting the consumption execution. | `lambda { |exception| Raven.capture_exception(exception) }` (see Sentry's [documentation](https://github.com/getsentry/raven-ruby) | 

data/happn.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "happn/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "happn"
+  spec.version       = Happn::VERSION
+  spec.authors       = ["Commuty"]
+  spec.email         = ["support@commuty.net"]
+  spec.summary       = "Gem to connect a RabbitMQ exchange and listen for events."
+  spec.description   = "Gem to connect a RabbitMQ exchange and listen for events."
+  spec.homepage      = "https://gitlab.spin42.me/commuty/happn"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler",                    ">=1.17"
+  spec.add_development_dependency "rake",                       ">=12.0"
+  spec.add_development_dependency "rspec",                      "~>3.0"
+  spec.add_dependency             "bunny",                      ">=2.19.0"
+  spec.add_dependency             "rabbitmq_http_api_client",   ">=2.0.0"
+end

data/lib/happn/configuration.rb

@@ -0,0 +1,20 @@
+module Happn
+  class Configuration
+    attr_accessor :logger,
+                  :rabbitmq_host,
+                  :rabbitmq_port,
+                  :rabbitmq_management_port,
+                  :rabbitmq_management_scheme,
+                  :rabbitmq_user,
+                  :rabbitmq_password,
+                  :rabbitmq_queue_name,
+                  :rabbitmq_exchange_name,
+                  :rabbitmq_exchange_durable,
+                  :rabbitmq_queue_mode,
+                  :rabbitmq_prefetch_size,
+                  :projector_classes,
+                  :bunny_options,
+                  :management_options,
+                  :on_error
+  end
+end

data/lib/happn/event.rb

@@ -0,0 +1,105 @@
+require "date"
+
+module Happn
+  class Event
+
+    def initialize(args)
+      @meta = deep_underscore_keys(args.fetch("meta"))
+      @data = deep_underscore_keys(args.fetch("data"))
+    end
+
+    def data
+      @data
+    end
+
+    def user_metadata
+      @data[:user_metadata]
+    end
+
+    def request_metadata
+      @data[:request_metadata]
+    end
+
+    def changes
+      @data[:changes]
+    end
+
+    def changes=(new_changes)
+      @data[:changes] = new_changes
+    end
+
+    def add_change(name, value)
+      new_value            = value == "" ? nil : value
+      changes[name.to_sym] = [nil, new_value]
+    end
+
+    def associations
+      @data[:associations]
+    end
+
+    def timestamp
+      DateTime.parse(@meta[:timestamp])
+    end
+
+    def id
+      @meta[:id]
+    end
+
+    def name
+      @meta[:name]
+    end
+
+    def status
+      @meta[:status]
+    end
+
+    def kind
+      @meta[:kind]
+    end
+
+    def emitter
+      @meta[:emitter]
+    end
+
+    def change_after(attribute_name)
+      changes[attribute_name.to_sym]&.last
+    end
+
+    def change_before(attribute_name)
+      changes[attribute_name.to_sym]&.first
+    end
+
+    def has_change?(attribute_name)
+      !changes[attribute_name].nil?
+    end
+
+    def delete_change(attribute_name)
+      changes.delete(attribute_name)
+    end
+
+    private
+
+    def underscore_key(key)
+      underscore(key).to_sym
+    end
+
+    def deep_underscore_keys(value)
+      case value
+        when Array
+          value.map(&method(:deep_underscore_keys))
+        when Hash
+          Hash[value.map { |key, value| [underscore_key(key), deep_underscore_keys(value)] }]
+        else
+          value
+       end
+    end
+
+    def underscore(camel_cased_word)
+      camel_cased_word.gsub(/::/, '/').
+        gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+        gsub(/([a-z\d])([A-Z])/,'\1_\2').
+        tr("-", "_").
+        downcase
+     end
+  end
+end

data/lib/happn/event_consumer.rb

@@ -0,0 +1,129 @@
+require "bunny"
+require "rabbitmq/http/client"
+
+module Happn
+  class EventConsumer
+    def initialize(logger, configuration, subscription_repository)
+      @configuration           = configuration
+      @logger                  = logger
+      @subscription_repository = subscription_repository
+      @queue_name              = @configuration.rabbitmq_queue_name
+      options                  = {
+        host: @configuration.rabbitmq_host,
+        port: @configuration.rabbitmq_port&.to_i,
+        user: @configuration.rabbitmq_user,
+        password: @configuration.rabbitmq_password,
+        automatically_recover: true
+      }.merge(@configuration.bunny_options || {})
+      @connection              = Bunny.new(options)
+
+      management_options = {
+        username: @configuration.rabbitmq_user,
+        password: @configuration.rabbitmq_password
+      }.merge(@configuration.management_options || {})
+      @management_client       = RabbitMQ::HTTP::Client.new("#{@configuration.rabbitmq_management_scheme || "http"}://#{@configuration.rabbitmq_host}:#{@configuration.rabbitmq_management_port}/", management_options)
+    end
+
+    def wait_until_connected
+      connected = false
+      while !connected
+        begin
+          connect
+          connected = true
+        rescue Bunny::TCPConnectionFailedForAllHosts
+          @logger.warn("RabbitMQ connection failed, try again in 1 second.")
+          sleep 2
+        end
+      end
+    end
+
+    def start
+      wait_until_connected
+      consume
+    end
+
+    private
+
+    def connect
+      @connection.start
+      channel_number                   = nil
+      consumer_pool_size               = 1
+      consumer_pool_abort_on_exception = true
+      @channel                         = @connection.create_channel(channel_number, consumer_pool_size, consumer_pool_abort_on_exception)
+      @channel.on_uncaught_exception do |exception|
+        @configuration.on_error&.call(exception)
+        @logger.error("An error occurred. Exiting events consumption.")
+        exit(1)
+      end
+      @channel.basic_qos(@configuration.rabbitmq_prefetch_size)
+      arguments                        = {}
+      arguments["x-queue-mode"]        = @configuration.rabbitmq_queue_mode unless @configuration.rabbitmq_queue_mode.nil?
+      @queue                           = @channel.queue(@queue_name, durable: true, arguments: arguments)
+      exchange                         = @channel.send(:topic,
+                                                       @configuration.rabbitmq_exchange_name,
+                                                       durable: @configuration.rabbitmq_exchange_durable)
+
+      routing_keys = @subscription_repository.find_all.map do | subscription |
+        subscription.query.to_routing_key
+      end
+      routing_keys.uniq.each do | routing_key |
+        @logger.info("Bind exchange to queue with routing key : #{routing_key}")
+        @queue.bind(exchange, routing_key: routing_key)
+      end
+
+      unbind_useless_routing_keys(@queue, exchange, routing_keys)
+
+      @logger.info("Ready!")
+    end
+
+    def consume
+      options  = {
+        manual_ack: true,
+        block: true
+      }
+      @queue.subscribe(options) do | delivery_info, _properties, event |
+        begin
+          handle_message(event, delivery_info)
+        rescue => exception
+          handle_exception(exception, delivery_info)
+        end
+      end
+    end
+
+    def handle_message(message, delivery_info)
+      event         = Event.new(JSON.parse(message))
+      subscriptions = @subscription_repository.find_subscriptions_for(event)
+
+      @logger.info("Executing #{subscriptions.size} handlers for event '#{event.name}' with id: #{event.id}.")
+      subscriptions.each do | subscription |
+        projector = subscription.projector
+        handler   = subscription.handler
+        projector.instance_exec(event, &handler)
+      end
+      @channel.acknowledge(delivery_info.delivery_tag, false)
+    end
+
+    def handle_exception(exception, delivery_info)
+      @logger.error(exception)
+      @channel.reject(delivery_info.delivery_tag, true)
+      @logger.fatal("Can't handle event, exit.")
+      raise exception
+    end
+
+    private
+
+    def unbind_useless_routing_keys(queue, exchange, useful_routing_keys)
+      all_routing_keys = find_all_routing_keys_of(queue)
+      keys_to_remove   = all_routing_keys - useful_routing_keys
+      keys_to_remove.each do | routing_key |
+        @queue.unbind(exchange, routing_key: routing_key)
+      end
+    end
+
+    def find_all_routing_keys_of(queue)
+      @management_client.list_queue_bindings("/", queue.name).map do | binding |
+        binding.routing_key
+      end
+    end
+  end
+end

data/lib/happn/projector.rb

@@ -0,0 +1,17 @@
+module Happn
+  class Projector
+
+    def initialize(logger, subscription_repository)
+      @logger                  = logger
+      @subscription_repository = subscription_repository
+    end
+
+    def define_handlers
+    end
+
+    def on(emitter: :all, kind: :all, name: :all, status: :all, &block)
+      query = Query.new(emitter, kind, name, status)
+      @subscription_repository.register(query, self, &block)
+    end
+  end
+end

data/lib/happn/query.rb

@@ -0,0 +1,27 @@
+module Happn
+  class Query
+
+    attr_reader :emitter, :kind, :name, :status
+
+    def initialize(emitter, kind, name, status)
+      if emitter.to_s.include?(".") || kind.to_s.include?(".") || name.to_s.include?(".") || status.to_s.include?(".")
+        raise "'Dot' is not a valid character"
+      end
+
+      @emitter = emitter
+      @kind    = kind
+      @name    = name
+      @status  = status
+    end
+
+    def to_routing_key
+      "#{to_expression(@status)}.#{to_expression(@emitter)}.#{to_expression(@kind)}.#{to_expression(@name)}"
+    end
+
+    private
+
+    def to_expression(query_expression)
+      query_expression == :all ? "*" : query_expression
+    end
+  end
+end

data/lib/happn/subscription.rb

@@ -0,0 +1,12 @@
+module Happn
+  class Subscription
+
+    attr_reader :handler, :projector, :query
+
+    def initialize(query, projector, &handler)
+      @query     = query
+      @projector = projector
+      @handler   = handler
+    end
+  end
+end

data/lib/happn/subscription_repository.rb

@@ -0,0 +1,57 @@
+module Happn
+  class SubscriptionRepository
+
+    def initialize(logger)
+      @subscriptions = {}
+      @logger        = logger
+    end
+
+    def register(query, projector, &block)
+      subscription = Subscription.new(query, projector, &block)
+      emitter      = query.emitter.to_s
+      kind         = query.kind.to_s
+      name         = query.name.to_s
+      status       = query.status.to_s
+      @subscriptions[status]                       ||= {}
+      @subscriptions[status][emitter]              ||= {}
+      @subscriptions[status][emitter][kind]        ||= {}
+      @subscriptions[status][emitter][kind][name]  ||= []
+      @subscriptions[status][emitter][kind][name].push(subscription)
+      @logger.info("Subscribe projector '#{projector.class}' to query : [#{status}][#{emitter}][#{kind}][#{name}]")
+    end
+
+    def find_all
+      flatten(@subscriptions)
+    end
+
+    def find_subscriptions_for(event)
+      possible_event_statuses = ["all", event.status.to_s]
+      possible_event_emitters = ["all", event.emitter.to_s]
+      possible_event_names    = ["all", event.name.to_s]
+      possible_event_kinds    = ["all", event.kind.to_s]
+      subscriptions           = []
+      possible_event_statuses.each do | status |
+        possible_event_emitters.each do | emitter |
+          possible_event_kinds.each do | kind |
+            possible_event_names.each do | name |
+              subscriptions += @subscriptions.dig(status, emitter, kind, name) || []
+            end
+          end
+        end
+      end
+      subscriptions
+    end
+
+    private
+
+    def flatten(item)
+      if item.instance_of?(Hash)
+        item.values.inject([]) do | result, value |
+          result += flatten(value)
+        end
+      else
+        item
+      end
+    end
+  end
+end

data/lib/happn/version.rb

@@ -0,0 +1,3 @@
+module Happn
+  VERSION = "1.1.0"
+end

data/lib/happn.rb

@@ -0,0 +1,71 @@
+require_relative "happn/event"
+require_relative "happn/query"
+require_relative "happn/version"
+require_relative "happn/configuration"
+require_relative "happn/event_consumer"
+require_relative "happn/subscription"
+require_relative "happn/subscription_repository"
+require_relative "happn/projector"
+require "logger"
+
+module Happn
+  def self.configure
+    yield @configuration ||= Happn::Configuration.new
+  end
+
+  def self.config
+    @configuration
+  end
+
+  def self.logger
+    @logger
+  end
+
+  def self.init
+    @logger                 = @configuration.logger || Logger.new(STDOUT)
+    subscription_repository = SubscriptionRepository.new(@logger)
+    Happn::register(@configuration.projector_classes, subscription_repository)
+    @event_consumer         = EventConsumer.new(@logger, @configuration, subscription_repository)
+  end
+
+  def self.start
+    @event_consumer.start
+  end
+
+  def self.create_queue_only
+    Happn.init
+    @event_consumer.wait_until_connected
+  end
+
+  configure do |config|
+    config.logger                     = nil
+    config.rabbitmq_host              = "localhost"
+    config.rabbitmq_port              = 5672
+    config.rabbitmq_management_scheme = "http"
+    config.rabbitmq_management_port   = 15672
+    config.rabbitmq_user              = ""
+    config.rabbitmq_password          = ""
+    config.rabbitmq_queue_name        = "happn-queue"
+    config.rabbitmq_exchange_name     = "events"
+    config.rabbitmq_exchange_durable  = true
+    config.rabbitmq_queue_mode        = nil
+    config.rabbitmq_prefetch_size     = 10
+    config.projector_classes          = []
+    config.on_error                   = nil
+    config.bunny_options              = {}
+    config.management_options         = {}
+    config.on_error                   = nil
+  end
+
+  private
+
+  def self.register(projector_classes, subscription_repository)
+    @logger.info("#{projector_classes.size} projector are going to be registered...")
+    projector_classes.each do | projector_class |
+      projector = projector_class.new(@logger, subscription_repository)
+      projector.define_handlers
+      @logger.info("Projector '#{projector_class}' registered")
+    end
+  end
+
+end

metadata

@@ -0,0 +1,124 @@
+--- !ruby/object:Gem::Specification
+name: happn
+version: !ruby/object:Gem::Version
+  version: 1.1.0
+platform: ruby
+authors:
+- Commuty
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.17'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.17'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '12.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '12.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: bunny
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.19.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.19.0
+- !ruby/object:Gem::Dependency
+  name: rabbitmq_http_api_client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+description: Gem to connect a RabbitMQ exchange and listen for events.
+email:
+- support@commuty.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- Gemfile
+- MIT-LICENSE
+- README.md
+- happn.gemspec
+- lib/happn.rb
+- lib/happn/configuration.rb
+- lib/happn/event.rb
+- lib/happn/event_consumer.rb
+- lib/happn/projector.rb
+- lib/happn/query.rb
+- lib/happn/subscription.rb
+- lib/happn/subscription_repository.rb
+- lib/happn/version.rb
+homepage: https://gitlab.spin42.me/commuty/happn
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.17
+specification_version: 4
+summary: Gem to connect a RabbitMQ exchange and listen for events.
+test_files: []