bug_bunny 2.0.0 → 2.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 619fcbcb8024b1952fb21a4764cc9ae3734df38d7e359ec32f5b41fc3009eccd
-  data.tar.gz: 5c950d6cc2ef61351e937c6f2a7a32e6dc8dee06f4f93dfdae1bed350ad9702a
+  metadata.gz: 8fccb3590fd16133119a7e2cea4c05002964846ac5a35e0714925f2d87115a06
+  data.tar.gz: 839ab64bb406eebee8e59f99c010c640a033dab15cd0f531e66f0fbc1e201c82
 SHA512:
-  metadata.gz: 5ca317931674edfef2bc57eff4ab9df4faea01edfb833ce8978cd74bcd1bf9bb0c5823efe9540039b16ef5dfca8d3800d7fa6a76720e4949e13d3138baeb7f8f
-  data.tar.gz: cfe9ee5d4d01ae4a786eac02028b623939228da9d695bfbdd0139621600ff4e8ad825ccc5c74178c8d88deb38f47ea05eec2137e58ccad2eb8c7d202bfed6168
+  metadata.gz: 4be8016e660aec70394814ffc85ecba71759aeb94df817abac412c201685ebee89c447fdd76b9904dfb5d2bc5f73e208ed0eed2d9bbc016a307c09978254c76e
+  data.tar.gz: 741552a099ae0aadb5717cb46fc4ff24c77c9f31f7dae677131dc158f784a75bca1a739bb6cf65eba42bff84fba853d25a2df54ca0d5884a23f679fa72c679b0

data/README.md

@@ -1,9 +1,172 @@
 # BugBunny
 
+## Configuration
+
+```ruby
+config/initializers/bug_bunny.rb
+BugBunny.configure do |config|
+  config.host = 'Host'
+  config.username = 'Username'
+  config.password = 'Password'
+  config.vhost = '/'
+  config.logger = Rails.logger
+  config.automatically_recover = false
+  config.network_recovery_interval = 5
+  config.connection_timeout = 10
+  config.read_timeout = 30
+  config.write_timeout = 30
+  config.heartbeat = 15
+  config.continuation_timeout = 15_000
+end
+```
+
 ## Publish
 
+### Rutas
+
+```
+# config/rabbit_rest.yml
+default: &default
+  healt_check:
+    up: 'healt_check/up'
+  manager:
+      services:
+        index: 'services/index'
+        create: 'services/create'
+        show: 'services/%<id>s/show'
+        update: 'services/%<id>s/update'
+        destroy: 'services/%<id>s/destroy'
+      swarm:
+        info: 'swarm/info'
+        version: 'swarm/version'
+        swarm: 'swarm/swarm'
+      tasks:
+        index: 'tasks/index'
+
+development:
+  <<: *default
+
+test:
+  <<: *default
+
+production:
+  <<: *default
+
+```
+
+### Configuration
+
+```ruby
+# config/initializers/bug_bunny.rb
+BUG_BUNNY_ENDPOINTS = Rails.application.config_for(:rabbit_rest)
+
+BUNNY_POOL = ConnectionPool.new(size: RABBIT_MAX_THREADS) do
+  BugBunny::Rabbit.create_connection(host: RABBIT_HOST, username: RABBIT_USER, password: RABBIT_PASS, vhost: RABBIT_VIRTUAL_HOST)
+end
+```
+
+### Publisher
+
+Creamos cualquier clase que herede de `BugBunny::Publisher`, luego definimos metodos de clase y dentro de cada una de ella su implementacion
+
+1. Mensajes sincronicos
+
+```
+class Rabbit::Publisher::Manager < BugBunny::Publisher
+  ROUTING_KEY = :manager
+  ROUTES = BUG_BUNNY_ENDPOINTS[:manager][:swarm]
+
+  def self.info(exchange:, message: nil)
+    obj = new(pool: NEW_BUNNY_POOL, exchange_name: exchange, action: self::ROUTES[:info], message: message)
+    obj.publish_and_consume!
+  end
+
+  def self.version(exchange:, message: nil)
+    obj = new(pool: NEW_BUNNY_POOL, exchange_name: exchange, action: self::ROUTES[:version], message: message)
+    obj.publish_and_consume!
+  end
+end
+```
+
+2. Mensajes Asincronicos
+
+```
+class Rabbit::Publisher::Manager < BugBunny::Publisher
+  ROUTING_KEY = :manager
+  ROUTES = BUG_BUNNY_ENDPOINTS[:manager][:swarm]
+
+  def self.info(exchange:, message: nil)
+    obj = new(pool: NEW_BUNNY_POOL, exchange_name: exchange, action: self::ROUTES[:info], message: message)
+    obj.publish!
+  end
+
+  def self.version(exchange:, message: nil)
+    obj = new(pool: NEW_BUNNY_POOL, exchange_name: exchange, action: self::ROUTES[:version], message: message)
+    obj.publish!
+  end
+end
+```
+
+3. Attributes del objeto BugBunny::Publisher
+
+- content_type
+- content_encoding
+- correlation_id
+- reply_to
+- message_id
+- timestamp
+- priority
+- expiration
+- user_id
+- app_id
+- action
+- aguments
+- cluster_id
+- persistent
+- expiration
+
 ## Consumer
 
