jruby-kafka 0.1.1-java

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: af575b070c304d11ac6aa1af46eaad548b61661b
+  data.tar.gz: 4bc817399ca6126b32c0df3f6072ae695fc49be4
+SHA512:
+  metadata.gz: a9fcd6fd838e6a2d87bd96ca8606bd19639c04e81722eb10e0be58b99369159af3eb595f7fa56c96da1938924a764cb6fedf526bce5dc156f2535fe7dcd80969
+  data.tar.gz: 8a40f64f4c7f1dbeed36daf62336610d96c88343a628f523ff529c9b0ab53c75638de657b8a6fdee08db6a992312f68c9db777cbeab0e51c829699bb357f4cfc

data/lib/jruby-kafka.rb

@@ -0,0 +1,17 @@
+# Because of a problem with a kafka dependency, jbundler 0.5.5 does not work. Therefore, you
+# need to do one of the following to have your Kafka jar dependencies available:
+#
+# - run your app under jbundler (adds a layer to bundler to manage jar dependencies)
+# - already have the Kafka jars loaded before requiring jruby-kafka
+# - set KAFKA_PATH in the environment to point to a Kafka binary installation
+#
+if not JBUNDLER_CLASSPATH and ENV['KAFKA_PATH']
+  require 'jruby-kafka/loader'
+end
+
+require "jruby-kafka/consumer"
+require "jruby-kafka/group"
+require "jruby-kafka/producer"
+
+module Kafka
+end

data/lib/jruby-kafka/consumer.rb

@@ -0,0 +1,44 @@
+require "java"
+require "jruby-kafka/namespace"
+
+java_import 'kafka.consumer.ConsumerIterator'
+java_import 'kafka.consumer.KafkaStream'
+java_import 'kafka.common.ConsumerRebalanceFailedException'
+java_import 'kafka.consumer.ConsumerTimeoutException'
+
+class Kafka::Consumer
+  include Java::JavaLang::Runnable
+  java_signature 'void run()'
+
+  @m_stream
+  @m_threadNumber
+  @m_queue
+
+    def initialize(a_stream, a_threadNumber, a_queue, a_bool_restart_on_exception, a_sleep_ms)
+      @m_threadNumber = a_threadNumber
+      @m_stream = a_stream
+      @m_queue = a_queue
+      @m_restart_on_exception = a_bool_restart_on_exception
+      @m_sleep_ms = 1.0 / 1000.0 * Float(a_sleep_ms)
+    end
+
+    def run
+      it = @m_stream.iterator()
+      begin
+        while it.hasNext()
+          begin
+            @m_queue << it.next().message()
+          end
+        end
+      rescue Exception => e
+        puts("#{self.class.name} caught exception: #{e.class.name}")
+        puts(e.message) if e.message != ''
+        if @m_restart_on_exception
+          sleep(@m_sleep_ms)
+          retry
+        else
+          raise e
+        end
+      end
+    end
+end

data/lib/jruby-kafka/error.rb

@@ -0,0 +1,9 @@
+require "jruby-kafka/namespace"
+
+class KafkaError < StandardError
+  attr_reader :object
+
+  def initialize(object)
+    @object = object
+  end
+end

data/lib/jruby-kafka/group.rb

