kafka 0.5.0

data/lib/kafka/ffi/admin/config_entry.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require "kafka/ffi/opaque_pointer"
+
+module Kafka::FFI::Admin
+  class ConfigEntry < ::Kafka::FFI::OpaquePointer
+    # Returns the configuration property name
+    #
+    # @return [String] Configuration property name
+    def name
+      ::Kafka::FFI.rd_kafka_ConfigEntry_name(self)
+    end
+
+    # Returns the configuration value
+    #
+    # @return [nil] Value is sensitive or unset
+    # @return [String] Configuration value
+    def value
+      ::Kafka::FFI.rd_kafka_ConfigEntry_value(self)
+    end
+
+    # Returns the source of the config
+    #
+    # @see ffi.rb config_source
+    #
+    # @return [Symbol] Source of the config
+    def source
+      ::Kafka::FFI.rd_kafka_ConfigEntry_source(self)
+    end
+
+    # List of synonyms for the config entry
+    #
+    # @return [nil] ConfigEntry was not returned by DescribeConfigs
+    # @return [Array<ConfigEntry>] Set of synonyms for the config
+    def synonyms
+      count = ::FFI::MemoryPointer.new(:pointer)
+
+      entries = ::Kafka::FFI.rd_kafka_ConfigEntry_synonyms(self, count)
+      if entries.null?
+        return nil
+      end
+
+      entries.read_array_of_pointer(count.read(:size_t)).map do |ptr|
+        ConfigEntry.new(ptr)
+      end
+    ensure
+      count.free
+    end
+
+    # rubocop:disable Naming/PredicateName
+
+    # Returns true if the config property is read-only on the broker. Only
+    # returns a boolean when called on a ConfigEntry from a DescribeConfigs
+    # result.
+    #
+    # @return [nil] ConfigEntry was not returned by DescribeConfigs
+    # @return [Boolean] If the property is read only
+    def is_read_only
+      val = ::Kafka::FFI.rd_kafka_ConfigEntry_is_read_only(self)
+      val == -1 ? nil : val == 1
+    end
+
+    # Returns true if the config property is set to its default. Only returns a
+    # boolean when use on a ConfigEntry from a DescribeConfigs result.
+    #
+    # @return [nil] ConfigEntry was not returned by DescribeConfigs
+    # @return [Boolean] If the property is set to default
+    def is_default
+      val = ::Kafka::FFI.rd_kafka_ConfigEntry_is_default(self)
+      val == -1 ? nil : val == 1
+    end
+
+    # Returns true if the config property is sensitive. Only returns a boolean
+    # when use on a ConfigEntry from a DescribeConfigs result.
+    #
+    # @return [nil] ConfigEntry was not returned by DescribeConfigs
+    # @return [Boolean] If the property is set to default
+    def is_sensitive
+      val = ::Kafka::FFI.rd_kafka_ConfigEntry_is_sensitive(self)
+      val == -1 ? nil : val == 1
+    end
+
+    # Returns true if the entry is a synonym for another config option.
+    #
+    # @return [Boolean]
+    def is_synonym
+      ::Kafka::FFI.rd_kafka_ConfigEntry_is_sensitive(self) == 1
+    end
+
+    # rubocop:enable Naming/PredicateName
+
+    alias read_only? is_read_only
+    alias default?   is_default
+    alias sensitive? is_sensitive
+    alias synonym?   is_synonym
+  end
+end

