@point3/node-rdkafka 3.6.0-1

package/deps/librdkafka/tests/rusage.c

@@ -0,0 +1,249 @@
+/*
+ * librdkafka - The Apache Kafka C/C++ library
+ *
+ * Copyright (c) 2019-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.
+ */
+
+
+/**
+ * @name Track test resource usage.
+ */
+
+#ifdef __APPLE__
+#define _DARWIN_C_SOURCE /* required for rusage.ru_maxrss, etc. */
+#endif
+
+#include "test.h"
+
+#if HAVE_GETRUSAGE
+
+#include <sys/time.h>
+#include <sys/resource.h>
+#include "rdfloat.h"
+
+
+/**
+ * @brief Call getrusage(2)
+ */
+static int test_getrusage(struct rusage *ru) {
+        if (getrusage(RUSAGE_SELF, ru) == -1) {
+                TEST_WARN("getrusage() failed: %s\n", rd_strerror(errno));
+                return -1;
+        }
+
+        return 0;
+}
+
+/* Convert timeval to seconds */
+#define _tv2s(TV)                                                              \
+        (double)((double)(TV).tv_sec + ((double)(TV).tv_usec / 1000000.0))
+
+/* Convert timeval to CPU usage percentage (5 = 5%, 130.3 = 130.3%) */
+#define _tv2cpu(TV, DURATION) ((_tv2s(TV) / (DURATION)) * 100.0)
+
+
+/**
+ * @brief Calculate difference between \p end and \p start rusage.
+ *
+ * @returns the delta
+ */
+static struct rusage test_rusage_calc(const struct rusage *start,
+                                      const struct rusage *end,
+                                      double duration) {
+        struct rusage delta = RD_ZERO_INIT;
+
+        timersub(&end->ru_utime, &start->ru_utime, &delta.ru_utime);
+        timersub(&end->ru_stime, &start->ru_stime, &delta.ru_stime);
+        /* FIXME: maxrss doesn't really work when multiple tests are
+         *        run in the same process since it only registers the
+         *        maximum RSS, not the current one.
+         *        Read this from /proc/<pid>/.. instead */
+        delta.ru_maxrss = end->ru_maxrss - start->ru_maxrss;
+        delta.ru_nvcsw  = end->ru_nvcsw - start->ru_nvcsw;
+        /* skip fields we're not interested in */
+
+        TEST_SAY(_C_MAG
+                 "Test resource usage summary: "
+                 "%.3fs (%.1f%%) User CPU time, "
+                 "%.3fs (%.1f%%) Sys CPU time, "
+                 "%.3fMB RSS memory increase, "
+                 "%ld Voluntary context switches\n",
+                 _tv2s(delta.ru_utime), _tv2cpu(delta.ru_utime, duration),
+                 _tv2s(delta.ru_stime), _tv2cpu(delta.ru_stime, duration),
+                 (double)delta.ru_maxrss / (1024.0 * 1024.0), delta.ru_nvcsw);
+
+        return delta;
+}
+
+
+/**
+ * @brief Check that test ran within threshold levels
+ */
+static int test_rusage_check_thresholds(struct test *test,
+                                        const struct rusage *ru,
+                                        double duration) {
+        static const struct rusage_thres defaults = {
+            .ucpu  = 5.0,  /* min value, see below */
+            .scpu  = 2.5,  /* min value, see below */
+            .rss   = 10.0, /* 10 megs */
+            .ctxsw = 100,  /* this is the default number of context switches
+                            * per test second.
+                            * note: when ctxsw is specified on a test
+                            *       it should be specified as the total
+                            *       number of context switches. */
+        };
+        /* CPU usage thresholds are too blunt for very quick tests.
+         * Use a forgiving default CPU threshold for any test that
+         * runs below a certain duration. */
+        const double min_duration = 2.0; /* minimum test duration for
+                                          * CPU thresholds to have effect. */
+        const double lax_cpu = 1000.0;   /* 1000% CPU usage (e.g 10 cores
+                                          * at full speed) allowed for any
+                                          * test that finishes in under 2s */
+        const struct rusage_thres *thres = &test->rusage_thres;
+        double cpu, mb, uthres, uthres_orig, sthres, rssthres;
+        int csthres;
+        char reasons[3][128];
+        int fails = 0;
+
+        if (duration < min_duration)
+                uthres = lax_cpu;
+        else if (rd_dbl_zero((uthres = thres->ucpu)))
+                uthres = defaults.ucpu;
+
+        uthres_orig = uthres;
+        uthres *= test_rusage_cpu_calibration;
+
+        cpu = _tv2cpu(ru->ru_utime, duration);
+        if (cpu > uthres) {
+                rd_snprintf(reasons[fails], sizeof(reasons[fails]),
+                            "User CPU time (%.3fs) exceeded: %.1f%% > %.1f%%",
+                            _tv2s(ru->ru_utime), cpu, uthres);
+                TEST_WARN("%s\n", reasons[fails]);
+                fails++;
+        }
+
+        /* Let the default Sys CPU be the maximum of the defaults.cpu
+         * and 20% of the User CPU. */
+        if (rd_dbl_zero((sthres = thres->scpu)))
+                sthres = duration < min_duration
+                             ? lax_cpu
+                             : RD_MAX(uthres_orig * 0.20, defaults.scpu);
+
+        sthres *= test_rusage_cpu_calibration;
+
+        cpu = _tv2cpu(ru->ru_stime, duration);
+        if (cpu > sthres) {
+                rd_snprintf(reasons[fails], sizeof(reasons[fails]),
+                            "Sys CPU time (%.3fs) exceeded: %.1f%% > %.1f%%",
+                            _tv2s(ru->ru_stime), cpu, sthres);
+                TEST_WARN("%s\n", reasons[fails]);
+                fails++;
+        }
+
+        rssthres = thres->rss > 0.0 ? thres->rss : defaults.rss;
+        if ((mb = (double)ru->ru_maxrss / (1024.0 * 1024.0)) > rssthres) {
+                rd_snprintf(reasons[fails], sizeof(reasons[fails]),
+                            "RSS memory exceeded: %.2fMB > %.2fMB", mb,
+                            rssthres);
+                TEST_WARN("%s\n", reasons[fails]);
+                fails++;
+        }
+
+
+        if (!(csthres = thres->ctxsw))
+                csthres = duration < min_duration
+                              ? defaults.ctxsw * 100
+                              : (int)(duration * (double)defaults.ctxsw);
+
+        /* FIXME: not sure how to use this */
+        if (0 && ru->ru_nvcsw > csthres) {
+                TEST_WARN(
+                    "Voluntary context switches exceeded: "
+                    "%ld > %d\n",
+                    ru->ru_nvcsw, csthres);
+                fails++;
+        }
+
+        TEST_ASSERT(fails <= (int)RD_ARRAYSIZE(reasons),
+                    "reasons[] array not big enough (needs %d slots)", fails);
+
+        if (!fails || !test_rusage)
+                return 0;
+
+        TEST_FAIL("Test resource usage exceeds %d threshold(s): %s%s%s%s%s",
+                  fails, reasons[0], fails > 1 ? ", " : "",
+                  fails > 1 ? reasons[1] : "", fails > 2 ? ", " : "",
+                  fails > 2 ? reasons[2] : "");
+
+
+        return -1;
+}
+#endif
+
+
+
+void test_rusage_start(struct test *test) {
+#if HAVE_GETRUSAGE
+        /* Can't do per-test rusage checks when tests run in parallel. */
+        if (test_concurrent_max > 1)
+                return;
+
+        if (test_getrusage(&test->rusage) == -1)
+                return;
+#endif
+}
+
+
+/**
+ * @brief Stop test rusage and check if thresholds were exceeded.
+ *        Call when test has finished.
+ *
+ * @returns -1 if thresholds were exceeded, else 0.
+ */
+int test_rusage_stop(struct test *test, double duration) {
+#if HAVE_GETRUSAGE
+        struct rusage start, end;
+
+        /* Can't do per-test rusage checks when tests run in parallel. */
+        if (test_concurrent_max > 1)
+                return 0;
+
+        if (test_getrusage(&end) == -1)
+                return 0;
+
+        /* Let duration be at least 1ms to avoid
+         * too-close-to-zero comparisons */
+        if (duration < 0.001)
+                duration = 0.001;
+
+        start        = test->rusage;
+        test->rusage = test_rusage_calc(&start, &end, duration);
+
+        return test_rusage_check_thresholds(test, &test->rusage, duration);
+#else
+        return 0;
+#endif
+}

