Examples with AbstractResponse org.apache.kafka.common.requests.AbstractResponse used on opensource projects

Example 21 with AbstractResponse

use of org.apache.kafka.common.requests.AbstractResponse in project kafka by apache.

the class KafkaAdminClient method describeLogDirs.

@Override
public DescribeLogDirsResult describeLogDirs(Collection<Integer> brokers, DescribeLogDirsOptions options) {
    final Map<Integer, KafkaFutureImpl<Map<String, LogDirDescription>>> futures = new HashMap<>(brokers.size());
    final long now = time.milliseconds();
    for (final Integer brokerId : brokers) {
        KafkaFutureImpl<Map<String, LogDirDescription>> future = new KafkaFutureImpl<>();
        futures.put(brokerId, future);
        runnable.call(new Call("describeLogDirs", calcDeadlineMs(now, options.timeoutMs()), new ConstantNodeIdProvider(brokerId)) {

            @Override
            public DescribeLogDirsRequest.Builder createRequest(int timeoutMs) {
                // Query selected partitions in all log directories
                return new DescribeLogDirsRequest.Builder(new DescribeLogDirsRequestData().setTopics(null));
            }

            @Override
            public void handleResponse(AbstractResponse abstractResponse) {
                DescribeLogDirsResponse response = (DescribeLogDirsResponse) abstractResponse;
                Map<String, LogDirDescription> descriptions = logDirDescriptions(response);
                if (descriptions.size() > 0) {
                    future.complete(descriptions);
                } else {
                    // Up to v3 DescribeLogDirsResponse did not have an error code field, hence it defaults to None
                    Errors error = response.data().errorCode() == Errors.NONE.code() ? Errors.CLUSTER_AUTHORIZATION_FAILED : Errors.forCode(response.data().errorCode());
                    future.completeExceptionally(error.exception());
                }
            }

            @Override
            void handleFailure(Throwable throwable) {
                future.completeExceptionally(throwable);
            }
        }, now);
    }
    return new DescribeLogDirsResult(new HashMap<>(futures));
}

Example 22 with AbstractResponse

use of org.apache.kafka.common.requests.AbstractResponse in project kafka by apache.

the class KafkaAdminClient method createAcls.

@Override
public CreateAclsResult createAcls(Collection<AclBinding> acls, CreateAclsOptions options) {
    final long now = time.milliseconds();
    final Map<AclBinding, KafkaFutureImpl<Void>> futures = new HashMap<>();
    final List<AclCreation> aclCreations = new ArrayList<>();
    final List<AclBinding> aclBindingsSent = new ArrayList<>();
    for (AclBinding acl : acls) {
        if (futures.get(acl) == null) {
            KafkaFutureImpl<Void> future = new KafkaFutureImpl<>();
            futures.put(acl, future);
            String indefinite = acl.toFilter().findIndefiniteField();
            if (indefinite == null) {
                aclCreations.add(CreateAclsRequest.aclCreation(acl));
                aclBindingsSent.add(acl);
            } else {
                future.completeExceptionally(new InvalidRequestException("Invalid ACL creation: " + indefinite));
            }
        }
    }
    final CreateAclsRequestData data = new CreateAclsRequestData().setCreations(aclCreations);
    runnable.call(new Call("createAcls", calcDeadlineMs(now, options.timeoutMs()), new LeastLoadedNodeProvider()) {

        @Override
        CreateAclsRequest.Builder createRequest(int timeoutMs) {
            return new CreateAclsRequest.Builder(data);
        }

        @Override
        void handleResponse(AbstractResponse abstractResponse) {
            CreateAclsResponse response = (CreateAclsResponse) abstractResponse;
            List<AclCreationResult> responses = response.results();
            Iterator<AclCreationResult> iter = responses.iterator();
            for (AclBinding aclBinding : aclBindingsSent) {
                KafkaFutureImpl<Void> future = futures.get(aclBinding);
                if (!iter.hasNext()) {
                    future.completeExceptionally(new UnknownServerException("The broker reported no creation result for the given ACL: " + aclBinding));
                } else {
                    AclCreationResult creation = iter.next();
                    Errors error = Errors.forCode(creation.errorCode());
                    ApiError apiError = new ApiError(error, creation.errorMessage());
                    if (apiError.isFailure())
                        future.completeExceptionally(apiError.exception());
                    else
                        future.complete(null);
                }
            }
        }

        @Override
        void handleFailure(Throwable throwable) {
            completeAllExceptionally(futures.values(), throwable);
        }
    }, now);
    return new CreateAclsResult(new HashMap<>(futures));
}

Example 23 with AbstractResponse

use of org.apache.kafka.common.requests.AbstractResponse in project kafka by apache.

the class KafkaAdminClient method alterConfigs.

