bug_bunny 1.0.1 → 2.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 04b430be6237b82713e183846665873b602b15ebece1dfc307031f92a665eb0f
-  data.tar.gz: 922b431bf9bf427cd7dab5ece6abc657b08dd759b72c52e7468f4c5d6e58c634
+  metadata.gz: 074005f6739a5a8486230e47edbce60b9719f5e15f35d9ab3ed95d91eaf28a47
+  data.tar.gz: 39f1d8afb65be6ff2b86e0461c16c93e0ff6ae6cbe629668ba8e6601fe898e80
 SHA512:
-  metadata.gz: fef3ed50441448e66f7e23d02189f5b8b51294c14bdfc61f27d3a68fb3b2179b9ada92bdea906ae0d4605a3761a051700a1e3f4957bbb8c4ef6afa0518e2a238
-  data.tar.gz: 3192b179b3e35c4b2850b5933410afdc71a9a904d1df1673a88efb4bb0e66ef2d5952d04def37b7aff82a580b26943d362169ff896924f4ff91a9947223caeb5
+  metadata.gz: 88e99f4d71b1bb78599cf7a1750218cf5fde2e9ccb010c1aa671d1ba5e1ffe011a9bc70c39fe284b150d6fb497827e94766a82085a3758308990e57eb0f0b5da
+  data.tar.gz: 66acaa871a7f5adabf4135c3b84216f71072be0f9bc7f76c4e42247dde064709596c78b88fed32c9bd24bc47a6ba737d54bc7c3396509f4dae61f06c69d026fd

data/README.md

@@ -1,63 +1,183 @@
 # BugBunny
 
-This gem simplify use of bunny gem. You can use 2 types of comunitaction, sync and async, Only is necessary define one `Adapter` to publish messages and `Consumer` to consume messages.
+## 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
+```
 
-# Example
+## Publish
+
+### Rutas
 
 ```
-# Adapter Code
-class TestAdapter < ::BugBunny::Adapter
-  def self.publish_and_consume
-    service_adapter = TestAdapter.new
-    sync_queue = service_adapter.build_queue(:queue_test, durable: true, exclusive: false, auto_delete: false)
+# 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
 
-    message = ::BugBunny::Message.new(service_action: :test_action, body: { msg: 'test message' })
+```
 
-    service_adapter.publish_and_consume!(message, sync_queue, check_consumers_count: false)
+### Configuration
 
-    service_adapter.close_connection! # ensure the adapter is close
+```ruby
+# config/initializers/bug_bunny.rb
+BUG_BUNNY_ENDPOINTS = Rails.application.config_for(:rabbit_rest)
 
-    service_adapter.make_response
-  end
+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
 
-# Controller Code
-class TestController < ::BugBunny::Controller
-  ##############################################################################
-  # SYNC SERVICE ACTIONS
-  ##############################################################################
-  def self.test_action(message)
-    puts 'sleeping 5 seconds...'
-    sleep 5
-    { status: :success, body: message.body }
+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]
 
-## Installation
+  def self.info(exchange:, message: nil)
+    obj = new(pool: NEW_BUNNY_POOL, exchange_name: exchange, action: self::ROUTES[:info], message: message)
+    obj.publish!
+  end
 
-TODO: Replace `UPDATE_WITH_YOUR_GEM_NAME_PRIOR_TO_RELEASE_TO_RUBYGEMS_ORG` with your gem name right after releasing it to RubyGems.org. Please do not do it earlier due to security reasons. Alternatively, replace this section with instructions to install your gem from git if you don't plan to release to RubyGems.org.
+  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
+```
 
-Install the gem and add to the application's Gemfile by executing:
+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
 
-    $ bundle add UPDATE_WITH_YOUR_GEM_NAME_PRIOR_TO_RELEASE_TO_RUBYGEMS_ORG
+```
+class Rabbit::Controllers::Application < BugBunny::Controller
+end
 
-If bundler is not being used to manage dependencies, install the gem by executing:
+class Rabbit::Controllers::Swarm < Rabbit::Controllers::Application
+  def info
+    render status: :ok, json: Api::Docker.info
+  end
 