data/lib/kafka/ffi/admin/config_resource.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require "kafka/ffi/opaque_pointer"
+
+module Kafka::FFI::Admin
+  class ConfigResource < ::Kafka::FFI::OpaquePointer
+    # Create a new ConfigResource
+    #
+    # @example Build ConfigResource for a topic
+    #   ConfigResource.new(:topic, "events")
+    #
+    # @example Build ConfigResource for a broker
+    #   ConfigResource.new(:broker, broker_id)
+    #
+    # @see ffi.rb resource_type enum
+    #
+    # @param type [:broker, :topic, :group] Type of config resource
+    # @param name [String] Name of resource (broker_id, topic name, etc...)
+    def self.new(type, name)
+      ::Kafka::FFI.rd_kafka_ConfigResource_new(type, name)
+    end
+
+    # Set configuration name and value pair
+    #
+    # @note This will overwrite the current value
+    #
+    # @param name [String] Config option name
+    # @param value [nil] Revert config to default
+    # @param value [String] Value to set config option to
+    #
+    # @raise [Kafka::ResponseError] Invalid input
+    def set_config(name, value)
+      err = ::Kafka::FFI.rd_kafka_ConfigResource_set_config(self, name, value)
+      if err != :ok
+        raise ::Kafka::ResponseError, err
+      end
+
+      nil
+    end
+
+    # Retrieve an array of ConfigEntry from the resource.
+    #
+    # @return [Array<ConfigEntry>] Config entries for the resource
+    def configs
+      count = ::FFI::MemoryPointer.new(:pointer)
+
+      configs = ::Kafka::FFI.rd_kafka_ConfigResource_configs(self, count)
+      if configs.null?
+        return nil
+      end
+
+      configs = configs.read_array_of_pointer(count.read(:size_t))
+      configs.map! { |p| ConfigEntry.from_native(p, nil) }
+    ensure
+      count.free
+    end
+
+    # Returns the type of the resource
+    #
+    # @see ffi.rb resource_type enum
+    #
+    # @return [Symbol] Type of config resource
+    def type
+      ::Kafka::FFI.rd_kafka_ConfigResource_type(self)
+    end
+
+    # Returns the config option name
+    #
+    # @return [String] Name of the config
+    def name
+      ::Kafka::FFI.rd_kafka_ConfigResource_name(self)
+    end
+
+    # Returns the response error received from an AlterConfigs request.
+    #
+    # @note Only set when ConfigResource was returned from AlterConfigs.
+    #
+    # @return [nil] No error
+    # @return [Kafka::ResponseError] AlterConfig request error
+    def error
+      err = ::Kafka::FFI.rd_kafka_ConfigResource_error(self)
+      err == :ok ? nil : ::Kafka::ResponseError.new(err)
+    end
+
+    # Returns a string describing the error received for this resource during
+    # an AlterConfigs request.
+    #
+    # @note Only set when ConfigResource was returned from AlterConfigs.
+    #
+    # @return [nil] No error
+    # @return [String] AlterConfig request error
+    def error_string
+      ::Kafka::FFI.rd_kafka_ConfigResource_error_string(self)
+    end
+
+    # Destroy the ConfigResource, returning its resources back to the system.
+    def destroy
+      ::Kafka::FFI.rd_kafka_ConfigResource_destroy(self)
+    end
+  end
+end

data/lib/kafka/ffi/admin/delete_topic.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "kafka/ffi/opaque_pointer"
+
+module Kafka::FFI::Admin
+  class DeleteTopic < ::Kafka::FFI::OpaquePointer
+    def self.new(topic)
+      ::Kafka::FFI.rd_kafka_DeleteTopic_new(topic)
+    end
+
+    # Release the resources used by the DeleteTopic. It is the application's
+    # responsibility to call #destroy when it is done with the object.
+    def destroy
+      if !pointer.null?
+        ::Kafka::FFI.rd_kafka_DeleteTopic_destroy(self)
+      end
+    end
+  end
+end