private Map<ConfigResource, KafkaFutureImpl<Void>> alterConfigs(Map<ConfigResource, Config> configs, final AlterConfigsOptions options, Collection<ConfigResource> resources, NodeProvider nodeProvider) {
    final Map<ConfigResource, KafkaFutureImpl<Void>> futures = new HashMap<>();
    final Map<ConfigResource, AlterConfigsRequest.Config> requestMap = new HashMap<>(resources.size());
    for (ConfigResource resource : resources) {
        List<AlterConfigsRequest.ConfigEntry> configEntries = new ArrayList<>();
        for (ConfigEntry configEntry : configs.get(resource).entries()) configEntries.add(new AlterConfigsRequest.ConfigEntry(configEntry.name(), configEntry.value()));
        requestMap.put(resource, new AlterConfigsRequest.Config(configEntries));
        futures.put(resource, new KafkaFutureImpl<>());
    }
    final long now = time.milliseconds();
    runnable.call(new Call("alterConfigs", calcDeadlineMs(now, options.timeoutMs()), nodeProvider) {

        @Override
        public AlterConfigsRequest.Builder createRequest(int timeoutMs) {
            return new AlterConfigsRequest.Builder(requestMap, options.shouldValidateOnly());
        }

        @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
        void handleFailure(Throwable throwable) {
            completeAllExceptionally(futures.values(), throwable);
        }
    }, now);
    return futures;
}

Example 24 with AbstractResponse

use of org.apache.kafka.common.requests.AbstractResponse in project kafka by apache.

the class KafkaAdminClient method describeFeatures.

@Override
public DescribeFeaturesResult describeFeatures(final DescribeFeaturesOptions options) {
    final KafkaFutureImpl<FeatureMetadata> future = new KafkaFutureImpl<>();
    final long now = time.milliseconds();
    final Call call = new Call("describeFeatures", calcDeadlineMs(now, options.timeoutMs()), new LeastLoadedNodeProvider()) {

        private FeatureMetadata createFeatureMetadata(final ApiVersionsResponse response) {
            final Map<String, FinalizedVersionRange> finalizedFeatures = new HashMap<>();
            for (final FinalizedFeatureKey key : response.data().finalizedFeatures().valuesSet()) {
                finalizedFeatures.put(key.name(), new FinalizedVersionRange(key.minVersionLevel(), key.maxVersionLevel()));
            }
            Optional<Long> finalizedFeaturesEpoch;
            if (response.data().finalizedFeaturesEpoch() >= 0L) {
                finalizedFeaturesEpoch = Optional.of(response.data().finalizedFeaturesEpoch());
            } else {
                finalizedFeaturesEpoch = Optional.empty();
            }
            final Map<String, SupportedVersionRange> supportedFeatures = new HashMap<>();
            for (final SupportedFeatureKey key : response.data().supportedFeatures().valuesSet()) {
                supportedFeatures.put(key.name(), new SupportedVersionRange(key.minVersion(), key.maxVersion()));
            }
            return new FeatureMetadata(finalizedFeatures, finalizedFeaturesEpoch, supportedFeatures);
        }

        @Override
        ApiVersionsRequest.Builder createRequest(int timeoutMs) {
            return new ApiVersionsRequest.Builder();
        }

        @Override
        void handleResponse(AbstractResponse response) {
            final ApiVersionsResponse apiVersionsResponse = (ApiVersionsResponse) response;
            if (apiVersionsResponse.data().errorCode() == Errors.NONE.code()) {
                future.complete(createFeatureMetadata(apiVersionsResponse));
            } else {
                future.completeExceptionally(Errors.forCode(apiVersionsResponse.data().errorCode()).exception());
            }
        }

        @Override
        void handleFailure(Throwable throwable) {
            completeAllExceptionally(Collections.singletonList(future), throwable);
        }
    };
    runnable.call(call, now);
    return new DescribeFeaturesResult(future);
}

Example 25 with AbstractResponse

use of org.apache.kafka.common.requests.AbstractResponse in project kafka by apache.

the class NetworkClient method handleCompletedReceives.

/**
 * Handle any completed receives and update the response list with the responses received.
 *
 * @param responses The list of responses to update
 * @param now The current time
 */
private void handleCompletedReceives(List<ClientResponse> responses, long now) {
    for (NetworkReceive receive : this.selector.completedReceives()) {
        String source = receive.source();
        InFlightRequest req = inFlightRequests.completeNext(source);
        AbstractResponse response = parseResponse(receive.payload(), req.header);
        if (throttleTimeSensor != null)
            throttleTimeSensor.record(response.throttleTimeMs(), now);
        if (log.isDebugEnabled()) {
            log.debug("Received {} response from node {} for request with header {}: {}", req.header.apiKey(), req.destination, req.header, response);
        }
        // If the received response includes a throttle delay, throttle the connection.
        maybeThrottle(response, req.header.apiVersion(), req.destination, now);
        if (req.isInternalRequest && response instanceof MetadataResponse)
            metadataUpdater.handleSuccessfulResponse(req.header, now, (MetadataResponse) response);
        else if (req.isInternalRequest && response instanceof ApiVersionsResponse)
            handleApiVersionsResponse(responses, req, now, (ApiVersionsResponse) response);
        else
            responses.add(req.completed(response, now));
    }
}