@@ -0,0 +1,216 @@
+# basically we are porting this https://cwiki.apache.org/confluence/display/KAFKA/Consumer+Group+Example
+
+require "java"
+
+require "jruby-kafka/namespace"
+require "jruby-kafka/consumer"
+require "jruby-kafka/error"
+
+java_import 'java.util.concurrent.ExecutorService'
+java_import 'java.util.concurrent.Executors'
+java_import 'org.I0Itec.zkclient.exception.ZkException'
+
+class Kafka::Group
+  @consumer
+  @executor
+  @topic
+  @auto_offset_reset
+  @zk_connect
+  @group_id
+
+  # Create a Kafka client group
+  #
+  # options:
+  # :zk_connect => "localhost:2181" - REQUIRED: The connection string for the
+  #   zookeeper connection in the form host:port. Multiple URLS can be given to allow fail-over.
+  # :zk_connect_timeout => "6000" - (optional) The max time that the client waits while establishing a connection to zookeeper.
+  # :group_id => "group" - REQUIRED: The group id to consume on.
+  # :topic_id => "topic" - REQUIRED: The topic id to consume on.
+  # :reset_beginning => "from-beginning" - (optional) If the consumer does not already have an established offset
+  #   to consume from, start with the earliest message present in the log rather than the latest message.
+  # :consumer_restart_on_error => "true" - (optional) Controls if consumer threads are to restart on caught exceptions.
+  #   exceptions are logged.
+  def initialize(options={})
+    validate_required_arguments(options)
+
+    @zk_connect = options[:zk_connect]
+    @group_id = options[:group_id]
+    @topic = options[:topic_id]
+    @zk_session_timeout = '6000'
+    @zk_connect_timeout = '6000'
+    @zk_sync_time = '2000'
+    @auto_offset_reset = 'largest'
+    @auto_commit_interval = '1000'
+    @running = false
+    @rebalance_max_retries = '4'
+    @rebalance_backoff_ms = '2000'
+    @socket_timeout_ms = "#{30 * 1000}"
+    @socket_receive_buffer_bytes = "#{64 * 1024}"
+    @fetch_message_max_bytes = "#{1024 * 1024}"
+    @auto_commit_enable = "#{true}"
+    @queued_max_message_chunks = '10'
+    @fetch_min_bytes = '1'
+    @fetch_wait_max_ms = '100'
+    @refresh_leader_backoff_ms = '200'
+    @consumer_timeout_ms = '-1'
+    @consumer_restart_on_error = "#{false}"
+    @consumer_restart_sleep_ms = '0'
+    @consumer_id = nil
+
+    if options[:zk_connect_timeout]
+      @zk_connect_timeout = "#{options[:zk_connect_timeout]}"
+    end
+    if options[:zk_session_timeout]
+      @zk_session_timeout = "#{options[:zk_session_timeout]}"
+    end
+    if options[:zk_sync_time]
+      @zk_sync_time = "#{options[:zk_sync_time]}"
+    end
+    if options[:auto_commit_interval]
+      @auto_commit_interval = "#{options[:auto_commit_interval]}"
+    end
+
+    if options[:rebalance_max_retries]
+      @rebalance_max_retries = "#{options[:rebalance_max_retries]}"
+    end
+
+    if options[:rebalance_backoff_ms]
+      @rebalance_backoff_ms = "#{options[:rebalance_backoff_ms]}"
+    end
+
+    if options[:socket_timeout_ms]
+      @socket_timeout_ms = "#{options[:socket_timeout_ms]}"
+    end
+
+    if options[:socket_receive_buffer_bytes]
+      @socket_receive_buffer_bytes = "#{options[:socket_receive_buffer_bytes]}"
+    end
+
+    if options[:fetch_message_max_bytes]
+      @fetch_message_max_bytes = "#{options[:fetch_message_max_bytes]}"
+    end
+
+    if options[:auto_commit_enable]
+      @auto_commit_enable = "#{options[:auto_commit_enable]}"
+    end
+
+    if options[:queued_max_message_chunks]
+      @queued_max_message_chunks = "#{options[:queued_max_message_chunks]}"
+    end
+
+    if options[:fetch_min_bytes]
+      @fetch_min_bytes = "#{options[:fetch_min_bytes]}"
+    end
+
+    if options[:fetch_wait_max_ms]
+      @fetch_wait_max_ms = "#{options[:fetch_wait_max_ms]}"
+    end
+
+    if options[:refresh_leader_backoff_ms]
+      @refresh_leader_backoff_ms = "#{options[:refresh_leader_backoff_ms]}"
+    end
+
+    if options[:consumer_timeout_ms]
+      @consumer_timeout_ms = "#{options[:consumer_timeout_ms]}"
+    end
+
+    if options[:consumer_restart_on_error]
+      @consumer_restart_on_error = "#{options[:consumer_restart_on_error]}"
+    end
+
+    if options[:consumer_restart_sleep_ms]
+      @consumer_restart_sleep_ms = "#{options[:consumer_restart_sleep_ms]}"
+    end
+
+
+    if options[:reset_beginning]
+      if options[:reset_beginning] == 'from-beginning'
+        @auto_offset_reset = 'smallest'
+      else
+        @auto_offset_reset = 'largest'
+      end
+    end
+
+    if options[:consumer_id]
+      @consumer_id = options[:consumer_id]
+    end
+  end
+
+  private
+  def validate_required_arguments(options={})
+    [:zk_connect, :group_id, :topic_id].each do |opt|
+      raise(ArgumentError, "#{opt} is required.") unless options[opt]
+    end
+  end
+
+  public
+  def shutdown()
+    if @consumer
+      @consumer.shutdown()
+    end
+    if @executor
+      @executor.shutdown()
+    end
+    @running = false
+  end
+
+  public
+  def run(a_numThreads, a_queue)
+    begin
+      if @auto_offset_reset == 'smallest'
+        Java::kafka::utils::ZkUtils.maybeDeletePath(@zk_connect, "/consumers/#{@group_id}")
+      end
+
+      @consumer = Java::kafka::consumer::Consumer.createJavaConsumerConnector(createConsumerConfig())
+    rescue ZkException => e
+      raise KafkaError.new(e), "Got ZkException: #{e}"
+    end
+    topicCountMap = java.util.HashMap.new()
+    thread_value = a_numThreads.to_java Java::int
+    topicCountMap.put(@topic, thread_value)
+    consumerMap = @consumer.createMessageStreams(topicCountMap)
+    streams = Array.new(consumerMap[@topic])
+
+    @executor = Executors.newFixedThreadPool(a_numThreads)
+    @executor_submit = @executor.java_method(:submit, [Java::JavaLang::Runnable.java_class])
+
+    threadNumber = 0
+    for stream in streams
+      @executor_submit.call(Kafka::Consumer.new(stream, threadNumber, a_queue, @consumer_restart_on_error, @consumer_restart_sleep_ms))
+      threadNumber += 1
+    end
+    @running = true
+  end
+
+  public
+  def running?
+    @running
+  end
+
+  private
+  def createConsumerConfig()
+    properties = java.util.Properties.new()
+    properties.put("zookeeper.connect", @zk_connect)
+    properties.put("group.id", @group_id)
+    properties.put("zookeeper.connection.timeout.ms", @zk_connect_timeout)
+    properties.put("zookeeper.session.timeout.ms", @zk_session_timeout)
+    properties.put("zookeeper.sync.time.ms", @zk_sync_time)
+    properties.put("auto.commit.interval.ms", @auto_commit_interval)
+    properties.put("auto.offset.reset", @auto_offset_reset)
+    properties.put("rebalance.max.retries", @rebalance_max_retries)
+    properties.put("rebalance.backoff.ms", @rebalance_backoff_ms)
+    properties.put("socket.timeout.ms", @socket_timeout_ms)
+    properties.put("socket.receive.buffer.bytes", @socket_receive_buffer_bytes)
+    properties.put("fetch.message.max.bytes", @fetch_message_max_bytes)
+    properties.put("auto.commit.enable", @auto_commit_enable)
+    properties.put("queued.max.message.chunks", @queued_max_message_chunks)
+    properties.put("fetch.min.bytes", @fetch_min_bytes)
+    properties.put("fetch.wait.max.ms", @fetch_wait_max_ms)
+    properties.put("refresh.leader.backoff.ms", @refresh_leader_backoff_ms)
+    properties.put("consumer.timeout.ms", @consumer_timeout_ms)
+    unless @consumer_id.nil?
+      properties.put('consumer.id', @consumer_id)
+    end
+    return Java::kafka::consumer::ConsumerConfig.new(properties)
+  end
+end

