@ohos-ports/confluentinc-kafka-javascript 1.10.0-beta.1

package/deps/librdkafka/tests/gen-ssl-certs.sh

@@ -0,0 +1,165 @@
+#!/bin/bash
+#
+#
+# This scripts generates:
+#  - root CA certificate
+#  - server certificate and keystore
+#  - client keys
+#
+# https://cwiki.apache.org/confluence/display/KAFKA/Deploying+SSL+for+Kafka
+#
+
+
+if [[ "$1" == "-k" ]]; then
+    USE_KEYTOOL=1
+    shift
+else
+    USE_KEYTOOL=0
+fi
+
+OP="$1"
+CA_CERT="$2"
+PFX="$3"
+HOST="$4"
+
+C=NN
+ST=NN
+L=NN
+O=NN
+OU=NN
+CN="$HOST"
+ 
+
+# Password
+PASS="abcdefgh"
+
+# Cert validity, in days
+VALIDITY=10000
+
+set -e
+
+export LC_ALL=C
+
+if [[ $OP == "ca" && ! -z "$CA_CERT" && ! -z "$3" ]]; then
+    CN="$3"
+    openssl req -new -x509 -keyout ${CA_CERT}.key -out $CA_CERT -days $VALIDITY -passin "pass:$PASS" -passout "pass:$PASS" <<EOF
+${C}
+${ST}
+${L}
+${O}
+${OU}
+${CN}
+$USER@${CN}
+.
+.
+EOF
+
+
+
+elif [[ $OP == "server" && ! -z "$CA_CERT" && ! -z "$PFX" && ! -z "$CN" ]]; then
+
+    #Step 1
+    echo "############ Generating key"
+    keytool -storepass "$PASS" -keypass "$PASS" -keystore ${PFX}server.keystore.jks -alias localhost -validity $VALIDITY -genkey -keyalg RSA <<EOF
+$CN
+$OU
+$O
+$L
+$ST
+$C
+yes
+yes
+EOF
+	
+    #Step 2
+    echo "############ Adding CA"
+    keytool -storepass "$PASS" -keypass "$PASS" -keystore ${PFX}server.truststore.jks -alias CARoot -import -file $CA_CERT <<EOF
+yes
+EOF
+    
+    #Step 3
+    echo "############ Export certificate"
+    keytool -storepass "$PASS" -keypass "$PASS" -keystore ${PFX}server.keystore.jks -alias localhost -certreq -file ${PFX}cert-file
+
+    echo "############ Sign certificate"
+    openssl x509 -req -CA $CA_CERT -CAkey ${CA_CERT}.key -in ${PFX}cert-file -out ${PFX}cert-signed -days $VALIDITY -CAcreateserial -passin "pass:$PASS"
+    
+    
+    echo "############ Import CA"
+    keytool -storepass "$PASS" -keypass "$PASS" -keystore ${PFX}server.keystore.jks -alias CARoot -import -file $CA_CERT <<EOF
+yes
+EOF
+    
+    echo "############ Import signed CA"
+    keytool -storepass "$PASS" -keypass "$PASS" -keystore ${PFX}server.keystore.jks -alias localhost -import -file ${PFX}cert-signed    
+
+    
+elif [[ $OP == "client" && ! -z "$CA_CERT" && ! -z "$PFX" && ! -z "$CN" ]]; then
+
+    if [[ $USE_KEYTOOL == 1 ]]; then
+	echo "############ Creating client truststore"
+
+	[[ -f ${PFX}client.truststore.jks ]] || keytool -storepass "$PASS" -keypass "$PASS" -keystore ${PFX}client.truststore.jks -alias CARoot -import -file $CA_CERT <<EOF
+yes
+EOF
+
+	echo "############ Generating key"
+	keytool -storepass "$PASS" -keypass "$PASS" -keystore ${PFX}client.keystore.jks -alias localhost -validity $VALIDITY -genkey -keyalg RSA <<EOF
+$CN
+$OU
+$O
+$L
+$ST
+$C
+yes
+yes
+EOF
+	echo "########### Export certificate"
+	keytool -storepass "$PASS" -keystore ${PFX}client.keystore.jks -alias localhost -certreq -file ${PFX}cert-file
+
+	echo "########### Sign certificate"
+	openssl x509 -req -CA ${CA_CERT} -CAkey ${CA_CERT}.key -in ${PFX}cert-file -out ${PFX}cert-signed -days $VALIDITY -CAcreateserial -passin pass:$PASS	
+
+	echo "########### Import CA"
+	keytool -storepass "$PASS" -keypass "$PASS" -keystore ${PFX}client.keystore.jks -alias CARoot -import -file ${CA_CERT} <<EOF
+yes
+EOF
+
+	echo "########### Import signed CA"
+	keytool -storepass "$PASS" -keypass "$PASS" -keystore ${PFX}client.keystore.jks -alias localhost -import -file ${PFX}cert-signed
+
+    else
+	# Standard OpenSSL keys
+	echo "############ Generating key"
+	openssl genrsa -des3 -passout "pass:$PASS" -out ${PFX}client.key 2048 
+	
+	echo "############ Generating request"
+	openssl req -passin "pass:$PASS" -passout "pass:$PASS" -key ${PFX}client.key -new -out ${PFX}client.req \
+		<<EOF
+$C
+$ST
+$L
+$O
+$OU
+$CN
+.
+$PASS
+.
+EOF
+
+	echo "########### Signing key"
+	openssl x509 -req -passin "pass:$PASS" -in ${PFX}client.req -CA $CA_CERT -CAkey ${CA_CERT}.key -CAcreateserial -out ${PFX}client.pem -days $VALIDITY
+
+    fi
+
+    
+    
+
+else
+    echo "Usage: $0 ca <ca-cert-file> <CN>"
+    echo "       $0 [-k] server|client <ca-cert-file> <file_prefix> <hostname>"
+    echo ""
+    echo "       -k = Use keytool/Java Keystore, else standard SSL keys"
+    exit 1
+fi
+

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;
+}