@point3/node-rdkafka 3.6.0-1

package/deps/librdkafka/packaging/cmake/README.md

@@ -0,0 +1,38 @@
+# Build librdkafka with cmake
+
+The cmake build mode is experimental and not officially supported,
+the community is asked to maintain and support this mode through PRs.
+
+Set up build environment (from top-level librdkafka directory):
+
+    $ cmake -H. -B_cmake_build
+
+On MacOSX and OpenSSL from Homebrew you might need to do:
+
+    $ cmake -H. -B_cmake_build -DOPENSSL_ROOT_DIR=/usr/local/opt/openssl
+
+
+Build the library:
+
+    $ cmake --build _cmake_build
+
+If you want to build static library:
+
+    $ cmake --build _cmake_build -DRDKAFKA_BUILD_STATIC=1
+
+
+Run (local) tests:
+
+    $ (cd _cmake_build && ctest -VV -R RdKafkaTestBrokerLess)
+
+
+Install library:
+
+    $ cmake --build _cmake_build --target install
+
+
+If you use librdkafka as submodule in cmake project and want static link of librdkafka:
+
+      set(RDKAFKA_BUILD_STATIC ON CACHE BOOL "")
+      add_subdirectory(librdkafka)
+      target_link_libraries(your_library_or_executable rdkafka)

package/deps/librdkafka/packaging/cmake/config.h.in

@@ -0,0 +1,52 @@
+#cmakedefine01 WITHOUT_OPTIMIZATION
+#cmakedefine01 ENABLE_DEVEL
+#cmakedefine01 ENABLE_REFCNT_DEBUG
+
+#cmakedefine01 HAVE_ATOMICS_32
+#cmakedefine01 HAVE_ATOMICS_32_SYNC
+
+#if (HAVE_ATOMICS_32)
+# if (HAVE_ATOMICS_32_SYNC)
+#  define ATOMIC_OP32(OP1,OP2,PTR,VAL) __sync_ ## OP1 ## _and_ ## OP2(PTR, VAL)
+# else
+#  define ATOMIC_OP32(OP1,OP2,PTR,VAL) __atomic_ ## OP1 ## _ ## OP2(PTR, VAL, __ATOMIC_SEQ_CST)
+# endif
+#endif
+
+#cmakedefine01 HAVE_ATOMICS_64
+#cmakedefine01 HAVE_ATOMICS_64_SYNC
+
+#if (HAVE_ATOMICS_64)
+# if (HAVE_ATOMICS_64_SYNC)
+#  define ATOMIC_OP64(OP1,OP2,PTR,VAL) __sync_ ## OP1 ## _and_ ## OP2(PTR, VAL)
+# else
+#  define ATOMIC_OP64(OP1,OP2,PTR,VAL) __atomic_ ## OP1 ## _ ## OP2(PTR, VAL, __ATOMIC_SEQ_CST)
+# endif
+#endif
+
+#cmakedefine01 WITH_PKGCONFIG
+#cmakedefine01 WITH_HDRHISTOGRAM
+#cmakedefine01 WITH_ZLIB
+#cmakedefine01 WITH_CURL
+#cmakedefine01 WITH_OAUTHBEARER_OIDC
+#cmakedefine01 WITH_ZSTD
+#cmakedefine01 WITH_LIBDL
+#cmakedefine01 WITH_PLUGINS
+#define WITH_SNAPPY 1
+#define WITH_SOCKEM 1
+#cmakedefine01 WITH_SSL
+#cmakedefine01 WITH_SASL
+#cmakedefine01 WITH_SASL_SCRAM
+#cmakedefine01 WITH_SASL_OAUTHBEARER
+#cmakedefine01 WITH_SASL_CYRUS
+#cmakedefine01 WITH_LZ4_EXT
+#cmakedefine01 HAVE_REGEX
+#cmakedefine01 HAVE_STRNDUP
+#cmakedefine01 HAVE_RAND_R
+#cmakedefine01 HAVE_PTHREAD_SETNAME_GNU
+#cmakedefine01 HAVE_PTHREAD_SETNAME_DARWIN
+#cmakedefine01 HAVE_PTHREAD_SETNAME_FREEBSD
+#cmakedefine01 WITH_C11THREADS
+#cmakedefine01 WITH_CRC32C_HW
+#define SOLIB_EXT "${CMAKE_SHARED_LIBRARY_SUFFIX}"
+#define BUILT_WITH  "${BUILT_WITH}"

package/deps/librdkafka/packaging/cmake/parseversion.cmake