data/lib/kafka/ffi/admin/new_partitions.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require "kafka/ffi/opaque_pointer"
+
+module Kafka::FFI::Admin
+  class NewPartitions < ::Kafka::FFI::OpaquePointer
+    # Allocates a new NewPartitions request for passing to CreatePartitions to
+    # increase the number of partitions for an existing topic.
+    #
+    # @param topic [String] Name of the topic to adjust
+    # @param partition_count [Integer] Increase the number of partitions to
+    #   this value.
+    #
+    # @raise [ArgumentError] Invalid topic or partition_count
+    def self.new(topic, partition_count)
+      error = ::FFI::MemoryPointer.new(:char, 512)
+
+      if topic.nil? || topic.empty?
+        # Check in Ruby as nil will cause a segfault as of 1.3.0
+        raise ArgumentError, "topic name is required"
+      end
+
+      req = ::Kafka::FFI.rd_kafka_NewPartitions_new(topic, partition_count, error, error.size)
+      if req.nil?
+        raise ArgumentError, error.read_string
+      end
+
+      req
+    ensure
+      error.free
+    end
+
+    # Assign the partition by index, relative to existing partition count, to
+    # be replicated on the set of brokers specified by broker_ids. If called,
+    # this method must be called consecutively for each new partition being
+    # created starting with an index of 0.
+    #
+    # @note This MUST either be called for all new partitions or not at all.
+    #
+    # @example Assigning broker assignments for two new partitions
+    #   # Topic already has 3 partitions and replication factor of 2.
+    #   request = NewPartitions("topic", 5)
+    #   request.set_replica_assignment(0, [1001, 1003])
+    #   request.set_replica_assignment(1, [1002, 1001])
+    #
+    # @param partition_index [Integer] Index of the new partition being
+    #   created.
+    # @param broker_ids [Array<Integer>] Broker IDs to be assigned a replica of
+    #   the topic. Number of broker ids should match the topic replication
+    #   factor.
+    #
+    # @raise [Kafka::ResponseError] Arguments were invalid or partition_index
+    #   was not called consecutively.
+    def set_replica_assignment(partition_index, broker_ids)
+      error = ::FFI::MemoryPointer.new(:char, 512)
+
+      broker_list = ::FFI::MemoryPointer.new(:int32, broker_ids.length)
+      broker_list.write_array_of_int32(broker_ids)
+
+      resp = ::Kafka::FFI.rd_kafka_NewPartitions_set_replica_assignment(self, partition_index, broker_list, broker_ids.length, error, error.size)
+      if resp != :ok
+        raise ::Kafka::ResponseError.new(resp, error.read_string)
+      end
+
+      nil
+    ensure
+      error.free
+    end
+
+    # Destroy and free the NewPartitions, releasing it's resources back to the
+    # system.
+    def destroy
+      ::Kafka::FFI.rd_kafka_NewPartitions_destroy(self)
+    end
+  end
+end
+

data/lib/kafka/ffi/admin/new_topic.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require "kafka/ffi/error"
+require "kafka/ffi/opaque_pointer"
+
+module Kafka::FFI::Admin
+  class NewTopic < ::Kafka::FFI::OpaquePointer
+    # Create a new NewTopic for passing to Admin::Client#create_topics. It is
+    # the application's responsiblity to call #destroy when done with the
+    # object.
+    #
+    # @param name [String] Name of the topic to create
+    # @param partitions [Integer] Number of partitions in the topic
+    #
+    # @param replication_factor [Integer] Default replication factor for the
+    #   topic's partitions.
+    # @param replication_factor [-1] Value from #set_replica_assignment will be
+    #   used.
+    #
+    # @raise [ArgumentError] Parameters were invalid
+    #
+    # @return [NewTopic]
+    def self.new(name, partitions, replication_factor)
+      # Allocate memory for the error message
+      error = ::FFI::MemoryPointer.new(:char, 512)
+
+      if name.nil? || name.empty?
+        raise ArgumentError, " name is required and cannot be blank"
+      end
+
+      obj = ::Kafka::FFI.rd_kafka_NewTopic_new(name, partitions, replication_factor, error, error.size)
+      if obj.nil?
+        raise ArgumentError, error.read_string
+      end
+
+      obj
+    ensure
+      error.free
+    end
+
+    # Set the broker assignment for partition to the replica set in broker_ids.
+    #
+    # @note If called, must be call consecutively for each partition, starting
+    #   at 0.
+    # @note new must have been called with replication_factor of -1
+    #
+    # @param partition [Integer] Partition to assign to the brokers
+    # @param broker_ids [Integer, Array<Integer>] Brokers that will be assigned
+    #   the partition for the topic.
+    #
+    # @raise [Kafka::ResponseError] Error occurred setting config
+    def set_replica_assignment(partition, broker_ids)
+      broker_ids = Array(broker_ids)
+
+      brokers = ::FFI::MemoryPointer.new(:int32, broker_ids.size)
+      error   = ::FFI::MemoryPointer.new(:char, 512)
+
+      brokers.write_array_of_int32(broker_ids)
+
+      err = ::Kafka::FFI.rd_kafka_NewTopic_set_replica_assignment(self, partition, brokers, broker_ids.size, error, error.size)
+      if err != :ok
+        raise ::Kafka::ResponseError, err
+      end
+
+      nil
+    ensure
+      error.free
+      brokers.free
+    end
+
+    # Set the broker side topic configuration name/value pair.
+    #
+    # @raise [Kafka::ResponseError] Arguments were invalid
+    def set_config(name, value)
+      err = ::Kafka::FFI.rd_kafka_NewTopic_set_config(self, name, value)
+      if err != :ok
+        raise ::Kafka::ResponseError, err
+      end
+
+      nil
+    end
+
+    # Release the memory held by NewTopic back to the system. This must be
+    # called by the application when it is done with the object.
+    def destroy
+      if !pointer.null?
+        ::Kafka::FFI.rd_kafka_NewTopic_destroy(self)
+      end
+    end
+  end
+end

