karafka 1.4.9 → 2.0.0.alpha1

data/lib/karafka/persistence/consumers.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-module Karafka
-  # Module used to provide a persistent cache layer for Karafka components that need to be
-  # shared inside of a same thread
-  module Persistence
-    # 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
-    class Consumers
-      # Thread.current scope under which we store consumers data
-      PERSISTENCE_SCOPE = :consumers
-
-      private_constant :PERSISTENCE_SCOPE
-
-      class << self
-        # @return [Hash] current thread's persistence scope hash with all the consumers
-        def current
-          Thread.current[PERSISTENCE_SCOPE] ||= Concurrent::Hash.new do |hash, key|
-            hash[key] = Concurrent::Hash.new
-          end
-        end
-
-        # Used to build (if block given) and/or fetch a current consumer instance that will be
-        #   used to process messages from a given topic and partition
-        # @param topic [Karafka::Routing::Topic] topic instance for which we might cache
-        # @param partition [Integer] number of partition for which we want to cache
-        # @return [Karafka::BaseConsumer] base consumer descendant
-        def fetch(topic, partition)
-          current[topic][partition] ||= topic.consumer.new(topic)
-        end
-
-        # Removes all persisted instances of consumers from the consumer cache
-        # @note This is used to reload consumers instances when code reloading in development mode
-        #   is present. This should not be used in production.
-        def clear
-          Thread
-            .list
-            .select { |thread| thread[PERSISTENCE_SCOPE] }
-            .each { |thread| thread[PERSISTENCE_SCOPE].clear }
-        end
-      end
-    end
-  end
-end

data/lib/karafka/persistence/topics.rb

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-
-module Karafka
-  module Persistence
-    # Local cache for routing topics
-    # We use it in order not to build string instances and remap incoming topic upon each
-    # message / message batches received
-    class Topics
-      # Thread.current scope under which we store topics data
-      PERSISTENCE_SCOPE = :topics
-
-      private_constant :PERSISTENCE_SCOPE
-
-      class << self
-        # @return [Concurrent::Hash] hash with all the topics from given groups
-        def current
-          Thread.current[PERSISTENCE_SCOPE] ||= Concurrent::Hash.new do |hash, key|
-            hash[key] = Concurrent::Hash.new
-          end
-        end
-
-        # @param group_id [String] group id for which we fetch a topic representation
-        # @param raw_topic_name [String] raw topic name (before remapping) for which we fetch a
-        #   topic representation
-        # @return [Karafka::Routing::Topics] remapped topic representation that can be used further
-        #   on when working with given parameters
-        def fetch(group_id, raw_topic_name)
-          current[group_id][raw_topic_name] ||= begin
-            # We map from incoming topic name, as it might be namespaced, etc.
-            # @see topic_mapper internal docs
-            mapped_topic_name = Karafka::App.config.topic_mapper.incoming(raw_topic_name)
-            Routing::Router.find("#{group_id}_#{mapped_topic_name}")
-          end
-        end
-
-        # Clears the whole topics cache for all the threads
-        # This is used for in-development code reloading as we need to get rid of all the
-        # preloaded and cached instances of objects to make it work
-        def clear
-          Thread
-            .list
-            .select { |thread| thread[PERSISTENCE_SCOPE] }
-            .each { |thread| thread[PERSISTENCE_SCOPE].clear }
-        end
-      end
-    end
-  end
-end

data/lib/karafka/responders/builder.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-module Karafka
-  # Responders namespace encapsulates all the internal responder implementation parts
-  module Responders
-    # Responders builder is used for finding (based on the consumer class name) a responder
-    # that match the consumer. We use it when user does not provide a responder inside routing,
-    # but he still names responder with the same convention (and namespaces) as consumer
-    #
-    # @example Matching responder exists
-    #   Karafka::Responder::Builder(NewEventsConsumer).build #=> NewEventsResponder
-    # @example Matching responder does not exist
-    #   Karafka::Responder::Builder(NewBuildsConsumer).build #=> nil
-    class Builder
-      # @param consumer_class [Karafka::BaseConsumer, nil] descendant of
-      #   Karafka::BaseConsumer
-      # @example Tries to find a responder that matches a given consumer. If nothing found,
-      #   will return nil (nil is accepted, because it means that a given consumer don't
-      #   pipe stuff further on)
-      def initialize(consumer_class)
-        @consumer_class = consumer_class
-      end
-
-      # Tries to figure out a responder based on a consumer class name
-      # @return [Class] Responder class (not an instance)
-      # @return [nil] or nil if there's no matching responding class
-      def build
-        Helpers::ClassMatcher.new(
-          @consumer_class,
-          from: 'Consumer',
-          to: 'Responder'
-        ).match
-      end
-    end
-  end
-end