@@ -0,0 +1,60 @@
+# hex2dec(<out-var> <input>):
+# Convert a hexadecimal value <input> to decimal and write the result
+# to <out-var>.
+macro(hex2dec var val)
+    set(${var} 0)
+
+    set(hex2dec_idx 0)
+    string(LENGTH "${val}" hex2dec_len)
+
+    while(hex2dec_idx LESS hex2dec_len)
+        string(SUBSTRING ${val} ${hex2dec_idx} 1 hex2dec_char)
+
+        if(hex2dec_char MATCHES "[0-9]")
+            set(hex2dec_char ${hex2dec_char})
+        elseif(hex2dec_char MATCHES "[aA]")
+            set(hex2dec_char 10)
+        elseif(hex2dec_char MATCHES "[bB]")
+            set(hex2dec_char 11)
+        elseif(hex2dec_char MATCHES "[cC]")
+            set(hex2dec_char 12)
+        elseif(hex2dec_char MATCHES "[dD]")
+            set(hex2dec_char 13)
+        elseif(hex2dec_char MATCHES "[eE]")
+            set(hex2dec_char 14)
+        elseif(hex2dec_char MATCHES "[fF]")
+            set(hex2dec_char 15)
+        else()
+            message(FATAL_ERROR "Invalid format for hexidecimal character: " ${hex2dec_char})
+        endif()
+
+        math(EXPR hex2dec_char "${hex2dec_char} << ((${hex2dec_len}-${hex2dec_idx}-1)*4)")
+        math(EXPR ${var} "${${var}}+${hex2dec_char}")
+        math(EXPR hex2dec_idx "${hex2dec_idx}+1")
+    endwhile()
+endmacro(hex2dec)
+
+# parseversion(<filepath>):
+# Parse the file given by <filepath> for the RD_KAFKA_VERSION constant
+# and convert the hex value to decimal version numbers.
+# Creates the following CMake variables:
+# * RDKAFKA_VERSION
+# * RDKAFKA_VERSION_MAJOR
+# * RDKAFKA_VERSION_MINOR
+# * RDKAFKA_VERSION_REVISION
+# * RDKAFKA_VERSION_PRERELEASE
+macro(parseversion path)
+    file(STRINGS ${path} rdkafka_version_def REGEX "#define  *RD_KAFKA_VERSION  *\(0x[a-f0-9]*\)\.*")
+    string(REGEX REPLACE "#define  *RD_KAFKA_VERSION  *0x" "" rdkafka_version_hex ${rdkafka_version_def})
+
+    string(SUBSTRING ${rdkafka_version_hex} 0 2 rdkafka_version_major_hex)
+    string(SUBSTRING ${rdkafka_version_hex} 2 2 rdkafka_version_minor_hex)
+    string(SUBSTRING ${rdkafka_version_hex} 4 2 rdkafka_version_revision_hex)
+    string(SUBSTRING ${rdkafka_version_hex} 6 2 rdkafka_version_prerelease_hex)
+
+    hex2dec(RDKAFKA_VERSION_MAJOR ${rdkafka_version_major_hex})
+    hex2dec(RDKAFKA_VERSION_MINOR ${rdkafka_version_minor_hex})
+    hex2dec(RDKAFKA_VERSION_REVISION ${rdkafka_version_revision_hex})
+    hex2dec(RDKAFKA_VERSION_PRERELEASE ${rdkafka_version_prerelease_hex})
+    set(RDKAFKA_VERSION "${RDKAFKA_VERSION_MAJOR}.${RDKAFKA_VERSION_MINOR}.${RDKAFKA_VERSION_REVISION}")
+endmacro(parseversion)

package/deps/librdkafka/packaging/cmake/rdkafka.pc.in

@@ -0,0 +1,12 @@
+prefix=@CMAKE_INSTALL_PREFIX@
+exec_prefix=${prefix}
+includedir=${prefix}/include
+libdir=${prefix}/lib
+
+Name: @PKG_CONFIG_NAME@
+Description: @PKG_CONFIG_DESCRIPTION@
+Version: @PKG_CONFIG_VERSION@
+Requires.private: @PKG_CONFIG_REQUIRES_PRIVATE@
+Cflags: @PKG_CONFIG_CFLAGS@
+Libs: @PKG_CONFIG_LIBS@
+Libs.private: @PKG_CONFIG_LIBS_PRIVATE@

package/deps/librdkafka/packaging/cmake/try_compile/atomic_32_test.c

