/**
* @brief This is called prior to parsing the ProduceResponse,
* we use it to inject errors.
*
* @locality an internal rdkafka thread
*/
static rd_kafka_resp_err_t handle_ProduceResponse (rd_kafka_t *rk,
int32_t brokerid,
uint64_t msgseq,
rd_kafka_resp_err_t err) {
rd_kafka_resp_err_t new_err = err;
int n;
if (err == RD_KAFKA_RESP_ERR__RETRY)
return err; /* Skip internal retries, such as triggered by
* rd_kafka_broker_bufq_purge_by_toppar() */
n = rd_atomic32_add(&state.produce_cnt, 1);
/* Let the first N ProduceRequests fail with request timeout.
* Do allow the first request through. */
if (n > 1 && n <= state.initial_fail_batch_cnt) {
if (err)
TEST_WARN("First %d ProduceRequests should not "
"have failed, this is #%d with error %s for "
"brokerid %"PRId32" and msgseq %"PRIu64"\n",
state.initial_fail_batch_cnt, n,
rd_kafka_err2name(err), brokerid, msgseq);
assert(!err &&
*"First N ProduceRequests should not have failed");
new_err = RD_KAFKA_RESP_ERR__TIMED_OUT;
}
TEST_SAY("handle_ProduceResponse(broker %"PRId32
", MsgSeq %"PRId64", Error %s) -> new Error %s\n",
brokerid, msgseq,
rd_kafka_err2name(err),
rd_kafka_err2name(new_err));
return new_err;
}
static void dr_msg_cb (rd_kafka_t *rk, const rd_kafka_message_t *rkmessage,
void *opaque) {
msg_dr_cnt++;
TEST_SAYL(3, "Delivery for message %.*s: %s\n",
(int)rkmessage->len, (const char *)rkmessage->payload,
rd_kafka_err2name(rkmessage->err));
if (rkmessage->err) {
TEST_FAIL_LATER("Expected message to succeed, got %s",
rd_kafka_err2str(rkmessage->err));
msg_dr_fail_cnt++;
}
}
/**
* @brief Local test: test event generation
*/
int main_0039_event (int argc, char **argv) {
rd_kafka_t *rk;
rd_kafka_conf_t *conf;
rd_kafka_queue_t *eventq;
int waitevent = 1;
/* Set up a config with ERROR events enabled and
* configure an invalid broker so that _TRANSPORT or ALL_BROKERS_DOWN
* is promptly generated. */
conf = rd_kafka_conf_new();
rd_kafka_conf_set_events(conf, RD_KAFKA_EVENT_ERROR);
rd_kafka_conf_set(conf, "bootstrap.servers", "0:65534", NULL, 0);
/* Create kafka instance */
rk = test_create_handle(RD_KAFKA_PRODUCER, conf);
eventq = rd_kafka_queue_get_main(rk);
while (waitevent) {
rd_kafka_event_t *rkev;
rkev = rd_kafka_queue_poll(eventq, 1000);
switch (rd_kafka_event_type(rkev))
{
case RD_KAFKA_EVENT_ERROR:
TEST_SAY("Got %s%s event: %s: %s\n",
rd_kafka_event_error_is_fatal(rkev) ?
"FATAL " : "",
rd_kafka_event_name(rkev),
rd_kafka_err2name(rd_kafka_event_error(rkev)),
rd_kafka_event_error_string(rkev));
waitevent = 0;
break;
default:
TEST_SAY("Unhandled event: %s\n",
rd_kafka_event_name(rkev));
break;
}
rd_kafka_event_destroy(rkev);
}
rd_kafka_queue_destroy(eventq);
/* Destroy rdkafka instance */
TEST_SAY("Destroying kafka instance %s\n", rd_kafka_name(rk));
rd_kafka_destroy(rk);
return 0;
}
static void rebalance_cb (rd_kafka_t *rk,
rd_kafka_resp_err_t err,
rd_kafka_topic_partition_list_t *parts,
void *opaque) {
struct _consumer *cons = opaque;
cons->rebalance_cnt++;
TEST_SAY(_C_BLU "%s rebalance #%d/%d: %s: %d partition(s)\n",
rd_kafka_name(cons->rk),
cons->rebalance_cnt, cons->max_rebalance_cnt,
rd_kafka_err2name(err),
parts->cnt);
TEST_ASSERT(cons->rebalance_cnt <= cons->max_rebalance_cnt,
"%s rebalanced %d times, max was %d",
rd_kafka_name(cons->rk),
cons->rebalance_cnt, cons->max_rebalance_cnt);
if (err == RD_KAFKA_RESP_ERR__ASSIGN_PARTITIONS)
rd_kafka_assign(rk, parts);
else
rd_kafka_assign(rk, NULL);
}
/**
* @brief Test DescribeConfigs
*/
static void do_test_DescribeConfigs (rd_kafka_t *rk, rd_kafka_queue_t *rkqu) {
#define MY_CONFRES_CNT 3
char *topics[MY_CONFRES_CNT];
rd_kafka_ConfigResource_t *configs[MY_CONFRES_CNT];
rd_kafka_AdminOptions_t *options;
rd_kafka_resp_err_t exp_err[MY_CONFRES_CNT];
rd_kafka_event_t *rkev;
rd_kafka_resp_err_t err;
const rd_kafka_DescribeConfigs_result_t *res;
const rd_kafka_ConfigResource_t **rconfigs;
size_t rconfig_cnt;
char errstr[128];
const char *errstr2;
int ci = 0;
int i;
int fails = 0;
/*
* Only create one topic, the others will be non-existent.
*/
rd_strdupa(&topics[0], test_mk_topic_name("DescribeConfigs_exist", 1));
for (i = 1 ; i < MY_CONFRES_CNT ; i++)
rd_strdupa(&topics[i],
test_mk_topic_name("DescribeConfigs_notexist", 1));
test_CreateTopics_simple(rk, NULL, topics, 1, 1, NULL);
/*
* ConfigResource #0: topic config, no config entries.
*/
configs[ci] = rd_kafka_ConfigResource_new(
RD_KAFKA_RESOURCE_TOPIC, topics[ci]);
exp_err[ci] = RD_KAFKA_RESP_ERR_NO_ERROR;
ci++;
/*
* ConfigResource #1:broker config, no config entries
*/
configs[ci] = rd_kafka_ConfigResource_new(
RD_KAFKA_RESOURCE_BROKER,
tsprintf("%"PRId32, avail_brokers[0]));
exp_err[ci] = RD_KAFKA_RESP_ERR_NO_ERROR;
ci++;
/*
* ConfigResource #2: topic config, non-existent topic, no config entr.
*/
configs[ci] = rd_kafka_ConfigResource_new(
RD_KAFKA_RESOURCE_TOPIC, topics[ci]);
/* FIXME: This is a bug in the broker (<v2.0.0), it returns a full response
* for unknown topics.
* https://issues.apache.org/jira/browse/KAFKA-6778
*/
if (test_broker_version < TEST_BRKVER(2,0,0,0))
exp_err[ci] = RD_KAFKA_RESP_ERR_NO_ERROR;
else
exp_err[ci] = RD_KAFKA_RESP_ERR_UNKNOWN_TOPIC_OR_PART;
ci++;
/*
* Timeout options
*/
options = rd_kafka_AdminOptions_new(rk, RD_KAFKA_ADMIN_OP_ANY);
err = rd_kafka_AdminOptions_set_request_timeout(options, 10000, errstr,
sizeof(errstr));
TEST_ASSERT(!err, "%s", errstr);
/*
* Fire off request
*/
rd_kafka_DescribeConfigs(rk, configs, ci, options, rkqu);
rd_kafka_AdminOptions_destroy(options);
/*
* Wait for result
*/
rkev = test_wait_admin_result(rkqu,
RD_KAFKA_EVENT_DESCRIBECONFIGS_RESULT,
10000+1000);
/*
* Extract result
*/
res = rd_kafka_event_DescribeConfigs_result(rkev);
TEST_ASSERT(res, "Expected DescribeConfigs result, not %s",
rd_kafka_event_name(rkev));
err = rd_kafka_event_error(rkev);
errstr2 = rd_kafka_event_error_string(rkev);
TEST_ASSERT(!err,
"Expected success, not %s: %s",
rd_kafka_err2name(err), errstr2);
rconfigs = rd_kafka_DescribeConfigs_result_resources(res, &rconfig_cnt);
TEST_ASSERT((int)rconfig_cnt == ci,
"Expected %d result resources, got %"PRIusz"\n",
ci, rconfig_cnt);
/*
* Verify status per resource
*/
for (i = 0 ; i < (int)rconfig_cnt ; i++) {
const rd_kafka_ConfigEntry_t **entries;
size_t entry_cnt;
err = rd_kafka_ConfigResource_error(rconfigs[i]);
errstr2 = rd_kafka_ConfigResource_error_string(rconfigs[i]);
entries = rd_kafka_ConfigResource_configs(rconfigs[i],
&entry_cnt);
TEST_SAY("ConfigResource #%d: type %s (%d), \"%s\": "
"%"PRIusz" ConfigEntries, error %s (%s)\n",
i,
rd_kafka_ResourceType_name(
rd_kafka_ConfigResource_type(rconfigs[i])),
rd_kafka_ConfigResource_type(rconfigs[i]),
rd_kafka_ConfigResource_name(rconfigs[i]),
entry_cnt,
rd_kafka_err2name(err), errstr2 ? errstr2 : "");
test_print_ConfigEntry_array(entries, entry_cnt, 1);
if (rd_kafka_ConfigResource_type(rconfigs[i]) !=
rd_kafka_ConfigResource_type(configs[i]) ||
strcmp(rd_kafka_ConfigResource_name(rconfigs[i]),
rd_kafka_ConfigResource_name(configs[i]))) {
TEST_FAIL_LATER(
"ConfigResource #%d: "
"expected type %s name %s, "
"got type %s name %s",
i,
rd_kafka_ResourceType_name(rd_kafka_ConfigResource_type(configs[i])),
rd_kafka_ConfigResource_name(configs[i]),
rd_kafka_ResourceType_name(rd_kafka_ConfigResource_type(rconfigs[i])),
rd_kafka_ConfigResource_name(rconfigs[i]));
fails++;
continue;
}
if (err != exp_err[i]) {
TEST_FAIL_LATER("ConfigResource #%d: "
"expected %s (%d), got %s (%s)",
i,
rd_kafka_err2name(exp_err[i]),
exp_err[i],
rd_kafka_err2name(err),
errstr2 ? errstr2 : "");
fails++;
}
}
TEST_ASSERT(!fails, "See %d previous failure(s)", fails);
rd_kafka_event_destroy(rkev);
rd_kafka_ConfigResource_destroy_array(configs, ci);
#undef MY_CONFRES_CNT
}
/**
* @brief Test AlterConfigs
*/
static void do_test_AlterConfigs (rd_kafka_t *rk, rd_kafka_queue_t *rkqu) {
#define MY_CONFRES_CNT 3
char *topics[MY_CONFRES_CNT];
rd_kafka_ConfigResource_t *configs[MY_CONFRES_CNT];
rd_kafka_AdminOptions_t *options;
rd_kafka_resp_err_t exp_err[MY_CONFRES_CNT];
rd_kafka_event_t *rkev;
rd_kafka_resp_err_t err;
const rd_kafka_AlterConfigs_result_t *res;
const rd_kafka_ConfigResource_t **rconfigs;
size_t rconfig_cnt;
char errstr[128];
const char *errstr2;
int ci = 0;
int i;
int fails = 0;
/*
* Only create one topic, the others will be non-existent.
*/
for (i = 0 ; i < MY_CONFRES_CNT ; i++)
rd_strdupa(&topics[i], test_mk_topic_name(__FUNCTION__, 1));
test_CreateTopics_simple(rk, NULL, topics, 1, 1, NULL);
/*
* ConfigResource #0: valid topic config
*/
configs[ci] = rd_kafka_ConfigResource_new(
RD_KAFKA_RESOURCE_TOPIC, topics[ci]);
err = rd_kafka_ConfigResource_set_config(configs[ci],
"compression.type", "gzip");
TEST_ASSERT(!err, "%s", rd_kafka_err2str(err));
err = rd_kafka_ConfigResource_set_config(configs[ci],
"flush.ms", "12345678");
TEST_ASSERT(!err, "%s", rd_kafka_err2str(err));
exp_err[ci] = RD_KAFKA_RESP_ERR_NO_ERROR;
ci++;
if (test_broker_version >= TEST_BRKVER(1, 1, 0, 0)) {
/*
* ConfigResource #1: valid broker config
*/
configs[ci] = rd_kafka_ConfigResource_new(
RD_KAFKA_RESOURCE_BROKER,
tsprintf("%"PRId32, avail_brokers[0]));
err = rd_kafka_ConfigResource_set_config(
configs[ci],
"sasl.kerberos.min.time.before.relogin", "58000");
TEST_ASSERT(!err, "%s", rd_kafka_err2str(err));
exp_err[ci] = RD_KAFKA_RESP_ERR_NO_ERROR;
ci++;
} else {
TEST_WARN("Skipping RESOURCE_BROKER test on unsupported "
"broker version\n");
}
/*
* ConfigResource #2: valid topic config, non-existent topic
*/
configs[ci] = rd_kafka_ConfigResource_new(
RD_KAFKA_RESOURCE_TOPIC, topics[ci]);
err = rd_kafka_ConfigResource_set_config(configs[ci],
"compression.type", "lz4");
TEST_ASSERT(!err, "%s", rd_kafka_err2str(err));
err = rd_kafka_ConfigResource_set_config(configs[ci],
"offset.metadata.max.bytes",
"12345");
TEST_ASSERT(!err, "%s", rd_kafka_err2str(err));
exp_err[ci] = RD_KAFKA_RESP_ERR_UNKNOWN;
ci++;
/*
* Timeout options
*/
options = rd_kafka_AdminOptions_new(rk, RD_KAFKA_ADMIN_OP_ALTERCONFIGS);
err = rd_kafka_AdminOptions_set_request_timeout(options, 10000, errstr,
sizeof(errstr));
TEST_ASSERT(!err, "%s", errstr);
/*
* Fire off request
*/
rd_kafka_AlterConfigs(rk, configs, ci, options, rkqu);
rd_kafka_AdminOptions_destroy(options);
/*
* Wait for result
*/
rkev = test_wait_admin_result(rkqu, RD_KAFKA_EVENT_ALTERCONFIGS_RESULT,
10000+1000);
/*
* Extract result
*/
res = rd_kafka_event_AlterConfigs_result(rkev);
TEST_ASSERT(res, "Expected AlterConfigs result, not %s",
rd_kafka_event_name(rkev));
err = rd_kafka_event_error(rkev);
errstr2 = rd_kafka_event_error_string(rkev);
TEST_ASSERT(!err,
"Expected success, not %s: %s",
rd_kafka_err2name(err), errstr2);
rconfigs = rd_kafka_AlterConfigs_result_resources(res, &rconfig_cnt);
TEST_ASSERT((int)rconfig_cnt == ci,
"Expected %d result resources, got %"PRIusz"\n",
ci, rconfig_cnt);
/*
* Verify status per resource
*/
for (i = 0 ; i < (int)rconfig_cnt ; i++) {
const rd_kafka_ConfigEntry_t **entries;
size_t entry_cnt;
err = rd_kafka_ConfigResource_error(rconfigs[i]);
errstr2 = rd_kafka_ConfigResource_error_string(rconfigs[i]);
entries = rd_kafka_ConfigResource_configs(rconfigs[i],
&entry_cnt);
TEST_SAY("ConfigResource #%d: type %s (%d), \"%s\": "
"%"PRIusz" ConfigEntries, error %s (%s)\n",
i,
rd_kafka_ResourceType_name(
rd_kafka_ConfigResource_type(rconfigs[i])),
rd_kafka_ConfigResource_type(rconfigs[i]),
rd_kafka_ConfigResource_name(rconfigs[i]),
entry_cnt,
rd_kafka_err2name(err), errstr2 ? errstr2 : "");
test_print_ConfigEntry_array(entries, entry_cnt, 1);
if (rd_kafka_ConfigResource_type(rconfigs[i]) !=
rd_kafka_ConfigResource_type(configs[i]) ||
strcmp(rd_kafka_ConfigResource_name(rconfigs[i]),
rd_kafka_ConfigResource_name(configs[i]))) {
TEST_FAIL_LATER(
"ConfigResource #%d: "
"expected type %s name %s, "
"got type %s name %s",
i,
rd_kafka_ResourceType_name(rd_kafka_ConfigResource_type(configs[i])),
rd_kafka_ConfigResource_name(configs[i]),
rd_kafka_ResourceType_name(rd_kafka_ConfigResource_type(rconfigs[i])),
rd_kafka_ConfigResource_name(rconfigs[i]));
fails++;
continue;
}
if (err != exp_err[i]) {
TEST_FAIL_LATER("ConfigResource #%d: "
"expected %s (%d), got %s (%s)",
i,
rd_kafka_err2name(exp_err[i]),
exp_err[i],
rd_kafka_err2name(err),
errstr2 ? errstr2 : "");
fails++;
}
}
TEST_ASSERT(!fails, "See %d previous failure(s)", fails);
rd_kafka_event_destroy(rkev);
rd_kafka_ConfigResource_destroy_array(configs, ci);
#undef MY_CONFRES_CNT
}
static void do_test_CreateTopics (const char *what,
rd_kafka_t *rk, rd_kafka_queue_t *useq,
int op_timeout, rd_bool_t validate_only) {
rd_kafka_queue_t *q = useq ? useq : rd_kafka_queue_new(rk);
#define MY_NEW_TOPICS_CNT 6
char *topics[MY_NEW_TOPICS_CNT];
rd_kafka_NewTopic_t *new_topics[MY_NEW_TOPICS_CNT];
rd_kafka_AdminOptions_t *options = NULL;
rd_kafka_resp_err_t exp_topicerr[MY_NEW_TOPICS_CNT] = {0};
rd_kafka_resp_err_t exp_err = RD_KAFKA_RESP_ERR_NO_ERROR;
/* Expected topics in metadata */
rd_kafka_metadata_topic_t exp_mdtopics[MY_NEW_TOPICS_CNT] = {{0}};
int exp_mdtopic_cnt = 0;
/* Not expected topics in metadata */
rd_kafka_metadata_topic_t exp_not_mdtopics[MY_NEW_TOPICS_CNT] = {{0}};
int exp_not_mdtopic_cnt = 0;
int i;
char errstr[512];
const char *errstr2;
rd_kafka_resp_err_t err;
test_timing_t timing;
rd_kafka_event_t *rkev;
const rd_kafka_CreateTopics_result_t *res;
const rd_kafka_topic_result_t **restopics;
size_t restopic_cnt;
int metadata_tmout ;
int num_replicas = (int)avail_broker_cnt;
int32_t *replicas;
/* Set up replicas */
replicas = rd_alloca(sizeof(*replicas) * num_replicas);
for (i = 0 ; i < num_replicas ; i++)
replicas[i] = avail_brokers[i];
TEST_SAY(_C_MAG "[ %s CreateTopics with %s, "
"op_timeout %d, validate_only %d ]\n",
rd_kafka_name(rk), what, op_timeout, validate_only);
/**
* Construct NewTopic array with different properties for
* different partitions.
*/
for (i = 0 ; i < MY_NEW_TOPICS_CNT ; i++) {
char *topic = rd_strdup(test_mk_topic_name(__FUNCTION__, 1));
int num_parts = i * 7 + 1;
int set_config = (i & 1);
int add_invalid_config = (i == 1);
int set_replicas = !(i % 3);
rd_kafka_resp_err_t this_exp_err = RD_KAFKA_RESP_ERR_NO_ERROR;
topics[i] = topic;
new_topics[i] = rd_kafka_NewTopic_new(topic,
num_parts,
set_replicas ? -1 :
num_replicas,
NULL, 0);
if (set_config) {
/*
* Add various configuration properties
*/
err = rd_kafka_NewTopic_set_config(
new_topics[i], "compression.type", "lz4");
TEST_ASSERT(!err, "%s", rd_kafka_err2str(err));
err = rd_kafka_NewTopic_set_config(
new_topics[i], "delete.retention.ms", "900");
TEST_ASSERT(!err, "%s", rd_kafka_err2str(err));
}
if (add_invalid_config) {
/* Add invalid config property */
err = rd_kafka_NewTopic_set_config(
new_topics[i],
"dummy.doesntexist",
"broker is verifying this");
TEST_ASSERT(!err, "%s", rd_kafka_err2str(err));
this_exp_err = RD_KAFKA_RESP_ERR_INVALID_CONFIG;
}
TEST_SAY("Expected result for topic #%d: %s "
"(set_config=%d, add_invalid_config=%d, "
"set_replicas=%d)\n",
i, rd_kafka_err2name(this_exp_err),
set_config, add_invalid_config, set_replicas);
if (set_replicas) {
int32_t p;
/*
* Set valid replica assignments
*/
for (p = 0 ; p < num_parts ; p++) {
err = rd_kafka_NewTopic_set_replica_assignment(
new_topics[i], p,
replicas, num_replicas,
errstr, sizeof(errstr));
TEST_ASSERT(!err, "%s", errstr);
}
}
if (this_exp_err || validate_only) {
exp_topicerr[i] = this_exp_err;
exp_not_mdtopics[exp_not_mdtopic_cnt++].topic = topic;
} else {
exp_mdtopics[exp_mdtopic_cnt].topic = topic;
exp_mdtopics[exp_mdtopic_cnt].partition_cnt =
num_parts;
exp_mdtopic_cnt++;
}
}
if (op_timeout != -1 || validate_only) {
options = rd_kafka_AdminOptions_new(
rk, RD_KAFKA_ADMIN_OP_CREATETOPICS);
if (op_timeout != -1) {
err = rd_kafka_AdminOptions_set_operation_timeout(
options, op_timeout, errstr, sizeof(errstr));
TEST_ASSERT(!err, "%s", rd_kafka_err2str(err));
}
if (validate_only) {
err = rd_kafka_AdminOptions_set_validate_only(
options, validate_only, errstr, sizeof(errstr));
TEST_ASSERT(!err, "%s", rd_kafka_err2str(err));
}
}
TIMING_START(&timing, "CreateTopics");
TEST_SAY("Call CreateTopics\n");
rd_kafka_CreateTopics(rk, new_topics, MY_NEW_TOPICS_CNT,
options, q);
TIMING_ASSERT_LATER(&timing, 0, 50);
/* Poll result queue for CreateTopics result.
* Print but otherwise ignore other event types
* (typically generic Error events). */
TIMING_START(&timing, "CreateTopics.queue_poll");
do {
rkev = rd_kafka_queue_poll(q, tmout_multip(20*1000));
TEST_SAY("CreateTopics: got %s in %.3fms\n",
rd_kafka_event_name(rkev),
TIMING_DURATION(&timing) / 1000.0f);
if (rd_kafka_event_error(rkev))
TEST_SAY("%s: %s\n",
rd_kafka_event_name(rkev),
rd_kafka_event_error_string(rkev));
} while (rd_kafka_event_type(rkev) !=
RD_KAFKA_EVENT_CREATETOPICS_RESULT);
/* Convert event to proper result */
res = rd_kafka_event_CreateTopics_result(rkev);
TEST_ASSERT(res, "expected CreateTopics_result, not %s",
rd_kafka_event_name(rkev));
/* Expecting error */
err = rd_kafka_event_error(rkev);
errstr2 = rd_kafka_event_error_string(rkev);
TEST_ASSERT(err == exp_err,
"expected CreateTopics to return %s, not %s (%s)",
rd_kafka_err2str(exp_err),
rd_kafka_err2str(err),
err ? errstr2 : "n/a");
TEST_SAY("CreateTopics: returned %s (%s)\n",
rd_kafka_err2str(err), err ? errstr2 : "n/a");
/* Extract topics */
restopics = rd_kafka_CreateTopics_result_topics(res, &restopic_cnt);
/* Scan topics for proper fields and expected failures. */
for (i = 0 ; i < (int)restopic_cnt ; i++) {
const rd_kafka_topic_result_t *terr = restopics[i];
/* Verify that topic order matches our request. */
if (strcmp(rd_kafka_topic_result_name(terr), topics[i]))
TEST_FAIL_LATER("Topic result order mismatch at #%d: "
"expected %s, got %s",
i, topics[i],
rd_kafka_topic_result_name(terr));
TEST_SAY("CreateTopics result: #%d: %s: %s: %s\n",
i,
rd_kafka_topic_result_name(terr),
rd_kafka_err2name(rd_kafka_topic_result_error(terr)),
rd_kafka_topic_result_error_string(terr));
if (rd_kafka_topic_result_error(terr) != exp_topicerr[i])
TEST_FAIL_LATER(
"Expected %s, not %d: %s",
rd_kafka_err2name(exp_topicerr[i]),
rd_kafka_topic_result_error(terr),
rd_kafka_err2name(rd_kafka_topic_result_error(
terr)));
}
/**
* Verify that the expecteded topics are created and the non-expected
* are not. Allow it some time to propagate.
*/
if (validate_only) {
/* No topics should have been created, give it some time
* before checking. */
rd_sleep(2);
metadata_tmout = 5 * 1000;
} else {
if (op_timeout > 0)
metadata_tmout = op_timeout + 1000;
else
metadata_tmout = 10 * 1000;
}
test_wait_metadata_update(rk,
exp_mdtopics,
exp_mdtopic_cnt,
exp_not_mdtopics,
exp_not_mdtopic_cnt,
metadata_tmout);
rd_kafka_event_destroy(rkev);
for (i = 0 ; i < MY_NEW_TOPICS_CNT ; i++) {
rd_kafka_NewTopic_destroy(new_topics[i]);
rd_free(topics[i]);
}
if (options)
rd_kafka_AdminOptions_destroy(options);
if (!useq)
rd_kafka_queue_destroy(q);
#undef MY_NEW_TOPICS_CNT
}
/**
* @brief Test deletion of topics
*
*
*/
static void do_test_DeleteTopics (const char *what,
rd_kafka_t *rk, rd_kafka_queue_t *useq,
int op_timeout) {
rd_kafka_queue_t *q = useq ? useq : rd_kafka_queue_new(rk);
const int skip_topic_cnt = 2;
#define MY_DEL_TOPICS_CNT 9
char *topics[MY_DEL_TOPICS_CNT];
rd_kafka_DeleteTopic_t *del_topics[MY_DEL_TOPICS_CNT];
rd_kafka_AdminOptions_t *options = NULL;
rd_kafka_resp_err_t exp_topicerr[MY_DEL_TOPICS_CNT] = {0};
rd_kafka_resp_err_t exp_err = RD_KAFKA_RESP_ERR_NO_ERROR;
/* Expected topics in metadata */
rd_kafka_metadata_topic_t exp_mdtopics[MY_DEL_TOPICS_CNT] = {{0}};
int exp_mdtopic_cnt = 0;
/* Not expected topics in metadata */
rd_kafka_metadata_topic_t exp_not_mdtopics[MY_DEL_TOPICS_CNT] = {{0}};
int exp_not_mdtopic_cnt = 0;
int i;
char errstr[512];
const char *errstr2;
rd_kafka_resp_err_t err;
test_timing_t timing;
rd_kafka_event_t *rkev;
const rd_kafka_DeleteTopics_result_t *res;
const rd_kafka_topic_result_t **restopics;
size_t restopic_cnt;
int metadata_tmout;
TEST_SAY(_C_MAG "[ %s DeleteTopics with %s, op_timeout %d ]\n",
rd_kafka_name(rk), what, op_timeout);
/**
* Construct DeleteTopic array
*/
for (i = 0 ; i < MY_DEL_TOPICS_CNT ; i++) {
char *topic = rd_strdup(test_mk_topic_name(__FUNCTION__, 1));
int notexist_topic = i >= MY_DEL_TOPICS_CNT - skip_topic_cnt;
topics[i] = topic;
del_topics[i] = rd_kafka_DeleteTopic_new(topic);
if (notexist_topic)
exp_topicerr[i] =
RD_KAFKA_RESP_ERR_UNKNOWN_TOPIC_OR_PART;
else {
exp_topicerr[i] =
RD_KAFKA_RESP_ERR_NO_ERROR;
exp_mdtopics[exp_mdtopic_cnt++].topic = topic;
}
exp_not_mdtopics[exp_not_mdtopic_cnt++].topic = topic;
}
if (op_timeout != -1) {
options = rd_kafka_AdminOptions_new(
rk, RD_KAFKA_ADMIN_OP_ANY);
err = rd_kafka_AdminOptions_set_operation_timeout(
options, op_timeout, errstr, sizeof(errstr));
TEST_ASSERT(!err, "%s", rd_kafka_err2str(err));
}
/* Create the topics first, minus the skip count. */
test_CreateTopics_simple(rk, NULL, topics,
MY_DEL_TOPICS_CNT-skip_topic_cnt,
2/*num_partitions*/,
NULL);
/* Verify that topics are reported by metadata */
test_wait_metadata_update(rk,
exp_mdtopics, exp_mdtopic_cnt,
NULL, 0,
15*1000);
TIMING_START(&timing, "DeleteTopics");
TEST_SAY("Call DeleteTopics\n");
rd_kafka_DeleteTopics(rk, del_topics, MY_DEL_TOPICS_CNT,
options, q);
TIMING_ASSERT_LATER(&timing, 0, 50);
/* Poll result queue for DeleteTopics result.
* Print but otherwise ignore other event types
* (typically generic Error events). */
TIMING_START(&timing, "DeleteTopics.queue_poll");
while (1) {
rkev = rd_kafka_queue_poll(q, tmout_multip(20*1000));
TEST_SAY("DeleteTopics: got %s in %.3fms\n",
rd_kafka_event_name(rkev),
TIMING_DURATION(&timing) / 1000.0f);
if (rd_kafka_event_error(rkev))
TEST_SAY("%s: %s\n",
rd_kafka_event_name(rkev),
rd_kafka_event_error_string(rkev));
if (rd_kafka_event_type(rkev) ==
RD_KAFKA_EVENT_DELETETOPICS_RESULT)
break;
rd_kafka_event_destroy(rkev);
}
/* Convert event to proper result */
res = rd_kafka_event_DeleteTopics_result(rkev);
TEST_ASSERT(res, "expected DeleteTopics_result, not %s",
rd_kafka_event_name(rkev));
/* Expecting error */
err = rd_kafka_event_error(rkev);
errstr2 = rd_kafka_event_error_string(rkev);
TEST_ASSERT(err == exp_err,
"expected DeleteTopics to return %s, not %s (%s)",
rd_kafka_err2str(exp_err),
rd_kafka_err2str(err),
err ? errstr2 : "n/a");
TEST_SAY("DeleteTopics: returned %s (%s)\n",
rd_kafka_err2str(err), err ? errstr2 : "n/a");
/* Extract topics */
restopics = rd_kafka_DeleteTopics_result_topics(res, &restopic_cnt);
/* Scan topics for proper fields and expected failures. */
for (i = 0 ; i < (int)restopic_cnt ; i++) {
const rd_kafka_topic_result_t *terr = restopics[i];
/* Verify that topic order matches our request. */
if (strcmp(rd_kafka_topic_result_name(terr), topics[i]))
TEST_FAIL_LATER("Topic result order mismatch at #%d: "
"expected %s, got %s",
i, topics[i],
rd_kafka_topic_result_name(terr));
TEST_SAY("DeleteTopics result: #%d: %s: %s: %s\n",
i,
rd_kafka_topic_result_name(terr),
rd_kafka_err2name(rd_kafka_topic_result_error(terr)),
rd_kafka_topic_result_error_string(terr));
if (rd_kafka_topic_result_error(terr) != exp_topicerr[i])
TEST_FAIL_LATER(
"Expected %s, not %d: %s",
rd_kafka_err2name(exp_topicerr[i]),
rd_kafka_topic_result_error(terr),
rd_kafka_err2name(rd_kafka_topic_result_error(
terr)));
}
/**
* Verify that the expected topics are deleted and the non-expected
* are not. Allow it some time to propagate.
*/
if (op_timeout > 0)
metadata_tmout = op_timeout + 1000;
else
metadata_tmout = 10 * 1000;
test_wait_metadata_update(rk,
NULL, 0,
exp_not_mdtopics,
exp_not_mdtopic_cnt,
metadata_tmout);
rd_kafka_event_destroy(rkev);
for (i = 0 ; i < MY_DEL_TOPICS_CNT ; i++) {
rd_kafka_DeleteTopic_destroy(del_topics[i]);
rd_free(topics[i]);
}
if (options)
rd_kafka_AdminOptions_destroy(options);
if (!useq)
rd_kafka_queue_destroy(q);
#undef MY_DEL_TOPICS_CNT
}
int main_0089_max_poll_interval (int argc, char **argv) {
const char *topic = test_mk_topic_name("0089_max_poll_interval", 1);
uint64_t testid;
const int msgcnt = 10;
rd_kafka_t *c[2];
rd_kafka_conf_t *conf;
int64_t ts_next[2] = { 0, 0 };
int64_t ts_exp_msg[2] = { 0, 0 };
int cmsgcnt = 0;
int i;
int bad = -1;
testid = test_id_generate();
test_create_topic(topic, 1, 1);
test_produce_msgs_easy(topic, testid, -1, msgcnt);
test_conf_init(&conf, NULL, 60);
test_conf_set(conf, "session.timeout.ms", "6000");
test_conf_set(conf, "max.poll.interval.ms", "10000" /*10s*/);
test_conf_set(conf, "auto.offset.reset", "earliest");
c[0] = test_create_consumer(topic, NULL, rd_kafka_conf_dup(conf), NULL);
c[1] = test_create_consumer(topic, NULL, conf, NULL);
test_consumer_subscribe(c[0], topic);
test_consumer_subscribe(c[1], topic);
while (1) {
for (i = 0 ; i < 2 ; i++) {
int64_t now;
rd_kafka_message_t *rkm;
/* Consumer is "processing" */
if (ts_next[i] > test_clock())
continue;
rkm = rd_kafka_consumer_poll(c[i], 100);
if (!rkm)
continue;
if (rkm->err) {
TEST_WARN("Consumer %d error: %s: "
"ignoring\n", i,
rd_kafka_message_errstr(rkm));
continue;
}
now = test_clock();
cmsgcnt++;
TEST_SAY("Consumer %d received message (#%d) "
"at offset %"PRId64"\n",
i, cmsgcnt, rkm->offset);
if (ts_exp_msg[i]) {
/* This consumer is expecting a message
* after a certain time, namely after the
* rebalance following max.poll.. being
* exceeded in the other consumer */
TEST_ASSERT(now > ts_exp_msg[i],
"Consumer %d: did not expect "
"message for at least %dms",
i,
(int)((ts_exp_msg[i] - now)/1000));
TEST_ASSERT(now < ts_exp_msg[i] + 10000*1000,
"Consumer %d: expected message "
"within 10s, not after %dms",
i,
(int)((now - ts_exp_msg[i])/1000));
TEST_SAY("Consumer %d: received message "
"at offset %"PRId64
" after rebalance\n",
i, rkm->offset);
rd_kafka_message_destroy(rkm);
goto done;
} else if (cmsgcnt == 1) {
/* Process this message for 20s */
ts_next[i] = now + (20000 * 1000);
/* Exp message on other consumer after
* max.poll.interval.ms */
ts_exp_msg[i^1] = now + (10000 * 1000);
/* This is the bad consumer */
bad = i;
TEST_SAY("Consumer %d processing message at "
"offset %"PRId64"\n",
i, rkm->offset);
rd_kafka_message_destroy(rkm);
} else {
rd_kafka_message_destroy(rkm);
TEST_FAIL("Consumer %d did not expect "
"a message", i);
}
}
}
done:
TEST_ASSERT(bad != -1, "Bad consumer not set");
/* Wait for error ERR__MAX_POLL_EXCEEDED on the bad consumer. */
while (1) {
rd_kafka_message_t *rkm;
rkm = rd_kafka_consumer_poll(c[bad], 1000);
TEST_ASSERT(rkm, "Expected consumer result within 1s");
TEST_ASSERT(rkm->err, "Did not expect message on bad consumer");
TEST_SAY("Consumer error: %s: %s\n",
rd_kafka_err2name(rkm->err),
rd_kafka_message_errstr(rkm));
if (rkm->err == RD_KAFKA_RESP_ERR__MAX_POLL_EXCEEDED) {
rd_kafka_message_destroy(rkm);
break;
}
rd_kafka_message_destroy(rkm);
}
for (i = 0 ; i < 2 ; i++)
rd_kafka_destroy_flags(c[i],
RD_KAFKA_DESTROY_F_NO_CONSUMER_CLOSE);
return 0;
}
/**
* @brief Test AdminOptions
*/
static void do_test_options (rd_kafka_t *rk) {
#define _all_apis { RD_KAFKA_ADMIN_OP_CREATETOPICS, \
RD_KAFKA_ADMIN_OP_DELETETOPICS, \
RD_KAFKA_ADMIN_OP_CREATEPARTITIONS, \
RD_KAFKA_ADMIN_OP_ALTERCONFIGS, \
RD_KAFKA_ADMIN_OP_DESCRIBECONFIGS, \
RD_KAFKA_ADMIN_OP_ANY /* Must be last */}
struct {
const char *setter;
const rd_kafka_admin_op_t valid_apis[8];
} matrix[] = {
{ "request_timeout", _all_apis },
{ "operation_timeout", { RD_KAFKA_ADMIN_OP_CREATETOPICS,
RD_KAFKA_ADMIN_OP_DELETETOPICS,
RD_KAFKA_ADMIN_OP_CREATEPARTITIONS } },
{ "validate_only", { RD_KAFKA_ADMIN_OP_CREATETOPICS,
RD_KAFKA_ADMIN_OP_CREATEPARTITIONS,
RD_KAFKA_ADMIN_OP_ALTERCONFIGS } },
{ "broker", _all_apis },
{ "opaque", _all_apis },
{ NULL },
};
int i;
rd_kafka_AdminOptions_t *options;
for (i = 0 ; matrix[i].setter ; i++) {
static const rd_kafka_admin_op_t all_apis[] = _all_apis;
const rd_kafka_admin_op_t *for_api;
for (for_api = all_apis ; ; for_api++) {
rd_kafka_resp_err_t err = RD_KAFKA_RESP_ERR_NO_ERROR;
rd_kafka_resp_err_t exp_err = RD_KAFKA_RESP_ERR_NO_ERROR;
char errstr[512];
int fi;
options = rd_kafka_AdminOptions_new(rk, *for_api);
TEST_ASSERT(options,
"AdminOptions_new(%d) failed", *for_api);
if (!strcmp(matrix[i].setter, "request_timeout"))
err = rd_kafka_AdminOptions_set_request_timeout(
options, 1234, errstr, sizeof(errstr));
else if (!strcmp(matrix[i].setter, "operation_timeout"))
err = rd_kafka_AdminOptions_set_operation_timeout(
options, 12345, errstr, sizeof(errstr));
else if (!strcmp(matrix[i].setter, "validate_only"))
err = rd_kafka_AdminOptions_set_validate_only(
options, 1, errstr, sizeof(errstr));
else if (!strcmp(matrix[i].setter, "broker"))
err = rd_kafka_AdminOptions_set_broker(
options, 5, errstr, sizeof(errstr));
else if (!strcmp(matrix[i].setter, "opaque")) {
rd_kafka_AdminOptions_set_opaque(
options, (void *)options);
err = RD_KAFKA_RESP_ERR_NO_ERROR;
} else
TEST_FAIL("Invalid setter: %s",
matrix[i].setter);
TEST_SAYL(3, "AdminOptions_set_%s on "
"RD_KAFKA_ADMIN_OP_%d options "
"returned %s: %s\n",
matrix[i].setter,
*for_api,
rd_kafka_err2name(err),
err ? errstr : "success");
/* Scan matrix valid_apis to see if this
* setter should be accepted or not. */
if (exp_err) {
/* An expected error is already set */
} else if (*for_api != RD_KAFKA_ADMIN_OP_ANY) {
exp_err = RD_KAFKA_RESP_ERR__INVALID_ARG;
for (fi = 0 ; matrix[i].valid_apis[fi] ; fi++) {
if (matrix[i].valid_apis[fi] ==
*for_api)
exp_err = RD_KAFKA_RESP_ERR_NO_ERROR;
}
} else {
exp_err = RD_KAFKA_RESP_ERR_NO_ERROR;
}
if (err != exp_err)
TEST_FAIL_LATER("Expected AdminOptions_set_%s "
"for RD_KAFKA_ADMIN_OP_%d "
"options to return %s, "
"not %s",
matrix[i].setter,
*for_api,
rd_kafka_err2name(exp_err),
rd_kafka_err2name(err));
rd_kafka_AdminOptions_destroy(options);
if (*for_api == RD_KAFKA_ADMIN_OP_ANY)
break; /* This was the last one */
}
}
/* Try an invalid for_api */
options = rd_kafka_AdminOptions_new(rk, (rd_kafka_admin_op_t)1234);
TEST_ASSERT(!options, "Expectred AdminOptions_new() to fail "
"with an invalid for_api, didn't.");
TEST_LATER_CHECK();
}
int main_0006_symbols (int argc, char **argv) {
if (argc < 0 /* always false */) {
rd_kafka_version();
rd_kafka_version_str();
rd_kafka_get_debug_contexts();
rd_kafka_get_err_descs(NULL, NULL);
rd_kafka_err2str(RD_KAFKA_RESP_ERR_NO_ERROR);
rd_kafka_err2name(RD_KAFKA_RESP_ERR_NO_ERROR);
rd_kafka_errno2err(EINVAL);
rd_kafka_errno();
rd_kafka_last_error();
rd_kafka_conf_new();
rd_kafka_conf_destroy(NULL);
rd_kafka_conf_dup(NULL);
rd_kafka_conf_set(NULL, NULL, NULL, NULL, 0);
rd_kafka_conf_set_dr_cb(NULL, NULL);
rd_kafka_conf_set_dr_msg_cb(NULL, NULL);
rd_kafka_conf_set_error_cb(NULL, NULL);
rd_kafka_conf_set_stats_cb(NULL, NULL);
rd_kafka_conf_set_log_cb(NULL, NULL);
rd_kafka_conf_set_socket_cb(NULL, NULL);
rd_kafka_conf_set_rebalance_cb(NULL, NULL);
rd_kafka_conf_set_offset_commit_cb(NULL, NULL);
rd_kafka_conf_set_throttle_cb(NULL, NULL);
rd_kafka_conf_set_default_topic_conf(NULL, NULL);
rd_kafka_conf_get(NULL, NULL, NULL, NULL);
#ifndef _MSC_VER
rd_kafka_conf_set_open_cb(NULL, NULL);
#endif
rd_kafka_conf_set_opaque(NULL, NULL);
rd_kafka_opaque(NULL);
rd_kafka_conf_dump(NULL, NULL);
rd_kafka_topic_conf_dump(NULL, NULL);
rd_kafka_conf_dump_free(NULL, 0);
rd_kafka_conf_properties_show(NULL);
rd_kafka_topic_conf_new();
rd_kafka_topic_conf_dup(NULL);
rd_kafka_topic_conf_destroy(NULL);
rd_kafka_topic_conf_set(NULL, NULL, NULL, NULL, 0);
rd_kafka_topic_conf_set_opaque(NULL, NULL);
rd_kafka_topic_conf_get(NULL, NULL, NULL, NULL);
rd_kafka_topic_conf_set_partitioner_cb(NULL, NULL);
rd_kafka_topic_partition_available(NULL, 0);
rd_kafka_topic_opaque(NULL);
rd_kafka_msg_partitioner_random(NULL, NULL, 0, 0, NULL, NULL);
rd_kafka_msg_partitioner_consistent(NULL, NULL, 0, 0, NULL, NULL);
rd_kafka_msg_partitioner_consistent_random(NULL, NULL, 0, 0, NULL, NULL);
rd_kafka_new(0, NULL, NULL, 0);
rd_kafka_destroy(NULL);
rd_kafka_name(NULL);
rd_kafka_memberid(NULL);
rd_kafka_topic_new(NULL, NULL, NULL);
rd_kafka_topic_destroy(NULL);
rd_kafka_topic_name(NULL);
rd_kafka_message_destroy(NULL);
rd_kafka_message_errstr(NULL);
rd_kafka_message_timestamp(NULL, NULL);
rd_kafka_consume_start(NULL, 0, 0);
rd_kafka_consume_stop(NULL, 0);
rd_kafka_consume(NULL, 0, 0);
rd_kafka_consume_batch(NULL, 0, 0, NULL, 0);
rd_kafka_consume_callback(NULL, 0, 0, NULL, NULL);
rd_kafka_offset_store(NULL, 0, 0);
rd_kafka_produce(NULL, 0, 0, NULL, 0, NULL, 0, NULL);
rd_kafka_produce_batch(NULL, 0, 0, NULL, 0);
rd_kafka_poll(NULL, 0);
rd_kafka_brokers_add(NULL, NULL);
/* DEPRECATED: rd_kafka_set_logger(NULL, NULL); */
rd_kafka_set_log_level(NULL, 0);
rd_kafka_log_print(NULL, 0, NULL, NULL);
#ifndef _MSC_VER
rd_kafka_log_syslog(NULL, 0, NULL, NULL);
#endif
rd_kafka_outq_len(NULL);
rd_kafka_dump(NULL, NULL);
rd_kafka_thread_cnt();
rd_kafka_wait_destroyed(0);
rd_kafka_metadata(NULL, 0, NULL, NULL, 0);
rd_kafka_metadata_destroy(NULL);
rd_kafka_queue_destroy(NULL);
rd_kafka_consume_start_queue(NULL, 0, 0, NULL);
rd_kafka_consume_queue(NULL, 0);
rd_kafka_consume_batch_queue(NULL, 0, NULL, 0);
rd_kafka_consume_callback_queue(NULL, 0, NULL, NULL);
rd_kafka_seek(NULL, 0, 0, 0);
rd_kafka_yield(NULL);
rd_kafka_mem_free(NULL, NULL);
rd_kafka_list_groups(NULL, NULL, NULL, 0);
rd_kafka_group_list_destroy(NULL);
/* KafkaConsumer API */
rd_kafka_subscribe(NULL, NULL);
rd_kafka_unsubscribe(NULL);
rd_kafka_subscription(NULL, NULL);
rd_kafka_consumer_poll(NULL, 0);
rd_kafka_consumer_close(NULL);
rd_kafka_assign(NULL, NULL);
rd_kafka_assignment(NULL, NULL);
rd_kafka_commit(NULL, NULL, 0);
rd_kafka_commit_message(NULL, NULL, 0);
rd_kafka_committed(NULL, NULL, 0);
rd_kafka_position(NULL, NULL);
/* TopicPartition */
rd_kafka_topic_partition_list_new(0);
rd_kafka_topic_partition_list_destroy(NULL);
rd_kafka_topic_partition_list_add(NULL, NULL, 0);
rd_kafka_topic_partition_list_add_range(NULL, NULL, 0, 0);
rd_kafka_topic_partition_list_del(NULL, NULL, 0);
rd_kafka_topic_partition_list_del_by_idx(NULL, 0);
rd_kafka_topic_partition_list_copy(NULL);
rd_kafka_topic_partition_list_set_offset(NULL, NULL, 0, 0);
rd_kafka_topic_partition_list_find(NULL, NULL, 0);
rd_kafka_query_watermark_offsets(NULL, NULL, 0, NULL, NULL, 0);
rd_kafka_get_watermark_offsets(NULL, NULL, 0, NULL, NULL);
}
return 0;
}