data/lib/karafka/responders/topic.rb

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-module Karafka
-  module Responders
-    # Topic describes a single topic on which we want to respond with responding requirements
-    # @example Define topic (required by default)
-    #   Karafka::Responders::Topic.new(:topic_name, {}) #=> #<Karafka::Responders::Topic...
-    # @example Define optional topic
-    #   Karafka::Responders::Topic.new(:topic_name, required: false)
-    class Topic
-      # Name of the topic on which we want to respond
-      attr_reader :name
-
-      # @param name [Symbol, String] name of a topic on which we want to respond
-      # @param options [Hash] non-default options for this topic
-      # @return [Karafka::Responders::Topic] topic description object
-      def initialize(name, options)
-        @name = name.to_s
-        @options = options
-      end
-
-      # @return [Boolean] is this a required topic (if not, it is optional)
-      def required?
-        @options.key?(:required) ? @options[:required] : true
-      end
-
-      # @return [Boolean] was usage of this topic registered or not
-      def registered?
-        @options[:registered] == true
-      end
-
-      # @return [Class] Class to use to serialize messages for this topic
-      def serializer
-        @options[:serializer]
-      end
-
-      # @return [Boolean] do we want to use async producer. Defaults to false as the sync producer
-      #   is safer and introduces less problems
-      def async?
-        @options.key?(:async) ? @options[:async] : false
-      end
-
-      # @return [Hash] hash with this topic attributes and options
-      def to_h
-        {
-          name: name,
-          required: required?,
-          registered: registered?,
-          serializer: serializer,
-          async: async?
-        }
-      end
-    end
-  end
-end

data/lib/karafka/routing/topic_mapper.rb

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-module Karafka
-  module Routing
-    # Default topic mapper that does not remap things
-    # Mapper can be used for Kafka providers that require namespaced topic names. Instead of being
-    # provider dependent, we can then define mapper and use internally "pure" topic names in
-    # routes and responders
-    #
-    # @example Mapper for mapping prefixed topics
-    #   class MyMapper
-    #     PREFIX = "my_user_name."
-    #
-    #     def incoming(topic)
-    #       topic.to_s.gsub(PREFIX, '')
-    #     end
-    #
-    #     def outgoing(topic)
-    #       "#{PREFIX}#{topic}"
-    #     end
-    #   end
-    #
-    # @example Mapper for replacing "." with "_" in topic names
-    #   class MyMapper
-    #     PREFIX = "my_user_name."
-    #
-    #     def incoming(topic)
-    #       topic.to_s.gsub('.', '_')
-    #     end
-    #
-    #     def outgoing(topic)
-    #       topic.to_s.gsub('_', '.')
-    #     end
-    #   end
-    class TopicMapper
-      # @param topic [String, Symbol] topic
-      # @return [String, Symbol] same topic as on input
-      # @example
-      #   incoming('topic_name') #=> 'topic_name'
-      def incoming(topic)
-        topic
-      end
-
-      # @param topic [String, Symbol] topic
-      # @return [String, Symbol] same topic as on input
-      # @example
-      #   outgoing('topic_name') #=> 'topic_name'
-      def outgoing(topic)
-        topic
-      end
-    end
-  end
-end

data/lib/karafka/serialization/json/serializer.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-module Karafka
-  # Module for all supported by default serialization and deserialization ways
-  module Serialization
-    module Json
-      # Default Karafka Json serializer for serializing data
-      class Serializer
-        # @param content [Object] any object that we want to convert to a json string
-        # @return [String] Valid JSON string containing serialized data
-        # @raise [Karafka::Errors::SerializationError] raised when we don't have a way to
-        #   serialize provided data to json
-        # @note When string is passed to this method, we assume that it is already a json
-        #   string and we don't serialize it again. This allows us to serialize data before
-        #   it is being forwarded to this serializer if we want to have a custom (not that simple)
-        #   json serialization
-        #
-        # @example From an ActiveRecord object
-        #   Serializer.call(Repository.first) #=> "{\"repository\":{\"id\":\"04b504e0\"}}"
-        # @example From a string (no changes)
-        #   Serializer.call("{\"a\":1}") #=> "{\"a\":1}"
-        def call(content)
-          return content if content.is_a?(String)
-          return content.to_json if content.respond_to?(:to_json)
-
-          raise Karafka::Errors::SerializationError, content
-        end
-      end
-    end
-  end
-end

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

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-module Karafka
-  module Setup
-    # Configurators are used to post setup some of the components of Karafka after the core
-    # framework is initialized
-    module Configurators
-      # Class responsible for setting up WaterDrop configuration
-      class WaterDrop
-        # Sets up a WaterDrop settings
-        # @param config [Karafka::Setup::Config] Config we can user to setup things
-        # @note This will also inject Karafka monitor as a default monitor into WaterDrop,
-        #   so we have the same monitor within whole Karafka framework (same with logger)
-        def call(config)
-          ::WaterDrop.setup do |water_config|
-            water_config.deliver = true
-
-            config.to_h.reject { |k, _v| k == :kafka }.each do |k, v|
-              key_assignment = :"#{k}="
-              next unless water_config.respond_to?(key_assignment)
-
-              water_config.public_send(key_assignment, v)
-            end
-
-            config.kafka.to_h.each do |k, v|
-              key_assignment = :"#{k}="
-              next unless water_config.kafka.respond_to?(key_assignment)
-
-              water_config.kafka.public_send(key_assignment, v)
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/karafka/templates/application_responder.rb.erb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-# Application responder from which all Karafka responders should inherit
-# You can rename it if it would conflict with your current code base (in case you're integrating
-# Karafka with other frameworks)
-class ApplicationResponder < Karafka::BaseResponder
-  # This method needs to be implemented in each of the responders
-  # def respond(data)
-  #   respond_to :topic, data.to_json
-  # end
-end