@@ -0,0 +1,8 @@
+#include <inttypes.h>
+
+int32_t foo(int32_t i) {
+        return __atomic_add_fetch(&i, 1, __ATOMIC_SEQ_CST);
+}
+
+int main() {
+}

package/deps/librdkafka/packaging/cmake/try_compile/atomic_64_test.c

@@ -0,0 +1,8 @@
+#include <inttypes.h>
+
+int64_t foo(int64_t i) {
+        return __atomic_add_fetch(&i, 1, __ATOMIC_SEQ_CST);
+}
+
+int main() {
+}

package/deps/librdkafka/packaging/cmake/try_compile/c11threads_test.c

@@ -0,0 +1,14 @@
+#include <threads.h>
+
+static int start_func(void *arg) {
+        int iarg = *(int *)arg;
+        return iarg;
+}
+
+void main(void) {
+        thrd_t thr;
+        int arg = 1;
+        if (thrd_create(&thr, start_func, (void *)&arg) != thrd_success) {
+                ;
+        }
+}

package/deps/librdkafka/packaging/cmake/try_compile/crc32c_hw_test.c

@@ -0,0 +1,27 @@
+#include <inttypes.h>
+#include <stdio.h>
+#define LONGx1 "8192"
+#define LONGx2 "16384"
+void main(void) {
+        const char *n = "abcdefghijklmnopqrstuvwxyz0123456789";
+        uint64_t c0 = 0, c1 = 1, c2 = 2;
+        uint64_t s;
+        uint32_t eax = 1, ecx;
+        __asm__("cpuid" : "=c"(ecx) : "a"(eax) : "%ebx", "%edx");
+        __asm__(
+            "crc32b\t"
+            "(%1), %0"
+            : "=r"(c0)
+            : "r"(n), "0"(c0));
+        __asm__(
+            "crc32q\t"
+            "(%3), %0\n\t"
+            "crc32q\t" LONGx1
+            "(%3), %1\n\t"
+            "crc32q\t" LONGx2 "(%3), %2"
+            : "=r"(c0), "=r"(c1), "=r"(c2)
+            : "r"(n), "0"(c0), "1"(c1), "2"(c2));
+        s = c0 + c1 + c2;
+        printf("avoiding unused code removal by printing %d, %d, %d\n", (int)s,
+               (int)eax, (int)ecx);
+}

package/deps/librdkafka/packaging/cmake/try_compile/dlopen_test.c

@@ -0,0 +1,11 @@
+#include <string.h>
+#include <dlfcn.h>
+
+int main() {
+        void *h;
+        /* Try loading anything, we don't care if it works */
+        h = dlopen("__nothing_rdkafka.so", RTLD_NOW | RTLD_LOCAL);
+        if (h)
+                dlclose(h);
+        return 0;
+}

package/deps/librdkafka/packaging/cmake/try_compile/libsasl2_test.c

@@ -0,0 +1,7 @@
+#include <string.h>
+#include <sasl/sasl.h>
+
+int main() {
+        sasl_done();
+        return 0;
+}

package/deps/librdkafka/packaging/cmake/try_compile/pthread_setname_darwin_test.c

@@ -0,0 +1,6 @@
+#include <pthread.h>
+
+int main() {
+        pthread_setname_np("abc");
+        return 0;
+}

package/deps/librdkafka/packaging/cmake/try_compile/pthread_setname_freebsd_test.c

@@ -0,0 +1,7 @@
+#include <pthread.h>
+#include <pthread_np.h>
+
+int main() {
+        pthread_set_name_np(pthread_self(), "abc");
+        return 0;
+}

package/deps/librdkafka/packaging/cmake/try_compile/pthread_setname_gnu_test.c

@@ -0,0 +1,5 @@
+#include <pthread.h>
+
+int main() {
+        return pthread_setname_np(pthread_self(), "abc");
+}

package/deps/librdkafka/packaging/cmake/try_compile/rand_r_test.c

@@ -0,0 +1,7 @@
+#include <stdlib.h>
+
+int main() {
+        unsigned int seed = 0xbeaf;
+        (void)rand_r(&seed);
+        return 0;
+}

package/deps/librdkafka/packaging/cmake/try_compile/rdkafka_setup.cmake