+```
+class Rabbit::Controllers::Application < BugBunny::Controller
+end
+
+class Rabbit::Controllers::Swarm < Rabbit::Controllers::Application
+  def info
+    render status: :ok, json: Api::Docker.info
+  end
+
+  def version
+    render status: :ok, json: Api::Docker.version
+  end
+
+  def swarm
+    render status: :ok, json: Api::Docker.swarm
+  end
+end
+
+```
+
+## Resource
+Solo para recursos que se adaptan al crud de rails estoy utilizando automaticamente la logica de los publicadores. Los atributos solo se ponen si son necesarios, si no la dejas vacia y actua igual que active resource.
+
+```
+class Manager::Application < BugBunny::Resource
+  self.resource_path = 'rabbit/publisher/manager'
+
+  attribute :id         # 'ID'
+  attribute :version    # 'Version'
+  attribute :created_at # 'CreatedAt'
+  attribute :update_at  # 'UpdatedAt'
+  attribute :spec       # 'Spec'
+end
+
+class Manager::Service < Manager::Application
+  attribute :endpoint # 'Endpoint'
+end
+
+```
+
 ## Exceptions
 - Error General:
  - `BugBunny::Error` hereda de `::StandardError` (Captura cualquier error de la gema.)
@@ -16,5 +179,5 @@
  - `BugBunny::ResponseError::NotFound`
  - `BugBunny::ResponseError::NotAcceptable`
  - `BugBunny::ResponseError::RequestTimeout`
- - `BugBunny::ResponseError::UnprocessableEntity`
+ - `BugBunny::ResponseError::UnprocessableEntity`: En este el error viene el error details a lo rails.
  - `BugBunny::ResponseError::InternalServerError`

data/lib/bug_bunny/exception.rb

@@ -3,6 +3,7 @@ module BugBunny
   # Ayuda a atrapar cualquier error de la gema con un solo 'rescue BugBunny::Error'.
   class Error < ::StandardError; end
   class PublishError < Error; end
+  class Connection < Error; end
 
   module ResponseError
     class Base < Error; end

data/lib/bug_bunny/publisher.rb

@@ -52,7 +52,7 @@ module BugBunny
     include ActiveModel::Attributes
 
     attribute :message
-    attribute :pool
+    attribute :connection
     attribute :routing_key, :string
     attribute :persistent, :boolean, default: false
     attribute :content_type, :string, default: "application/json"
@@ -66,25 +66,19 @@ module BugBunny
     attribute :expiration, :integer, default: -> { 1.day.in_milliseconds } #ms
     attribute :exchange_name, :string
     attribute :exchange_type, :string, default: 'direct'
-    attr_accessor :type
-
+    attribute :type, :string
     attribute :action, :string
-    attribute :arguments, default: {}
 
     def publish!
-      pool.with do |conn|
-        app = Rabbit.new(connection: conn)
-        app.build_exchange(name: exchange_name, type: exchange_type)
-        app.publish!(message, publish_opts)
-      end
+      app = Rabbit.new(connection: connection)
+      app.build_exchange(name: exchange_name, type: exchange_type)
+      app.publish!(message, publish_opts)
     end
 
     def publish_and_consume!
-      pool.with do |conn|
-        app = Rabbit.new(connection: conn)
-        app.build_exchange(name: exchange_name, type: exchange_type)
-        app.publish_and_consume!(message, publish_opts)
-      end
+      app = Rabbit.new(connection: connection)
+      app.build_exchange(name: exchange_name, type: exchange_type)
+      app.publish_and_consume!(message, publish_opts)
     end
 
     def publish_opts
@@ -101,14 +95,13 @@ module BugBunny
         expiration: expiration }
     end
 
-    def type
-      return if action.blank?
-
-      self.type = format(action, arguments)
-    end
-
     def initialize(attrs = {})
       super(attrs)
+      if attrs[:action].present?
+        args = attrs[:arguments] || {}
+
+        self.type = format(attrs[:action], args)
+      end
       self.routing_key ||= self.class::ROUTING_KEY
     end
   end

data/lib/bug_bunny/rabbit.rb

@@ -137,11 +137,11 @@ module BugBunny
       Rails.logger.debug("PUBLISHER Options: #{options}")
       publish!(msg, options)
 
