def handle_response(self, resp):
txn_manager = self._sender._txn_manager
group_id = self._group_id
error_type = Errors.for_code(resp.error_code)
if error_type is Errors.NoError:
log.debug("Successfully added consumer group %s to transaction",
group_id)
txn_manager.consumer_group_added(group_id)
return
elif (error_type is CoordinatorNotAvailableError
or error_type is NotCoordinatorError):
self._sender._coordinator_dead(CoordinationType.TRANSACTION)
elif (error_type is CoordinatorLoadInProgressError
or error_type is ConcurrentTransactions):
# We will just retry after backoff
pass
elif error_type is InvalidProducerEpoch:
raise ProducerFenced()
elif error_type is InvalidTxnState:
raise error_type()
elif error_type is TransactionalIdAuthorizationFailed:
raise error_type(txn_manager.transactional_id)
elif error_type is GroupAuthorizationFailedError:
txn_manager.error_transaction(error_type(self._group_id))
return
else:
log.error(
"Could not add consumer group due to unexpected error: %s",
error_type)
raise error_type()
return self._default_backoff
def handle_response(self, resp):
txn_manager = self._sender._txn_manager
group_id = self._group_id
for topic, partitions in resp.errors:
for partition, error_code in partitions:
tp = TopicPartition(topic, partition)
error_type = Errors.for_code(error_code)
if error_type is Errors.NoError:
offset = self._offsets[tp].offset
log.debug(
"Offset %s for partition %s committed to group %s",
offset, tp, group_id)
txn_manager.offset_committed(tp, offset, group_id)
elif (error_type is CoordinatorNotAvailableError
or error_type is NotCoordinatorError or
# Copied from Java. Not sure why it's only in this case
error_type is RequestTimedOutError):
self._sender._coordinator_dead(CoordinationType.GROUP)
return self._default_backoff
elif (error_type is CoordinatorLoadInProgressError
or error_type is UnknownTopicOrPartitionError):
# We will just retry after backoff
return self._default_backoff
elif error_type is InvalidProducerEpoch:
raise ProducerFenced()
else:
log.error(
"Could not commit offset for partition %s due to "
"unexpected error: %s", partition, error_type)
raise error_type()
def handle_response(self, resp):
txn_manager = self._sender._txn_manager
error_type = Errors.for_code(resp.error_code)
if error_type is Errors.NoError:
txn_manager.complete_transaction()
return
elif (error_type is CoordinatorNotAvailableError or
error_type is NotCoordinatorError):
self._sender._coordinator_dead(CoordinationType.TRANSACTION)
elif (error_type is CoordinatorLoadInProgressError or
error_type is ConcurrentTransactions):
# We will just retry after backoff
pass
elif error_type is InvalidProducerEpoch:
raise ProducerFenced()
elif error_type is InvalidTxnState:
raise error_type()
else:
log.error(
"Could not end transaction due to unexpected error: %s",
error_type)
raise error_type()
return self._default_backoff
def handle_response(self, response):
for topic, partitions in response.topics:
for partition_info in partitions:
global_error = None
log_start_offset = None
if response.API_VERSION < 2:
partition, error_code, offset = partition_info
# Mimic CREATE_TIME to take user provided timestamp
timestamp = -1
elif 2 <= response.API_VERSION <= 4:
partition, error_code, offset, timestamp = partition_info
elif 5 <= response.API_VERSION <= 7:
(
partition, error_code, offset, timestamp,
log_start_offset
) = partition_info
else:
# the ignored parameter is record_error of type
# list[(batch_index: int, error_message: str)]
(
partition, error_code, offset, timestamp,
log_start_offset, _, global_error
) = partition_info
tp = TopicPartition(topic, partition)
error = Errors.for_code(error_code)
batch = self._batches.get(tp)
if batch is None:
continue
if error is Errors.NoError:
batch.done(offset, timestamp, log_start_offset)
elif error is DuplicateSequenceNumber:
# If we have received a duplicate sequence error,
# it means that the sequence number has advanced
# beyond the sequence of the current batch, and we
# haven't retained batch metadata on the broker to
# return the correct offset and timestamp.
#
# The only thing we can do is to return success to
# the user and not return a valid offset and
# timestamp.
batch.done(offset, timestamp, log_start_offset)
elif not self._can_retry(error(), batch):
if error is InvalidProducerEpoch:
exc = ProducerFenced()
elif error is TopicAuthorizationFailedError:
exc = error(topic)
else:
exc = error()
batch.failure(exception=exc)
else:
log.warning(
"Got error produce response on topic-partition"
" %s, retrying. Error: %s", tp, global_error or error)
# Ok, we can retry this batch
if getattr(error, "invalid_metadata", False):
self._client.force_metadata_update()
self._to_reenqueue.append(batch)
def handle_response(self, resp):
txn_manager = self._sender._txn_manager
unauthorized_topics = set()
for topic, partitions in resp.errors:
for partition, error_code in partitions:
tp = TopicPartition(topic, partition)
error_type = Errors.for_code(error_code)
if error_type is Errors.NoError:
log.debug("Added partition %s to transaction", tp)
txn_manager.partition_added(tp)
elif (error_type is CoordinatorNotAvailableError
or error_type is NotCoordinatorError):
self._sender._coordinator_dead(
CoordinationType.TRANSACTION)
return self._default_backoff
elif error_type is ConcurrentTransactions:
# See KAFKA-5477: There is some time between commit and
# actual transaction marker write, that will produce this
# ConcurrentTransactions. We don't want the 100ms latency
# in that case.
if not txn_manager.txn_partitions:
return BACKOFF_OVERRIDE
else:
return self._default_backoff
elif (error_type is CoordinatorLoadInProgressError
or error_type is UnknownTopicOrPartitionError):
return self._default_backoff
elif error_type is InvalidProducerEpoch:
raise ProducerFenced()
elif (error_type is InvalidProducerIdMapping
or error_type is InvalidTxnState):
raise error_type()
elif error_type is TopicAuthorizationFailedError:
unauthorized_topics.add(topic)
elif error_type is OperationNotAttempted:
pass
elif error_type is TransactionalIdAuthorizationFailed:
raise error_type(txn_manager.transactional_id)
else:
log.error(
"Could not add partition %s due to unexpected error:"
" %s", partition, error_type)
raise error_type()
if unauthorized_topics:
txn_manager.error_transaction(
TopicAuthorizationFailedError(unauthorized_topics))
return