railway-ipc 0.1.3 → 0.1.4

data/lib/railway_ipc/concerns/message_handling.rb

@@ -1,118 +0,0 @@
-module RailwayIpc
-  module Concerns
-    module MessageHandling
-
-      HANDLERS = {}
-
-      def self.included(klass)
-        klass.extend(ClassMethods)
-      end
-
-      attr_reader :message, :handler
-      alias_method :responder, :handler
-
-      def work(payload)
-        decoded_payload = RailwayIpc::Rabbitmq::Payload.decode(payload)
-        @handler = handler_class(decoded_payload.type).new if handler_class(decoded_payload.type)
-        message_klass = message_class(decoded_payload.type)
-        if !message_klass
-          @message = self.rpc_error_message.decode(decoded_payload.message)
-          raise RailwayIpc::UnhandledMessageError, "#{self.class} does not know how to handle #{decoded_payload.type}"
-        else
-
-          @message = message_klass.decode(decoded_payload.message)
-        end
-      rescue StandardError => e
-        RailwayIpc.logger.log_exception({
-          feature: "railway_consumer",
-          error: e.class,
-          error_message: e.message,
-          payload: payload
-        })
-        raise e
-      end
-
-      def rpc_error_adapter
-        self.class.rpc_error_adapter_class
-      end
-
-      def rpc_error_message
-        self.class.rpc_error_message_class
-      end
-
-      private
-
-      def handler_class(message_type)
-        HANDLERS
-          .fetch(message_type, {})
-          .fetch(:handler_class, null_handler)
-      end
-
-      def message_class(message_type)
-        HANDLERS
-          .fetch(message_type, {})
-          .fetch(:message_class, null_message)
-      end
-
-      def null_message
-        self.class.ancestors
-          .grep(RailwayIpc::Concerns::MessageHandling::ClassMethods)
-          .reverse
-          .first
-          .null_message_class
-      end
-
-
-      def null_handler
-        self.class.ancestors
-          .grep(RailwayIpc::Concerns::MessageHandling::ClassMethods)
-          .reverse
-          .first
-          .null_handler_class
-      end
-
-      module ClassMethods
-        def rpc_error_message(rpc_error_message_class)
-          @rpc_error_message_class = rpc_error_message_class
-        end
-
-        def rpc_error_message_class
-          @rpc_error_message_class
-        end
-
-        def rpc_error_adapter(rpc_error_adapter)
-          @rpc_error_adapter_class = rpc_error_adapter
-        end
-
-        def rpc_error_adapter_class
-          @rpc_error_adapter_class
-        end
-
-        def handle_null_messages_with(null_handler)
-          @null_handler = null_handler
-        end
-
-        def null_handler_class
-          @null_handler
-        end
-
-        def handle_unknown_messages_as(null_message)
-          @null_message = null_message
-        end
-
-        def null_message_class
-          @null_message
-        end
-
-        def handle(message_type, with:nil)
-          HANDLERS[message_type.to_s] = {
-            handler_class: with,
-            message_class: message_type
-          }
-        end
-        alias_method :respond_to, :handle
-        alias_method :handle_response, :handle
-      end
-    end
-  end
-end

data/lib/railway_ipc/consumer.rb

@@ -1,26 +0,0 @@
-require 'json'
-require 'base64'
-require "railway_ipc/null_handler"
-
-module RailwayIpc
-  class Consumer
-    include Sneakers::Worker
-    include RailwayIpc::Concerns::MessageHandling
-
-    handle_unknown_messages_as RailwayIpc::NullMessage
-    handle_null_messages_with RailwayIpc::NullHandler
-
-    def self.listen_to(queue:, exchange:)
-      from_queue queue,
-        exchange: exchange,
-        durable: true,
-        exchange_type: :fanout,
-        connection: RailwayIpc.bunny_connection
-    end
-
-    def work(payload)
-      super
-      handler.handle(message)
-    end
-  end
-end

data/lib/railway_ipc/rabbitmq/connection.rb

@@ -1,55 +0,0 @@
-require 'bunny'
-module RailwayIpc
-  module Rabbitmq
-    module Connection
-
-      def self.included(klass)
-        klass.extend(ClassMethods)
-      end
-
-      def self.create_bunny_connection(opts={automatic_recovery: true})
-        settings = AMQ::Settings.parse_amqp_url(ENV["RAILWAY_RABBITMQ_CONNECTION_URL"])
-        Bunny.new(
-          host: settings[:host],
-          user: settings[:user],
-          pass: settings[:pass],
-          port: settings[:port],
-          automatic_recovery: opts[:automatic_recovery],
-          logger: RailwayIpc.bunny_logger)
-      end
-
-      def initialize(queue=nil, pool=nil, opts={automatic_recovery: true})
-        @connection = RailwayIpc::Rabbitmq::Connection.create_bunny_connection(opts)
-        connection.start
-        @channel = connection.create_channel
-      end
-
-      def stop
-        channel.close
-        connection.close
-      end
-
-      private
-
-      attr_reader :channel, :exchange, :queue, :connection
-
-      module ClassMethods
-        def queue(queue)
-          @queue_name = queue
-        end
-
-        def queue_name
-          @queue_name
-        end
-
-        def exchange(exchange)
-          @exchange_name = exchange
-        end
-
-        def exchange_name
-          @exchange_name
-        end
-      end
-    end
-  end
-end

data/lib/railway_ipc/server.rb

@@ -1,50 +0,0 @@
-require "railway_ipc/rabbitmq/connection"
-require "railway_ipc/concerns/message_handling"
-
-module RailwayIpc
-  class Server
-    include RailwayIpc::Rabbitmq::Connection
-    include RailwayIpc::Concerns::MessageHandling
-
-    def self.listen_to(queue:)
-      queue(queue)
-    end
-
-    def initialize(queue=nil, pool=nil, opts={automatic_recovery: true})
-      super
-      @exchange = channel.default_exchange
-    end
-
-    def run
-      @queue = channel.queue(self.class.queue_name, durable: true)
-      subscribe_to_queue
-    end
-
-    def work(payload)
-      super
-      responder.respond(message)
-    end
-
-    private
-
-    def subscribe_to_queue
-      queue.subscribe do |_delivery_info, metadata, payload|
-        handle_request(payload)
-      end
-    end
-
-    def handle_request(payload)
-      begin
-        response = work(payload)
-      rescue StandardError => e
-        RailwayIpc.logger.error(message, "Error responding to message. Error: #{e.class}, #{e.message}")
-        response = self.rpc_error_adapter.error_message(e, message)
-      ensure
-        exchange.publish(
-          RailwayIpc::Rabbitmq::Payload.encode(response),
-          routing_key: message.reply_to
-        ) if response
-      end
-    end
-  end
-end