railway-ipc 0.1.4 → 1.0.1

data/lib/railway_ipc/errors.rb

@@ -1 +1,9 @@
-class RailwayIpc::InvalidProtobuf < StandardError; end
+# frozen_string_literal: true
+
+# rubocop:disable Style/ClassAndModuleChildren
+class RailwayIpc::Error < StandardError; end
+class RailwayIpc::InvalidProtobuf < RailwayIpc::Error; end
+class RailwayIpc::FailedToStoreOutgoingMessage < RailwayIpc::Error; end
+class RailwayIpc::IncomingMessage::ParserError < RailwayIpc::Error; end
+class RailwayIpc::IncomingMessage::InvalidMessage < RailwayIpc::Error; end
+# rubocop:enable Style/ClassAndModuleChildren

data/lib/railway_ipc/handler.rb

@@ -1,6 +1,7 @@
+# frozen_string_literal: true
+
 module RailwayIpc
   class Handler
-    include Sneakers::Worker
     class << self
       attr_reader :block
     end
@@ -10,14 +11,12 @@ module RailwayIpc
     end
 
     def handle(message)
-      RailwayIpc.logger.info(message, "Handling message")
+      RailwayIpc.logger.info(message, 'Handling message')
       response = self.class.block.call(message)
       if response.success?
-        RailwayIpc.logger.info(message, "Successfully handled message")
-        ack!
+        RailwayIpc.logger.info(message, 'Successfully handled message')
       else
-        RailwayIpc.logger.error(message, "Failed to handle message")
-        ack!
+        RailwayIpc.logger.error(message, 'Failed to handle message')
       end
 
       response

data/lib/railway_ipc/handler_manifest.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RailwayIpc
   class HandlerManifest
     attr_reader :message, :handler

data/lib/railway_ipc/handler_store.rb

@@ -1,7 +1,10 @@
+# frozen_string_literal: true
+
 require 'railway_ipc/handler_manifest'
 module RailwayIpc
   class HandlerStore
     attr_reader :handler_map
+
     def initialize
       @handler_map = {}
     end

data/lib/railway_ipc/incoming_message.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module RailwayIpc
+  class IncomingMessage
+    attr_reader :type, :payload, :parsed_payload, :errors
+
+    def initialize(payload)
+      @parsed_payload = JSON.parse(payload)
+      @type = parsed_payload['type']
+      @payload = payload
+      @errors = {}
+    rescue JSON::ParserError => e
+      raise RailwayIpc::IncomingMessage::ParserError.new(e)
+    end
+
+    def uuid
+      decoded.uuid
+    end
+
+    def user_uuid
+      decoded.user_uuid
+    end
+
+    def correlation_id
+      decoded.correlation_id
+    end
+
+    def valid?
+      errors[:uuid] = 'uuid is required' unless uuid.present?
+      errors[:correlation_id] = 'correlation_id is required' unless correlation_id.present?
+      errors.none?
+    end
+
+    def decoded
+      @decoded ||=
+        begin
+          protobuf_msg = Base64.decode64(parsed_payload['encoded_message'])
+          decoder = Kernel.const_get(type)
+          decoder.decode(protobuf_msg)
+        rescue Google::Protobuf::ParseError => e
+          raise RailwayIpc::IncomingMessage::ParserError.new(e)
+        rescue NameError
+          RailwayIpc::Messages::Unknown.decode(protobuf_msg)
+        end
+    end
+
+    def stringify_errors
+      errors.values.join(', ')
+    end
+  end
+end

data/lib/railway_ipc/logger.rb

@@ -1,6 +1,7 @@
+# frozen_string_literal: true
+
 module RailwayIpc
   class Logger
-
     attr_reader :logger
 
     def initialize(logger)
@@ -23,8 +24,8 @@ module RailwayIpc
       logger.error("[#{message_header(message)}] #{statement}")
     end
 
-    def log_exception(e)
-      logger.error(e)
+    def log_exception(exception)
+      logger.error(exception)
     end
 
     def message_header(message)

data/lib/railway_ipc/models/consumed_message.rb

@@ -1,29 +1,56 @@
+# frozen_string_literal: true
+
 module RailwayIpc
   class ConsumedMessage < ActiveRecord::Base