@@ -0,0 +1,122 @@
+try_compile(
+    HAVE_REGEX
+    "${CMAKE_CURRENT_BINARY_DIR}/try_compile"
+    "${TRYCOMPILE_SRC_DIR}/regex_test.c"
+)
+
+try_compile(
+    HAVE_STRNDUP
+    "${CMAKE_CURRENT_BINARY_DIR}/try_compile"
+    "${TRYCOMPILE_SRC_DIR}/strndup_test.c"
+)
+
+try_compile(
+    HAVE_RAND_R
+    "${CMAKE_CURRENT_BINARY_DIR}/try_compile"
+    "${TRYCOMPILE_SRC_DIR}/rand_r_test.c"
+)
+
+try_compile(
+    HAVE_PTHREAD_SETNAME_GNU
+    "${CMAKE_CURRENT_BINARY_DIR}/try_compile"
+    "${TRYCOMPILE_SRC_DIR}/pthread_setname_gnu_test.c"
+    COMPILE_DEFINITIONS "-D_GNU_SOURCE"
+    LINK_LIBRARIES "-lpthread"
+)
+
+try_compile(
+    HAVE_PTHREAD_SETNAME_DARWIN
+    "${CMAKE_CURRENT_BINARY_DIR}/try_compile"
+    "${TRYCOMPILE_SRC_DIR}/pthread_setname_darwin_test.c"
+    COMPILE_DEFINITIONS "-D_DARWIN_C_SOURCE"
+    LINK_LIBRARIES "-lpthread"
+)
+
+try_compile(
+    HAVE_PTHREAD_SETNAME_FREEBSD
+    "${CMAKE_CURRENT_BINARY_DIR}/try_compile"
+    "${TRYCOMPILE_SRC_DIR}/pthread_setname_freebsd_test.c"
+    LINK_LIBRARIES "-lpthread"
+)
+
+# Atomic 32 tests {
+set(LINK_ATOMIC NO)
+set(HAVE_ATOMICS_32 NO)
+set(HAVE_ATOMICS_32_SYNC NO)
+
+try_compile(
+    _atomics_32
+    "${CMAKE_CURRENT_BINARY_DIR}/try_compile"
+    "${TRYCOMPILE_SRC_DIR}/atomic_32_test.c"
+)
+
+if(_atomics_32)
+  set(HAVE_ATOMICS_32 YES)
+else()
+  try_compile(
+      _atomics_32_lib
+      "${CMAKE_CURRENT_BINARY_DIR}/try_compile"
+      "${TRYCOMPILE_SRC_DIR}/atomic_32_test.c"
+      LINK_LIBRARIES "-latomic"
+  )
+  if(_atomics_32_lib)
+    set(HAVE_ATOMICS_32 YES)
+    set(LINK_ATOMIC YES)
+  else()
+    try_compile(
+        HAVE_ATOMICS_32_SYNC
+        "${CMAKE_CURRENT_BINARY_DIR}/try_compile"
+        "${TRYCOMPILE_SRC_DIR}/sync_32_test.c"
+    )
+  endif()
+endif()
+# }
+
+# Atomic 64 tests {
+set(HAVE_ATOMICS_64 NO)
+set(HAVE_ATOMICS_64_SYNC NO)
+
+try_compile(
+    _atomics_64
+    "${CMAKE_CURRENT_BINARY_DIR}/try_compile"
+    "${TRYCOMPILE_SRC_DIR}/atomic_64_test.c"
+)
+
+if(_atomics_64)
+  set(HAVE_ATOMICS_64 YES)
+else()
+  try_compile(
+      _atomics_64_lib
+      "${CMAKE_CURRENT_BINARY_DIR}/try_compile"
+      "${TRYCOMPILE_SRC_DIR}/atomic_64_test.c"
+      LINK_LIBRARIES "-latomic"
+  )
+  if(_atomics_64_lib)
+    set(HAVE_ATOMICS_64 YES)
+    set(LINK_ATOMIC YES)
+  else()
+    try_compile(
+        HAVE_ATOMICS_64_SYNC
+        "${CMAKE_CURRENT_BINARY_DIR}/try_compile"
+        "${TRYCOMPILE_SRC_DIR}/sync_64_test.c"
+    )
+  endif()
+endif()
+# }
+
+# C11 threads
+try_compile(
+    WITH_C11THREADS
+    "${CMAKE_CURRENT_BINARY_DIR}/try_compile"
+    "${TRYCOMPILE_SRC_DIR}/c11threads_test.c"
+    LINK_LIBRARIES "-pthread"
+)
+# }
+
+# CRC32C {
+try_compile(
+    WITH_CRC32C_HW
+    "${CMAKE_CURRENT_BINARY_DIR}/try_compile"
+    "${TRYCOMPILE_SRC_DIR}/crc32c_hw_test.c"
+)
+# }

