railway-ipc 0.1.3 → 0.1.4

data/lib/railway_ipc/handler_manifest.rb

@@ -0,0 +1,10 @@
+module RailwayIpc
+  class HandlerManifest
+    attr_reader :message, :handler
+
+    def initialize(message:, handler:)
+      @message = message
+      @handler = handler
+    end
+  end
+end

data/lib/railway_ipc/handler_store.rb

@@ -0,0 +1,21 @@
+require 'railway_ipc/handler_manifest'
+module RailwayIpc
+  class HandlerStore
+    attr_reader :handler_map
+    def initialize
+      @handler_map = {}
+    end
+
+    def registered
+      handler_map.keys
+    end
+
+    def register(message:, handler:)
+      handler_map[message.to_s] = HandlerManifest.new(message: message, handler: handler)
+    end
+
+    def get(response_message)
+      handler_map[response_message]
+    end
+  end
+end

data/lib/railway_ipc/models/consumed_message.rb

@@ -0,0 +1,48 @@
+module RailwayIpc
+  class ConsumedMessage < ActiveRecord::Base
+    STATUSES = {
+      success: 'success',
+      processing: 'processing',
+      unknown_message_type: 'unknown_message_type',
+      failed_to_process: 'failed_to_process'
+    }
+
+    attr_reader :decoded_message
+    self.table_name = 'railway_ipc_consumed_messages'
+    self.primary_key = 'uuid'
+
+    validates :uuid, :status, presence: true
+    validates :status, inclusion: { in: STATUSES.values }
+
+    def processed?
+      self.status == STATUSES[:success]
+    end
+
+    def encoded_protobuf=(encoded_protobuf)
+      self.encoded_message = Base64.encode64(encoded_protobuf)
+    end
+
+    def decoded_message
+      @decoded_message ||= decode_message
+    end
+
+    private
+
+    def timestamp_attributes_for_create
+      super << :inserted_at
+    end
+
+    def decode_message
+      begin
+        message_class = Kernel.const_get(self.message_type)
+      rescue NameError
+        message_class = RailwayIpc::BaseMessage
+      end
+      message_class.decode(decoded_protobuf)
+    end
+
+    def decoded_protobuf
+      Base64.decode64(self.encoded_message)
+    end
+  end
+end

data/lib/railway_ipc/models/published_message.rb

@@ -0,0 +1,27 @@
+module RailwayIpc
+  class PublishedMessage < ActiveRecord::Base
+    self.table_name = 'railway_ipc_published_messages'
+    self.primary_key = "uuid"
+
+    validates :uuid, :status, presence: true
+
+    def self.store_message(exchange_name, message)
+      encoded_message = RailwayIpc::Rabbitmq::Payload.encode(message)
+      self.create(
+          uuid: message.uuid,
+          message_type: message.class.to_s,
+          user_uuid: message.user_uuid,
+          correlation_id: message.correlation_id,
+          encoded_message: encoded_message,
+          status: "sent",
+          exchange: exchange_name
+      )
+    end
+
+    private
+
+    def timestamp_attributes_for_create
+      super << :inserted_at
+    end
+  end
+end

data/lib/railway_ipc/null_message.rb

@@ -1,6 +1,6 @@
 module RailwayIpc
   class NullMessage
-    def self.decode(message)
+    def self.decode(_message)
       self.new
     end
   end

data/lib/railway_ipc/publisher.rb

@@ -1,4 +1,5 @@
 require 'singleton'
+
 module RailwayIpc
   class Publisher < Sneakers::Publisher
     include ::Singleton
@@ -12,14 +13,18 @@ module RailwayIpc
       @exchange_name
     end
 
-
     def initialize
       super(exchange: self.class.exchange_name, exchange_type: :fanout)
     end
 
-    def publish(message)
-      RailwayIpc.logger.info(message, "Publishing message")
-      super(RailwayIpc::Rabbitmq::Payload.encode(message))
+    def publish(message, published_message_store=RailwayIpc::PublishedMessage)
+      RailwayIpc.logger.info(message, 'Publishing message')
+      result = super(RailwayIpc::Rabbitmq::Payload.encode(message))
+      published_message_store.store_message(self.class.exchange_name, message)
+      result
+    rescue RailwayIpc::InvalidProtobuf => e
+      RailwayIpc.logger.error(message, 'Invalid protobuf')
+      raise e
     end
   end
 end

data/lib/railway_ipc/rabbitmq/adapter.rb