-    STATUSES = {
-      success: 'success',
-      processing: 'processing',
-      unknown_message_type: 'unknown_message_type',
-      failed_to_process: 'failed_to_process'
-    }
+    STATUS_SUCCESS = 'success'
+    STATUS_PROCESSING = 'processing'
+    STATUS_IGNORED = 'ignored'
+    STATUS_UNKNOWN_MESSAGE_TYPE = 'unknown_message_type'
+    STATUS_FAILED_TO_PROCESS = 'failed_to_process'
+
+    VALID_STATUSES = [
+      STATUS_SUCCESS,
+      STATUS_PROCESSING,
+      STATUS_IGNORED,
+      STATUS_UNKNOWN_MESSAGE_TYPE,
+      STATUS_FAILED_TO_PROCESS
+    ].freeze
 
     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]
+    validates :status, inclusion: { in: VALID_STATUSES }
+
+    def self.create_processing(consumer, incoming_message)
+      # rubocop:disable Style/RedundantSelf
+      self.create!(
+        uuid: incoming_message.uuid,
+        status: STATUS_PROCESSING,
+        message_type: incoming_message.type,
+        user_uuid: incoming_message.user_uuid,
+        correlation_id: incoming_message.correlation_id,
+        queue: consumer.queue_name,
+        exchange: consumer.exchange_name,
+        encoded_message: incoming_message.payload
+      )
+      # rubocop:enable Style/RedundantSelf
     end
 
-    def encoded_protobuf=(encoded_protobuf)
-      self.encoded_message = Base64.encode64(encoded_protobuf)
+    def update_with_lock(job)
+      with_lock('FOR UPDATE NOWAIT') do
+        job.run
+        self.status = job.status
+        save
+      end
     end
 
-    def decoded_message
-      @decoded_message ||= decode_message
+    def processed?
+      # rubocop:disable Style/RedundantSelf
+      self.status == STATUS_SUCCESS
+      # rubocop:enable Style/RedundantSelf
     end
 
     private
@@ -31,18 +58,5 @@ module RailwayIpc
     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

@@ -1,20 +1,22 @@
+# frozen_string_literal: true
+
 module RailwayIpc
   class PublishedMessage < ActiveRecord::Base
     self.table_name = 'railway_ipc_published_messages'
-    self.primary_key = "uuid"
+    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
+      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
 

data/lib/railway_ipc/publisher.rb

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 require 'singleton'
 
 module RailwayIpc
-  class Publisher < Sneakers::Publisher
+  class SingletonPublisher < Sneakers::Publisher
     include ::Singleton
 
     def self.exchange(exchange)
@@ -10,6 +12,7 @@ module RailwayIpc
 
     def self.exchange_name
       raise 'Subclass must set the exchange' unless @exchange_name
+
       @exchange_name
     end
 
@@ -18,7 +21,11 @@ module RailwayIpc
     end
 
     def publish(message, published_message_store=RailwayIpc::PublishedMessage)
+      RailwayIpc.logger.logger.warn('DEPRECATED: Use new PublisherInstance class')
+      ensure_message_uuid(message)
+      ensure_correlation_id(message)
       RailwayIpc.logger.info(message, 'Publishing message')
+
       result = super(RailwayIpc::Rabbitmq::Payload.encode(message))
       published_message_store.store_message(self.class.exchange_name, message)
       result
@@ -26,5 +33,55 @@ module RailwayIpc
       RailwayIpc.logger.error(message, 'Invalid protobuf')
       raise e
     end
+
+    private
+
+    def ensure_message_uuid(message)
+      message.uuid = SecureRandom.uuid if message.uuid.blank?
+      message
+    end
+
+    def ensure_correlation_id(message)
+      message.correlation_id = SecureRandom.uuid if message.correlation_id.blank?
+      message
+    end
+  end
+end
+
+module RailwayIpc
+  class Publisher < Sneakers::Publisher
+    attr_reader :exchange_name, :message_store
+
+    def initialize(opts={})
+      @exchange_name = opts.fetch(:exchange_name)
+      @message_store = opts.fetch(:message_store, RailwayIpc::PublishedMessage)
+      connection = opts.fetch(:connection, nil)
+      options = {
+        exchange: exchange_name,
+        connection: connection,
+        exchange_type: :fanout
+      }.compact
+      super(options)
+    end
+
+    # rubocop:disable Metrics/AbcSize
+    def publish(message)
+      message.uuid = SecureRandom.uuid if message.uuid.blank?
+      message.correlation_id = SecureRandom.uuid if message.correlation_id.blank?
+      RailwayIpc.logger.info(message, 'Publishing message')
+
+      stored_message = message_store.store_message(exchange_name, message)
+      super(RailwayIpc::Rabbitmq::Payload.encode(message))
+    rescue RailwayIpc::InvalidProtobuf => e
+      RailwayIpc.logger.error(message, 'Invalid protobuf')
+      raise e
+    rescue ActiveRecord::RecordInvalid => e
+      RailwayIpc.logger.error(message, 'Failed to store outgoing message')
+      raise RailwayIpc::FailedToStoreOutgoingMessage.new(e)
+    rescue StandardError => e
+      stored_message&.destroy
+      raise e
+    end
+    # rubocop:enable Metrics/AbcSize
   end
 end

