karafka 1.0.0 → 1.2.0

data/lib/karafka/params/params.rb

@@ -1,101 +0,0 @@
-# frozen_string_literal: true
-
-module Karafka
-  # Params namespace encapsulating all the logic that is directly related to params handling
-  module Params
-    # Class-wrapper for hash with indifferent access with additional lazy loading feature
-    # It provides lazy loading not only until the first usage, but also allows us to skip
-    # using parser until we execute our logic. That way we can operate with
-    # heavy-parsing data without slowing down the whole application.
-    class Params < HashWithIndifferentAccess
-      # Kafka::FetchedMessage attributes that we want to use inside of params
-      KAFKA_MESSAGE_ATTRIBUTES = %i[
-        value
-        partition
-        offset
-        key
-      ].freeze
-
-      class << self
-        # We allow building instances only via the #build method
-
-        # @param message [Kafka::FetchedMessage, Hash] message that we get out of Kafka
-        #   in case of building params inside main Karafka process in
-        #   Karafka::Connection::Consumer, or a hash when we retrieve data that is already parsed
-        # @param parser [Class] parser class that we will use to unparse data
-        # @return [Karafka::Params::Params] Karafka params object not yet used parser for
-        #   retrieving data that we've got from Kafka
-        # @example Build params instance from a hash
-        #   Karafka::Params::Params.build({ key: 'value' }) #=> params object
-        # @example Build params instance from a Kafka::FetchedMessage object
-        #   Karafka::Params::Params.build(message) #=> params object
-        def build(message, parser)
-          # Hash case happens inside backends that interchange data
-          if message.is_a?(Hash)
-            new(parser: parser).send(:merge!, message)
-          else
-            # This happens inside Kafka::FetchedMessagesProcessor
-            new(
-              parser: parser,
-              parsed: false,
-              received_at: Time.now
-            ).tap do |instance|
-              KAFKA_MESSAGE_ATTRIBUTES.each do |attribute|
-                instance[attribute] = message.send(attribute)
-              end
-
-              # When we get raw messages, they might have a topic, that was modified by a
-              # topic mapper. We need to "reverse" this change and map back to the non-modified
-              # format, so our internal flow is not corrupted with the mapping
-              instance[:topic] = Karafka::App.config.topic_mapper.incoming(message.topic)
-            end
-          end
-        end
-      end
-
-      # @return [Karafka::Params::Params] this will trigger parser execution. If we decide to
-      #   retrieve data, parser will be executed to parse data. Output of parsing will be merged
-      #   to the current object. This object will be also marked as already parsed, so we won't
-      #   parse it again.
-      def retrieve!
-        return self if self[:parsed]
-
-        merge!(parse(delete(:value)))
-      end
-
-
-      private
-
-      # Overwritten merge! method - it behaves differently for keys that are the same in our hash
-      #  and in a other_hash - it will not replace keys that are the same in our hash
-      #  and in the other one
-      # @param other_hash [Hash, HashWithIndifferentAccess] hash that we want to merge into current
-      # @return [Karafka::Params::Params] our parameters hash with merged values
-      # @example Merge with hash without same keys
-      #   new(a: 1, b: 2).merge!(c: 3) #=> { a: 1, b: 2, c: 3 }
-      # @example Merge with hash with same keys (symbol based)
-      #   new(a: 1).merge!(a: 2) #=> { a: 1 }
-      # @example Merge with hash with same keys (string based)
-      #   new(a: 1).merge!('a' => 2) #=> { a: 1 }
-      # @example Merge with hash with same keys (current string based)
-      #   new('a' => 1).merge!(a: 2) #=> { a: 1 }
-      def merge!(other_hash)
-        super(other_hash) { |_key, base_value, _new_value| base_value }
-      end
-
-      # @param value [String] Raw data that we want to parse using controller's parser
-      # @note If something goes wrong, it will return raw data in a hash with a message key
-      # @return [Hash] parsed data or a hash with message key containing raw data if something
-      #   went wrong during parsing
-      def parse(value)
-        self[:parser].parse(value)
-        # We catch both of them, because for default JSON - we use JSON parser directly
-      rescue ::Karafka::Errors::ParserError => e
-        Karafka.monitor.notice_error(self.class, e)
-        raise e
-      ensure
-        self[:parsed] = true
-      end
-    end
-  end
-end

data/lib/karafka/persistence.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-module Karafka
-  # Module used to provide a persistent cache across batch requests for a given
-  # topic and partition to store some additional details when the persistent mode
-  # for a given topic is turned on
-  module Persistence
-    # @param topic [Karafka::Routing::Topic] topic instance for which we might cache
-    # @param partition [Integer] number of partition for which we want to cache
-    # @param resource [Symbol] name of the resource that we want to store
-    def self.fetch(topic, partition, resource)
-      return yield unless topic.persistent
-      Thread.current[topic.id] ||= {}
-      Thread.current[topic.id][partition] ||= {}
-      Thread.current[topic.id][partition][resource] ||= yield
-    end
-  end
-end

data/lib/karafka/setup/configurators/celluloid.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-module Karafka
-  module Setup
-    class Configurators
-      # Class responsible for setting up Celluloid settings
-      class Celluloid < Base
-        # How many seconds should we wait for actors (listeners) before forcefully shutting them
-        SHUTDOWN_TIME = 30
-
-        # Sets up a Karafka logger as celluloid logger
-        def setup
-          ::Celluloid.logger = ::Karafka.logger
-          # This is just a precaution - it should automatically close the current
-          # connection and shutdown actor - but in case it didn't (hanged, etc)
-          # we will kill it after waiting for some time
-          ::Celluloid.shutdown_timeout = SHUTDOWN_TIME
-        end
-      end
-    end
-  end
-end