@platformatic/rdkafka 4.0.0

package/deps/librdkafka/tests/interactive_broker_version.py

@@ -0,0 +1,170 @@
+#!/usr/bin/env python3
+#
+#
+# Run librdkafka regression tests on different supported broker versions.
+#
+# Requires:
+#  trivup python module
+#  gradle in your PATH
+
+from cluster_testing import read_scenario_conf
+from broker_version_tests import test_it
+
+import os
+import sys
+import argparse
+import json
+
+
+def version_as_number(version):
+    if version == 'trunk':
+        return sys.maxsize
+    tokens = version.split('.')
+    return float('%s.%s' % (tokens[0], tokens[1]))
+
+
+def test_version(version, cmd=None, deploy=True, conf={}, debug=False,
+                 exec_cnt=1,
+                 root_path='tmp', broker_cnt=3, scenario='default',
+                 kraft=False):
+    """
+    @brief Create, deploy and start a Kafka cluster using Kafka \\p version
+    Then run librdkafka's regression tests. Use inherited environment.
+    """
+    conf['test_mode'] = 'bash'
+    test_it(version, deploy, conf, {}, None, True, debug,
+            scenario, kraft, True)
+    return True
+
+
+if __name__ == '__main__':
+
+    parser = argparse.ArgumentParser(
+        description='Start a Kafka cluster and provide an interactive shell')
+
+    parser.add_argument('versions', type=str, default=None, nargs='+',
+                        help='Kafka version(s) to deploy')
+    parser.add_argument('--no-deploy', action='store_false', dest='deploy',
+                        default=True,
+                        help='Dont deploy applications, '
+                        'assume already deployed.')
+    parser.add_argument('--conf', type=str, dest='conf', default=None,
+                        help='''
+    JSON config object (not file).
+    This does not translate to broker configs directly.
+    If broker config properties are to be specified,
+    they should be specified with
+    --conf \'{"conf": ["key=value", "key=value"]}\'''')
+    parser.add_argument('--scenario', type=str, dest='scenario',
+                        default='default',
+                        help='Test scenario (see scenarios/ directory)')
+    parser.add_argument('-c', type=str, dest='cmd', default=None,
+                        help='Command to execute instead of shell')
+    parser.add_argument('-n', type=int, dest='exec_cnt', default=1,
+                        help='Number of times to execute -c ..')
+    parser.add_argument('--debug', action='store_true', dest='debug',
+                        default=False,
+                        help='Enable trivup debugging')
+    parser.add_argument(
+        '--root',
+        type=str,
+        default=os.environ.get(
+            'TRIVUP_ROOT',
+            'tmp'),
+        help='Root working directory')
+    parser.add_argument(
+        '--port',
+        default=None,
+        help='Base TCP port to start allocating from')
+    parser.add_argument(
+        '--kafka-src',
+        dest='kafka_path',
+        type=str,
+        default=None,
+        help='Path to Kafka git repo checkout (used for version=trunk)')
+    parser.add_argument(
+        '--brokers',
+        dest='broker_cnt',
+        type=int,
+        default=3,
+        help='Number of Kafka brokers')
+    parser.add_argument('--ssl', dest='ssl', action='store_true',
+                        default=False,
+                        help='Enable SSL endpoints')
+    parser.add_argument(
+        '--sasl',
+        dest='sasl',
+        type=str,
+        default=None,
+        help='SASL mechanism (PLAIN, SCRAM-SHA-nnn, GSSAPI, OAUTHBEARER)')
+    parser.add_argument(
+        '--oauthbearer-method',
+        dest='sasl_oauthbearer_method',
+        type=str,
+        default=None,
+        help='OAUTHBEARER/OIDC method (DEFAULT, OIDC), \
+             must config SASL mechanism to OAUTHBEARER')
+    parser.add_argument(
+        '--max-reauth-ms',
+        dest='reauth_ms',
+        type=int,
+        default='10000',
+        help='''
+        Sets the value of connections.max.reauth.ms on the brokers.
+        Set 0 to disable.''')
+    parser.add_argument(
+        '--kraft',
+        dest='kraft',
+        action='store_true',
+        default=False,
+        help='Run in KRaft mode')
+
+    args = parser.parse_args()
+    if args.conf is not None:
+        args.conf = json.loads(args.conf)
+    else:
+        args.conf = {}
+
+    args.conf.update(read_scenario_conf(args.scenario))
+
+    if args.port is not None:
+        args.conf['port_base'] = int(args.port)
+    if args.kafka_path is not None:
+        args.conf['kafka_path'] = args.kafka_path
+    if args.ssl:
+        args.conf['security.protocol'] = 'SSL'
+    if args.sasl:
+        if (args.sasl == 'PLAIN' or args.sasl.find('SCRAM')
+                != -1) and 'sasl_users' not in args.conf:
+            args.conf['sasl_users'] = 'testuser=testpass'
+        args.conf['sasl_mechanisms'] = args.sasl
+    retcode = 0
+    if args.sasl_oauthbearer_method:
+        if args.sasl_oauthbearer_method == "OIDC" and \
+           args.conf['sasl_mechanisms'] != 'OAUTHBEARER':
+            print('If config `--oauthbearer-method=OIDC`, '
+                  '`--sasl` must be set to `OAUTHBEARER`')
+            retcode = 3
+            sys.exit(retcode)
+        args.conf['sasl_oauthbearer_method'] = \
+            args.sasl_oauthbearer_method
+
+    if 'conf' not in args.conf:
+        args.conf['conf'] = []
+
+    args.conf['conf'].append(
+        "connections.max.reauth.ms={}".format(
+            args.reauth_ms))
+    args.conf['conf'].append("log.retention.bytes=1000000000")
+
+    for version in args.versions:
+        r = test_version(version, cmd=args.cmd, deploy=args.deploy,
+                         conf=args.conf, debug=args.debug,
+                         exec_cnt=args.exec_cnt,
+                         root_path=args.root, broker_cnt=args.broker_cnt,
+                         scenario=args.scenario,
+                         kraft=args.kraft)
+        if not r:
+            retcode = 2
+
+    sys.exit(retcode)