data/lib/jruby-kafka/loader.rb

@@ -0,0 +1,12 @@
+module Kafka
+  def self.load_jars(kafka_path = nil)
+    kafka_path ||= ENV['KAFKA_PATH']
+
+    raise 'Please set KAFKA_PATH' unless kafka_path
+    dir = File.join(kafka_path, 'libs')
+    jars = Dir.glob(File.join(dir, '*.jar'))
+    raise "KAFKA_PATH set, but #{dir} contains no jar files." if jars.empty?
+    jars.each { |jar| require jar }
+  end
+end
+

data/lib/jruby-kafka/namespace.rb

@@ -0,0 +1,3 @@
+module Kafka
+
+end

data/lib/jruby-kafka/producer.rb

@@ -0,0 +1,97 @@
+# basically we are porting this https://cwiki.apache.org/confluence/display/KAFKA/0.8.0+Producer+Example
+
+require "java"
+
+require "jruby-kafka/namespace"
+require "jruby-kafka/error"
+
+class Kafka::Producer
+  java_import 'kafka.producer.ProducerConfig'
+  java_import 'kafka.producer.KeyedMessage'
+  KafkaProducer = Java::kafka.javaapi.producer.Producer
+  java_import 'kafka.message.NoCompressionCodec'
+  java_import 'kafka.message.GZIPCompressionCodec'
+  java_import 'kafka.message.SnappyCompressionCodec'
+
+  VALIDATIONS = {
+    'request.required.acks' => %w[ 0 1 -1 ],
+    'required.codecs' => [NoCompressionCodec.name, GZIPCompressionCodec.name, SnappyCompressionCodec.name],
+    'producer.type' => %w[ sync async ]
+  }
+
+  REQUIRED = %w[
+    metadata.broker.list
+  ]
+
+  # List of all available options extracted from http://kafka.apache.org/documentation.html#producerconfigs Apr. 27, 2014
+  # If new options are added, they should just work. Please add them to the list so that we can get handy warnings.
+  KNOWN = %w[
+    acks                   max.request.size              receive.buffer.bytes
+    batch.num.messages     message.send.max.retries      reconnect.backoff.ms
+    batch.size             metadata.broker.list          request.required.acks
+    block.on.buffer.full   metadata.fetch.timeout.ms     request.timeout.ms
+    bootstrap.servers      metadata.max.age.ms           retries
+    buffer.memory          metric.reporters              retry.backoff.ms
+    client.id              metrics.num.samples           retry.backoff.ms
+    client.id              metrics.sample.window.ms      send.buffer.bytes
+    compressed.topics      partitioner.class             send.buffer.bytes
+    compression.codec      producer.type                 serializer.class
+    compression.type       queue.buffering.max.messages  timeout.ms
+    key.serializer.class   queue.buffering.max.ms        topic.metadata.refresh.interval.ms
+    linger.ms              queue.enqueue.timeout.ms
+  ]
+
+  attr_reader :producer, :send_method, :options
+
+  # Create a Kafka Producer
+  #
+  # options:
+  # metadata_broker_list: ["localhost:9092"] - REQUIRED: a seed list of kafka brokers
+  def initialize(opts = {})
+    @options = opts.reduce({}) do |opts, (k, v)|
+      opts[k.to_s.gsub(/_/, '.')] = v
+      opts
+    end
+    if options['broker.list']
+      options['metadata.broker.list'] = options.delete 'broker.list'
+    end
+    if options['compressed.topics'].to_s == 'none'
+      options.delete 'compressed.topics'
+    end
+    if options['metadata.broker.list'].is_a? Array
+      options['metadata.broker.list'] = options['metadata.broker.list'].join(',')
+    end
+    validate_arguments
+    @send_method = proc { throw StandardError.new "Producer is not connected" }
+  end
+
+  def connect()
+    @producer = KafkaProducer.new(createProducerConfig)
+    @send_method = producer.java_method :send, [KeyedMessage]
+  end
+
+  # throws FailedToSendMessageException or if not connected, StandardError.
+  def sendMsg(topic, key, msg)
+    send_method.call(KeyedMessage.new(topic, key, msg))
+  end
+
+  private
+
+  def validate_arguments
+    errors = []
+    missing = REQUIRED.reject { |opt| options[opt] }
+    errors = ["Required settings: #{ missing.join(', ')}"] if missing.any?
+    invalid = VALIDATIONS.reject { |opt, valid| options[opt].nil? or valid.include? options[opt].to_s }
+    errors += invalid.map { |opt, valid| "#{ opt } should be one of: [#{ valid.join(', ')}]" }
+    fail StandardError.new "Invalid configuration arguments: #{ errors.join('; ') }" if errors.any?
+    options.keys.each do |opt|
+      STDERR.puts "WARNING: Unknown configuration key: #{opt}" unless KNOWN.include? opt
+    end
+  end
+
+  def createProducerConfig()
+    properties = java.util.Properties.new()
+    options.each { |opt, value| properties.put opt, value.to_s }
+    return ProducerConfig.new(properties)
+  end
+end

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification
+name: jruby-kafka
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: java
+authors:
+- Joseph Lawson
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2014-09-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: jbundler
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.5.5
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.5.5
+  prerelease: false
+  type: :runtime
+description: this is primarily to be used as an interface for logstash
+email:
+- joe@joekiller.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/jruby-kafka.rb
+- lib/jruby-kafka/consumer.rb
+- lib/jruby-kafka/error.rb
+- lib/jruby-kafka/group.rb
+- lib/jruby-kafka/loader.rb
+- lib/jruby-kafka/namespace.rb
+- lib/jruby-kafka/producer.rb
+homepage: https://github.com/joekiller/jruby-kafka
+licenses:
+- Apache 2.0
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements:
+- jar 'org.apache.kafka:kafka_2.9.2', '0.8.1'
+- jar 'log4j:log4j', '1.2.14'
+rubyforge_project:
+rubygems_version: 2.2.2
+signing_key:
+specification_version: 4
+summary: jruby Kafka wrapper
+test_files: []