data/lib/railway_ipc/rabbitmq/adapter.rb

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 module RailwayIpc
   module Rabbitmq
     class Adapter
-      class TimeoutError < StandardError;
-      end
+      class TimeoutError < StandardError; end
       extend Forwardable
       attr_reader :connection, :exchange, :exchange_name, :queue, :queue_name, :channel
+
       def_delegators :connection,
                      :automatically_recover?,
                      :connected?,
@@ -14,22 +16,26 @@ module RailwayIpc
                      :port,
                      :user
 
-      def initialize(amqp_url: ENV["RAILWAY_RABBITMQ_CONNECTION_URL"], exchange_name:, queue_name: '', options: {})
+      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)
+        vhost = settings[:vhost] || '/'
         @connection = Bunny.new({
-                                    host: settings[:host],
-                                    user: settings[:user],
-                                    pass: settings[:pass],
-                                    port: settings[:port],
-                                    automatic_recovery: false,
-                                    logger: RailwayIpc.bunny_logger}.merge(options)
-        )
+          host: settings[:host],
+          user: settings[:user],
+          pass: settings[:pass],
+          port: settings[:port],
+          vhost: vhost,
+          automatic_recovery: false,
+          logger: RailwayIpc.bunny_logger
+        }.merge(options))
       end
 
-      def publish(message, options = {})
+      def publish(message, options={})
+        # rubocop:disable Style/SafeNavigation
         exchange.publish(message, options) if exchange
+        # rubocop:enable Style/SafeNavigation
       end
 
       def reply(message, from)
@@ -64,17 +70,19 @@ module RailwayIpc
         self
       end
 
-      def create_exchange(strategy: :fanout, options: {durable: true})
-        @exchange = Bunny::Exchange.new(connection.channel, :fanout, exchange_name, options)
+      def create_exchange(strategy: :fanout, options: { durable: true })
+        @exchange = Bunny::Exchange.new(connection.channel, strategy, exchange_name, options)
         self
       end
 
       def delete_exchange
+        # rubocop:disable Style/SafeNavigation
         exchange.delete if exchange
+        # rubocop:enable Style/SafeNavigation
         self
       end
 
-      def create_queue(options = {durable: true})
+      def create_queue(options={ durable: true })
         @queue = @channel.queue(queue_name, options)
         self
       end
@@ -85,7 +93,9 @@ module RailwayIpc
       end
 
       def delete_queue
+        # rubocop:disable Style/SafeNavigation
         queue.delete if queue
+        # rubocop:enable Style/SafeNavigation
         self
       end
     end

data/lib/railway_ipc/rabbitmq/payload.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RailwayIpc
   module Rabbitmq
     class Payload
@@ -7,6 +9,7 @@ module RailwayIpc
         type = message.class.to_s
         begin
           message = Base64.encode64(message.class.encode(message))
+        # TODO: also need to rescue Google::Protobuf::TypeError
         rescue NoMethodError
           raise RailwayIpc::InvalidProtobuf.new("Message #{message} is not a valid protobuf")
         end
@@ -15,8 +18,8 @@ module RailwayIpc
 
       def self.decode(message)
         message = JSON.parse(message)
-        type = message["type"]
-        message = Base64.decode64(message["encoded_message"])
+        type = message['type']
+        message = Base64.decode64(message['encoded_message'])
         new(type, message)
       end
 
@@ -25,12 +28,14 @@ module RailwayIpc
         @message = message
       end
 
+      # rubocop:disable Lint/ToJSON
       def to_json
         {
-            type: type,
-            encoded_message: message
+          type: type,
+          encoded_message: message
         }.to_json
       end
+      # rubocop:enable Lint/ToJSON
     end
   end
 end