-    $ gem install UPDATE_WITH_YOUR_GEM_NAME_PRIOR_TO_RELEASE_TO_RUBYGEMS_ORG
+  def version
+    render status: :ok, json: Api::Docker.version
+  end
 
-## Usage
+  def swarm
+    render status: :ok, json: Api::Docker.swarm
+  end
+end
 
-TODO: Write usage instructions here
+```
 
-## Development
+## 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.
 
-After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+```
+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
 
-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 the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+class Manager::Service < Manager::Application
+  attribute :endpoint # 'Endpoint'
+end
 
-## Contributing
+```
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/bug_bunny.
+## Exceptions
+- Error General:
+ - `BugBunny::Error` hereda de `::StandardError` (Captura cualquier error de la gema.)
+- Error de Publicadores:
+ - `BugBunny::PublishError` hereda de `BugBunny::Error` (Para fallos de envío o conexión.)
+- Error de Respuestas:
+ - `BugBunny::ResponseError::Base` hereda de `BugBunny::Error` (Captura todos los errores de respuesta).
+- Errores Específicos de Respuesta:
+ - `BugBunny::ResponseError::BadRequest`
+ - `BugBunny::ResponseError::NotFound`
+ - `BugBunny::ResponseError::NotAcceptable`
+ - `BugBunny::ResponseError::RequestTimeout`
+ - `BugBunny::ResponseError::UnprocessableEntity`: En este el error viene el error details a lo rails.
+ - `BugBunny::ResponseError::InternalServerError`

data/Rakefile

@@ -1,4 +1,8 @@
 # frozen_string_literal: true
 
 require "bundler/gem_tasks"
-task default: %i[]
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: :rubocop

data/lib/bug_bunny/config.rb

@@ -1,11 +1,11 @@
 module BugBunny
   class Config
     # getter y setter para cada propiedad.
-    attr_accessor :user, :pass, :host, :virtual_host, :logger, :log_level
+    attr_accessor :host, :username, :password, :vhost, :logger, :automatically_recover, :network_recovery_interval, :connection_timeout, :read_timeout, :write_timeout, :heartbeat, :continuation_timeout
 
     # Método para generar la URL de conexión
     def url
-      "amqp://#{user}:#{pass}@#{host}/#{virtual_host}"
+      "amqp://#{username}:#{password}@#{host}/#{vhost}"
     end
   end
 end

data/lib/bug_bunny/controller.rb

@@ -1,16 +1,89 @@
 module BugBunny
   class Controller
-    def self.health_check(_message)
-      { status: :success, body: {} }
+    include ActiveModel::Model
+    include ActiveModel::Attributes
+
+    attribute :headers
+    attribute :params
+    attribute :raw_string
+
+    attr_reader :rendered_response
+
+    def self.before_actions
+      # Nota el uso de '@' en lugar de '@@'
+      @before_actions ||= Hash.new { |hash, key| hash[key] = [] }
+    end
+
+    def self.before_action(method_name, **options)
+      actions = options.delete(:only) || []
+
+      if actions.empty?
+        before_actions[:_all_actions] << method_name
+      else
+        Array(actions).each do |action|
+          before_actions[action.to_sym] << method_name
+        end
+      end
+    end
+
+    def _run_before_actions
+      current_action = headers[:action].to_sym
+
+      callbacks = self.class.before_actions[:_all_actions] + self.class.before_actions[current_action]
+
+      callbacks.each do |method_name|
+        send(method_name) if respond_to?(method_name, true)
+        return false if @rendered_response
+      end
+
+      true
+    end
+
+    def render(status:, json: nil)
+      @rendered_response = self.class.render(status: status, json: json)
+    end
+
+    def safe_parse_body(body)
+      self.params ||= {}
+
+      return if body.blank?
+
+      case headers[:content_type]
+      when 'application/json', 'application/x-www-form-urlencoded'
+        if body.instance_of?(Hash)
+          params.merge!(body.deep_symbolize_keys)
+        else # es string
+          params.merge!(ActiveSupport::JSON.decode(body).deep_symbolize_keys)
+        end
+      when 'text/plain'
+        self.raw_string = body
+      end
     end
 
-    def self.exec_action(message)
-      send(message.service_action, message)
+    def self.status_code_number(code)
+      codes = Rack::Utils::SYMBOL_TO_STATUS_CODE
+      codes[:unprocessable_entity] = 422
+      code = codes[code.to_sym] if codes.key?(code.to_sym)
+      code
     end
 
-    def self.method_missing(name, message, *args, &block)
-      Session.message = message
-      message.build_message(reply_to: message.reply_to).server_no_action!
+    def self.render(status:, json: nil)
+      status_number = status_code_number(status)
+      { status: status_number, body: json }
+    end
+
+    def self.call(headers:, body: {})
+      controller = new(headers: headers)
+      controller.safe_parse_body(body)
+      controller.params[:id] = headers[:id] if headers.key?(:id)
+      controller.params.with_indifferent_access
+      return controller.rendered_response unless controller._run_before_actions
+
+      controller.send(controller.headers[:action])
+    rescue NoMethodError => e # action controller no exist
+      raise e
+    rescue StandardError => e
+      render status: :internal_server_error, json: e.message
     end
   end
 end

data/lib/bug_bunny/exception.rb

@@ -1,69 +1,17 @@
 module BugBunny
-  class Exception
-    class ServiceError < StandardError
-      def to_s
-        :service_error
-      end
-    end
-
-    class NeedSignature < StandardError
-      def to_s
-        :need_signature
-      end
-    end
-
-    class InvalidSignature < StandardError
-      def to_s
-        :invalid_signature
-      end
-    end
-
-    class GatewayError < StandardError
-      def to_s
-        :gateway_error
-      end
-    end
-
-    class UltraCriticError < StandardError
-    end
-
-    class ComunicationRabbitError < StandardError
-      attr_accessor :backtrace
-
-      def initialize(msg, backtrace)
-        @backtrace = backtrace
-        super(msg)
-      end
-    end
-
-    class WithOutConsumer < StandardError
-      attr_accessor :backtrace
-
-      def initialize(msg, backtrace)
-        @backtrace = backtrace
-        super(msg)
-      end
-    end
-
-    class RetryWithoutError < StandardError
-      def to_s
-        "retry_sidekiq_without_error"
-      end
-
-      def backtrace
-        []
-      end
-    end
-
-    ServiceClasses = [
-      Exception::NeedSignature,
-      Exception::InvalidSignature,
-      Exception::ServiceError,
-      Exception::GatewayError,
-      Exception::RetryWithoutError
-    ]
-
-    # Exceptions from ActiveRecord::StatementInvalid
-    PG_EXCEPTIONS_TO_EXIT = %w[PG::ConnectionBad PG::UnableToSend].freeze
+  # Clase base para TODOS los errores de la gema BugBunny.
+  # Ayuda a atrapar cualquier error de la gema con un solo 'rescue BugBunny::Error'.
+  class Error < ::StandardError; end
+  class PublishError < Error; end
+
+  module ResponseError
+    class Base < Error; end
+
+    class BadRequest < Base; end           # HTTP 400
+    class NotFound < Base; end             # HTTP 404
+    class NotAcceptable < Base; end        # HTTP 406
+    class RequestTimeout < Base; end       # HTTP 408
+    class UnprocessableEntity < Base; end  # HTTP 422
+    class InternalServerError < Base; end  # HTTP 500
   end
 end

data/lib/bug_bunny/publisher.rb

@@ -0,0 +1,115 @@
+# content_type:
+# Propósito: Indica el formato de codificación del cuerpo del mensaje (ej. application/json, text/plain, application/xml).
+# Uso Recomendado: dice a tu código qué lógica de deserialización aplicar. Si es application/json, usas JSON.parse.
+
+# content_encoding:
+# Propósito: Indica cómo se comprimió o codificó el cuerpo del mensaje (ej. gzip, utf-8).
+# Uso Recomendado: Si envías cuerpos grandes, puedes comprimirlos (ej. con Gzip) para ahorrar ancho de banda y usar este campo para que el consumidor sepa cómo descomprimirlos antes de usar el content_type.
+
+# correlation_id:
+# Propósito: Un identificador único que se usa para correlacionar una respuesta con una petición previa.
+# Uso Recomendado: Es indispensable en el patrón Remote Procedure Call (RPC). Si un productor envía una petición, copia este ID a la respuesta. Cuando el productor recibe la respuesta, usa este ID para saber a qué petición original corresponde.
+
+# reply_to:
+# Propósito: Especifica el nombre de la cola a la que el consumidor debe enviar la respuesta.
+# Uso Recomendado: También clave en RPC. El productor especifica aquí su cola de respuesta temporal o exclusiva. El consumidor toma el mensaje, procesa, y publica el resultado en la cola indicada en reply_to.
+
+# message_id:
+# Propósito: Un identificador único para el mensaje en sí.
+# Uso Recomendado: Ayuda a prevenir el procesamiento duplicado si un sistema de consumo cae y se recupera. El consumidor puede almacenar los message_id ya procesados.
+
+# timestamp:
+# Propósito: Indica la hora y fecha en que el mensaje fue publicado por el productor.
+# Uso Recomendado: Útil para auditoría, diagnóstico y seguimiento de la latencia del sistema.
+
+# priority:
+# Propósito: Un valor entero que indica la prioridad relativa del mensaje (de 0 a 9, siendo 9 la más alta).
+# Uso Recomendado: Solo funciona si la cola receptora está configurada como una Cola de Prioridades. Si lo está, RabbitMQ dará preferencia a los mensajes con mayor prioridad.
+
+# expiration:
+# Propósito: Especifica el tiempo de vida (TTL - Time To Live) del mensaje en la cola, en milisegundos.
+# Uso Recomendado: Si el mensaje caduca antes de ser consumido, RabbitMQ lo descartará o lo moverá a la Dead Letter Queue (DLQ). Es vital para mensajes sensibles al tiempo (ej. tokens o alertas).
+
+# user_id y app_id:
+# Propósito: Identificadores que especifican qué usuario y qué aplicación generaron el mensaje.
+# Uso Recomendado: Auditoría y seguridad. El broker (RabbitMQ) puede verificar que el user_id coincida con el usuario de la conexión AMQP utilizada para publicar.
+
+# type:
+# Propósito: Un identificador de aplicación para describir el "tipo" o "clase" de la carga útil del mensaje.
+# Uso Recomendado: Usado a menudo para el enrutamiento interno dentro de una aplicación consumidora, similar al header Action que usas. Por ejemplo, en lugar de usar headers[:action], podrías usar properties[:type].
+
+# cluster_id:
+# Propósito: Obsoleto en AMQP 0-9-1 y no debe ser utilizado.
+
+# persistent:
+# Un valor booleano (true o false). Cuando es true, le dice a RabbitMQ que el mensaje debe persistir en el disco. Si el servidor de RabbitMQ se reinicia, el mensaje no se perderá.
+
+# expiration:
+# El tiempo de vida del mensaje en milisegundos. Después de este tiempo, RabbitMQ lo descartará automáticamente si no ha sido consumido.
+module BugBunny
+  class Publisher
+    include ActiveModel::Model
+    include ActiveModel::Attributes
+
+    attribute :message
+    attribute :pool
+    attribute :routing_key, :string
+    attribute :persistent, :boolean, default: false
+    attribute :content_type, :string, default: "application/json"
+    attribute :content_encoding, :string, default: "utf-8"
+    attribute :correlation_id, :string
+    attribute :reply_to, :string
+    attribute :app_id, :string
+    attribute :headers, default: {}
+    attribute :message_id, :string, default: -> { SecureRandom.uuid }
+    attribute :timestamp, :datetime, default: -> { Time.zone.now.utc.to_i }
+    attribute :expiration, :integer, default: -> { 1.day.in_milliseconds } #ms
+    attribute :exchange_name, :string
+    attribute :exchange_type, :string, default: 'direct'
+    attr_accessor :type
+
+    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
+    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
+    end
+
+    def publish_opts
+      { routing_key: routing_key,
+        type: type,
+        persistent: persistent,
+        content_type: content_type,
+        content_encoding: content_encoding,
+        correlation_id: correlation_id,
+        reply_to: reply_to,
+        app_id: app_id,
+        headers: headers,
+        timestamp: timestamp,
+        expiration: expiration }
+    end
+
+    def type
+      return if action.blank?
+
+      self.type = format(action, arguments)
+    end
+
+    def initialize(attrs = {})
+      super(attrs)
+      self.routing_key ||= self.class::ROUTING_KEY
+    end
+  end
+end