static void do_produce (const char *topic, int msgcnt) {
rd_kafka_t *rk;
rd_kafka_conf_t *conf;
int i;
rd_kafka_resp_err_t err;
test_conf_init(&conf, NULL, 0);
test_conf_set(conf, "acks", "all");
rd_kafka_conf_set_dr_msg_cb(conf, dr_msg_cb);
rd_kafka_conf_interceptor_add_on_new(conf, __FILE__, on_new, NULL);
rk = test_create_handle(RD_KAFKA_PRODUCER, conf);
/* First message is without headers (negative testing) */
i = 0;
err = rd_kafka_producev(
rk,
RD_KAFKA_V_TOPIC(topic),
RD_KAFKA_V_PARTITION(0),
RD_KAFKA_V_VALUE(&i, sizeof(i)),
RD_KAFKA_V_MSGFLAGS(RD_KAFKA_MSG_F_COPY),
RD_KAFKA_V_END);
TEST_ASSERT(!err,
"producev() failed: %s", rd_kafka_err2str(err));
exp_msgid++;
for (i = 1 ; i < msgcnt ; i++, exp_msgid++) {
err = rd_kafka_producev(
rk,
RD_KAFKA_V_TOPIC(topic),
RD_KAFKA_V_PARTITION(0),
RD_KAFKA_V_VALUE(&i, sizeof(i)),
RD_KAFKA_V_MSGFLAGS(RD_KAFKA_MSG_F_COPY),
RD_KAFKA_V_HEADER("msgid", &i, sizeof(i)),
RD_KAFKA_V_HEADER("static", "hey", -1),
RD_KAFKA_V_HEADER("multi", "multi1", -1),
RD_KAFKA_V_HEADER("multi", "multi2", 6),
RD_KAFKA_V_HEADER("multi", "multi3", strlen("multi3")),
RD_KAFKA_V_HEADER("null", NULL, 0),
RD_KAFKA_V_HEADER("empty", "", 0),
RD_KAFKA_V_END);
TEST_ASSERT(!err,
"producev() failed: %s", rd_kafka_err2str(err));
}
/* Reset expected message id for dr */
exp_msgid = 0;
/* Wait for timeouts and delivery reports */
rd_kafka_flush(rk, tmout_multip(5000));
rd_kafka_destroy(rk);
}
static rd_kafka_resp_err_t
Producer_producev (Handle *self,
const char *topic, int32_t partition,
const void *value, size_t value_len,
const void *key, size_t key_len,
void *opaque, int64_t timestamp
#ifdef RD_KAFKA_V_HEADERS
,rd_kafka_headers_t *headers
#endif
) {
return rd_kafka_producev(self->rk,
RD_KAFKA_V_MSGFLAGS(RD_KAFKA_MSG_F_COPY),
RD_KAFKA_V_TOPIC(topic),
RD_KAFKA_V_PARTITION(partition),
RD_KAFKA_V_KEY(key, (size_t)key_len),
RD_KAFKA_V_VALUE((void *)value,
(size_t)value_len),
RD_KAFKA_V_TIMESTAMP(timestamp),
#ifdef RD_KAFKA_V_HEADERS
RD_KAFKA_V_HEADERS(headers),
#endif
RD_KAFKA_V_OPAQUE(opaque),
RD_KAFKA_V_END);
}
/**
* @brief Produce messages according to compress \p codec
*/
static void produce_msgs (const char *topic, int partition, uint64_t testid,
int msgcnt, const char *broker_version,
const char *codec) {
rd_kafka_conf_t *conf;
rd_kafka_t *rk;
int i;
char key[128], buf[100];
int msgcounter = msgcnt;
test_conf_init(&conf, NULL, 0);
rd_kafka_conf_set_dr_cb(conf, test_dr_cb);
test_conf_set(conf, "compression.codec", codec);
test_conf_set(conf, "broker.version.fallback", broker_version);
if (strstr(broker_version, "0.10."))
test_conf_set(conf, "api.version.request", "true");
else
test_conf_set(conf, "api.version.request", "false");
/* Make sure to trigger a bunch of MessageSets */
test_conf_set(conf, "batch.num.messages", tsprintf("%d", msgcnt/5));
rk = test_create_handle(RD_KAFKA_PRODUCER, conf);
for (i = 0 ; i < msgcnt ; i++) {
rd_kafka_resp_err_t err;
test_prepare_msg(testid, partition, i,
buf, sizeof(buf), key, sizeof(key));
err = rd_kafka_producev(rk,
RD_KAFKA_V_TOPIC(topic),
RD_KAFKA_V_VALUE(buf, sizeof(buf)),
RD_KAFKA_V_KEY(key, sizeof(key)),
RD_KAFKA_V_TIMESTAMP(my_timestamp.min),
RD_KAFKA_V_MSGFLAGS(RD_KAFKA_MSG_F_COPY),
RD_KAFKA_V_OPAQUE(&msgcounter),
RD_KAFKA_V_END);
if (err)
TEST_FAIL("producev() failed at msg #%d/%d: %s",
i, msgcnt, rd_kafka_err2str(err));
}
TEST_SAY("Waiting for %d messages to be produced\n", msgcounter);
while (msgcounter > 0)
rd_kafka_poll(rk, 100);
rd_kafka_destroy(rk);
}
static void do_test_produce (rd_kafka_t *rk, const char *topic,
int32_t partition, int msgid, int exp_fail,
int exp_ic_cnt) {
rd_kafka_resp_err_t err;
char key[16];
struct msg_state *msg = &msgs[msgid];
int i;
/* Message state should be empty, no interceptors should have
* been called yet.. */
for (i = 0 ; i < _ON_CNT ; i++)
TEST_ASSERT(msg->bits[i] == 0);
msg->id = msgid;
rd_snprintf(key, sizeof(key), "%d", msgid);
err = rd_kafka_producev(rk,
RD_KAFKA_V_TOPIC(topic),
RD_KAFKA_V_PARTITION(partition),
RD_KAFKA_V_KEY(key, strlen(key)+1),
RD_KAFKA_V_MSGFLAGS(RD_KAFKA_MSG_F_COPY),
RD_KAFKA_V_OPAQUE(msg),
RD_KAFKA_V_END);
msg_verify_ic_cnt(msg, "on_send", msg->bits[_ON_SEND], exp_ic_cnt);
if (err) {
msg_verify_ic_cnt(msg, "on_ack", msg->bits[_ON_ACK], exp_ic_cnt);
TEST_ASSERT(exp_fail,
"producev() failed: %s", rd_kafka_err2str(err));
} else {
msg_verify_ic_cnt(msg, "on_ack", msg->bits[_ON_ACK], 0);
TEST_ASSERT(!exp_fail,
"expected produce failure for msg #%d, not %s",
msgid, rd_kafka_err2str(err));
}
}