package/deps/librdkafka/tests/interceptor_test/CMakeLists.txt

@@ -0,0 +1,16 @@
+set(
+    sources
+    interceptor_test.c
+)
+
+
+add_library(interceptor_test SHARED ${sources})
+
+target_include_directories(interceptor_test PUBLIC ${PROJECT_SOURCE_DIR}/src)
+
+target_link_libraries(interceptor_test PUBLIC rdkafka)
+
+# Remove "lib" prefix
+set_target_properties(interceptor_test PROPERTIES PREFIX "")
+set_target_properties(interceptor_test PROPERTIES
+                      LIBRARY_OUTPUT_DIRECTORY ${tests_OUTPUT_DIRECTORY}/interceptor_test/)

package/deps/librdkafka/tests/interceptor_test/Makefile

@@ -0,0 +1,22 @@
+PKGNAME=	interceptor_test
+LIBNAME=	interceptor_test
+LIBVER=		1
+
+-include ../../Makefile.config
+
+SRCS=		interceptor_test.c
+
+OBJS=		$(SRCS:.c=.o)
+
+# For rdkafka.h
+CPPFLAGS+=-I../../src
+LDFLAGS+=-L../../src
+LIBS+=-lrdkafka
+
+all: lib
+
+include ../../mklove/Makefile.base
+
+clean: lib-clean
+
+-include $(DEPS)

package/deps/librdkafka/tests/interceptor_test/interceptor_test.c