package/deps/librdkafka/packaging/cmake/try_compile/regex_test.c

@@ -0,0 +1,10 @@
+#include <stddef.h>
+#include <regex.h>
+
+int main() {
+        regcomp(NULL, NULL, 0);
+        regexec(NULL, NULL, 0, NULL, 0);
+        regerror(0, NULL, NULL, 0);
+        regfree(NULL);
+        return 0;
+}

package/deps/librdkafka/packaging/cmake/try_compile/strndup_test.c

@@ -0,0 +1,5 @@
+#include <string.h>
+
+int main() {
+        return strndup("hi", 2) ? 0 : 1;
+}

package/deps/librdkafka/packaging/cmake/try_compile/sync_32_test.c

@@ -0,0 +1,8 @@
+#include <inttypes.h>
+
+int32_t foo(int32_t i) {
+        return __sync_add_and_fetch(&i, 1);
+}
+
+int main() {
+}

package/deps/librdkafka/packaging/cmake/try_compile/sync_64_test.c

@@ -0,0 +1,8 @@
+#include <inttypes.h>
+
+int64_t foo(int64_t i) {
+        return __sync_add_and_fetch(&i, 1);
+}
+
+int main() {
+}

package/deps/librdkafka/packaging/cp/README.md

@@ -0,0 +1,16 @@
+# Confluent Platform package verification
+
+This small set of scripts verifies the librdkafka packages that
+are part of the Confluent Platform.
+
+The base_url is the http S3 bucket path to the a PR job, or similar.
+Pass the platform (e.g. linux/arm64) and the expected librdkafka version too.
+
+## How to use
+
+```
+$ ./verify-packages.sh https://packages.confluent.io linux/amd64 2.8.0
+```
+
+Requires docker and patience.
+

package/deps/librdkafka/packaging/cp/check_features.c

@@ -0,0 +1,72 @@
+#include <stdio.h>
+#include <string.h>
+#include <librdkafka/rdkafka.h>
+
+int main(int argc, char **argv) {
+        rd_kafka_conf_t *conf;
+        char buf[512];
+        size_t sz = sizeof(buf);
+        rd_kafka_conf_res_t res;
+        static const char *expected_features = "ssl,sasl_gssapi,lz4,zstd";
+        char errstr[512];
+        int i;
+        int failures = 0;
+
+        printf("librdkafka %s (0x%x, define: 0x%x)\n", rd_kafka_version_str(),
+               rd_kafka_version(), RD_KAFKA_VERSION);
+
+        if (argc < 2 || (argc > 2 && (argc & 1))) {
+                printf(
+                    "Usage: %s  <version_string> [config.property config-value "
+                    "..]\n",
+                    argv[0]);
+                return 1;
+        }
+
+        if (!strstr(rd_kafka_version_str(), argv[1])) {
+                printf("ERROR: version string mismatch: expected %s, got %s\n",
+                       argv[1], rd_kafka_version_str());
+                return 1;
+        }
+
+        conf = rd_kafka_conf_new();
+        res  = rd_kafka_conf_get(conf, "builtin.features", buf, &sz);
+
+        if (res != RD_KAFKA_CONF_OK) {
+                printf("ERROR: conf_get failed: %d\n", res);
+                return 1;
+        }
+
+        printf("builtin.features: %s\n", buf);
+
+        /* librdkafka allows checking for expected features
+         * by setting the corresponding feature flags in builtin.features,
+         * which will return an error if one or more flags are not enabled. */
+        if (rd_kafka_conf_set(conf, "builtin.features", expected_features,
+                              errstr, sizeof(errstr)) != RD_KAFKA_CONF_OK) {
+                printf(
+                    "ERROR: expected at least features: %s\n"
+                    "got error: %s\n",
+                    expected_features, errstr);
+                failures++;
+        }
+
+        printf("all expected features matched: %s\n", expected_features);
+
+        /* Apply config from argv key value pairs */
+        for (i = 2; i + 1 < argc; i += 2) {
+                printf("verifying config %s=%s\n", argv[i], argv[i + 1]);
+                if (rd_kafka_conf_set(conf, argv[i], argv[i + 1], errstr,
+                                      sizeof(errstr)) != RD_KAFKA_CONF_OK) {
+                        printf("ERROR: failed to set %s=%s: %s\n", argv[i],
+                               argv[i + 1], errstr);
+                        failures++;
+                }
+        }
+
+        rd_kafka_conf_destroy(conf);
+
+        printf("%d failures\n", failures);
+
+        return !!failures;
+}