data/lib/kafka/ffi/admin/result.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Kafka::FFI::Admin
+  class Result < Array
+    def initialize(event)
+      @event = event
+
+      super(get_results(event))
+    end
+
+    def get_results(event)
+      count = ::FFI::MemoryPointer.new(:size_t)
+
+      klass, results =
+        case event.type
+        when :create_topics
+          [
+            TopicResult,
+            ::Kafka::FFI.rd_kafka_CreateTopics_result_topics(event, count),
+          ]
+        when :delete_topics
+          [
+            TopicResult,
+            ::Kafka::FFI.rd_kafka_DeleteTopics_result_topics(event, count),
+          ]
+        when :create_partitions
+          [
+            TopicResult,
+            ::Kafka::FFI.rd_kafka_CreateTopics_result_topics(event, count),
+          ]
+        when :alter_configs
+          [
+            ConfigResource,
+            ::Kafka::FFI.rd_kafka_AlterConfigs_result_resources(event, count),
+          ]
+        when :describe_configs
+          [
+            ConfigResource,
+            ::Kafka::FFI.rd_kafka_DescribeConfigs_result_resources(event, count),
+          ]
+        else
+          raise ArgumentError, "unable to map #{event.class} to result type"
+        end
+
+      if results.null?
+        return []
+      end
+
+      results = results.read_array_of_pointer(count.read(:size_t))
+      results.map! { |p| klass.from_native(p, nil) }
+    ensure
+      count.free
+    end
+
+    def destroy
+      if @event
+        @event.destroy
+        @event = nil
+      end
+
+      clear
+
+      nil
+    end
+  end
+end

data/lib/kafka/ffi/admin/topic_result.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "ffi"
+require "kafka/ffi/opaque_pointer"
+
+module Kafka::FFI::Admin
+  class TopicResult < ::Kafka::FFI::OpaquePointer
+    # Returns the name of the topic the result is for.
+    #
+    # @return [String] Topic name
+    def name
+      ::Kafka::FFI.rd_kafka_topic_result_name(self)
+    end
+    alias topic name
+
+    # Returns either nil for success or an error with details about why the
+    # topic operation failed.
+    #
+    # @return [nil] Topic operation was successful for this topic.
+    # @return [Kafka::ResponseError] Error performing the operation for this
+    #   topic.
+    def error
+      err = ::Kafka::FFI.rd_kafka_topic_result_error(self)
+      if err != :ok
+        ::Kafka::ResponseError.new(
+          err,
+          ::Kafka::FFI.rd_kafka_topic_result_error_string(self),
+        )
+      end
+    end
+  end
+end

data/lib/kafka/ffi/admin.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "kafka/ffi"
+
+module Kafka::FFI
+  module Admin
+    require "kafka/ffi/admin/result"
+    require "kafka/ffi/admin/new_topic"
+    require "kafka/ffi/admin/delete_topic"
+    require "kafka/ffi/admin/topic_result"
+    require "kafka/ffi/admin/admin_options"
+    require "kafka/ffi/admin/config_entry"
+    require "kafka/ffi/admin/new_partitions"
+    require "kafka/ffi/admin/config_resource"
+  end
+end

data/lib/kafka/ffi/broker_metadata.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Kafka::FFI
+  class BrokerMetadata < ::FFI::Struct
+    layout(
+      :id,   :int32,
+      :host, :string,
+      :port, :int
+    )
+
+    # Returns the Broker's cluster ID
+    #
+    # @return [Integer] Broker ID
+    def id
+      self[:id]
+    end
+
+    # Returns the hostname of the Broker
+    #
+    # @return [String] Broker hostname
+    def host
+      self[:host]
+    end
+
+    # Returns the port used to connect to the Broker
+    #
+    # @return [Integer] Broker port
+    def port
+      self[:port]
+    end
+  end
+end