@@ -0,0 +1,314 @@
+/*
+ * librdkafka - The Apache Kafka C/C++ library
+ *
+ * Copyright (c) 2017-2022, Magnus Edenhill
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+
+/**
+ * @brief Interceptor plugin test library
+ *
+ * Interceptors can be implemented in the app itself and use
+ * the direct API to set the interceptors methods, or be implemented
+ * as an external plugin library that uses the direct APIs.
+ *
+ * This file implements the latter, an interceptor plugin library.
+ */
+
+#define _CRT_SECURE_NO_WARNINGS /* Silence MSVC nonsense */
+
+#include "../test.h"
+
+#include <stdio.h>
+#include <string.h>
+#include <assert.h>
+
+/* typical include path outside tests is <librdkafka/rdkafka.h> */
+#include "rdkafka.h"
+
+#include "interceptor_test.h"
+
+#ifdef _WIN32
+#define DLL_EXPORT __declspec(dllexport)
+#else
+#define DLL_EXPORT
+#endif
+
+/**
+ * @brief Interceptor instance.
+ *
+ * An interceptor instance is created for each intercepted configuration
+ * object (triggered through conf_init() which is the plugin loader,
+ * or by conf_dup() which is a copying of a conf previously seen by conf_init())
+ */
+struct ici {
+        rd_kafka_conf_t *conf; /**< Interceptor config */
+        char *config1;         /**< Interceptor-specific config */
+        char *config2;
+
+        int on_new_cnt;
+        int on_conf_destroy_cnt;
+};
+
+static char *my_interceptor_plug_opaque = "my_interceptor_plug_opaque";
+
+
+
+/* Producer methods */
+rd_kafka_resp_err_t
+on_send(rd_kafka_t *rk, rd_kafka_message_t *rkmessage, void *ic_opaque) {
+        struct ici *ici = ic_opaque;
+        printf("on_send: %p\n", ici);
+        return RD_KAFKA_RESP_ERR_NO_ERROR;
+}
+
+
+rd_kafka_resp_err_t on_acknowledgement(rd_kafka_t *rk,
+                                       rd_kafka_message_t *rkmessage,
+                                       void *ic_opaque) {
+        struct ici *ici = ic_opaque;
+        printf("on_acknowledgement: %p: err %d, partition %" PRId32 "\n", ici,
+               rkmessage->err, rkmessage->partition);
+        return RD_KAFKA_RESP_ERR_NO_ERROR;
+}
+
+/* Consumer methods */
+rd_kafka_resp_err_t
+on_consume(rd_kafka_t *rk, rd_kafka_message_t *rkmessage, void *ic_opaque) {
+        struct ici *ici = ic_opaque;
+        printf("on_consume: %p: partition %" PRId32 " @ %" PRId64 "\n", ici,
+               rkmessage->partition, rkmessage->offset);
+        return RD_KAFKA_RESP_ERR_NO_ERROR;
+}
+
+rd_kafka_resp_err_t on_commit(rd_kafka_t *rk,
+                              const rd_kafka_topic_partition_list_t *offsets,
+                              rd_kafka_resp_err_t err,
+                              void *ic_opaque) {
+        struct ici *ici = ic_opaque;
+        printf("on_commit: %p: err %d\n", ici, err);
+        return RD_KAFKA_RESP_ERR_NO_ERROR;
+}
+
+
+static void ici_destroy(struct ici *ici) {
+        if (ici->conf)
+                rd_kafka_conf_destroy(ici->conf);
+        if (ici->config1)
+                free(ici->config1);
+        if (ici->config2)
+                free(ici->config2);
+        free(ici);
+}
+
+rd_kafka_resp_err_t on_destroy(rd_kafka_t *rk, void *ic_opaque) {
+        struct ici *ici = ic_opaque;
+        printf("on_destroy: %p\n", ici);
+        /* the ici is freed from on_conf_destroy() */
+        return RD_KAFKA_RESP_ERR_NO_ERROR;
+}
+
+
+/**
+ * @brief Called from rd_kafka_new(). We use it to set up interceptors.
+ */
+static rd_kafka_resp_err_t on_new(rd_kafka_t *rk,
+                                  const rd_kafka_conf_t *conf,
+                                  void *ic_opaque,
+                                  char *errstr,
+                                  size_t errstr_size) {
+        struct ici *ici = ic_opaque;
+
+        ictest.on_new.cnt++;
+        ici->on_new_cnt++;
+
+        TEST_SAY("on_new(rk %p, conf %p, ici->conf %p): %p: #%d\n", rk, conf,
+                 ici->conf, ici, ictest.on_new.cnt);
+
+        ICTEST_CNT_CHECK(on_new);
+        TEST_ASSERT(ici->on_new_cnt == 1);
+
+        TEST_ASSERT(!ictest.session_timeout_ms);
+        TEST_ASSERT(!ictest.socket_timeout_ms);
+        /* Extract some well known config properties from the interceptor's
+         * configuration. */
+        ictest.session_timeout_ms =
+            rd_strdup(test_conf_get(ici->conf, "session.timeout.ms"));
+        ictest.socket_timeout_ms =
+            rd_strdup(test_conf_get(ici->conf, "socket.timeout.ms"));
+        ictest.config1 = rd_strdup(ici->config1);
+        ictest.config2 = rd_strdup(ici->config2);
+
+        rd_kafka_interceptor_add_on_send(rk, __FILE__, on_send, ici);
+        rd_kafka_interceptor_add_on_acknowledgement(rk, __FILE__,
+                                                    on_acknowledgement, ici);
+        rd_kafka_interceptor_add_on_consume(rk, __FILE__, on_consume, ici);
+        rd_kafka_interceptor_add_on_commit(rk, __FILE__, on_commit, ici);
+        rd_kafka_interceptor_add_on_destroy(rk, __FILE__, on_destroy, ici);
+
+        return RD_KAFKA_RESP_ERR_NO_ERROR;
+}
+
+
+/**
+ * @brief Configuration set handler
+ */
+static rd_kafka_conf_res_t on_conf_set(rd_kafka_conf_t *conf,
+                                       const char *name,
+                                       const char *val,
+                                       char *errstr,
+                                       size_t errstr_size,
+                                       void *ic_opaque) {
+        struct ici *ici = ic_opaque;
+        int level       = 3;
+
+        if (!strcmp(name, "session.timeout.ms") ||
+            !strcmp(name, "socket.timeout.ms") ||
+            !strncmp(name, "interceptor_test", strlen("interceptor_test")))
+                level = 2;
+
+        TEST_SAYL(level, "on_conf_set(conf %p, \"%s\", \"%s\"): %p\n", conf,
+                  name, val, ici);
+
+        if (!strcmp(name, "interceptor_test.good"))
+                return RD_KAFKA_CONF_OK;
+        else if (!strcmp(name, "interceptor_test.bad")) {
+                strncpy(errstr, "on_conf_set failed deliberately",
+                        errstr_size - 1);
+                errstr[errstr_size - 1] = '\0';
+                return RD_KAFKA_CONF_INVALID;
+        } else if (!strcmp(name, "interceptor_test.config1")) {
+                if (ici->config1) {
+                        free(ici->config1);
+                        ici->config1 = NULL;
+                }
+                if (val)
+                        ici->config1 = rd_strdup(val);
+                TEST_SAY("on_conf_set(conf %p, %s, %s): %p\n", conf, name, val,
+                         ici);
+                return RD_KAFKA_CONF_OK;
+        } else if (!strcmp(name, "interceptor_test.config2")) {
+                if (ici->config2) {
+                        free(ici->config2);
+                        ici->config2 = NULL;
+                }
+                if (val)
+                        ici->config2 = rd_strdup(val);
+                return RD_KAFKA_CONF_OK;
+        } else {
+                /* Apply intercepted client's config properties on
+                 * interceptor config. */
+                rd_kafka_conf_set(ici->conf, name, val, errstr, errstr_size);
+                /* UNKNOWN makes the conf_set() call continue with
+                 * other interceptors and finally the librdkafka properties. */
+                return RD_KAFKA_CONF_UNKNOWN;
+        }
+
+        return RD_KAFKA_CONF_UNKNOWN;
+}
+
+static void conf_init0(rd_kafka_conf_t *conf);
+
+
+/**
+ * @brief Set up new configuration on copy.
+ */
+static rd_kafka_resp_err_t on_conf_dup(rd_kafka_conf_t *new_conf,
+                                       const rd_kafka_conf_t *old_conf,
+                                       size_t filter_cnt,
+                                       const char **filter,
+                                       void *ic_opaque) {
+        struct ici *ici = ic_opaque;
+        TEST_SAY("on_conf_dup(new_conf %p, old_conf %p, filter_cnt %" PRIusz
+                 ", ici %p)\n",
+                 new_conf, old_conf, filter_cnt, ici);
+        conf_init0(new_conf);
+        return RD_KAFKA_RESP_ERR_NO_ERROR;
+}
+
+
+static rd_kafka_resp_err_t on_conf_destroy(void *ic_opaque) {
+        struct ici *ici = ic_opaque;
+        ici->on_conf_destroy_cnt++;
+        printf("conf_destroy called (opaque %p vs %p) ici %p\n", ic_opaque,
+               my_interceptor_plug_opaque, ici);
+        TEST_ASSERT(ici->on_conf_destroy_cnt == 1);
+        ici_destroy(ici);
+        return RD_KAFKA_RESP_ERR_NO_ERROR;
+}
+
+
+
+/**
+ * @brief Configuration init is intercepted both from plugin.library.paths
+ *        as well as rd_kafka_conf_dup().
+ *        This internal method serves both cases.
+ */
+static void conf_init0(rd_kafka_conf_t *conf) {
+        struct ici *ici;
+        const char *filter[] = {"plugin.library.paths", "interceptor_test."};
+        size_t filter_cnt    = sizeof(filter) / sizeof(*filter);
+
+        /* Create new interceptor instance */
+        ici = calloc(1, sizeof(*ici));
+
+        ictest.conf_init.cnt++;
+        ICTEST_CNT_CHECK(conf_init);
+
+        /* Create own copy of configuration, after filtering out what
+         * brought us here (plugins and our own interceptor config). */
+        ici->conf = rd_kafka_conf_dup_filter(conf, filter_cnt, filter);
+        TEST_SAY("conf_init0(conf %p) for ici %p with ici->conf %p\n", conf,
+                 ici, ici->conf);
+
+
+        /* Add interceptor methods */
+        rd_kafka_conf_interceptor_add_on_new(conf, __FILE__, on_new, ici);
+
+        rd_kafka_conf_interceptor_add_on_conf_set(conf, __FILE__, on_conf_set,
+                                                  ici);
+        rd_kafka_conf_interceptor_add_on_conf_dup(conf, __FILE__, on_conf_dup,
+                                                  ici);
+        rd_kafka_conf_interceptor_add_on_conf_destroy(conf, __FILE__,
+                                                      on_conf_destroy, ici);
+}
+
+/**
+ * @brief Plugin conf initializer called when plugin.library.paths is set.
+ */
+DLL_EXPORT
+rd_kafka_resp_err_t conf_init(rd_kafka_conf_t *conf,
+                              void **plug_opaquep,
+                              char *errstr,
+                              size_t errstr_size) {
+        *plug_opaquep = (void *)my_interceptor_plug_opaque;
+
+        TEST_SAY("conf_init(conf %p) called (setting opaque to %p)\n", conf,
+                 *plug_opaquep);
+
+        conf_init0(conf);
+
+        return RD_KAFKA_RESP_ERR_NO_ERROR;
+}