@@ -0,0 +1,93 @@
+module RailwayIpc
+  module Rabbitmq
+    class Adapter
+      class TimeoutError < StandardError;
+      end
+      extend Forwardable
+      attr_reader :connection, :exchange, :exchange_name, :queue, :queue_name, :channel
+      def_delegators :connection,
+                     :automatically_recover?,
+                     :connected?,
+                     :host,
+                     :logger,
+                     :pass,
+                     :port,
+                     :user
+
+      def initialize(amqp_url: ENV["RAILWAY_RABBITMQ_CONNECTION_URL"], exchange_name:, queue_name: '', options: {})
+        @queue_name = queue_name
+        @exchange_name = exchange_name
+        settings = AMQ::Settings.parse_amqp_url(amqp_url)
+        @connection = Bunny.new({
+                                    host: settings[:host],
+                                    user: settings[:user],
+                                    pass: settings[:pass],
+                                    port: settings[:port],
+                                    automatic_recovery: false,
+                                    logger: RailwayIpc.bunny_logger}.merge(options)
+        )
+      end
+
+      def publish(message, options = {})
+        exchange.publish(message, options) if exchange
+      end
+
+      def reply(message, from)
+        channel.default_exchange.publish(message, routing_key: from)
+      end
+
+      def subscribe(&block)
+        queue.subscribe(&block)
+      end
+
+      def check_for_message(timeout: 10, time_elapsed: 0, &block)
+        raise TimeoutError.new if time_elapsed >= timeout
+
+        block ||= ->(result) { result }
+
+        result = queue.pop
+        return block.call(*result) if result.compact.any?
+
+        sleep 1
+        check_for_message(timeout: timeout, time_elapsed: time_elapsed + 1, &block)
+      end
+
+      def connect
+        connection.start
+        @channel = connection.channel
+        self
+      end
+
+      def disconnect
+        channel.close
+        connection.close
+        self
+      end
+
+      def create_exchange(strategy: :fanout, options: {durable: true})
+        @exchange = Bunny::Exchange.new(connection.channel, :fanout, exchange_name, options)
+        self
+      end
+
+      def delete_exchange
+        exchange.delete if exchange
+        self
+      end
+
+      def create_queue(options = {durable: true})
+        @queue = @channel.queue(queue_name, options)
+        self
+      end
+
+      def bind_queue_to_exchange
+        queue.bind(exchange)
+        self
+      end
+
+      def delete_queue
+        queue.delete if queue
+        self
+      end
+    end
+  end
+end

data/lib/railway_ipc/rabbitmq/payload.rb

@@ -5,7 +5,11 @@ module RailwayIpc
 
       def self.encode(message)
         type = message.class.to_s
-        message = Base64.encode64(message.class.encode(message))
+        begin
+          message = Base64.encode64(message.class.encode(message))
+        rescue NoMethodError
+          raise RailwayIpc::InvalidProtobuf.new("Message #{message} is not a valid protobuf")
+        end
         new(type, message).to_json
       end
 
@@ -23,8 +27,8 @@ module RailwayIpc
 
       def to_json
         {
-          type: type,
-          encoded_message: message
+            type: type,
+            encoded_message: message
         }.to_json
       end
     end

data/lib/railway_ipc/rpc/client/client.rb

