/**
* NOTE: 'offsets' may be NULL, see official documentation.
*/
rd_kafka_resp_err_t
rd_kafka_commit (rd_kafka_t *rk,
const rd_kafka_topic_partition_list_t *offsets, int async) {
rd_kafka_cgrp_t *rkcg;
rd_kafka_resp_err_t err;
rd_kafka_q_t *repq = NULL;
rd_kafka_replyq_t rq = RD_KAFKA_NO_REPLYQ;
if (!(rkcg = rd_kafka_cgrp_get(rk)))
return RD_KAFKA_RESP_ERR__UNKNOWN_GROUP;
if (!async)
repq = rd_kafka_q_new(rk);
if (!async)
rq = RD_KAFKA_REPLYQ(repq, 0);
err = rd_kafka_commit0(rk, offsets, NULL, rq, NULL, NULL);
if (!err && !async) {
err = rd_kafka_q_wait_result(repq, RD_POLL_INFINITE);
rd_kafka_q_destroy(repq);
}
return err;
}
rd_kafka_resp_err_t
rd_kafka_subscription (rd_kafka_t *rk,
rd_kafka_topic_partition_list_t **topics){
rd_kafka_op_t *rko;
rd_kafka_resp_err_t err;
rd_kafka_cgrp_t *rkcg;
if (!(rkcg = rd_kafka_cgrp_get(rk)))
return RD_KAFKA_RESP_ERR__UNKNOWN_GROUP;
rko = rd_kafka_op_req2(rkcg->rkcg_ops, RD_KAFKA_OP_GET_SUBSCRIPTION);
if (!rko)
return RD_KAFKA_RESP_ERR__TIMED_OUT;
err = rko->rko_err;
*topics = rko->rko_u.subscribe.topics;
rko->rko_u.subscribe.topics = NULL;
rd_kafka_op_destroy(rko);
if (!*topics && !err) {
/* Create an empty list for convenience of the caller */
*topics = rd_kafka_topic_partition_list_new(0);
}
return err;
}
/**
* Commit a list of offsets asynchronously. Response will be queued on 'replyq'.
* Optional \p cb will be set on requesting op.
*
* Makes a copy of \p offsets (may be NULL for current assignment)
*/
static rd_kafka_resp_err_t
rd_kafka_commit0 (rd_kafka_t *rk,
const rd_kafka_topic_partition_list_t *offsets,
rd_kafka_toppar_t *rktp,
rd_kafka_replyq_t replyq,
void (*cb) (rd_kafka_t *rk,
rd_kafka_resp_err_t err,
rd_kafka_topic_partition_list_t *offsets,
void *opaque),
void *opaque) {
rd_kafka_cgrp_t *rkcg;
rd_kafka_op_t *rko;
if (!(rkcg = rd_kafka_cgrp_get(rk)))
return RD_KAFKA_RESP_ERR__UNKNOWN_GROUP;
rko = rd_kafka_op_new(RD_KAFKA_OP_OFFSET_COMMIT);
rko->rko_replyq = replyq;
rko->rko_u.offset_commit.cb = cb;
rko->rko_u.offset_commit.opaque = opaque;
if (rktp)
rko->rko_rktp = rd_kafka_toppar_keep(rktp);
if (offsets)
rko->rko_u.offset_commit.partitions =
rd_kafka_topic_partition_list_copy(offsets);
rd_kafka_q_enq(rkcg->rkcg_ops, rko);
return RD_KAFKA_RESP_ERR_NO_ERROR;
}
rd_kafka_resp_err_t
rd_kafka_assignment (rd_kafka_t *rk,
rd_kafka_topic_partition_list_t **partitions) {
rd_kafka_op_t *rko;
rd_kafka_resp_err_t err;
rd_kafka_cgrp_t *rkcg;
if (!(rkcg = rd_kafka_cgrp_get(rk)))
return RD_KAFKA_RESP_ERR__UNKNOWN_GROUP;
rko = rd_kafka_op_req2(rkcg->rkcg_ops, RD_KAFKA_OP_GET_ASSIGNMENT);
if (!rko)
return RD_KAFKA_RESP_ERR__TIMED_OUT;
err = rko->rko_err;
*partitions = rko->rko_u.assign.partitions;
rko->rko_u.assign.partitions = NULL;
rd_kafka_op_destroy(rko);
if (!*partitions && !err) {
/* Create an empty list for convenience of the caller */
*partitions = rd_kafka_topic_partition_list_new(0);
}
return err;
}
/**
* Commit a list of offsets asynchronously. Response will be queued on 'replyq'.
* Optional 'op_cb' will be set on requesting op.
* 'opaque' will be set as 'rko_opaque'.
*/
rd_kafka_resp_err_t
rd_kafka_commit0 (rd_kafka_t *rk,
const rd_kafka_topic_partition_list_t *offsets,
rd_kafka_q_t *replyq, void (*op_cb) (rd_kafka_t *,
rd_kafka_op_t *)) {
rd_kafka_cgrp_t *rkcg;
rd_kafka_op_t *rko;
if (!(rkcg = rd_kafka_cgrp_get(rk)))
return RD_KAFKA_RESP_ERR__UNKNOWN_GROUP;
rko = rd_kafka_op_new(RD_KAFKA_OP_OFFSET_COMMIT);
rko->rko_op_cb = op_cb;
rko->rko_replyq = replyq;
if (replyq)
rd_kafka_q_keep(rko->rko_replyq);
if (offsets)
rd_kafka_op_payload_set(
rko, rd_kafka_topic_partition_list_copy(offsets),
(void *)rd_kafka_topic_partition_list_destroy);
rd_kafka_q_enq(&rkcg->rkcg_ops, rko);
return RD_KAFKA_RESP_ERR_NO_ERROR;
}
rd_kafka_resp_err_t rd_kafka_unsubscribe (rd_kafka_t *rk) {
rd_kafka_cgrp_t *rkcg;
if (!(rkcg = rd_kafka_cgrp_get(rk)))
return RD_KAFKA_RESP_ERR__UNKNOWN_GROUP;
return rd_kafka_op_err_destroy(rd_kafka_op_req2(rkcg->rkcg_ops,
RD_KAFKA_OP_SUBSCRIBE));
}
rd_kafka_resp_err_t
rd_kafka_assign (rd_kafka_t *rk,
const rd_kafka_topic_partition_list_t *partitions) {
rd_kafka_op_t *rko;
rd_kafka_cgrp_t *rkcg;
if (!(rkcg = rd_kafka_cgrp_get(rk)))
return RD_KAFKA_RESP_ERR__UNKNOWN_GROUP;
rko = rd_kafka_op_new(RD_KAFKA_OP_ASSIGN);
if (partitions)
rko->rko_u.assign.partitions =
rd_kafka_topic_partition_list_copy(partitions);
return rd_kafka_op_err_destroy(
rd_kafka_op_req(rkcg->rkcg_ops, rko, RD_POLL_INFINITE));
}
rd_kafka_resp_err_t
rd_kafka_commit_queue (rd_kafka_t *rk,
const rd_kafka_topic_partition_list_t *offsets,
rd_kafka_queue_t *rkqu,
void (*cb) (rd_kafka_t *rk,
rd_kafka_resp_err_t err,
rd_kafka_topic_partition_list_t *offsets,
void *opaque),
void *opaque) {
rd_kafka_q_t *rkq;
rd_kafka_resp_err_t err;
if (!rd_kafka_cgrp_get(rk))
return RD_KAFKA_RESP_ERR__UNKNOWN_GROUP;
if (rkqu)
rkq = rkqu->rkqu_q;
else
rkq = rd_kafka_q_new(rk);
err = rd_kafka_commit0(rk, offsets, NULL,
RD_KAFKA_REPLYQ(rkq, 0),
cb, opaque);
if (!rkqu) {
rd_kafka_op_t *rko = rd_kafka_q_pop(rkq, RD_POLL_INFINITE, 0);
if (!rko)
err = RD_KAFKA_RESP_ERR__TIMED_OUT;
else {
err = rko->rko_err;
rd_kafka_op_handle_std(rk, rko);
rd_kafka_op_destroy(rko);
}
rd_kafka_q_destroy(rkq);
}
return err;
}
rd_kafka_resp_err_t
rd_kafka_subscribe (rd_kafka_t *rk,
const rd_kafka_topic_partition_list_t *topics) {
rd_kafka_op_t *rko;
rd_kafka_cgrp_t *rkcg;
if (!(rkcg = rd_kafka_cgrp_get(rk)))
return RD_KAFKA_RESP_ERR__UNKNOWN_GROUP;
/* Validate topics */
if (topics->cnt == 0 ||
rd_kafka_topic_partition_list_sum(topics,
_invalid_topic_cb, NULL) > 0)
return RD_KAFKA_RESP_ERR__INVALID_ARG;
rko = rd_kafka_op_new(RD_KAFKA_OP_SUBSCRIBE);
rko->rko_u.subscribe.topics = rd_kafka_topic_partition_list_copy(topics);
return rd_kafka_op_err_destroy(
rd_kafka_op_req(rkcg->rkcg_ops, rko, RD_POLL_INFINITE));
}
/**
* NOTE: 'offsets' may be NULL, see official documentation.
*/
rd_kafka_resp_err_t
rd_kafka_commit (rd_kafka_t *rk,
const rd_kafka_topic_partition_list_t *offsets, int async) {
rd_kafka_cgrp_t *rkcg;
rd_kafka_resp_err_t err;
rd_kafka_q_t *tmpq = NULL;
if (!(rkcg = rd_kafka_cgrp_get(rk)))
return RD_KAFKA_RESP_ERR__UNKNOWN_GROUP;
if (!async)
tmpq = rd_kafka_q_new(rk);
err = rd_kafka_commit0(rk, offsets,
async ? &rkcg->rkcg_ops : tmpq, NULL);
if (!async) {
rd_kafka_op_t *rko = rd_kafka_q_pop(tmpq, RD_POLL_INFINITE, 0);
err = rko->rko_err;
/* Enqueue offset_commit_cb if configured */
if (rko->rko_payload /* offset list */) {
rd_kafka_offset_commit_cb_op(
rk, rko->rko_err,
(rd_kafka_topic_partition_list_t *)
rko->rko_payload);
rko->rko_payload = NULL;
}
rd_kafka_op_destroy(rko);
rd_kafka_q_destroy(tmpq);
} else {
err = RD_KAFKA_RESP_ERR_NO_ERROR;
}
return err;
}
/**
* NOTE: 'offsets' may be NULL, see official documentation.
*/
rd_kafka_resp_err_t
rd_kafka_commit (rd_kafka_t *rk,
const rd_kafka_topic_partition_list_t *offsets, int async) {
rd_kafka_cgrp_t *rkcg;
rd_kafka_resp_err_t err;
rd_kafka_q_t *tmpq = NULL;
if (!(rkcg = rd_kafka_cgrp_get(rk)))
return RD_KAFKA_RESP_ERR__UNKNOWN_GROUP;
if (!async)
tmpq = rd_kafka_q_new(rk);
err = rd_kafka_commit0(rk, offsets, async ? NULL : tmpq, NULL);
if (!async) {
err = rd_kafka_q_wait_result(tmpq, RD_POLL_INFINITE);
rd_kafka_q_destroy(tmpq);
} else {
err = RD_KAFKA_RESP_ERR_NO_ERROR;
}
return err;
}