package/deps/librdkafka/tests/interceptor_test/interceptor_test.h

@@ -0,0 +1,54 @@
+#ifndef _INTERCEPTOR_TEST_H_
+#define _INTERCEPTOR_TEST_H_
+
+
+struct ictcnt {
+        int cnt;
+        int min;
+        int max;
+};
+
+struct ictest {
+        struct ictcnt conf_init;
+        struct ictcnt on_new;
+
+        /* intercepted interceptor_test.config1 and .config2 properties */
+        char *config1;
+        char *config2;
+
+        /* intercepted session.timeout.ms and socket.timeout.ms */
+        char *session_timeout_ms;
+        char *socket_timeout_ms;
+};
+
+#define ictest_init(ICT) memset((ICT), 0, sizeof(ictest))
+#define ictest_cnt_init(CNT, MIN, MAX)                                         \
+        do {                                                                   \
+                (CNT)->cnt = 0;                                                \
+                (CNT)->min = MIN;                                              \
+                (CNT)->max = MAX;                                              \
+        } while (0)
+
+#define ictest_free(ICT)                                                       \
+        do {                                                                   \
+                if ((ICT)->config1)                                            \
+                        free((ICT)->config1);                                  \
+                if ((ICT)->config2)                                            \
+                        free((ICT)->config2);                                  \
+                if ((ICT)->session_timeout_ms)                                 \
+                        free((ICT)->session_timeout_ms);                       \
+                if ((ICT)->socket_timeout_ms)                                  \
+                        free((ICT)->socket_timeout_ms);                        \
+        } while (0)
+
+#define ICTEST_CNT_CHECK(F)                                                    \
+        do {                                                                   \
+                if (ictest.F.cnt > ictest.F.max)                               \
+                        TEST_FAIL("interceptor %s count %d > max %d", #F,      \
+                                  ictest.F.cnt, ictest.F.max);                 \
+        } while (0)
+
+/* The ictest struct is defined and set up by the calling test. */
+extern struct ictest ictest;
+
+#endif /* _INTERCEPTOR_TEST_H_ */

