public static ApiError fromThrowable(Throwable t) { // Avoid populating the error message if it's a generic one Errors error = Errors.forException(t); String message = error.message().equals(t.getMessage()) ? null : t.getMessage(); return new ApiError(error, message); }
synchronized void addError(Throwable throwable, Node node) { ApiError error = ApiError.fromThrowable(throwable); if (error.message() == null || error.message().isEmpty()) { errors.add(error.error().exception("Error listing groups on " + node)); } else { errors.add(error.error().exception("Error listing groups on " + node + ": " + error.message())); } }
@Override public void handleResponse(AbstractResponse abstractResponse) { CreatePartitionsResponse response = (CreatePartitionsResponse) abstractResponse; // Check for controller change for (ApiError error : response.errors().values()) { if (error.error() == Errors.NOT_CONTROLLER) { metadataManager.clearController(); metadataManager.requestUpdate(); throw error.exception(); } } for (Map.Entry<String, ApiError> result : response.errors().entrySet()) { KafkaFutureImpl<Void> future = futures.get(result.getKey()); if (result.getValue().isSuccess()) { future.complete(null); } else { future.completeExceptionally(result.getValue().exception()); } } }
@Override public AbstractResponse getErrorResponse(int throttleTimeMs, Throwable e) { short version = version(); switch (version) { case 0: case 1: ApiError error = ApiError.fromThrowable(e); Map<ConfigResource, ApiError> errors = new HashMap<>(configs.size()); for (ConfigResource resource : configs.keySet()) errors.put(resource, error); return new AlterConfigsResponse(throttleTimeMs, errors); default: throw new IllegalArgumentException(String.format("Version %d is not valid. Valid versions for %s are 0 to %d", version, this.getClass().getSimpleName(), ApiKeys.ALTER_CONFIGS.latestVersion())); } }
@Override public Map<Errors, Integer> errorCounts() { Map<Errors, Integer> errorCounts = new HashMap<>(); for (AclCreationResponse response : aclCreationResponses) updateErrorCounts(errorCounts, response.error.error()); return errorCounts; }
if (error.error() == Errors.NOT_CONTROLLER) { metadataManager.clearController(); metadataManager.requestUpdate(); throw error.exception(); log.warn("Server response mentioned unknown topic {}", entry.getKey()); } else { ApiException exception = entry.getValue().exception(); if (exception != null) { future.completeExceptionally(exception);
@Override protected Struct toStruct(short version) { Struct struct = new Struct(ApiKeys.CREATE_PARTITIONS.responseSchema(version)); List<Struct> topicErrors = new ArrayList<>(errors.size()); for (Map.Entry<String, ApiError> error : errors.entrySet()) { Struct errorStruct = struct.instance(TOPIC_ERRORS_KEY_NAME); errorStruct.set(TOPIC_NAME, error.getKey()); error.getValue().write(errorStruct); topicErrors.add(errorStruct); } struct.set(THROTTLE_TIME_MS, throttleTimeMs); struct.set(TOPIC_ERRORS_KEY_NAME, topicErrors.toArray(new Object[topicErrors.size()])); return struct; }
public boolean isFailure() { return !isSuccess(); }
public boolean isSuccess() { return is(Errors.NONE); }
@Override public void handleResponse(AbstractResponse abstractResponse) { AlterConfigsResponse response = (AlterConfigsResponse) abstractResponse; for (Map.Entry<ConfigResource, KafkaFutureImpl<Void>> entry : futures.entrySet()) { KafkaFutureImpl<Void> future = entry.getValue(); ApiException exception = response.errors().get(entry.getKey()).exception(); if (exception != null) { future.completeExceptionally(exception); } else { future.complete(null); } } }
@Override public AbstractResponse getErrorResponse(int throttleTimeMs, Throwable throwable) { short versionId = version(); switch (versionId) { case 0: case 1: return new DescribeAclsResponse(throttleTimeMs, ApiError.fromThrowable(throwable), Collections.emptySet()); default: throw new IllegalArgumentException(String.format("Version %d is not valid. Valid versions for %s are 0 to %d", versionId, this.getClass().getSimpleName(), ApiKeys.DESCRIBE_ACLS.latestVersion())); } }
@Override public Map<Errors, Integer> errorCounts() { return errorCounts(error.error()); }
@Override void handleResponse(AbstractResponse abstractResponse) { CreateAclsResponse response = (CreateAclsResponse) abstractResponse; List<AclCreationResponse> responses = response.aclCreationResponses(); Iterator<AclCreationResponse> iter = responses.iterator(); for (AclCreation aclCreation : aclCreations) { KafkaFutureImpl<Void> future = futures.get(aclCreation.acl()); if (!iter.hasNext()) { future.completeExceptionally(new UnknownServerException( "The broker reported no creation result for the given ACL.")); } else { AclCreationResponse creation = iter.next(); if (creation.error().isFailure()) { future.completeExceptionally(creation.error().exception()); } else { future.complete(null); } } } }
@Override protected Struct toStruct(short version) { Struct struct = new Struct(ApiKeys.CREATE_TOPICS.responseSchema(version)); struct.setIfExists(THROTTLE_TIME_MS, throttleTimeMs); List<Struct> topicErrorsStructs = new ArrayList<>(errors.size()); for (Map.Entry<String, ApiError> topicError : errors.entrySet()) { Struct topicErrorsStruct = struct.instance(TOPIC_ERRORS_KEY_NAME); topicErrorsStruct.set(TOPIC_NAME, topicError.getKey()); topicError.getValue().write(topicErrorsStruct); topicErrorsStructs.add(topicErrorsStruct); } struct.set(TOPIC_ERRORS_KEY_NAME, topicErrorsStructs.toArray()); return struct; }
@Override public AbstractResponse getErrorResponse(int throttleTimeMs, Throwable e) { ElectPreferredLeadersResponseData response = new ElectPreferredLeadersResponseData(); response.setThrottleTimeMs(throttleTimeMs); ApiError apiError = ApiError.fromThrowable(e); for (TopicPartitions topic : data.topicPartitions()) { ReplicaElectionResult electionResult = new ReplicaElectionResult().setTopic(topic.topic()); for (Integer partitionId : topic.partitionId()) { electionResult.partitionResult().add(new ElectPreferredLeadersResponseData.PartitionResult() .setPartitionId(partitionId) .setErrorCode(apiError.error().code()) .setErrorMessage(apiError.message())); } response.replicaElectionResults().add(electionResult); } return new ElectPreferredLeadersResponse(response); }
public CreateTopicsResponse(Struct struct) { Object[] topicErrorStructs = struct.getArray(TOPIC_ERRORS_KEY_NAME); Map<String, ApiError> errors = new HashMap<>(); for (Object topicErrorStructObj : topicErrorStructs) { Struct topicErrorStruct = (Struct) topicErrorStructObj; String topic = topicErrorStruct.get(TOPIC_NAME); errors.put(topic, new ApiError(topicErrorStruct)); } this.throttleTimeMs = struct.getOrElse(THROTTLE_TIME_MS, DEFAULT_THROTTLE_TIME); this.errors = errors; }
@Override public AbstractResponse getErrorResponse(int throttleTimeMs, Throwable e) { Map<String, ApiError> topicErrors = new HashMap<>(); for (String topic : newPartitions.keySet()) { topicErrors.put(topic, ApiError.fromThrowable(e)); } short versionId = version(); switch (versionId) { case 0: case 1: return new CreatePartitionsResponse(throttleTimeMs, topicErrors); default: throw new IllegalArgumentException(String.format("Version %d is not valid. Valid versions for %s are 0 to %d", versionId, this.getClass().getSimpleName(), ApiKeys.CREATE_PARTITIONS.latestVersion())); } }
@Override public Map<Errors, Integer> errorCounts() { Map<Errors, Integer> errorCounts = new HashMap<>(); for (Config response : configs.values()) updateErrorCounts(errorCounts, response.error.error()); return errorCounts; }
@Override void handleResponse(AbstractResponse abstractResponse) { DeleteAclsResponse response = (DeleteAclsResponse) abstractResponse; List<AclFilterResponse> responses = response.responses(); Iterator<AclFilterResponse> iter = responses.iterator(); for (AclBindingFilter filter : filterList) { KafkaFutureImpl<FilterResults> future = futures.get(filter); if (!iter.hasNext()) { future.completeExceptionally(new UnknownServerException( "The broker reported no deletion result for the given filter.")); } else { AclFilterResponse deletion = iter.next(); if (deletion.error().isFailure()) { future.completeExceptionally(deletion.error().exception()); } else { List<FilterResult> filterResults = new ArrayList<>(); for (AclDeletionResult deletionResult : deletion.deletions()) { filterResults.add(new FilterResult(deletionResult.acl(), deletionResult.error().exception())); } future.complete(new FilterResults(filterResults)); } } } }