package/deps/librdkafka/tests/sasl_test.py

@@ -0,0 +1,289 @@
+#!/usr/bin/env python3
+#
+#
+# Run librdkafka regression tests on with different SASL parameters
+# and broker verisons.
+#
+# Requires:
+#  trivup python module
+#  gradle in your PATH
+
+from cluster_testing import (
+    print_report_summary,
+    print_test_report_summary,
+    read_scenario_conf)
+from broker_version_tests import test_it
+
+import os
+import sys
+import argparse
+import json
+import tempfile
+
+
+def handle_report(report, version, suite):
+    """ Parse test report and return tuple (Passed(bool), Reason(str)) """
+    test_cnt = report.get('tests_run', 0)
+
+    if test_cnt == 0:
+        return (False, 'No tests run')
+
+    passed = report.get('tests_passed', 0)
+    failed = report.get('tests_failed', 0)
+    if 'all' in suite.get('expect_fail', []) or version in suite.get(
+            'expect_fail', []):
+        expect_fail = True
+    else:
+        expect_fail = False
+
+    if expect_fail:
+        if failed == test_cnt:
+            return (True, 'All %d/%d tests failed as expected' %
+                    (failed, test_cnt))
+        else:
+            return (False, '%d/%d tests failed: expected all to fail' %
+                    (failed, test_cnt))
+    else:
+        if failed > 0:
+            return (False, '%d/%d tests passed: expected all to pass' %
+                    (passed, test_cnt))
+        else:
+            return (True, 'All %d/%d tests passed as expected' %
+                    (passed, test_cnt))
+
+
+if __name__ == '__main__':
+
+    parser = argparse.ArgumentParser(
+        description='Run librdkafka test suit using SASL on a '
+        'trivupped cluster')
+
+    parser.add_argument('--conf', type=str, dest='conf', default=None,
+                        help='trivup JSON config object (not file)')
+    parser.add_argument('--rdkconf', type=str, dest='rdkconf', default=None,
+                        help='trivup JSON config object (not file) '
+                        'for LibrdkafkaTestApp')
+    parser.add_argument('--scenario', type=str, dest='scenario',
+                        default='default',
+                        help='Test scenario (see scenarios/ directory)')
+    parser.add_argument('--tests', type=str, dest='tests', default=None,
+                        help='Test to run (e.g., "0002")')
+    parser.add_argument('--no-ssl', action='store_false', dest='ssl',
+                        default=True,
+                        help='Don\'t run SSL tests')
+    parser.add_argument('--no-sasl', action='store_false', dest='sasl',
+                        default=True,
+                        help='Don\'t run SASL tests')
+    parser.add_argument('--no-oidc', action='store_false', dest='oidc',
+                        default=True,
+                        help='Don\'t run OAuth/OIDC tests')
+    parser.add_argument('--no-plaintext', action='store_false',
+                        dest='plaintext', default=True,
+                        help='Don\'t run PLAINTEXT tests')
+
+    parser.add_argument('--report', type=str, dest='report', default=None,
+                        help='Write test suites report to this filename')
+    parser.add_argument('--debug', action='store_true', dest='debug',
+                        default=False,
+                        help='Enable trivup debugging')
+    parser.add_argument('--suite', type=str, default=None,
+                        help='Only run matching suite(s) (substring match)')
+    parser.add_argument('versions', type=str, default=None,
+                        nargs='*', help='Limit broker versions to these')
+    parser.add_argument(
+        '--kraft',
+        dest='kraft',
+        action='store_true',
+        default=False,
+        help='Run in KRaft mode')
+
+    args = parser.parse_args()
+
+    conf = dict()
+    rdkconf = dict()
+
+    if args.conf is not None:
+        conf.update(json.loads(args.conf))
+    if args.rdkconf is not None:
+        rdkconf.update(json.loads(args.rdkconf))
+    if args.tests is not None:
+        tests = args.tests.split(',')
+    else:
+        tests = None
+
+    conf.update(read_scenario_conf(args.scenario))
+
+    # Test version,supported mechs + suite matrix
+    versions = list()
+    if len(args.versions):
+        for v in args.versions:
+            versions.append(
+                (v, ['SCRAM-SHA-512', 'PLAIN', 'GSSAPI', 'OAUTHBEARER']))
+    else:
+        versions = [('3.1.0',
+                     ['SCRAM-SHA-512', 'PLAIN', 'GSSAPI', 'OAUTHBEARER']),
+                    ('2.1.0',
+                     ['SCRAM-SHA-512', 'PLAIN', 'GSSAPI', 'OAUTHBEARER']),
+                    ('0.10.2.0', ['SCRAM-SHA-512', 'PLAIN', 'GSSAPI']),
+                    ('0.9.0.1', ['GSSAPI']),
+                    ('0.8.2.2', [])]
+    sasl_plain_conf = {'sasl_mechanisms': 'PLAIN',
+                       'sasl_users': 'myuser=mypassword'}
+    sasl_scram_conf = {'sasl_mechanisms': 'SCRAM-SHA-512',
+                       'sasl_users': 'myuser=mypassword'}
+    ssl_sasl_plain_conf = {'sasl_mechanisms': 'PLAIN',
+                           'sasl_users': 'myuser=mypassword',
+                           'security.protocol': 'SSL'}
+    sasl_oauthbearer_conf = {'sasl_mechanisms': 'OAUTHBEARER',
+                             'sasl_oauthbearer_config':
+                             'scope=requiredScope principal=admin'}
+    sasl_oauth_oidc_conf = {'sasl_mechanisms': 'OAUTHBEARER',
+                            'sasl_oauthbearer_method': 'OIDC'}
+    sasl_kerberos_conf = {'sasl_mechanisms': 'GSSAPI',
+                          'sasl_servicename': 'kafka'}
+    suites = [{'name': 'SASL PLAIN',
+               'run': (args.sasl and args.plaintext),
+               'conf': sasl_plain_conf,
+               'tests': ['0001'],
+               'expect_fail': ['0.9.0.1', '0.8.2.2']},
+              {'name': 'SASL SCRAM',
+               'run': (args.sasl and args.plaintext),
+               'conf': sasl_scram_conf,
+               'expect_fail': ['0.9.0.1', '0.8.2.2']},
+              {'name': 'PLAINTEXT (no SASL)',
+               'run': args.plaintext,
+               'tests': ['0001']},
+              {'name': 'SSL (no SASL)',
+               'run': args.ssl,
+               'conf': {'security.protocol': 'SSL'},
+               'expect_fail': ['0.8.2.2']},
+              {'name': 'SASL_SSL PLAIN',
+               'run': (args.sasl and args.ssl and args.plaintext),
+               'conf': ssl_sasl_plain_conf,
+               'expect_fail': ['0.9.0.1', '0.8.2.2']},
+              {'name': 'SASL PLAIN with wrong username',
+               'run': (args.sasl and args.plaintext),
+               'conf': sasl_plain_conf,
+               'rdkconf': {'sasl_users': 'wrongjoe=mypassword'},
+               'tests': ['0001'],
+               'expect_fail': ['all']},
+              {'name': 'SASL OAUTHBEARER',
+               'run': args.sasl,
+               'conf': sasl_oauthbearer_conf,
+               'tests': ['0001'],
+               'expect_fail': ['0.10.2.0', '0.9.0.1', '0.8.2.2']},
+              {'name': 'SASL OAUTHBEARER with wrong scope',
+               'run': args.sasl,
+               'conf': sasl_oauthbearer_conf,
+               'rdkconf': {'sasl_oauthbearer_config': 'scope=wrongScope'},
+               'tests': ['0001'],
+               'expect_fail': ['all']},
+              {'name': 'OAuth/OIDC',
+               'run': args.oidc,
+               'tests': ['0001', '0126'],
+               'conf': sasl_oauth_oidc_conf,
+               'minver': '3.1.0',
+               'expect_fail': ['2.8.1', '2.1.0', '0.10.2.0',
+                               '0.9.0.1', '0.8.2.2']},
+              {'name': 'SASL Kerberos',
+               'run': args.sasl,
+               'conf': sasl_kerberos_conf,
+               'expect_fail': ['0.8.2.2']}]
+
+    pass_cnt = 0
+    fail_cnt = 0
+    for version, supported in versions:
+        if len(args.versions) > 0 and version not in args.versions:
+            print('### Skipping version %s' % version)
+            continue
+
+        for suite in suites:
+            if not suite.get('run', True):
+                continue
+
+            if args.suite is not None and suite['name'].find(args.suite) == -1:
+                print(
+                    f'# Skipping {suite["name"]} due to --suite {args.suite}')
+                continue
+
+            if 'minver' in suite:
+                minver = [int(x) for x in suite['minver'].split('.')][:3]
+                this_version = [int(x) for x in version.split('.')][:3]
+                if this_version < minver:
+                    print(
+                        f'# Skipping {suite["name"]} due to version {version} < minimum required version {suite["minver"]}')  # noqa: E501
+                    continue
+
+            _conf = conf.copy()
+            _conf.update(suite.get('conf', {}))
+            _rdkconf = _conf.copy()
+            _rdkconf.update(rdkconf)
+            _rdkconf.update(suite.get('rdkconf', {}))
+
+            if 'version' not in suite:
+                suite['version'] = dict()
+
+            # Disable SASL broker config if broker version does
+            # not support the selected mechanism
+            mech = suite.get('conf', dict()).get('sasl_mechanisms', None)
+            if mech is not None and mech not in supported:
+                print('# Disabled SASL for broker version %s' % version)
+                _conf.pop('sasl_mechanisms', None)
+
+            # Run tests
+            print(
+                '#### Version %s, suite %s: STARTING' %
+                (version, suite['name']))
+            if tests is None:
+                tests_to_run = suite.get('tests', None)
+            else:
+                tests_to_run = tests
+            report = test_it(version, tests=tests_to_run, conf=_conf,
+                             rdkconf=_rdkconf,
+                             debug=args.debug, scenario=args.scenario,
+                             kraft=args.kraft)
+
+            # Handle test report
+            report['version'] = version
+            passed, reason = handle_report(report, version, suite)
+            report['PASSED'] = passed
+            report['REASON'] = reason
+
+            if passed:
+                print('\033[42m#### Version %s, suite %s: PASSED: %s\033[0m' %
+                      (version, suite['name'], reason))
+                pass_cnt += 1
+            else:
+                print('\033[41m#### Version %s, suite %s: FAILED: %s\033[0m' %
+                      (version, suite['name'], reason))
+                print_test_report_summary('%s @ %s' %
+                                          (suite['name'], version), report)
+                fail_cnt += 1
+            print('#### Test output: %s/stderr.log' % (report['root_path']))
+
+            suite['version'][version] = report
+
+    # Write test suite report JSON file
+    if args.report is not None:
+        test_suite_report_file = args.report
+        f = open(test_suite_report_file, 'w')
+    else:
+        fd, test_suite_report_file = tempfile.mkstemp(prefix='test_suite_',
+                                                      suffix='.json',
+                                                      dir='.')
+        f = os.fdopen(fd, 'w')
+
+    full_report = {'suites': suites, 'pass_cnt': pass_cnt,
+                   'fail_cnt': fail_cnt, 'total_cnt': pass_cnt + fail_cnt}
+
+    f.write(json.dumps(full_report))
+    f.close()
+
+    print('\n\n\n')
+    print_report_summary(full_report)
+    print('#### Full test suites report in: %s' % test_suite_report_file)
+
+    if pass_cnt == 0 or fail_cnt > 0:
+        sys.exit(1)
+    else:
+        sys.exit(0)

package/deps/librdkafka/tests/scenarios/README.md

@@ -0,0 +1,6 @@
+# Test scenarios
+
+A test scenario defines the trivup Kafka cluster setup.
+
+The scenario name is the name of the file (without .json extension)
+and the contents is the trivup configuration dict.

package/deps/librdkafka/tests/scenarios/ak23.json

@@ -0,0 +1,6 @@
+{
+    "versions": ["2.3.0"],
+    "auto_create_topics": "true",
+    "num_partitions": 4,
+    "replication_factor": 3,
+}

package/deps/librdkafka/tests/scenarios/default.json

@@ -0,0 +1,5 @@
+{
+    "auto_create_topics": "true",
+    "num_partitions": 4,
+    "replication_factor": 3,
+}

package/deps/librdkafka/tests/scenarios/noautocreate.json

@@ -0,0 +1,5 @@
+{
+    "auto_create_topics": "false",
+    "num_partitions": 4,
+    "replication_factor": 3,
+}