-      if response_latch.wait(RABBIT_READ_TIMEOUT)
+      if response_latch.wait(RABBIT_CONNECTION_TIMEOUT)
         subscription.cancel
         build_response(status: response[:status], body: response[:body])
       else
-        raise "Timeout: No response received within #{RABBIT_READ_TIMEOUT} seconds."
+        raise "Timeout: No response received within #{RABBIT_CONNECTION_TIMEOUT} seconds."
       end
     rescue BugBunny::ResponseError::Base => e
       subscription&.cancel
@@ -303,6 +303,10 @@ module BugBunny
       )
 
       bunny.tap(&:start)
+    rescue Timeout::Error, Bunny::ConnectionError => e
+      # Timeout::Error (para el timeout de conexión TCP) se captura separadamente.
+      # Bunny::ConnectionError cubre TCPConnectionFailed, AuthenticationFailure, AccessRefused, etc.
+      raise BugBunny::Error::Connection, e.message
     end
   end
 end

data/lib/bug_bunny/resource.rb

@@ -21,16 +21,18 @@ module BugBunny
     end
 
     class ExchangeScope
-      attr_reader :exchange_name, :klass
+      attr_reader :exchange_name, :routing_key, :klass
 
-      def initialize(klass, exchange_name)
+      def initialize(klass, exchange_name, routing_key = nil)
         @klass = klass
         @exchange_name = exchange_name
+        @routing_key = routing_key
       end
 
       def method_missing(method_name, *args, **kwargs, &block)
         if @klass.respond_to?(method_name, true)
           kwargs[:exchange] = @exchange_name
+          kwargs[:routing_key] = @routing_key if @routing_key.present?
           @klass.execute(method_name.to_sym, *args, **kwargs, &block)
         else
           super
@@ -103,7 +105,7 @@ module BugBunny
 
       return self if persisted? && changes.empty?
 
-      obj = self.class.publisher.send(action, exchange: current_exchange, message: changes_to_send)
+      obj = self.class.publisher.send(action, exchange: current_exchange, routing_key: current_routing_key, message: changes_to_send)
 
       assign_attributes(obj) # refresco el objeto
       self.persisted = true
@@ -119,7 +121,7 @@ module BugBunny
       return self unless persisted?
 
       # Llamada al PUBLISHER sin el argumento 'box'
-      self.class.publisher.send(destroy_action.to_sym, exchange: current_exchange, id: id)
+      self.class.publisher.send(destroy_action.to_sym, exchange: current_exchange, routing_key: current_routing_key, id: id)
 
       self.persisted = false
       true
@@ -132,20 +134,28 @@ module BugBunny
       self.class.current_exchange
     end
 
-    def self.for_exchange(exchange_name)
+    def current_routing_key
+      self.class.current_routing_key
+    end
+
+    def self.for_exchange(exchange_name, routing_key = nil)
       raise ArgumentError, 'Exchange name must be specified.' if exchange_name.blank?
 
-      ExchangeScope.new(self, exchange_name)
+      ExchangeScope.new(self, exchange_name, routing_key)
     end
 
     def self.execute(name, *args, **kwargs, &block)
       original_exchange = Thread.current[:bugbunny_current_exchange]
       Thread.current[:bugbunny_current_exchange] = kwargs[:exchange]
+      original_routing_key = Thread.current[:bugbunny_current_routing_key]
+      Thread.current[:bugbunny_current_routing_key] = kwargs[:routing_key]
       begin
         kwargs.delete(:exchange)
+        kwargs.delete(:routing_key)
         send(name, *args, **kwargs, &block)
       ensure
         Thread.current[:bugbunny_current_exchange] = original_exchange
+        Thread.current[:bugbunny_current_routing_key] = original_routing_key
       end
     end
 
@@ -153,12 +163,16 @@ module BugBunny
       Thread.current[:bugbunny_current_exchange]
     end
 
+    def self.current_routing_key
+      Thread.current[:bugbunny_current_routing_key]
+    end
+
     def self.all
       where
     end
 
     def self.where(query = {})
-      body = publisher.send(index_action.to_sym, exchange: current_exchange, message: query)
+      body = publisher.send(index_action.to_sym, exchange: current_exchange, routing_key: current_routing_key, message: query)
       instances = []
 
       body.each do |obj|
@@ -171,7 +185,7 @@ module BugBunny
     end
 
     def self.find(id)
-      obj = publisher.send(show_action.to_sym, exchange: current_exchange, id: id)
+      obj = publisher.send(show_action.to_sym, exchange: current_exchange, routing_key: current_routing_key, id: id)
       return if obj.blank?
 
       instance = new

data/lib/bug_bunny/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module BugBunny
-  VERSION = "2.0.0"
+  VERSION = "2.0.2"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bug_bunny
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.0.2
 platform: ruby
 authors:
 - gabix