/**
* Terminate broker offset store
*/
static void rd_kafka_offset_broker_term (rd_kafka_toppar_t *rktp) {
rd_kafka_timer_stop(rktp->rktp_rkt->rkt_rk,
&rktp->rktp_offset_commit_tmr, 1/*lock*/);
if (rktp->rktp_stored_offset > rktp->rktp_commited_offset)
rd_kafka_toppar_offset_commit(rktp, rktp->rktp_stored_offset);
}
/**
* Terminates toppar's offset store, this is the finalizing step after
* offset_store_stop().
*
* Locks: rd_kafka_toppar_lock() MUST be held.
*/
void rd_kafka_offset_store_term (rd_kafka_toppar_t *rktp,
rd_kafka_resp_err_t err) {
rd_kafka_resp_err_t err2;
rd_kafka_dbg(rktp->rktp_rkt->rkt_rk, TOPIC, "STORETERM",
"%s [%"PRId32"]: offset store terminating",
rktp->rktp_rkt->rkt_topic->str,
rktp->rktp_partition);
rktp->rktp_flags &= ~RD_KAFKA_TOPPAR_F_OFFSET_STORE_STOPPING;
rd_kafka_timer_stop(&rktp->rktp_rkt->rkt_rk->rk_timers,
&rktp->rktp_offset_commit_tmr, 1/*lock*/);
switch (rktp->rktp_rkt->rkt_conf.offset_store_method)
{
case RD_KAFKA_OFFSET_METHOD_FILE:
err2 = rd_kafka_offset_file_term(rktp);
break;
case RD_KAFKA_OFFSET_METHOD_BROKER:
err2 = rd_kafka_offset_broker_term(rktp);
break;
case RD_KAFKA_OFFSET_METHOD_NONE:
err2 = RD_KAFKA_RESP_ERR_NO_ERROR;
break;
}
/* Prioritize the input error (probably from commit), fall
* back on termination error. */
if (!err)
err = err2;
rd_kafka_toppar_fetch_stopped(rktp, err);
}
/**
* Decommissions the use of an offset file for a toppar.
* The file content will not be touched and the file will not be removed.
*
* NOTE: toppar_lock(rktp) must be held.
*/
static void rd_kafka_offset_file_term (rd_kafka_toppar_t *rktp) {
if (rktp->rktp_rkt->rkt_conf.offset_store_sync_interval_ms > 0)
rd_kafka_timer_stop(rktp->rktp_rkt->rkt_rk,
&rktp->rktp_offset_sync_tmr, 1/*lock*/);
rd_kafka_timer_stop(rktp->rktp_rkt->rkt_rk,
&rktp->rktp_offset_commit_tmr, 1/*lock*/);
if (rktp->rktp_stored_offset > rktp->rktp_commited_offset)
rd_kafka_offset_file_commit(rktp, rktp->rktp_stored_offset);
rd_kafka_offset_file_close(rktp);
free(rktp->rktp_offset_path);
rktp->rktp_offset_path = NULL;
}
/**
* Per handle SASL term.
*
* Locality: broker thread
*/
void rd_kafka_broker_sasl_term (rd_kafka_broker_t *rkb) {
rd_kafka_t *rk = rkb->rkb_rk;
if (!rk->rk_conf.sasl.kinit_cmd)
return;
rd_kafka_timer_stop(&rk->rk_timers, &rkb->rkb_sasl_kinit_refresh_tmr,1);
}
void rd_kafka_timers_destroy (rd_kafka_timers_t *rkts) {
rd_kafka_timer_t *rtmr;
rd_kafka_assert(NULL, TAILQ_EMPTY(&rkts->rkts_timers));
while ((rtmr = TAILQ_FIRST(&rkts->rkts_timers)))
rd_kafka_timer_stop(rkts, rtmr, 0);
rd_kafka_assert(rkts->rkts_rk, TAILQ_EMPTY(&rkts->rkts_timers));
cnd_destroy(&rkts->rkts_cond);
mtx_destroy(&rkts->rkts_lock);
}
/**
* Start the provided timer with the given interval.
* Upon expiration of the interval (us) the callback will be called in the
* main rdkafka thread, after callback return the timer will be restarted.
*
* Use rd_kafka_timer_stop() to stop a timer.
*/
void rd_kafka_timer_start (rd_kafka_timers_t *rkts,
rd_kafka_timer_t *rtmr, int interval,
void (*callback) (rd_kafka_timers_t *rkts, void *arg),
void *arg) {
rd_kafka_timers_lock(rkts);
rd_kafka_timer_stop(rkts, rtmr, 0/*!lock*/);
rtmr->rtmr_interval = interval;
rtmr->rtmr_callback = callback;
rtmr->rtmr_arg = arg;
rd_kafka_timer_schedule(rkts, rtmr, 0);
rd_kafka_timers_unlock(rkts);
}
/**
* Decommissions the use of an offset file for a toppar.
* The file content will not be touched and the file will not be removed.
*/
static rd_kafka_resp_err_t rd_kafka_offset_file_term (rd_kafka_toppar_t *rktp) {
rd_kafka_resp_err_t err = RD_KAFKA_RESP_ERR_NO_ERROR;
/* Sync offset file if the sync is intervalled (> 0) */
if (rktp->rktp_rkt->rkt_conf.offset_store_sync_interval_ms > 0) {
rd_kafka_offset_file_sync(rktp);
rd_kafka_timer_stop(&rktp->rktp_rkt->rkt_rk->rk_timers,
&rktp->rktp_offset_sync_tmr, 1/*lock*/);
}
rd_kafka_offset_file_close(rktp);
rd_free(rktp->rktp_offset_path);
rktp->rktp_offset_path = NULL;
return err;
}