package/deps/librdkafka/packaging/cp/verify-deb.sh

@@ -0,0 +1,33 @@
+#!/bin/bash
+#
+
+set -e
+
+base_url=$1
+version=$2
+
+if [[ -z $base_url ]]; then
+    echo "Usage: $0 <base_url>"
+    exit 1
+fi
+
+apt-get update
+apt-get install -y apt-transport-https wget gnupg2 lsb-release
+
+wget -qO - ${base_url}/clients/deb/archive.key | apt-key add -
+
+release=$(lsb_release -cs)
+cat >/etc/apt/sources.list.d/Confluent.list <<EOF
+deb $base_url/clients/deb ${release} main
+EOF
+
+apt-get update
+apt-get install -y librdkafka-dev gcc
+
+gcc /v/check_features.c -o /tmp/check_features -lrdkafka
+
+/tmp/check_features $version
+
+# FIXME: publish plugins in newer versions
+# apt-get install -y confluent-librdkafka-plugins
+#/tmp/check_features plugin.library.paths monitoring-interceptor

package/deps/librdkafka/packaging/cp/verify-packages.sh

@@ -0,0 +1,69 @@
+#!/bin/bash
+#
+# Verifies RPM and DEB packages from Confluent Platform
+#
+base_url=$1
+platform=$2
+version=$3
+
+if [[ -z $base_url || -z $version ]]; then
+    echo "Usage: $0 <base-url> <platform> <version>"
+    echo ""
+    echo " <base-url> is the release base bucket URL"
+    echo " <platform> is platform to verify (e.g. linux/amd64)"
+    echo " <version> is the expected version"
+    exit 1
+fi
+
+thisdir="$( cd "$(dirname "$0")" ; pwd -P )"
+
+verify_debian() {
+    local version=$2
+    docker run -v $thisdir:/v $1 /v/verify-deb.sh $base_url $version
+    deb_status=$?
+    if [[ $deb_status == 0 ]]; then
+        echo "SUCCESS: Debian based $1 $2 packages verified"
+    else
+        echo "ERROR: Debian based $1 $2 package verification failed"
+        exit 1
+    fi
+}
+
+verify_rpm() {
+    local version=$2
+    docker run -v $thisdir:/v $1 /v/verify-rpm.sh $base_url $version
+    rpm_status=$?
+    if [[ $rpm_status == 0 ]]; then
+        echo "SUCCESS: RPM $1 $2 packages verified"
+    else
+        echo "ERROR: RPM $1 $2 package verification failed"
+        exit 1
+    fi
+}
+
+verify_rpm_distros() {
+    local platform=$1
+    local version=$2
+    echo "#### Verifying RPM packages for $platform ####"
+    # Last RHEL 8 version is 2.4.0
+    verify_rpm rockylinux:8 "2.4.0"
+    verify_rpm rockylinux:9 $version
+}
+
+verify_debian_distros() {
+    local platform=$1
+    local version=$2
+    echo "#### Verifying Debian packages for $platform ####"
+    verify_debian debian:11 $version
+    verify_debian debian:12 $version
+    verify_debian ubuntu:20.04 $version
+    verify_debian ubuntu:22.04 $version
+    verify_debian ubuntu:24.04 $version
+}
+
+verify_distros() {
+    verify_rpm_distros $1 $2
+    verify_debian_distros $1 $2
+}
+
+verify_distros $platform $version

package/deps/librdkafka/packaging/cp/verify-rpm.sh

@@ -0,0 +1,32 @@
+#!/bin/bash
+#
+
+set -e
+
+base_url=$1
+version=$2
+
+if [[ -z $base_url ]]; then
+    echo "Usage: $0 <base_url>"
+    exit 1
+fi
+
+cat >/etc/yum.repos.d/Confluent.repo <<EOF
+[Confluent-Clients]
+name=Confluent Clients repository
+baseurl=$base_url/clients/rpm/centos/\$releasever/\$basearch
+gpgcheck=1
+gpgkey=$base_url/clients/rpm/archive.key
+enabled=1
+EOF
+
+yum install -y librdkafka-devel gcc
+
+gcc /v/check_features.c -o /tmp/check_features -lrdkafka
+
+/tmp/check_features $version
+
+# Verify plugins
+# yum install -y confluent-librdkafka-plugins
+
+# /tmp/check_features plugin.library.paths monitoring-interceptor