@@ -0,0 +1,104 @@
+require "railway_ipc/rpc/client/client_response_handlers"
+require "railway_ipc/rpc/concerns/publish_location_configurable"
+require "railway_ipc/rpc/concerns/error_adapter_configurable"
+require "railway_ipc/rpc/client/errors/timeout_error"
+
+module RailwayIpc
+  class Client
+    attr_accessor :response_message, :request_message
+    attr_reader :rabbit_connection, :message
+    extend RailwayIpc::RPC::PublishLocationConfigurable
+    extend RailwayIpc::RPC::ErrorAdapterConfigurable
+
+    def self.request(message)
+      new(message).request
+    end
+
+    def self.handle_response(response_type)
+      RPC::ClientResponseHandlers.instance.register(response_type)
+    end
+
+    def initialize(request_message, opts = { automatic_recovery: false }, rabbit_adapter: RailwayIpc::Rabbitmq::Adapter)
+      @rabbit_connection = rabbit_adapter.new(exchange_name: self.class.exchange_name, options: opts)
+      @request_message = request_message
+    end
+
+    def request(timeout = 10)
+      setup_rabbit_connection
+      attach_reply_queue_to_message
+      publish_message
+      await_response(timeout)
+      response_message
+    end
+
+    def registered_handlers
+      RailwayIpc::RPC::ClientResponseHandlers.instance.registered
+    end
+
+    def process_payload(response)
+      decoded_payload = decode_payload(response)
+      case decoded_payload.type
+      when *registered_handlers
+        @message = get_message_class(decoded_payload).decode(decoded_payload.message)
+        RailwayIpc.logger.info(message, "Handling response")
+        RailwayIpc::Response.new(message, success: true)
+      else
+        @message = LearnIpc::ErrorMessage.decode(decoded_payload.message)
+        raise RailwayIpc::UnhandledMessageError, "#{self.class} does not know how to handle #{decoded_payload.type}"
+      end
+    end
+
+    def setup_rabbit_connection
+      rabbit_connection
+        .connect
+        .create_exchange
+        .create_queue(auto_delete: true, exclusive: true)
+    end
+
+    def await_response(timeout)
+      rabbit_connection.check_for_message(timeout: timeout) do |_, _, payload|
+        self.response_message = process_payload(payload)
+      end
+    rescue RailwayIpc::Rabbitmq::Adapter::TimeoutError
+      error = self.class.rpc_error_adapter_class.error_message(TimeoutError.new, self.request_message)
+      self.response_message = RailwayIpc::Response.new(error, success: false)
+    rescue StandardError
+      self.response_message = RailwayIpc::Response.new(message, success: false)
+    ensure
+      rabbit_connection.disconnect
+    end
+
+    private
+
+    def log_exception(e, payload)
+      RailwayIpc.logger.log_exception(
+        feature: "railway_consumer",
+        error: e.class,
+        error_message: e.message,
+        payload: decode_for_error(e, payload),
+      )
+    end
+
+    def get_message_class(decoded_payload)
+      RailwayIpc::RPC::ClientResponseHandlers.instance.get(decoded_payload.type)
+    end
+
+    def decode_payload(response)
+      RailwayIpc::Rabbitmq::Payload.decode(response)
+    end
+
+    def attach_reply_queue_to_message
+      request_message.reply_to = rabbit_connection.queue.name
+    end
+
+    def publish_message
+      RailwayIpc.logger.info(request_message, "Sending request")
+      rabbit_connection.publish(RailwayIpc::Rabbitmq::Payload.encode(request_message), routing_key: "")
+    end
+
+    def decode_for_error(e, payload)
+      return e.message unless payload
+      self.class.rpc_error_adapter_class.error_message(payload, self.request_message)
+    end
+  end
+end

data/lib/railway_ipc/rpc/client/client_response_handlers.rb

@@ -0,0 +1,25 @@
+module RailwayIpc
+  module RPC
+    class ClientResponseHandlers
+      include Singleton
+
+      def registered
+        handler_map.keys
+      end
+
+      def register(response_message)
+        handler_map[response_message.to_s] = response_message
+      end
+
+      def get(response_message)
+        handler_map[response_message]
+      end
+
+      private
+
+      def handler_map
+        @handler_map ||= {}
+      end
+    end
+  end
+end

data/lib/railway_ipc/rpc/client/errors/timeout_error.rb

@@ -0,0 +1,5 @@
+module RailwayIpc
+  class Client
+    class TimeoutError < StandardError; end
+  end
+end

data/lib/railway_ipc/rpc/concerns/error_adapter_configurable.rb

@@ -0,0 +1,13 @@
+module RailwayIpc
+  module RPC
+    module ErrorAdapterConfigurable
+      def rpc_error_adapter(rpc_error_adapter)
+        @rpc_error_adapter = rpc_error_adapter
+      end
+
+      def rpc_error_adapter_class
+        @rpc_error_adapter
+      end
+    end
+  end
+end

data/lib/railway_ipc/rpc/concerns/message_observation_configurable.rb

@@ -0,0 +1,18 @@
+module RailwayIpc
+  module RPC
+    module MessageObservationConfigurable
+      def listen_to(exchange:, queue:)
+        @exchange_name = exchange
+        @queue_name = queue
+      end
+
+      def queue_name
+        @queue_name
+      end
+
+      def exchange_name
+        @exchange_name
+      end
+    end
+  end
+end

data/lib/railway_ipc/rpc/concerns/publish_location_configurable.rb

@@ -0,0 +1,13 @@
+module RailwayIpc
+  module RPC
+    module PublishLocationConfigurable
+      def publish_to(exchange:)
+        @exchange_name = exchange
+      end
+
+      def exchange_name
+        @exchange_name
+      end
+    end
+  end
+end