package/deps/librdkafka/tests/java/IncrementalRebalanceCli.java

@@ -0,0 +1,97 @@
+/*
+ * librdkafka - Apache Kafka C library
+ *
+ * Copyright (c) 2020-2022, Magnus Edenhill
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+import java.io.IOException;
+import java.io.PrintWriter;
+
+import org.apache.kafka.clients.consumer.KafkaConsumer;
+import org.apache.kafka.clients.consumer.Consumer;
+import org.apache.kafka.clients.consumer.ConsumerConfig;
+import org.apache.kafka.clients.consumer.ConsumerRecord;
+import org.apache.kafka.clients.consumer.ConsumerRecords;
+import org.apache.kafka.clients.consumer.CooperativeStickyAssignor;
+import org.apache.kafka.common.KafkaException;
+
+import java.lang.Integer;
+import java.util.HashMap;
+import java.util.List;
+import java.util.ArrayList;
+import java.util.Properties;
+import java.time.Duration;
+
+
+public class IncrementalRebalanceCli {
+    public static void main (String[] args) throws Exception {
+        String testName = args[0];
+        String brokerList = args[1];
+        String topic1 = args[2];
+        String topic2 = args[3];
+        String group = args[4];
+
+        if (!testName.equals("test1")) {
+            throw new Exception("Unknown command: " + testName);
+        }
+
+        Properties consumerConfig = new Properties();
+        consumerConfig.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, brokerList);
+        consumerConfig.put(ConsumerConfig.GROUP_ID_CONFIG, group);
+        consumerConfig.put(ConsumerConfig.CLIENT_ID_CONFIG, "java_incrreb_consumer");
+        consumerConfig.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.ByteArrayDeserializer");
+        consumerConfig.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.ByteArrayDeserializer");
+        consumerConfig.put(ConsumerConfig.PARTITION_ASSIGNMENT_STRATEGY_CONFIG, CooperativeStickyAssignor.class.getName());
+        Consumer<byte[], byte[]> consumer = new KafkaConsumer<>(consumerConfig);
+
+        List<String> topics = new ArrayList<>();
+        topics.add(topic1);
+        topics.add(topic2);
+        consumer.subscribe(topics);
+
+        long startTime = System.currentTimeMillis();
+        long timeout_s = 300;
+
+        try {
+            boolean running = true;
+            while (running) {
+                ConsumerRecords<byte[], byte[]> records = consumer.poll(Duration.ofMillis(1000));
+                if (System.currentTimeMillis() - startTime > 1000 * timeout_s) {
+                    // Ensure process exits eventually no matter what happens.
+                    System.out.println("IncrementalRebalanceCli timed out");
+                    running = false;
+                }
+                if (consumer.assignment().size() == 6) {
+                    // librdkafka has unsubscribed from topic #2, exit cleanly.
+                    running = false;
+                }
+            }
+        } finally {
+            consumer.close();
+        }
+
+        System.out.println("Java consumer process exiting");
+    }
+}

package/deps/librdkafka/tests/java/Makefile

@@ -0,0 +1,12 @@
+
+KAFKA_JARS?=$(KAFKA_PATH)/libs
+
+CLASSES=Murmur2Cli.class TransactionProducerCli.class IncrementalRebalanceCli.class
+
+all: $(CLASSES)
+
+%.class: %.java
+	javac -classpath $(KAFKA_JARS)/kafka-clients-*.jar $^
+
+clean:
+	rm -f *.class