index int64 0 0 | repo_id stringlengths 26 205 | file_path stringlengths 51 246 | content stringlengths 8 433k | __index_level_0__ int64 0 10k |
|---|---|---|---|---|
0 | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/util/NoopSubscription.java | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.awssdk.core.internal.util;
import org.reactivestreams.Subscriber;
import org.reactivestreams.Subscription;
import software.amazon.awssdk.annotations.SdkInternalApi;
/** An implementation of {@link org.reactivestreams.Subscription} that does nothing.
* <p>
* Useful in situations where a {@link org.reactivestreams.Publisher} needs to
* signal {@code exceptionOccurred} or {@code onComplete} immediately after
* {@code subscribe()} but but it needs to signal{@code onSubscription} first.
*/
@SdkInternalApi
public final class NoopSubscription implements Subscription {
private final Subscriber<?> subscriber;
public NoopSubscription(Subscriber<?> subscriber) {
this.subscriber = subscriber;
}
@Override
public void request(long l) {
if (l < 1) {
subscriber.onError(new IllegalArgumentException("Demand must be positive!"));
}
}
@Override
public void cancel() {
}
}
| 1,900 |
0 | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/util/HttpChecksumResolver.java | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.awssdk.core.internal.util;
import java.util.ArrayList;
import java.util.List;
import software.amazon.awssdk.annotations.SdkInternalApi;
import software.amazon.awssdk.core.checksums.Algorithm;
import software.amazon.awssdk.core.checksums.ChecksumSpecs;
import software.amazon.awssdk.core.interceptor.ExecutionAttributes;
import software.amazon.awssdk.core.interceptor.SdkExecutionAttribute;
import software.amazon.awssdk.core.interceptor.SdkInternalExecutionAttribute;
import software.amazon.awssdk.core.interceptor.trait.HttpChecksum;
/**
* Class to resolve the different Checksums specs from ExecutionAttributes.
*/
@SdkInternalApi
public final class HttpChecksumResolver {
private HttpChecksumResolver() {
}
public static ChecksumSpecs getResolvedChecksumSpecs(ExecutionAttributes executionAttributes) {
ChecksumSpecs checksumSpecs = executionAttributes.getAttribute(SdkExecutionAttribute.RESOLVED_CHECKSUM_SPECS);
if (checksumSpecs != null) {
return checksumSpecs;
}
return resolveChecksumSpecs(executionAttributes);
}
public static ChecksumSpecs resolveChecksumSpecs(ExecutionAttributes executionAttributes) {
HttpChecksum httpChecksumTraitInOperation = executionAttributes.getAttribute(SdkInternalExecutionAttribute.HTTP_CHECKSUM);
if (httpChecksumTraitInOperation == null) {
return null;
}
boolean hasRequestValidation = hasRequestValidationMode(httpChecksumTraitInOperation);
String requestAlgorithm = httpChecksumTraitInOperation.requestAlgorithm();
String checksumHeaderName = requestAlgorithm != null ? HttpChecksumUtils.httpChecksumHeader(requestAlgorithm) : null;
List<Algorithm> responseValidationAlgorithms = getResponseValidationAlgorithms(httpChecksumTraitInOperation);
return ChecksumSpecs.builder()
.algorithm(Algorithm.fromValue(httpChecksumTraitInOperation.requestAlgorithm()))
.headerName(checksumHeaderName)
.responseValidationAlgorithms(responseValidationAlgorithms)
.isValidationEnabled(hasRequestValidation)
.isRequestChecksumRequired(httpChecksumTraitInOperation.isRequestChecksumRequired())
.isRequestStreaming(httpChecksumTraitInOperation.isRequestStreaming())
.build();
}
private static boolean hasRequestValidationMode(HttpChecksum httpChecksum) {
return httpChecksum.requestValidationMode() != null;
}
private static List<Algorithm> getResponseValidationAlgorithms(HttpChecksum httpChecksumTraitInOperation) {
List<String> responseAlgorithms = httpChecksumTraitInOperation.responseAlgorithms();
if (responseAlgorithms != null && !responseAlgorithms.isEmpty()) {
List<Algorithm> responseValidationAlgorithms = new ArrayList<>(responseAlgorithms.size());
for (String algorithmName : responseAlgorithms) {
responseValidationAlgorithms.add(Algorithm.fromValue(algorithmName));
}
return responseValidationAlgorithms;
}
return null;
}
}
| 1,901 |
0 | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/util/HttpChecksumUtils.java | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.awssdk.core.internal.util;
import static software.amazon.awssdk.core.HttpChecksumConstant.SIGNING_METHOD;
import static software.amazon.awssdk.core.HttpChecksumConstant.X_AMZ_TRAILER;
import static software.amazon.awssdk.core.internal.util.HttpChecksumResolver.getResolvedChecksumSpecs;
import java.io.BufferedInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.nio.ByteBuffer;
import java.util.Objects;
import java.util.Optional;
import software.amazon.awssdk.annotations.SdkInternalApi;
import software.amazon.awssdk.core.ClientType;
import software.amazon.awssdk.core.HttpChecksumConstant;
import software.amazon.awssdk.core.checksums.Algorithm;
import software.amazon.awssdk.core.checksums.ChecksumSpecs;
import software.amazon.awssdk.core.checksums.SdkChecksum;
import software.amazon.awssdk.core.interceptor.ExecutionAttributes;
import software.amazon.awssdk.core.interceptor.SdkExecutionAttribute;
import software.amazon.awssdk.core.internal.signer.SigningMethod;
import software.amazon.awssdk.http.SdkHttpRequest;
import software.amazon.awssdk.http.SdkHttpResponse;
import software.amazon.awssdk.utils.Pair;
import software.amazon.awssdk.utils.StringUtils;
@SdkInternalApi
public final class HttpChecksumUtils {
private static final int CHECKSUM_BUFFER_SIZE = 16 * 1024;
private HttpChecksumUtils() {
}
/**
* @param algorithmName Checksum Algorithm Name
* @return Http Checksum header for a given Algorithm.
*/
public static String httpChecksumHeader(String algorithmName) {
return String.format("%s-%s", HttpChecksumConstant.HTTP_CHECKSUM_HEADER_PREFIX,
StringUtils.lowerCase(algorithmName));
}
/**
* The header based Checksum is computed only if following criteria is met
* - Flexible checksum is not already computed.
* -
* - HeaderChecksumSpecs are defined.
* - Unsigned Payload request.
*/
public static boolean isStreamingUnsignedPayload(SdkHttpRequest sdkHttpRequest,
ExecutionAttributes executionAttributes,
ChecksumSpecs headerChecksumSpecs,
boolean isContentStreaming) {
SigningMethod signingMethodUsed = executionAttributes.getAttribute(SIGNING_METHOD);
String protocol = sdkHttpRequest.protocol();
if (isHeaderBasedSigningAuth(signingMethodUsed, protocol)) {
return false;
}
return isUnsignedPayload(signingMethodUsed, protocol, isContentStreaming) && headerChecksumSpecs.isRequestStreaming();
}
public static boolean isHeaderBasedSigningAuth(SigningMethod signingMethodUsed, String protocol) {
switch (signingMethodUsed) {
case HEADER_BASED_AUTH: {
return true;
}
case PROTOCOL_BASED_UNSIGNED: {
return "http".equals(protocol);
}
default: {
return false;
}
}
}
/**
* @param signingMethod Signing Method.
* @param protocol The http/https protocol.
* @return true if Payload signing is resolved to Unsigned payload.
*/
public static boolean isUnsignedPayload(SigningMethod signingMethod, String protocol, boolean isContentStreaming) {
switch (signingMethod) {
case UNSIGNED_PAYLOAD:
return true;
case PROTOCOL_STREAMING_SIGNING_AUTH:
return "https".equals(protocol) || !isContentStreaming;
case PROTOCOL_BASED_UNSIGNED:
return "https".equals(protocol);
default:
return false;
}
}
/**
* Computes the Checksum of the data in the given input stream and returns it as an array of bytes.
*
* @param is InputStream for which checksum needs to be calculated.
* @param algorithm algorithm that will be used to compute the checksum of input stream.
* @return Calculated checksum in bytes.
* @throws IOException I/O errors while reading.
*/
public static byte[] computeChecksum(InputStream is, Algorithm algorithm) throws IOException {
SdkChecksum sdkChecksum = SdkChecksum.forAlgorithm(algorithm);
try (BufferedInputStream bis = new BufferedInputStream(is)) {
byte[] buffer = new byte[CHECKSUM_BUFFER_SIZE];
int bytesRead;
while ((bytesRead = bis.read(buffer, 0, buffer.length)) != -1) {
sdkChecksum.update(buffer, 0, bytesRead);
}
return sdkChecksum.getChecksumBytes();
}
}
/**
*
* @param executionAttributes Execution attributes defined for the request.
* @return Optional ChecksumSpec if checksum Algorithm exist for the checksumSpec
*/
public static Optional<ChecksumSpecs> checksumSpecWithRequestAlgorithm(ExecutionAttributes executionAttributes) {
ChecksumSpecs resolvedChecksumSpecs = getResolvedChecksumSpecs(executionAttributes);
if (resolvedChecksumSpecs != null && resolvedChecksumSpecs.algorithm() != null) {
return Optional.of(resolvedChecksumSpecs);
}
return Optional.empty();
}
/**
* Checks if the request header is already updated with Calculated checksum.
*
* @param sdkHttpRequest SdkHttpRequest
* @return True if the flexible checksum header was already updated.
*/
public static boolean isHttpChecksumPresent(SdkHttpRequest sdkHttpRequest, ChecksumSpecs checksumSpec) {
//check for the Direct header Or check if Trailer Header is present.
return sdkHttpRequest.firstMatchingHeader(checksumSpec.headerName()).isPresent() ||
isTrailerChecksumPresent(sdkHttpRequest, checksumSpec);
}
public static boolean isMd5ChecksumRequired(ExecutionAttributes executionAttributes) {
ChecksumSpecs resolvedChecksumSpecs = getResolvedChecksumSpecs(executionAttributes);
if (resolvedChecksumSpecs == null) {
return false;
}
return resolvedChecksumSpecs.algorithm() == null && resolvedChecksumSpecs.isRequestChecksumRequired();
}
private static boolean isTrailerChecksumPresent(SdkHttpRequest sdkHttpRequest, ChecksumSpecs checksumSpec) {
Optional<String> trailerBasedChecksum = sdkHttpRequest.firstMatchingHeader(X_AMZ_TRAILER);
if (trailerBasedChecksum.isPresent()) {
return trailerBasedChecksum.filter(checksum -> checksum.equalsIgnoreCase(checksumSpec.headerName())).isPresent();
}
return false;
}
/**
* The trailer based Checksum is computed only if following criteria is met
* - Flexible checksum is not already computed.
* - Streaming Unsigned Payload defined.
* - Unsigned Payload request.
*/
public static boolean isTrailerBasedFlexibleChecksumComputed(SdkHttpRequest sdkHttpRequest,
ExecutionAttributes executionAttributes,
ChecksumSpecs checksumSpecs,
boolean hasRequestBody,
boolean isContentStreaming) {
return hasRequestBody &&
!HttpChecksumUtils.isHttpChecksumPresent(sdkHttpRequest, checksumSpecs) &&
HttpChecksumUtils.isStreamingUnsignedPayload(sdkHttpRequest, executionAttributes,
checksumSpecs, isContentStreaming);
}
/**
*
* @param executionAttributes Execution attributes for the request.
* @param httpRequest Http Request.
* @param clientType Client Type for which the Trailer checksum is appended.
* @param checksumSpecs Checksum specs for the request.
* @param hasRequestBody Request body.
* @return True if Trailer checksum needs to be calculated and appended.
*/
public static boolean isTrailerBasedChecksumForClientType(
ExecutionAttributes executionAttributes, SdkHttpRequest httpRequest,
ClientType clientType, ChecksumSpecs checksumSpecs, boolean hasRequestBody, boolean isContentSteaming) {
ClientType actualClientType = executionAttributes.getAttribute(SdkExecutionAttribute.CLIENT_TYPE);
return actualClientType.equals(clientType) &&
checksumSpecs != null &&
HttpChecksumUtils.isTrailerBasedFlexibleChecksumComputed(
httpRequest, executionAttributes, checksumSpecs, hasRequestBody, isContentSteaming);
}
/**
* Loops through the Supported list of checksum for the operation, and gets the Header value for the checksum header.
* @param sdkHttpResponse response from service.
* @param resolvedChecksumSpecs Resolved checksum specification for the operation.
* @return Algorithm and its corresponding checksum value as sent by the service.
*/
public static Pair<Algorithm, String> getAlgorithmChecksumValuePair(SdkHttpResponse sdkHttpResponse,
ChecksumSpecs resolvedChecksumSpecs) {
return resolvedChecksumSpecs.responseValidationAlgorithms().stream().map(
algorithm -> {
Optional<String> firstMatchingHeader = sdkHttpResponse.firstMatchingHeader(httpChecksumHeader(algorithm.name()));
return firstMatchingHeader.map(s -> Pair.of(algorithm, s)).orElse(null);
}).filter(Objects::nonNull).findFirst().orElse(null);
}
/**
*
* @param resolvedChecksumSpecs Resolved checksum specification for the operation.
* @return True is Response is to be validated for checksum checks.
*/
public static boolean isHttpChecksumValidationEnabled(ChecksumSpecs resolvedChecksumSpecs) {
return resolvedChecksumSpecs != null &&
resolvedChecksumSpecs.isValidationEnabled() &&
resolvedChecksumSpecs.responseValidationAlgorithms() != null;
}
public static byte[] longToByte(Long input) {
ByteBuffer buffer = ByteBuffer.allocate(Long.BYTES);
buffer.putLong(input);
return buffer.array();
}
}
| 1,902 |
0 | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/util/Mimetype.java | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.awssdk.core.internal.util;
import java.io.BufferedReader;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.nio.charset.StandardCharsets;
import java.nio.file.Path;
import java.util.HashMap;
import java.util.Map;
import java.util.Optional;
import java.util.StringTokenizer;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import software.amazon.awssdk.annotations.SdkInternalApi;
import software.amazon.awssdk.utils.IoUtils;
import software.amazon.awssdk.utils.StringUtils;
import software.amazon.awssdk.utils.Validate;
/**
* Utility class that maintains a listing of known Mimetypes, and determines the
* mimetype of files based on file extensions.
* <p>
* This class is obtained with the {#link {@link #getInstance()} method that
* recognizes loaded mime types from the file <code>mime.types</code> if this
* file is available at the root of the classpath. The mime.types file format,
* and most of the content, is taken from the Apache HTTP server's mime.types
* file.
* <p>
* The format for mime type setting documents is:
* <code>mimetype + extension (+ extension)*</code>. Any
* blank lines in the file are ignored, as are lines starting with
* <code>#</code> which are considered comments.
*
* @see <a href="https://github.com/apache/httpd/blob/trunk/docs/conf/mime.types">mime.types</a>
*/
@SdkInternalApi
public final class Mimetype {
/** The default XML mimetype: application/xml */
public static final String MIMETYPE_XML = "application/xml";
/** The default HTML mimetype: text/html */
public static final String MIMETYPE_HTML = "text/html";
/** The default binary mimetype: application/octet-stream */
public static final String MIMETYPE_OCTET_STREAM = "application/octet-stream";
/** The default gzip mimetype: application/x-gzip */
public static final String MIMETYPE_GZIP = "application/x-gzip";
public static final String MIMETYPE_TEXT_PLAIN = "text/plain";
public static final String MIMETYPE_EVENT_STREAM = "application/vnd.amazon.eventstream";
private static final Logger LOG = LoggerFactory.getLogger(Mimetype.class);
private static final String MIME_TYPE_PATH = "software/amazon/awssdk/core/util/mime.types";
private static final ClassLoader CLASS_LOADER = ClassLoaderHelper.classLoader(Mimetype.class);
private static volatile Mimetype mimetype;
/**
* Map that stores file extensions as keys, and the corresponding mimetype as values.
*/
private final Map<String, String> extensionToMimetype = new HashMap<>();
private Mimetype() {
Optional.ofNullable(CLASS_LOADER).map(loader -> loader.getResourceAsStream(MIME_TYPE_PATH)).ifPresent(
stream -> {
try {
loadAndReplaceMimetypes(stream);
} catch (IOException e) {
LOG.debug("Failed to load mime types from file in the classpath: mime.types", e);
} finally {
IoUtils.closeQuietly(stream, null);
}
}
);
}
/**
* Loads MIME type info from the file 'mime.types' in the classpath, if it's available.
*/
public static Mimetype getInstance() {
if (mimetype == null) {
synchronized (Mimetype.class) {
if (mimetype == null) {
mimetype = new Mimetype();
}
}
}
return mimetype;
}
/**
* Determines the mimetype of a file by looking up the file's extension in an internal listing
* to find the corresponding mime type. If the file has no extension, or the extension is not
* available in the listing contained in this class, the default mimetype
* <code>application/octet-stream</code> is returned.
*
* @param path the file whose extension may match a known mimetype.
* @return the file's mimetype based on its extension, or a default value of
* <code>application/octet-stream</code> if a mime type value cannot be found.
*/
public String getMimetype(Path path) {
Validate.notNull(path, "path");
Path file = path.getFileName();
if (file != null) {
return getMimetype(file.toString());
}
return MIMETYPE_OCTET_STREAM;
}
/**
* Determines the mimetype of a file by looking up the file's extension in an internal listing
* to find the corresponding mime type. If the file has no extension, or the extension is not
* available in the listing contained in this class, the default mimetype
* <code>application/octet-stream</code> is returned.
*
* @param file the file whose extension may match a known mimetype.
* @return the file's mimetype based on its extension, or a default value of
* <code>application/octet-stream</code> if a mime type value cannot be found.
*/
public String getMimetype(File file) {
return getMimetype(file.toPath());
}
/**
* Determines the mimetype of a file by looking up the file's extension in
* an internal listing to find the corresponding mime type. If the file has
* no extension, or the extension is not available in the listing contained
* in this class, the default mimetype <code>application/octet-stream</code>
* is returned.
*
* @param fileName The name of the file whose extension may match a known
* mimetype.
* @return The file's mimetype based on its extension, or a default value of
* {@link #MIMETYPE_OCTET_STREAM} if a mime type value cannot
* be found.
*/
String getMimetype(String fileName) {
int lastPeriodIndex = fileName.lastIndexOf('.');
if (lastPeriodIndex > 0 && lastPeriodIndex + 1 < fileName.length()) {
String ext = StringUtils.lowerCase(fileName.substring(lastPeriodIndex + 1));
if (extensionToMimetype.containsKey(ext)) {
return extensionToMimetype.get(ext);
}
}
return MIMETYPE_OCTET_STREAM;
}
/**
* Reads and stores the mime type setting corresponding to a file extension, by reading
* text from an InputStream. If a mime type setting already exists when this method is run,
* the mime type value is replaced with the newer one.
*/
private void loadAndReplaceMimetypes(InputStream is) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(is, StandardCharsets.UTF_8));
br.lines().filter(line -> !line.startsWith("#")).forEach(line -> {
line = line.trim();
StringTokenizer st = new StringTokenizer(line, " \t");
if (st.countTokens() > 1) {
String mimetype = st.nextToken();
while (st.hasMoreTokens()) {
String extension = st.nextToken();
extensionToMimetype.put(StringUtils.lowerCase(extension), mimetype);
}
}
});
}
}
| 1,903 |
0 | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/util/MetricUtils.java | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.awssdk.core.internal.util;
import static software.amazon.awssdk.core.http.HttpResponseHandler.X_AMZN_REQUEST_ID_HEADERS;
import static software.amazon.awssdk.core.http.HttpResponseHandler.X_AMZ_ID_2_HEADER;
import java.net.URI;
import java.net.URISyntaxException;
import java.time.Duration;
import java.util.concurrent.Callable;
import java.util.concurrent.CompletableFuture;
import java.util.function.Supplier;
import software.amazon.awssdk.annotations.SdkInternalApi;
import software.amazon.awssdk.core.exception.SdkClientException;
import software.amazon.awssdk.core.internal.http.RequestExecutionContext;
import software.amazon.awssdk.core.metrics.CoreMetric;
import software.amazon.awssdk.http.HttpMetric;
import software.amazon.awssdk.http.SdkHttpFullRequest;
import software.amazon.awssdk.http.SdkHttpFullResponse;
import software.amazon.awssdk.metrics.MetricCollector;
import software.amazon.awssdk.metrics.NoOpMetricCollector;
import software.amazon.awssdk.metrics.SdkMetric;
import software.amazon.awssdk.utils.Pair;
/**
* Utility methods for working with metrics.
*/
@SdkInternalApi
public final class MetricUtils {
private MetricUtils() {
}
/**
* Measure the duration of the given callable.
*
* @param c The callable to measure.
* @return A {@code Pair} containing the result of {@code c} and the duration.
*/
public static <T> Pair<T, Duration> measureDuration(Supplier<T> c) {
long start = System.nanoTime();
T result = c.get();
Duration d = Duration.ofNanos(System.nanoTime() - start);
return Pair.of(result, d);
}
/**
* Report a duration metric of the given {@link CompletableFuture} supplier.
*
* @param c The callable to measure.
* @param metricCollector The MetricCollector where the metric is to be reported.
* @param metric The metric to be reported.
* @return A {@code Pair} containing the result of {@code c} and the duration.
*/
public static <T> CompletableFuture<T> reportDuration(Supplier<CompletableFuture<T>> c,
MetricCollector metricCollector,
SdkMetric<Duration> metric) {
long start = System.nanoTime();
CompletableFuture<T> result = c.get();
result.whenComplete((r, t) -> {
Duration d = Duration.ofNanos(System.nanoTime() - start);
metricCollector.reportMetric(metric, d);
});
return result;
}
/**
* Measure the duration of the given callable.
*
* @param c The callable to measure.
* @return A {@code Pair} containing the result of {@code c} and the duration.
*/
public static <T> Pair<T, Duration> measureDurationUnsafe(Callable<T> c) throws Exception {
long start = System.nanoTime();
T result = c.call();
Duration d = Duration.ofNanos(System.nanoTime() - start);
return Pair.of(result, d);
}
/**
* Collect the SERVICE_ENDPOINT metric for this request.
*/
public static void collectServiceEndpointMetrics(MetricCollector metricCollector, SdkHttpFullRequest httpRequest) {
if (metricCollector != null && !(metricCollector instanceof NoOpMetricCollector) && httpRequest != null) {
// Only interested in the service endpoint so don't include any path, query, or fragment component
URI requestUri = httpRequest.getUri();
try {
URI serviceEndpoint = new URI(requestUri.getScheme(), requestUri.getAuthority(), null, null, null);
metricCollector.reportMetric(CoreMetric.SERVICE_ENDPOINT, serviceEndpoint);
} catch (URISyntaxException e) {
// This should not happen since getUri() should return a valid URI
throw SdkClientException.create("Unable to collect SERVICE_ENDPOINT metric", e);
}
}
}
public static void collectHttpMetrics(MetricCollector metricCollector, SdkHttpFullResponse httpResponse) {
if (metricCollector != null && !(metricCollector instanceof NoOpMetricCollector) && httpResponse != null) {
metricCollector.reportMetric(HttpMetric.HTTP_STATUS_CODE, httpResponse.statusCode());
X_AMZN_REQUEST_ID_HEADERS.forEach(h -> {
httpResponse.firstMatchingHeader(h).ifPresent(v -> metricCollector.reportMetric(CoreMetric.AWS_REQUEST_ID, v));
});
httpResponse.firstMatchingHeader(X_AMZ_ID_2_HEADER)
.ifPresent(v -> metricCollector.reportMetric(CoreMetric.AWS_EXTENDED_REQUEST_ID, v));
}
}
public static MetricCollector createAttemptMetricsCollector(RequestExecutionContext context) {
MetricCollector parentCollector = context.executionContext().metricCollector();
if (parentCollector != null) {
return parentCollector.createChild("ApiCallAttempt");
}
return NoOpMetricCollector.create();
}
public static MetricCollector createHttpMetricsCollector(RequestExecutionContext context) {
MetricCollector parentCollector = context.attemptMetricCollector();
if (parentCollector != null) {
return parentCollector.createChild("HttpClient");
}
return NoOpMetricCollector.create();
}
}
| 1,904 |
0 | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/InputStreamResponseTransformer.java | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.awssdk.core.internal.async;
import java.nio.ByteBuffer;
import java.util.concurrent.CompletableFuture;
import software.amazon.awssdk.annotations.SdkInternalApi;
import software.amazon.awssdk.core.ResponseInputStream;
import software.amazon.awssdk.core.SdkResponse;
import software.amazon.awssdk.core.async.AsyncResponseTransformer;
import software.amazon.awssdk.core.async.SdkPublisher;
import software.amazon.awssdk.utils.async.InputStreamSubscriber;
/**
* A {@link AsyncResponseTransformer} that allows performing blocking reads on the response data.
* <p>
* Created with {@link AsyncResponseTransformer#toBlockingInputStream()}.
*/
@SdkInternalApi
public class InputStreamResponseTransformer<ResponseT extends SdkResponse>
implements AsyncResponseTransformer<ResponseT, ResponseInputStream<ResponseT>> {
private volatile CompletableFuture<ResponseInputStream<ResponseT>> future;
private volatile ResponseT response;
@Override
public CompletableFuture<ResponseInputStream<ResponseT>> prepare() {
CompletableFuture<ResponseInputStream<ResponseT>> result = new CompletableFuture<>();
this.future = result;
return result;
}
@Override
public void onResponse(ResponseT response) {
this.response = response;
}
@Override
public void onStream(SdkPublisher<ByteBuffer> publisher) {
InputStreamSubscriber inputStreamSubscriber = new InputStreamSubscriber();
publisher.subscribe(inputStreamSubscriber);
future.complete(new ResponseInputStream<>(response, inputStreamSubscriber));
}
@Override
public void exceptionOccurred(Throwable error) {
future.completeExceptionally(error);
}
}
| 1,905 |
0 | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/SdkPublishers.java | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.awssdk.core.internal.async;
import java.nio.ByteBuffer;
import java.nio.charset.StandardCharsets;
import org.reactivestreams.Publisher;
import software.amazon.awssdk.annotations.SdkInternalApi;
import software.amazon.awssdk.core.async.SdkPublisher;
/**
* Common implementations of {@link SdkPublisher} that are provided for convenience when building asynchronous
* interceptors to be used with specific clients.
*/
@SdkInternalApi
public final class SdkPublishers {
private SdkPublishers() {
}
/**
* Constructs an {@link SdkPublisher} that wraps a {@link ByteBuffer} publisher and inserts additional content
* that wraps the published content like an envelope. This can be used when you want to transform the content of
* an asynchronous SDK response by putting it in an envelope. This publisher implementation does not comply with
* the complete flow spec (as it inserts data into the middle of a flow between a third-party publisher and
* subscriber rather than acting as a fully featured independent publisher) and therefore should only be used in a
* limited fashion when we have complete control over how data is being published to the publisher it wraps.
* @param publisher The underlying publisher to wrap the content of.
* @param envelopePrefix A string representing the content to be inserted as the head of the containing envelope.
* @param envelopeSuffix A string representing the content to be inserted as the tail of containing envelope.
* @return An {@link SdkPublisher} that wraps the provided publisher.
*/
public static SdkPublisher<ByteBuffer> envelopeWrappedPublisher(Publisher<ByteBuffer> publisher,
String envelopePrefix,
String envelopeSuffix) {
return EnvelopeWrappedSdkPublisher.of(publisher,
wrapUtf8(envelopePrefix),
wrapUtf8(envelopeSuffix),
SdkPublishers::concat);
}
private static ByteBuffer wrapUtf8(String s) {
return ByteBuffer.wrap(s.getBytes(StandardCharsets.UTF_8));
}
private static ByteBuffer concat(ByteBuffer b1, ByteBuffer b2) {
ByteBuffer result = ByteBuffer.allocate(b1.remaining() + b2.remaining());
result.put(b1);
result.put(b2);
result.rewind();
return result;
}
}
| 1,906 |
0 | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/EnvelopeWrappedSdkPublisher.java | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.awssdk.core.internal.async;
import java.util.function.BiFunction;
import org.reactivestreams.Publisher;
import org.reactivestreams.Subscriber;
import org.reactivestreams.Subscription;
import software.amazon.awssdk.annotations.SdkInternalApi;
import software.amazon.awssdk.core.async.SdkPublisher;
/**
* Publisher implementation that wraps the content of another publisher in an envelope with an optional prefix (or
* header) and suffix (or footer). The prefix content will be prepended to the first published object from the
* wrapped publisher, and the suffix content will be published when the wrapped publisher signals completion.
* <p>
* The envelope prefix will not be published until the wrapped publisher publishes something or is completed.
* The envelope suffix will not be published until the wrapped publisher is completed.
* <p>
* This class can be used in an asynchronous interceptor in the AWS SDK to wrap content around the incoming
* bytestream from a response.
* <p>
* A function must be supplied that can be used to concatenate the envelope content with the content being published by
* the wrapped publisher. Example usage:
* {@code
* Publisher<String> wrappedPublisher = ContentEnvelopeWrappingPublisher.of(publisher, "S", "E", (s1, s2) -> s1 + s2);
* }
* If publisher publishes a single string "1", wrappedPublisher will publish "S1" (prepending the envelop prefix). If
* publisher then publishes a second string "2", wrappedPublisher will then publish "2" (no added content). If
* publisher then completes, wrappedPublisher will then publish "E" and then complete.
* <p>
* WARNING: This publisher implementation does not comply with the complete flow spec (as it inserts data into the
* middle of a flow between a third-party publisher and subscriber rather than acting as a fully featured
* independent publisher) and therefore should only be used in a limited fashion when we have complete control over
* how data is being published to the publisher it wraps.
*
* @param <T> The type of objects being published
*/
@SdkInternalApi
public class EnvelopeWrappedSdkPublisher<T> implements SdkPublisher<T> {
private final Publisher<T> wrappedPublisher;
private final T contentPrefix;
private final T contentSuffix;
private final BiFunction<T, T, T> mergeContentFunction;
private EnvelopeWrappedSdkPublisher(Publisher<T> wrappedPublisher,
T contentPrefix,
T contentSuffix,
BiFunction<T, T, T> mergeContentFunction) {
this.wrappedPublisher = wrappedPublisher;
this.contentPrefix = contentPrefix;
this.contentSuffix = contentSuffix;
this.mergeContentFunction = mergeContentFunction;
}
/**
* Create a new publisher that wraps the content of an existing publisher.
* @param wrappedPublisher The publisher who's content will be wrapped.
* @param contentPrefix The content to be inserted in front of the wrapped content.
* @param contentSuffix The content to be inserted at the back of the wrapped content.
* @param mergeContentFunction A function that will be used to merge the inserted content into the wrapped content.
* @param <T> The content type.
* @return A newly initialized instance of this class.
*/
public static <T> EnvelopeWrappedSdkPublisher<T> of(Publisher<T> wrappedPublisher,
T contentPrefix,
T contentSuffix,
BiFunction<T, T, T> mergeContentFunction) {
return new EnvelopeWrappedSdkPublisher<>(wrappedPublisher, contentPrefix, contentSuffix, mergeContentFunction);
}
/**
* See {@link Publisher#subscribe(Subscriber)}
*/
@Override
public void subscribe(Subscriber<? super T> subscriber) {
if (subscriber == null) {
throw new NullPointerException("subscriber must be non-null on call to subscribe()");
}
wrappedPublisher.subscribe(new ContentWrappedSubscriber(subscriber));
}
private class ContentWrappedSubscriber implements Subscriber<T> {
private final Subscriber<? super T> wrappedSubscriber;
private boolean prefixApplied = false;
private boolean suffixApplied = false;
private ContentWrappedSubscriber(Subscriber<? super T> wrappedSubscriber) {
this.wrappedSubscriber = wrappedSubscriber;
}
@Override
public void onSubscribe(Subscription subscription) {
wrappedSubscriber.onSubscribe(subscription);
}
@Override
public void onNext(T t) {
T contentToSend = t;
if (!prefixApplied) {
prefixApplied = true;
if (contentPrefix != null) {
contentToSend = mergeContentFunction.apply(contentPrefix, t);
}
}
wrappedSubscriber.onNext(contentToSend);
}
@Override
public void onError(Throwable throwable) {
wrappedSubscriber.onError(throwable);
}
@Override
public void onComplete() {
try {
// Only transmit the close of the envelope once and only if the prefix has been previously sent.
if (!suffixApplied && prefixApplied) {
suffixApplied = true;
if (contentSuffix != null) {
// TODO: This should respect the demand from the subscriber as technically an onComplete
// signal could be received even if there is no demand. We have minimized the impact of this
// by only making it applicable in situations where there data has already been transmitted
// over the stream.
wrappedSubscriber.onNext(contentSuffix);
}
}
} finally {
wrappedSubscriber.onComplete();
}
}
}
}
| 1,907 |
0 | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/ChecksumValidatingPublisher.java | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.awssdk.core.internal.async;
import java.nio.ByteBuffer;
import org.reactivestreams.Publisher;
import org.reactivestreams.Subscriber;
import org.reactivestreams.Subscription;
import software.amazon.awssdk.annotations.SdkInternalApi;
import software.amazon.awssdk.core.async.SdkPublisher;
import software.amazon.awssdk.core.checksums.SdkChecksum;
import software.amazon.awssdk.core.exception.SdkClientException;
import software.amazon.awssdk.utils.BinaryUtils;
/**
* Publisher to update the checksum as it reads the data and
* finally compares the computed checksum with expected Checksum.
*/
@SdkInternalApi
public final class ChecksumValidatingPublisher implements SdkPublisher<ByteBuffer> {
private final Publisher<ByteBuffer> publisher;
private final SdkChecksum sdkChecksum;
private final String expectedChecksum;
public ChecksumValidatingPublisher(Publisher<ByteBuffer> publisher,
SdkChecksum sdkChecksum,
String expectedChecksum) {
this.publisher = publisher;
this.sdkChecksum = sdkChecksum;
this.expectedChecksum = expectedChecksum;
}
@Override
public void subscribe(Subscriber<? super ByteBuffer> s) {
publisher.subscribe(new ChecksumValidatingSubscriber(s, sdkChecksum, expectedChecksum));
}
private static class ChecksumValidatingSubscriber implements Subscriber<ByteBuffer> {
private final Subscriber<? super ByteBuffer> wrapped;
private final SdkChecksum sdkChecksum;
private final String expectedChecksum;
private String calculatedChecksum = null;
ChecksumValidatingSubscriber(Subscriber<? super ByteBuffer> wrapped,
SdkChecksum sdkChecksum,
String expectedChecksum) {
this.wrapped = wrapped;
this.sdkChecksum = sdkChecksum;
this.expectedChecksum = expectedChecksum;
}
@Override
public void onSubscribe(Subscription s) {
wrapped.onSubscribe(s);
}
@Override
public void onNext(ByteBuffer byteBuffer) {
byteBuffer.mark();
try {
sdkChecksum.update(byteBuffer);
} finally {
byteBuffer.reset();
}
wrapped.onNext(byteBuffer);
}
@Override
public void onError(Throwable t) {
wrapped.onError(t);
}
@Override
public void onComplete() {
if (this.calculatedChecksum == null) {
calculatedChecksum = BinaryUtils.toBase64(sdkChecksum.getChecksumBytes());
if (!expectedChecksum.equals(calculatedChecksum)) {
onError(SdkClientException.create(
String.format("Data read has a different checksum than expected. Was %s, but expected %s",
calculatedChecksum, expectedChecksum)));
return; // Return after onError and not call onComplete below
}
}
wrapped.onComplete();
}
}
}
| 1,908 |
0 | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/ByteBuffersAsyncRequestBody.java | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.awssdk.core.internal.async;
import java.nio.ByteBuffer;
import java.util.Arrays;
import java.util.Optional;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicInteger;
import org.reactivestreams.Subscriber;
import org.reactivestreams.Subscription;
import software.amazon.awssdk.annotations.SdkInternalApi;
import software.amazon.awssdk.core.async.AsyncRequestBody;
import software.amazon.awssdk.core.internal.util.Mimetype;
import software.amazon.awssdk.utils.Logger;
/**
* An implementation of {@link AsyncRequestBody} for providing data from the supplied {@link ByteBuffer} array. This is created
* using static methods on {@link AsyncRequestBody}
*
* @see AsyncRequestBody#fromBytes(byte[])
* @see AsyncRequestBody#fromBytesUnsafe(byte[])
* @see AsyncRequestBody#fromByteBuffer(ByteBuffer)
* @see AsyncRequestBody#fromByteBufferUnsafe(ByteBuffer)
* @see AsyncRequestBody#fromByteBuffers(ByteBuffer...)
* @see AsyncRequestBody#fromByteBuffersUnsafe(ByteBuffer...)
* @see AsyncRequestBody#fromString(String)
*/
@SdkInternalApi
public final class ByteBuffersAsyncRequestBody implements AsyncRequestBody {
private static final Logger log = Logger.loggerFor(ByteBuffersAsyncRequestBody.class);
private final String mimetype;
private final Long length;
private final ByteBuffer[] buffers;
private ByteBuffersAsyncRequestBody(String mimetype, Long length, ByteBuffer... buffers) {
this.mimetype = mimetype;
this.length = length;
this.buffers = buffers;
}
@Override
public Optional<Long> contentLength() {
return Optional.ofNullable(length);
}
@Override
public String contentType() {
return mimetype;
}
@Override
public void subscribe(Subscriber<? super ByteBuffer> s) {
// As per rule 1.9 we must throw NullPointerException if the subscriber parameter is null
if (s == null) {
throw new NullPointerException("Subscription MUST NOT be null.");
}
// As per 2.13, this method must return normally (i.e. not throw).
try {
s.onSubscribe(
new Subscription() {
private final AtomicInteger index = new AtomicInteger(0);
private final AtomicBoolean completed = new AtomicBoolean(false);
@Override
public void request(long n) {
if (completed.get()) {
return;
}
if (n > 0) {
int i = index.getAndIncrement();
if (i >= buffers.length) {
return;
}
long remaining = n;
do {
ByteBuffer buffer = buffers[i];
s.onNext(buffer.asReadOnlyBuffer());
remaining--;
} while (remaining > 0 && (i = index.getAndIncrement()) < buffers.length);
if (i >= buffers.length - 1 && completed.compareAndSet(false, true)) {
s.onComplete();
}
} else {
s.onError(new IllegalArgumentException("§3.9: non-positive requests are not allowed!"));
}
}
@Override
public void cancel() {
completed.set(true);
}
}
);
} catch (Throwable ex) {
log.error(() -> s + " violated the Reactive Streams rule 2.13 by throwing an exception from onSubscribe.", ex);
}
}
public static ByteBuffersAsyncRequestBody of(ByteBuffer... buffers) {
long length = Arrays.stream(buffers)
.mapToLong(ByteBuffer::remaining)
.sum();
return new ByteBuffersAsyncRequestBody(Mimetype.MIMETYPE_OCTET_STREAM, length, buffers);
}
public static ByteBuffersAsyncRequestBody of(Long length, ByteBuffer... buffers) {
return new ByteBuffersAsyncRequestBody(Mimetype.MIMETYPE_OCTET_STREAM, length, buffers);
}
public static ByteBuffersAsyncRequestBody of(String mimetype, ByteBuffer... buffers) {
long length = Arrays.stream(buffers)
.mapToLong(ByteBuffer::remaining)
.sum();
return new ByteBuffersAsyncRequestBody(mimetype, length, buffers);
}
public static ByteBuffersAsyncRequestBody of(String mimetype, Long length, ByteBuffer... buffers) {
return new ByteBuffersAsyncRequestBody(mimetype, length, buffers);
}
public static ByteBuffersAsyncRequestBody from(byte[] bytes) {
return new ByteBuffersAsyncRequestBody(Mimetype.MIMETYPE_OCTET_STREAM, (long) bytes.length,
ByteBuffer.wrap(bytes));
}
public static ByteBuffersAsyncRequestBody from(String mimetype, byte[] bytes) {
return new ByteBuffersAsyncRequestBody(mimetype, (long) bytes.length, ByteBuffer.wrap(bytes));
}
}
| 1,909 |
0 | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncRequestBodySplitHelper.java | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.awssdk.core.internal.async;
import java.nio.ByteBuffer;
import java.nio.file.Path;
import java.util.Optional;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicLong;
import org.reactivestreams.Subscriber;
import software.amazon.awssdk.annotations.SdkInternalApi;
import software.amazon.awssdk.annotations.SdkTestInternalApi;
import software.amazon.awssdk.core.async.AsyncRequestBody;
import software.amazon.awssdk.core.async.AsyncRequestBodySplitConfiguration;
import software.amazon.awssdk.core.async.SdkPublisher;
import software.amazon.awssdk.core.exception.SdkClientException;
import software.amazon.awssdk.utils.Logger;
import software.amazon.awssdk.utils.Validate;
import software.amazon.awssdk.utils.async.SimplePublisher;
/**
* A helper class to split a {@link FileAsyncRequestBody} to multiple smaller async request bodies. It ensures the buffer used to
* be under the configured size via {@link AsyncRequestBodySplitConfiguration#bufferSizeInBytes()} by tracking the number of
* concurrent ongoing {@link AsyncRequestBody}s.
*/
@SdkInternalApi
public final class FileAsyncRequestBodySplitHelper {
private static final Logger log = Logger.loggerFor(FileAsyncRequestBodySplitHelper.class);
private final AtomicBoolean isSendingRequestBody = new AtomicBoolean(false);
private final AtomicLong remainingBytes;
private final long totalContentLength;
private final Path path;
private final int bufferPerAsyncRequestBody;
private final long totalBufferSize;
private final long chunkSize;
private volatile boolean isDone = false;
private AtomicInteger numAsyncRequestBodiesInFlight = new AtomicInteger(0);
private AtomicInteger chunkIndex = new AtomicInteger(0);
public FileAsyncRequestBodySplitHelper(FileAsyncRequestBody asyncRequestBody,
AsyncRequestBodySplitConfiguration splitConfiguration) {
Validate.notNull(asyncRequestBody, "asyncRequestBody");
Validate.notNull(splitConfiguration, "splitConfiguration");
Validate.isTrue(asyncRequestBody.contentLength().isPresent(), "Content length must be present", asyncRequestBody);
this.totalContentLength = asyncRequestBody.contentLength().get();
this.remainingBytes = new AtomicLong(totalContentLength);
this.path = asyncRequestBody.path();
this.chunkSize = splitConfiguration.chunkSizeInBytes() == null ?
AsyncRequestBodySplitConfiguration.defaultConfiguration().chunkSizeInBytes() :
splitConfiguration.chunkSizeInBytes();
this.totalBufferSize = splitConfiguration.bufferSizeInBytes() == null ?
AsyncRequestBodySplitConfiguration.defaultConfiguration().bufferSizeInBytes() :
splitConfiguration.bufferSizeInBytes();
this.bufferPerAsyncRequestBody = asyncRequestBody.chunkSizeInBytes();
}
public SdkPublisher<AsyncRequestBody> split() {
SimplePublisher<AsyncRequestBody> simplePublisher = new SimplePublisher<>();
try {
sendAsyncRequestBody(simplePublisher);
} catch (Throwable throwable) {
simplePublisher.error(throwable);
}
return SdkPublisher.adapt(simplePublisher);
}
private void sendAsyncRequestBody(SimplePublisher<AsyncRequestBody> simplePublisher) {
do {
if (!isSendingRequestBody.compareAndSet(false, true)) {
return;
}
try {
doSendAsyncRequestBody(simplePublisher);
} finally {
isSendingRequestBody.set(false);
}
} while (shouldSendMore());
}
private void doSendAsyncRequestBody(SimplePublisher<AsyncRequestBody> simplePublisher) {
while (shouldSendMore()) {
AsyncRequestBody currentAsyncRequestBody = newFileAsyncRequestBody(simplePublisher);
simplePublisher.send(currentAsyncRequestBody);
numAsyncRequestBodiesInFlight.incrementAndGet();
checkCompletion(simplePublisher, currentAsyncRequestBody);
}
}
private void checkCompletion(SimplePublisher<AsyncRequestBody> simplePublisher, AsyncRequestBody currentAsyncRequestBody) {
long remaining = remainingBytes.addAndGet(-currentAsyncRequestBody.contentLength().get());
if (remaining == 0) {
isDone = true;
simplePublisher.complete();
} else if (remaining < 0) {
isDone = true;
simplePublisher.error(SdkClientException.create(
"Unexpected error occurred. Remaining data is negative: " + remaining));
}
}
private void startNextRequestBody(SimplePublisher<AsyncRequestBody> simplePublisher) {
numAsyncRequestBodiesInFlight.decrementAndGet();
sendAsyncRequestBody(simplePublisher);
}
private AsyncRequestBody newFileAsyncRequestBody(SimplePublisher<AsyncRequestBody> simplePublisher) {
long position = chunkSize * chunkIndex.getAndIncrement();
long numBytesToReadForThisChunk = Math.min(totalContentLength - position, chunkSize);
FileAsyncRequestBody fileAsyncRequestBody = FileAsyncRequestBody.builder()
.path(path)
.position(position)
.numBytesToRead(numBytesToReadForThisChunk)
.build();
return new FileAsyncRequestBodyWrapper(fileAsyncRequestBody, simplePublisher);
}
/**
* Should not send more if it's done OR sending next request body would exceed the total buffer size
*/
private boolean shouldSendMore() {
if (isDone) {
return false;
}
long currentUsedBuffer = (long) numAsyncRequestBodiesInFlight.get() * bufferPerAsyncRequestBody;
return currentUsedBuffer + bufferPerAsyncRequestBody <= totalBufferSize;
}
@SdkTestInternalApi
AtomicInteger numAsyncRequestBodiesInFlight() {
return numAsyncRequestBodiesInFlight;
}
private final class FileAsyncRequestBodyWrapper implements AsyncRequestBody {
private final FileAsyncRequestBody fileAsyncRequestBody;
private final SimplePublisher<AsyncRequestBody> simplePublisher;
FileAsyncRequestBodyWrapper(FileAsyncRequestBody fileAsyncRequestBody,
SimplePublisher<AsyncRequestBody> simplePublisher) {
this.fileAsyncRequestBody = fileAsyncRequestBody;
this.simplePublisher = simplePublisher;
}
@Override
public void subscribe(Subscriber<? super ByteBuffer> s) {
fileAsyncRequestBody.doAfterOnComplete(() -> startNextRequestBody(simplePublisher))
// The reason we still need to call startNextRequestBody when the subscription is
// cancelled is that upstream could cancel the subscription even though the stream has
// finished successfully before onComplete. If this happens, doAfterOnComplete callback
// will never be invoked, and if the current buffer is full, the publisher will stop
// sending new FileAsyncRequestBody, leading to uncompleted future.
.doAfterOnCancel(() -> startNextRequestBody(simplePublisher))
.subscribe(s);
}
@Override
public Optional<Long> contentLength() {
return fileAsyncRequestBody.contentLength();
}
}
}
| 1,910 |
0 | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/ChecksumCalculatingAsyncRequestBody.java | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.awssdk.core.internal.async;
import static software.amazon.awssdk.core.HttpChecksumConstant.DEFAULT_ASYNC_CHUNK_SIZE;
import static software.amazon.awssdk.core.internal.util.ChunkContentUtils.LAST_CHUNK_LEN;
import static software.amazon.awssdk.core.internal.util.ChunkContentUtils.calculateChecksumTrailerLength;
import static software.amazon.awssdk.core.internal.util.ChunkContentUtils.calculateChunkLength;
import static software.amazon.awssdk.core.internal.util.ChunkContentUtils.createChecksumTrailer;
import static software.amazon.awssdk.core.internal.util.ChunkContentUtils.createChunk;
import java.nio.ByteBuffer;
import java.util.Optional;
import java.util.concurrent.atomic.AtomicLong;
import org.reactivestreams.Subscriber;
import org.reactivestreams.Subscription;
import software.amazon.awssdk.annotations.SdkInternalApi;
import software.amazon.awssdk.core.async.AsyncRequestBody;
import software.amazon.awssdk.core.async.SdkPublisher;
import software.amazon.awssdk.core.checksums.Algorithm;
import software.amazon.awssdk.core.checksums.SdkChecksum;
import software.amazon.awssdk.core.exception.SdkException;
import software.amazon.awssdk.utils.BinaryUtils;
import software.amazon.awssdk.utils.Validate;
import software.amazon.awssdk.utils.async.DelegatingSubscriber;
import software.amazon.awssdk.utils.builder.SdkBuilder;
/**
* Wrapper class to wrap an AsyncRequestBody.
* This will read the data in chunk format and append Checksum as trailer at the end.
*/
@SdkInternalApi
public class ChecksumCalculatingAsyncRequestBody implements AsyncRequestBody {
private static final byte[] FINAL_BYTE = new byte[0];
private final AsyncRequestBody wrapped;
private final SdkChecksum sdkChecksum;
private final Algorithm algorithm;
private final String trailerHeader;
private final long totalBytes;
private ChecksumCalculatingAsyncRequestBody(DefaultBuilder builder) {
Validate.notNull(builder.asyncRequestBody, "wrapped AsyncRequestBody cannot be null");
Validate.notNull(builder.algorithm, "algorithm cannot be null");
Validate.notNull(builder.trailerHeader, "trailerHeader cannot be null");
this.wrapped = builder.asyncRequestBody;
this.algorithm = builder.algorithm;
this.sdkChecksum = builder.algorithm != null ? SdkChecksum.forAlgorithm(algorithm) : null;
this.trailerHeader = builder.trailerHeader;
this.totalBytes = wrapped.contentLength()
.orElseThrow(() -> new UnsupportedOperationException("Content length must be supplied."));
}
/**
* @return Builder instance to construct a {@link FileAsyncRequestBody}.
*/
public static ChecksumCalculatingAsyncRequestBody.Builder builder() {
return new DefaultBuilder();
}
public interface Builder extends SdkBuilder<ChecksumCalculatingAsyncRequestBody.Builder,
ChecksumCalculatingAsyncRequestBody> {
/**
* Sets the AsyncRequestBody that will be wrapped.
* @param asyncRequestBody AsyncRequestBody.
* @return This builder for method chaining.
*/
ChecksumCalculatingAsyncRequestBody.Builder asyncRequestBody(AsyncRequestBody asyncRequestBody);
/**
* Sets the checksum algorithm.
* @param algorithm algorithm that is used to compute the checksum.
* @return This builder for method chaining.
*/
ChecksumCalculatingAsyncRequestBody.Builder algorithm(Algorithm algorithm);
/**
* Sets the Trailer header where computed SdkChecksum will be updated.
* @param trailerHeader Trailer header name which will be appended at the end of the string.
* @return This builder for method chaining.
*/
ChecksumCalculatingAsyncRequestBody.Builder trailerHeader(String trailerHeader);
}
private static final class DefaultBuilder implements ChecksumCalculatingAsyncRequestBody.Builder {
private AsyncRequestBody asyncRequestBody;
private Algorithm algorithm;
private String trailerHeader;
@Override
public ChecksumCalculatingAsyncRequestBody build() {
return new ChecksumCalculatingAsyncRequestBody(this);
}
@Override
public Builder asyncRequestBody(AsyncRequestBody asyncRequestBody) {
this.asyncRequestBody = asyncRequestBody;
return this;
}
@Override
public ChecksumCalculatingAsyncRequestBody.Builder algorithm(Algorithm algorithm) {
this.algorithm = algorithm;
return this;
}
@Override
public ChecksumCalculatingAsyncRequestBody.Builder trailerHeader(String trailerHeader) {
this.trailerHeader = trailerHeader;
return this;
}
}
@Override
public Optional<Long> contentLength() {
if (wrapped.contentLength().isPresent() && algorithm != null) {
return Optional.of(calculateChunkLength(wrapped.contentLength().get())
+ LAST_CHUNK_LEN
+ calculateChecksumTrailerLength(algorithm, trailerHeader));
}
return wrapped.contentLength();
}
@Override
public String contentType() {
return wrapped.contentType();
}
@Override
public void subscribe(Subscriber<? super ByteBuffer> s) {
Validate.notNull(s, "Subscription MUST NOT be null.");
if (sdkChecksum != null) {
sdkChecksum.reset();
}
SynchronousChunkBuffer synchronousChunkBuffer = new SynchronousChunkBuffer(totalBytes);
alwaysInvokeOnNext(wrapped).flatMapIterable(synchronousChunkBuffer::buffer)
.subscribe(new ChecksumCalculatingSubscriber(s, sdkChecksum, trailerHeader, totalBytes));
}
private SdkPublisher<ByteBuffer> alwaysInvokeOnNext(SdkPublisher<ByteBuffer> source) {
return subscriber -> source.subscribe(new OnNextGuaranteedSubscriber(subscriber));
}
private static final class ChecksumCalculatingSubscriber implements Subscriber<ByteBuffer> {
private final Subscriber<? super ByteBuffer> wrapped;
private final SdkChecksum checksum;
private final String trailerHeader;
private byte[] checksumBytes;
private final AtomicLong remainingBytes;
private Subscription subscription;
ChecksumCalculatingSubscriber(Subscriber<? super ByteBuffer> wrapped,
SdkChecksum checksum,
String trailerHeader, long totalBytes) {
this.wrapped = wrapped;
this.checksum = checksum;
this.trailerHeader = trailerHeader;
this.remainingBytes = new AtomicLong(totalBytes);
}
@Override
public void onSubscribe(Subscription subscription) {
this.subscription = subscription;
wrapped.onSubscribe(subscription);
}
@Override
public void onNext(ByteBuffer byteBuffer) {
boolean lastByte = this.remainingBytes.addAndGet(-byteBuffer.remaining()) <= 0;
try {
if (checksum != null) {
byteBuffer.mark();
checksum.update(byteBuffer);
byteBuffer.reset();
}
if (lastByte && checksumBytes == null && checksum != null) {
checksumBytes = checksum.getChecksumBytes();
ByteBuffer allocatedBuffer = getFinalChecksumAppendedChunk(byteBuffer);
wrapped.onNext(allocatedBuffer);
} else {
ByteBuffer allocatedBuffer = createChunk(byteBuffer, false);
wrapped.onNext(allocatedBuffer);
}
} catch (SdkException sdkException) {
this.subscription.cancel();
onError(sdkException);
}
}
private ByteBuffer getFinalChecksumAppendedChunk(ByteBuffer byteBuffer) {
ByteBuffer finalChunkedByteBuffer = createChunk(ByteBuffer.wrap(FINAL_BYTE), true);
ByteBuffer checksumTrailerByteBuffer = createChecksumTrailer(
BinaryUtils.toBase64(checksumBytes), trailerHeader);
ByteBuffer contentChunk = byteBuffer.hasRemaining() ? createChunk(byteBuffer, false) : byteBuffer;
ByteBuffer checksumAppendedBuffer = ByteBuffer.allocate(
contentChunk.remaining()
+ finalChunkedByteBuffer.remaining()
+ checksumTrailerByteBuffer.remaining());
checksumAppendedBuffer
.put(contentChunk)
.put(finalChunkedByteBuffer)
.put(checksumTrailerByteBuffer);
checksumAppendedBuffer.flip();
return checksumAppendedBuffer;
}
@Override
public void onError(Throwable t) {
wrapped.onError(t);
}
@Override
public void onComplete() {
wrapped.onComplete();
}
}
private static final class SynchronousChunkBuffer {
private final ChunkBuffer chunkBuffer;
SynchronousChunkBuffer(long totalBytes) {
this.chunkBuffer = ChunkBuffer.builder().bufferSize(DEFAULT_ASYNC_CHUNK_SIZE).totalBytes(totalBytes).build();
}
private Iterable<ByteBuffer> buffer(ByteBuffer bytes) {
return chunkBuffer.split(bytes);
}
}
public static class OnNextGuaranteedSubscriber extends DelegatingSubscriber<ByteBuffer, ByteBuffer> {
private volatile boolean onNextInvoked;
public OnNextGuaranteedSubscriber(Subscriber<? super ByteBuffer> subscriber) {
super(subscriber);
}
@Override
public void onNext(ByteBuffer t) {
if (!onNextInvoked) {
onNextInvoked = true;
}
subscriber.onNext(t);
}
@Override
public void onComplete() {
if (!onNextInvoked) {
subscriber.onNext(ByteBuffer.wrap(new byte[0]));
}
super.onComplete();
}
}
} | 1,911 |
0 | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/ChunkBuffer.java | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.awssdk.core.internal.async;
import static software.amazon.awssdk.core.HttpChecksumConstant.DEFAULT_ASYNC_CHUNK_SIZE;
import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Optional;
import java.util.concurrent.atomic.AtomicLong;
import software.amazon.awssdk.annotations.SdkInternalApi;
import software.amazon.awssdk.utils.Logger;
import software.amazon.awssdk.utils.builder.SdkBuilder;
/**
* Class that will buffer incoming BufferBytes to chunks of bufferSize.
* If totalBytes is not provided, i.e. content-length is unknown, {@link #getBufferedData()} should be used in the Subscriber's
* {@code onComplete()} to check for a final chunk that is smaller than the chunk size, and send if present.
*/
@SdkInternalApi
public final class ChunkBuffer {
private static final Logger log = Logger.loggerFor(ChunkBuffer.class);
private final AtomicLong transferredBytes;
private final ByteBuffer currentBuffer;
private final int chunkSize;
private final Long totalBytes;
private ChunkBuffer(Long totalBytes, Integer bufferSize) {
int chunkSize = bufferSize != null ? bufferSize : DEFAULT_ASYNC_CHUNK_SIZE;
this.chunkSize = chunkSize;
this.currentBuffer = ByteBuffer.allocate(chunkSize);
this.totalBytes = totalBytes;
this.transferredBytes = new AtomicLong(0);
}
public static Builder builder() {
return new DefaultBuilder();
}
/**
* Split the input {@link ByteBuffer} into multiple smaller {@link ByteBuffer}s, each of which contains {@link #chunkSize}
* worth of bytes. If the last chunk of the input ByteBuffer contains less than {@link #chunkSize} data, the last chunk will
* be buffered.
*/
public synchronized Iterable<ByteBuffer> split(ByteBuffer inputByteBuffer) {
if (!inputByteBuffer.hasRemaining()) {
return Collections.singletonList(inputByteBuffer);
}
List<ByteBuffer> byteBuffers = new ArrayList<>();
// If current buffer is not empty, fill the buffer first.
if (currentBuffer.position() != 0) {
fillCurrentBuffer(inputByteBuffer);
if (isCurrentBufferFull()) {
addCurrentBufferToIterable(byteBuffers);
}
}
// If the input buffer is not empty, split the input buffer
if (inputByteBuffer.hasRemaining()) {
splitRemainingInputByteBuffer(inputByteBuffer, byteBuffers);
}
// If this is the last chunk, add data buffered to the iterable
if (isLastChunk()) {
addCurrentBufferToIterable(byteBuffers);
}
return byteBuffers;
}
private boolean isCurrentBufferFull() {
return currentBuffer.position() == chunkSize;
}
/**
* Splits the input ByteBuffer to multiple chunks and add them to the iterable.
*/
private void splitRemainingInputByteBuffer(ByteBuffer inputByteBuffer, List<ByteBuffer> byteBuffers) {
while (inputByteBuffer.hasRemaining()) {
ByteBuffer inputByteBufferCopy = inputByteBuffer.asReadOnlyBuffer();
if (inputByteBuffer.remaining() < chunkSize) {
currentBuffer.put(inputByteBuffer);
break;
}
int newLimit = inputByteBufferCopy.position() + chunkSize;
inputByteBufferCopy.limit(newLimit);
inputByteBuffer.position(newLimit);
byteBuffers.add(inputByteBufferCopy);
transferredBytes.addAndGet(chunkSize);
}
}
/**
* Retrieve the current buffered data.
*/
public Optional<ByteBuffer> getBufferedData() {
int remainingBytesInBuffer = currentBuffer.position();
if (remainingBytesInBuffer == 0) {
return Optional.empty();
}
ByteBuffer bufferedChunk = ByteBuffer.allocate(remainingBytesInBuffer);
currentBuffer.flip();
bufferedChunk.put(currentBuffer);
bufferedChunk.flip();
return Optional.of(bufferedChunk);
}
private boolean isLastChunk() {
if (totalBytes == null) {
return false;
}
long remainingBytes = totalBytes - transferredBytes.get();
return remainingBytes != 0 && remainingBytes == currentBuffer.position();
}
private void addCurrentBufferToIterable(List<ByteBuffer> byteBuffers) {
Optional<ByteBuffer> bufferedChunk = getBufferedData();
if (bufferedChunk.isPresent()) {
byteBuffers.add(bufferedChunk.get());
transferredBytes.addAndGet(bufferedChunk.get().remaining());
currentBuffer.clear();
}
}
private void fillCurrentBuffer(ByteBuffer inputByteBuffer) {
while (currentBuffer.position() < chunkSize) {
if (!inputByteBuffer.hasRemaining()) {
break;
}
int remainingCapacity = chunkSize - currentBuffer.position();
if (inputByteBuffer.remaining() < remainingCapacity) {
currentBuffer.put(inputByteBuffer);
} else {
ByteBuffer remainingChunk = inputByteBuffer.asReadOnlyBuffer();
int newLimit = inputByteBuffer.position() + remainingCapacity;
remainingChunk.limit(newLimit);
inputByteBuffer.position(newLimit);
currentBuffer.put(remainingChunk);
}
}
}
public interface Builder extends SdkBuilder<Builder, ChunkBuffer> {
Builder bufferSize(int bufferSize);
Builder totalBytes(long totalBytes);
}
private static final class DefaultBuilder implements Builder {
private Integer bufferSize;
private Long totalBytes;
@Override
public ChunkBuffer build() {
return new ChunkBuffer(totalBytes, bufferSize);
}
@Override
public Builder bufferSize(int bufferSize) {
this.bufferSize = bufferSize;
return this;
}
@Override
public Builder totalBytes(long totalBytes) {
this.totalBytes = totalBytes;
return this;
}
}
}
| 1,912 |
0 | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/CompressionAsyncRequestBody.java | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.awssdk.core.internal.async;
import static software.amazon.awssdk.core.internal.io.AwsChunkedInputStream.DEFAULT_CHUNK_SIZE;
import java.nio.ByteBuffer;
import java.util.Collections;
import java.util.Optional;
import org.reactivestreams.Subscriber;
import software.amazon.awssdk.annotations.SdkInternalApi;
import software.amazon.awssdk.core.async.AsyncRequestBody;
import software.amazon.awssdk.core.async.SdkPublisher;
import software.amazon.awssdk.core.internal.compression.Compressor;
import software.amazon.awssdk.utils.Validate;
import software.amazon.awssdk.utils.async.DelegatingSubscriber;
import software.amazon.awssdk.utils.async.FlatteningSubscriber;
import software.amazon.awssdk.utils.builder.SdkBuilder;
/**
* Wrapper class to wrap an AsyncRequestBody.
* This will chunk and compress the payload with the provided {@link Compressor}.
*/
@SdkInternalApi
public class CompressionAsyncRequestBody implements AsyncRequestBody {
private final AsyncRequestBody wrapped;
private final Compressor compressor;
private final ChunkBuffer chunkBuffer;
private CompressionAsyncRequestBody(DefaultBuilder builder) {
this.wrapped = Validate.paramNotNull(builder.asyncRequestBody, "asyncRequestBody");
this.compressor = Validate.paramNotNull(builder.compressor, "compressor");
int chunkSize = builder.chunkSize != null ? builder.chunkSize : DEFAULT_CHUNK_SIZE;
this.chunkBuffer = ChunkBuffer.builder()
.bufferSize(chunkSize)
.build();
}
@Override
public void subscribe(Subscriber<? super ByteBuffer> s) {
Validate.notNull(s, "Subscription MUST NOT be null.");
SdkPublisher<Iterable<ByteBuffer>> split =
split(wrapped).addTrailingData(() -> Collections.singleton(getBufferedDataIfPresent()));
SdkPublisher<ByteBuffer> flattening = flattening(split);
flattening.map(compressor::compress).subscribe(s);
}
@Override
public Optional<Long> contentLength() {
return wrapped.contentLength();
}
@Override
public String contentType() {
return wrapped.contentType();
}
private SdkPublisher<Iterable<ByteBuffer>> split(SdkPublisher<ByteBuffer> source) {
return subscriber -> source.subscribe(new SplittingSubscriber(subscriber));
}
private Iterable<ByteBuffer> getBufferedDataIfPresent() {
return chunkBuffer.getBufferedData()
.map(Collections::singletonList)
.orElse(Collections.emptyList());
}
private SdkPublisher<ByteBuffer> flattening(SdkPublisher<Iterable<ByteBuffer>> source) {
return subscriber -> source.subscribe(new FlatteningSubscriber<>(subscriber));
}
/**
* @return Builder instance to construct a {@link CompressionAsyncRequestBody}.
*/
public static Builder builder() {
return new DefaultBuilder();
}
public interface Builder extends SdkBuilder<CompressionAsyncRequestBody.Builder, CompressionAsyncRequestBody> {
/**
* Sets the AsyncRequestBody that will be wrapped.
* @param asyncRequestBody
* @return This builder for method chaining.
*/
Builder asyncRequestBody(AsyncRequestBody asyncRequestBody);
/**
* Sets the compressor to compress the request.
* @param compressor
* @return This builder for method chaining.
*/
Builder compressor(Compressor compressor);
/**
* Sets the chunk size. Default size is 128 * 1024.
* @param chunkSize
* @return This builder for method chaining.
*/
Builder chunkSize(Integer chunkSize);
}
private static final class DefaultBuilder implements Builder {
private AsyncRequestBody asyncRequestBody;
private Compressor compressor;
private Integer chunkSize;
@Override
public CompressionAsyncRequestBody build() {
return new CompressionAsyncRequestBody(this);
}
@Override
public Builder asyncRequestBody(AsyncRequestBody asyncRequestBody) {
this.asyncRequestBody = asyncRequestBody;
return this;
}
@Override
public Builder compressor(Compressor compressor) {
this.compressor = compressor;
return this;
}
@Override
public Builder chunkSize(Integer chunkSize) {
this.chunkSize = chunkSize;
return this;
}
}
private final class SplittingSubscriber extends DelegatingSubscriber<ByteBuffer, Iterable<ByteBuffer>> {
protected SplittingSubscriber(Subscriber<? super Iterable<ByteBuffer>> subscriber) {
super(subscriber);
}
@Override
public void onNext(ByteBuffer byteBuffer) {
Iterable<ByteBuffer> buffers = chunkBuffer.split(byteBuffer);
subscriber.onNext(buffers);
}
}
}
| 1,913 |
0 | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/AsyncStreamPrepender.java | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.awssdk.core.internal.async;
import java.util.concurrent.atomic.AtomicLong;
import org.reactivestreams.Publisher;
import org.reactivestreams.Subscriber;
import org.reactivestreams.Subscription;
import software.amazon.awssdk.annotations.SdkInternalApi;
@SdkInternalApi
public class AsyncStreamPrepender<T> implements Publisher<T> {
private final Publisher<T> delegate;
private final T firstItem;
public AsyncStreamPrepender(Publisher<T> delegate, T firstItem) {
this.delegate = delegate;
this.firstItem = firstItem;
}
@Override
public void subscribe(Subscriber<? super T> s) {
delegate.subscribe(new DelegateSubscriber(s));
}
private class DelegateSubscriber implements Subscriber<T> {
private final Subscriber<? super T> subscriber;
private volatile boolean complete = false;
private volatile boolean firstRequest = true;
private DelegateSubscriber(Subscriber<? super T> subscriber) {
this.subscriber = subscriber;
}
@Override
public void onSubscribe(Subscription subscription) {
subscriber.onSubscribe(new Subscription() {
private final AtomicLong requests = new AtomicLong(0L);
private volatile boolean cancelled = false;
private volatile boolean isOutermostCall = true;
@Override
public void request(long n) {
if (cancelled) {
return;
}
if (n <= 0) {
subscription.cancel();
subscriber.onError(new IllegalArgumentException("Requested " + n + " items"));
}
if (firstRequest) {
firstRequest = false;
if (n - 1 > 0) {
requests.addAndGet(n - 1);
}
isOutermostCall = false;
subscriber.onNext(firstItem);
isOutermostCall = true;
if (complete) {
subscriber.onComplete();
return;
}
} else {
requests.addAndGet(n);
}
if (isOutermostCall) {
try {
isOutermostCall = false;
long l;
while ((l = requests.getAndSet(0L)) > 0) {
subscription.request(l);
}
} finally {
isOutermostCall = true;
}
}
}
@Override
public void cancel() {
cancelled = true;
subscription.cancel();
}
});
}
@Override
public void onNext(T item) {
subscriber.onNext(item);
}
@Override
public void onError(Throwable t) {
subscriber.onError(t);
}
@Override
public void onComplete() {
complete = true;
if (!firstRequest) {
subscriber.onComplete();
}
}
}
}
| 1,914 |
0 | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncRequestBody.java | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.awssdk.core.internal.async;
import static software.amazon.awssdk.utils.FunctionalUtils.invokeSafely;
import static software.amazon.awssdk.utils.FunctionalUtils.runAndLogError;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousFileChannel;
import java.nio.channels.CompletionHandler;
import java.nio.file.Files;
import java.nio.file.NoSuchFileException;
import java.nio.file.Path;
import java.nio.file.StandardOpenOption;
import java.nio.file.attribute.FileTime;
import java.util.Optional;
import java.util.concurrent.atomic.AtomicLong;
import org.reactivestreams.Subscriber;
import org.reactivestreams.Subscription;
import software.amazon.awssdk.annotations.SdkInternalApi;
import software.amazon.awssdk.core.async.AsyncRequestBody;
import software.amazon.awssdk.core.async.AsyncRequestBodySplitConfiguration;
import software.amazon.awssdk.core.async.SdkPublisher;
import software.amazon.awssdk.core.internal.util.Mimetype;
import software.amazon.awssdk.core.internal.util.NoopSubscription;
import software.amazon.awssdk.utils.Logger;
import software.amazon.awssdk.utils.NumericUtils;
import software.amazon.awssdk.utils.Validate;
import software.amazon.awssdk.utils.builder.SdkBuilder;
/**
* Implementation of {@link AsyncRequestBody} that reads data from a file.
*
* @see AsyncRequestBody#fromFile(Path)
* @see AsyncRequestBody#fromFile(java.io.File)
*/
@SdkInternalApi
public final class FileAsyncRequestBody implements AsyncRequestBody {
private static final Logger log = Logger.loggerFor(FileAsyncRequestBody.class);
/**
* Default size (in bytes) of ByteBuffer chunks read from the file and delivered to the subscriber.
*/
private static final int DEFAULT_CHUNK_SIZE = 16 * 1024;
/**
* File to read.
*/
private final Path path;
private final long fileLength;
/**
* Size (in bytes) of ByteBuffer chunks read from the file and delivered to the subscriber.
*/
private final int chunkSizeInBytes;
private final long position;
private final long numBytesToRead;
private FileAsyncRequestBody(DefaultBuilder builder) {
this.path = builder.path;
this.chunkSizeInBytes = builder.chunkSizeInBytes == null ? DEFAULT_CHUNK_SIZE : builder.chunkSizeInBytes;
this.fileLength = invokeSafely(() -> Files.size(path));
this.position = builder.position == null ? 0 : Validate.isNotNegative(builder.position, "position");
this.numBytesToRead = builder.numBytesToRead == null ? fileLength - this.position :
Validate.isNotNegative(builder.numBytesToRead, "numBytesToRead");
}
@Override
public SdkPublisher<AsyncRequestBody> split(AsyncRequestBodySplitConfiguration splitConfiguration) {
Validate.notNull(splitConfiguration, "splitConfiguration");
return new FileAsyncRequestBodySplitHelper(this, splitConfiguration).split();
}
public Path path() {
return path;
}
public long fileLength() {
return fileLength;
}
public int chunkSizeInBytes() {
return chunkSizeInBytes;
}
public long position() {
return position;
}
public long numBytesToRead() {
return numBytesToRead;
}
@Override
public Optional<Long> contentLength() {
return Optional.of(numBytesToRead);
}
@Override
public String contentType() {
return Mimetype.getInstance().getMimetype(path);
}
@Override
public void subscribe(Subscriber<? super ByteBuffer> s) {
AsynchronousFileChannel channel = null;
try {
channel = openInputChannel(this.path);
// We need to synchronize here because the subscriber could call
// request() from within onSubscribe which would potentially
// trigger onNext before onSubscribe is finished.
Subscription subscription = new FileSubscription(channel, s);
synchronized (subscription) {
s.onSubscribe(subscription);
}
} catch (IOException | RuntimeException e) {
if (channel != null) {
runAndLogError(log.logger(), "Unable to close file channel", channel::close);
}
// subscribe() must return normally, so we need to signal the
// failure to open via onError() once onSubscribe() is signaled.
s.onSubscribe(new NoopSubscription(s));
s.onError(e);
}
}
/**
* @return Builder instance to construct a {@link FileAsyncRequestBody}.
*/
public static Builder builder() {
return new DefaultBuilder();
}
/**
* A builder for {@link FileAsyncRequestBody}.
*/
public interface Builder extends SdkBuilder<Builder, FileAsyncRequestBody> {
/**
* Sets the file to send to the service.
*
* @param path Path to file to read.
* @return This builder for method chaining.
*/
Builder path(Path path);
/**
* Sets the size of chunks to read from the file. Increasing this will cause more data to be buffered into memory but
* may yield better latencies. Decreasing this will reduce memory usage but may cause reduced latency. Setting this value
* is very dependent on upload speed and requires some performance testing to tune.
*
* <p>The default chunk size is {@value #DEFAULT_CHUNK_SIZE} bytes</p>
*
* @param chunkSize New chunk size in bytes.
* @return This builder for method chaining.
*/
Builder chunkSizeInBytes(Integer chunkSize);
/**
* Sets the file position at which the request body begins.
*
* <p>By default, it's 0, i.e., reading from the beginning.
*
* @param position the position of the file
* @return The builder for method chaining.
*/
Builder position(Long position);
/**
* Sets the number of bytes to read from this file.
*
* <p>By default, it's same as the file length.
*
* @param numBytesToRead number of bytes to read
* @return The builder for method chaining.
*/
Builder numBytesToRead(Long numBytesToRead);
}
private static final class DefaultBuilder implements Builder {
private Long position;
private Path path;
private Integer chunkSizeInBytes;
private Long numBytesToRead;
@Override
public Builder path(Path path) {
this.path = path;
return this;
}
public void setPath(Path path) {
path(path);
}
@Override
public Builder chunkSizeInBytes(Integer chunkSizeInBytes) {
this.chunkSizeInBytes = chunkSizeInBytes;
return this;
}
@Override
public Builder position(Long position) {
this.position = position;
return this;
}
@Override
public Builder numBytesToRead(Long numBytesToRead) {
this.numBytesToRead = numBytesToRead;
return this;
}
public void setChunkSizeInBytes(Integer chunkSizeInBytes) {
chunkSizeInBytes(chunkSizeInBytes);
}
@Override
public FileAsyncRequestBody build() {
return new FileAsyncRequestBody(this);
}
}
/**
* Reads the file for one subscriber.
*/
private final class FileSubscription implements Subscription {
private final AsynchronousFileChannel inputChannel;
private final Subscriber<? super ByteBuffer> subscriber;
private final AtomicLong currentPosition;
private final AtomicLong remainingBytes;
private final long sizeAtStart;
private final FileTime modifiedTimeAtStart;
private long outstandingDemand = 0;
private boolean readInProgress = false;
private volatile boolean done = false;
private final Object lock = new Object();
private FileSubscription(AsynchronousFileChannel inputChannel,
Subscriber<? super ByteBuffer> subscriber) throws IOException {
this.inputChannel = inputChannel;
this.subscriber = subscriber;
this.sizeAtStart = inputChannel.size();
this.modifiedTimeAtStart = Files.getLastModifiedTime(path);
this.remainingBytes = new AtomicLong(numBytesToRead);
this.currentPosition = new AtomicLong(position);
}
@Override
public void request(long n) {
if (done) {
return;
}
if (n < 1) {
IllegalArgumentException ex =
new IllegalArgumentException(subscriber + " violated the Reactive Streams rule 3.9 by requesting a "
+ "non-positive number of elements.");
signalOnError(ex);
} else {
try {
// We need to synchronize here because of the race condition
// where readData finishes reading at the same time request
// demand comes in
synchronized (lock) {
// As governed by rule 3.17, when demand overflows `Long.MAX_VALUE` we treat the signalled demand as
// "effectively unbounded"
if (Long.MAX_VALUE - outstandingDemand < n) {
outstandingDemand = Long.MAX_VALUE;
} else {
outstandingDemand += n;
}
if (!readInProgress) {
readInProgress = true;
readData();
}
}
} catch (Exception e) {
signalOnError(e);
}
}
}
@Override
public void cancel() {
synchronized (this) {
if (!done) {
done = true;
closeFile();
}
}
}
private void readData() {
// It's possible to have another request for data come in after we've closed the file.
if (!inputChannel.isOpen() || done) {
return;
}
ByteBuffer buffer = ByteBuffer.allocate(Math.min(chunkSizeInBytes, NumericUtils.saturatedCast(remainingBytes.get())));
inputChannel.read(buffer, currentPosition.get(), buffer, new CompletionHandler<Integer, ByteBuffer>() {
@Override
public void completed(Integer result, ByteBuffer attachment) {
try {
if (result > 0) {
attachment.flip();
int readBytes = attachment.remaining();
currentPosition.addAndGet(readBytes);
remainingBytes.addAndGet(-readBytes);
signalOnNext(attachment);
if (remainingBytes.get() == 0) {
closeFile();
signalOnComplete();
}
synchronized (lock) {
// If we have more permits, queue up another read.
if (--outstandingDemand > 0) {
readData();
} else {
readInProgress = false;
}
}
} else {
// Reached the end of the file, notify the subscriber and cleanup
closeFile();
signalOnComplete();
}
} catch (Throwable throwable) {
closeFile();
signalOnError(throwable);
}
}
@Override
public void failed(Throwable exc, ByteBuffer attachment) {
signalOnError(exc);
closeFile();
}
});
}
private void closeFile() {
try {
inputChannel.close();
} catch (IOException e) {
log.warn(() -> "Failed to close the file", e);
}
}
private void signalOnNext(ByteBuffer attachment) {
synchronized (this) {
if (!done) {
subscriber.onNext(attachment);
}
}
}
private void signalOnComplete() {
try {
long sizeAtEnd = Files.size(path);
if (sizeAtStart != sizeAtEnd) {
signalOnError(new IOException("File size changed after reading started. Initial size: " + sizeAtStart + ". "
+ "Current size: " + sizeAtEnd));
return;
}
if (remainingBytes.get() > 0) {
signalOnError(new IOException("Fewer bytes were read than were expected, was the file modified after "
+ "reading started?"));
return;
}
FileTime modifiedTimeAtEnd = Files.getLastModifiedTime(path);
if (modifiedTimeAtStart.compareTo(modifiedTimeAtEnd) != 0) {
signalOnError(new IOException("File last-modified time changed after reading started. Initial modification "
+ "time: " + modifiedTimeAtStart + ". Current modification time: " +
modifiedTimeAtEnd));
return;
}
} catch (NoSuchFileException e) {
signalOnError(new IOException("Unable to check file status after read. Was the file deleted or were its "
+ "permissions changed?", e));
return;
} catch (IOException e) {
signalOnError(new IOException("Unable to check file status after read.", e));
return;
}
synchronized (this) {
if (!done) {
done = true;
subscriber.onComplete();
}
}
}
private void signalOnError(Throwable t) {
synchronized (this) {
if (!done) {
done = true;
subscriber.onError(t);
}
}
}
}
private static AsynchronousFileChannel openInputChannel(Path path) throws IOException {
return AsynchronousFileChannel.open(path, StandardOpenOption.READ);
}
} | 1,915 |
0 | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/InputStreamWithExecutorAsyncRequestBody.java | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.awssdk.core.internal.async;
import java.io.IOException;
import java.io.InputStream;
import java.nio.ByteBuffer;
import java.util.Optional;
import java.util.concurrent.CancellationException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import org.reactivestreams.Subscriber;
import software.amazon.awssdk.annotations.SdkInternalApi;
import software.amazon.awssdk.annotations.SdkTestInternalApi;
import software.amazon.awssdk.core.async.AsyncRequestBody;
import software.amazon.awssdk.core.async.AsyncRequestBodyFromInputStreamConfiguration;
import software.amazon.awssdk.core.async.BlockingInputStreamAsyncRequestBody;
import software.amazon.awssdk.core.exception.NonRetryableException;
import software.amazon.awssdk.core.internal.util.NoopSubscription;
import software.amazon.awssdk.utils.IoUtils;
import software.amazon.awssdk.utils.Logger;
/**
* A {@link AsyncRequestBody} that allows reading data off of an {@link InputStream} using a background
* {@link ExecutorService}.
* <p>
* Created via {@link AsyncRequestBody#fromInputStream(InputStream, Long, ExecutorService)}.
*/
@SdkInternalApi
public class InputStreamWithExecutorAsyncRequestBody implements AsyncRequestBody {
private static final Logger log = Logger.loggerFor(InputStreamWithExecutorAsyncRequestBody.class);
private final Object subscribeLock = new Object();
private final InputStream inputStream;
private final Long contentLength;
private final ExecutorService executor;
private Future<?> writeFuture;
public InputStreamWithExecutorAsyncRequestBody(AsyncRequestBodyFromInputStreamConfiguration configuration) {
this.inputStream = configuration.inputStream();
this.contentLength = configuration.contentLength();
this.executor = configuration.executor();
IoUtils.markStreamWithMaxReadLimit(inputStream, configuration.maxReadLimit());
}
@Override
public Optional<Long> contentLength() {
return Optional.ofNullable(contentLength);
}
@Override
public void subscribe(Subscriber<? super ByteBuffer> s) {
// Each subscribe cancels the previous subscribe.
synchronized (subscribeLock) {
try {
if (writeFuture != null) {
writeFuture.cancel(true);
waitForCancellation(writeFuture); // Wait for the cancellation
tryReset(inputStream);
}
BlockingInputStreamAsyncRequestBody delegate = AsyncRequestBody.forBlockingInputStream(contentLength);
writeFuture = executor.submit(() -> doBlockingWrite(delegate));
delegate.subscribe(s);
} catch (Throwable t) {
s.onSubscribe(new NoopSubscription(s));
s.onError(t);
}
}
}
private void tryReset(InputStream inputStream) {
try {
inputStream.reset();
} catch (IOException e) {
String message = "Request cannot be retried, because the request stream could not be reset.";
throw NonRetryableException.create(message, e);
}
}
@SdkTestInternalApi
public Future<?> activeWriteFuture() {
synchronized (subscribeLock) {
return writeFuture;
}
}
private void doBlockingWrite(BlockingInputStreamAsyncRequestBody asyncRequestBody) {
try {
asyncRequestBody.writeInputStream(inputStream);
} catch (Throwable t) {
log.debug(() -> "Encountered error while writing input stream to service.", t);
throw t;
}
}
private void waitForCancellation(Future<?> writeFuture) {
try {
writeFuture.get(10, TimeUnit.SECONDS);
} catch (ExecutionException | CancellationException e) {
// Expected - we cancelled.
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
throw new RuntimeException(e);
} catch (TimeoutException e) {
throw new IllegalStateException("Timed out waiting to reset the input stream.", e);
}
}
}
| 1,916 |
0 | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/FileAsyncResponseTransformer.java | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.awssdk.core.internal.async;
import static software.amazon.awssdk.core.FileTransformerConfiguration.FileWriteOption.CREATE_OR_APPEND_TO_EXISTING;
import static software.amazon.awssdk.utils.FunctionalUtils.invokeSafely;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousFileChannel;
import java.nio.channels.CompletionHandler;
import java.nio.file.Files;
import java.nio.file.NoSuchFileException;
import java.nio.file.OpenOption;
import java.nio.file.Path;
import java.nio.file.StandardOpenOption;
import java.util.Collections;
import java.util.HashSet;
import java.util.Set;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.atomic.AtomicLong;
import java.util.function.Consumer;
import org.reactivestreams.Subscriber;
import org.reactivestreams.Subscription;
import software.amazon.awssdk.annotations.SdkInternalApi;
import software.amazon.awssdk.core.FileTransformerConfiguration;
import software.amazon.awssdk.core.FileTransformerConfiguration.FailureBehavior;
import software.amazon.awssdk.core.async.AsyncResponseTransformer;
import software.amazon.awssdk.core.async.SdkPublisher;
import software.amazon.awssdk.core.exception.SdkClientException;
/**
* {@link AsyncResponseTransformer} that writes the data to the specified file.
*
* @param <ResponseT> Response POJO type.
*/
@SdkInternalApi
public final class FileAsyncResponseTransformer<ResponseT> implements AsyncResponseTransformer<ResponseT, ResponseT> {
private final Path path;
private volatile AsynchronousFileChannel fileChannel;
private volatile CompletableFuture<Void> cf;
private volatile ResponseT response;
private final long position;
private final FileTransformerConfiguration configuration;
public FileAsyncResponseTransformer(Path path) {
this.path = path;
this.configuration = FileTransformerConfiguration.defaultCreateNew();
this.position = 0L;
}
public FileAsyncResponseTransformer(Path path, FileTransformerConfiguration fileConfiguration) {
this.path = path;
this.configuration = fileConfiguration;
this.position = determineFilePositionToWrite(path);
}
private long determineFilePositionToWrite(Path path) {
if (configuration.fileWriteOption() == CREATE_OR_APPEND_TO_EXISTING) {
try {
return Files.size(path);
} catch (NoSuchFileException e) {
// Ignore
} catch (IOException exception) {
throw SdkClientException.create("Cannot determine the current file size " + path, exception);
}
}
return 0L;
}
private AsynchronousFileChannel createChannel(Path path) throws IOException {
Set<OpenOption> options = new HashSet<>();
switch (configuration.fileWriteOption()) {
case CREATE_OR_APPEND_TO_EXISTING:
Collections.addAll(options, StandardOpenOption.WRITE, StandardOpenOption.CREATE);
break;
case CREATE_OR_REPLACE_EXISTING:
Collections.addAll(options, StandardOpenOption.WRITE, StandardOpenOption.CREATE,
StandardOpenOption.TRUNCATE_EXISTING);
break;
case CREATE_NEW:
Collections.addAll(options, StandardOpenOption.WRITE, StandardOpenOption.CREATE_NEW);
break;
default:
throw new IllegalArgumentException("Unsupported file write option: " + configuration.fileWriteOption());
}
ExecutorService executorService = configuration.executorService().orElse(null);
return AsynchronousFileChannel.open(path, options, executorService);
}
@Override
public CompletableFuture<ResponseT> prepare() {
cf = new CompletableFuture<>();
cf.whenComplete((r, t) -> {
if (t != null && fileChannel != null) {
invokeSafely(fileChannel::close);
}
});
return cf.thenApply(ignored -> response);
}
@Override
public void onResponse(ResponseT response) {
this.response = response;
}
@Override
public void onStream(SdkPublisher<ByteBuffer> publisher) {
// onStream may be called multiple times so reset the file channel every time
this.fileChannel = invokeSafely(() -> createChannel(path));
publisher.subscribe(new FileSubscriber(this.fileChannel, path, cf, this::exceptionOccurred,
position));
}
@Override
public void exceptionOccurred(Throwable throwable) {
try {
if (fileChannel != null) {
invokeSafely(fileChannel::close);
}
} finally {
if (configuration.failureBehavior() == FailureBehavior.DELETE) {
invokeSafely(() -> Files.deleteIfExists(path));
}
}
cf.completeExceptionally(throwable);
}
/**
* {@link Subscriber} implementation that writes chunks to a file.
*/
static class FileSubscriber implements Subscriber<ByteBuffer> {
private final AtomicLong position;
private final AsynchronousFileChannel fileChannel;
private final Path path;
private final CompletableFuture<Void> future;
private final Consumer<Throwable> onErrorMethod;
private volatile boolean writeInProgress = false;
private volatile boolean closeOnLastWrite = false;
private Subscription subscription;
FileSubscriber(AsynchronousFileChannel fileChannel, Path path, CompletableFuture<Void> future,
Consumer<Throwable> onErrorMethod, long startingPosition) {
this.fileChannel = fileChannel;
this.path = path;
this.future = future;
this.onErrorMethod = onErrorMethod;
this.position = new AtomicLong(startingPosition);
}
@Override
public void onSubscribe(Subscription s) {
if (this.subscription != null) {
s.cancel();
return;
}
this.subscription = s;
// Request the first chunk to start producing content
s.request(1);
}
@Override
public void onNext(ByteBuffer byteBuffer) {
if (byteBuffer == null) {
throw new NullPointerException("Element must not be null");
}
performWrite(byteBuffer);
}
private void performWrite(ByteBuffer byteBuffer) {
writeInProgress = true;
fileChannel.write(byteBuffer, position.get(), byteBuffer, new CompletionHandler<Integer, ByteBuffer>() {
@Override
public void completed(Integer result, ByteBuffer attachment) {
position.addAndGet(result);
if (byteBuffer.hasRemaining()) {
performWrite(byteBuffer);
} else {
synchronized (FileSubscriber.this) {
writeInProgress = false;
if (closeOnLastWrite) {
close();
} else {
subscription.request(1);
}
}
}
}
@Override
public void failed(Throwable exc, ByteBuffer attachment) {
subscription.cancel();
future.completeExceptionally(exc);
}
});
}
@Override
public void onError(Throwable t) {
onErrorMethod.accept(t);
}
@Override
public void onComplete() {
// if write in progress, tell write to close on finish.
synchronized (this) {
if (writeInProgress) {
closeOnLastWrite = true;
} else {
close();
}
}
}
private void close() {
try {
if (fileChannel != null) {
invokeSafely(fileChannel::close);
}
future.complete(null);
} catch (RuntimeException exception) {
future.completeExceptionally(exception);
}
}
@Override
public String toString() {
return getClass() + ":" + path.toString();
}
}
} | 1,917 |
0 | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/SplittingPublisher.java | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.awssdk.core.internal.async;
import java.nio.ByteBuffer;
import java.util.Optional;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicLong;
import org.reactivestreams.Subscriber;
import org.reactivestreams.Subscription;
import software.amazon.awssdk.annotations.SdkInternalApi;
import software.amazon.awssdk.core.async.AsyncRequestBody;
import software.amazon.awssdk.core.async.AsyncRequestBodySplitConfiguration;
import software.amazon.awssdk.core.async.SdkPublisher;
import software.amazon.awssdk.core.exception.NonRetryableException;
import software.amazon.awssdk.core.internal.util.NoopSubscription;
import software.amazon.awssdk.utils.Logger;
import software.amazon.awssdk.utils.Validate;
import software.amazon.awssdk.utils.async.SimplePublisher;
/**
* Splits an {@link AsyncRequestBody} to multiple smaller {@link AsyncRequestBody}s, each of which publishes a specific portion of
* the original data.
*
* <p>If content length is known, each {@link AsyncRequestBody} is sent to the subscriber right after it's initialized.
* Otherwise, it is sent after the entire content for that chunk is buffered. This is required to get content length.
*/
@SdkInternalApi
public class SplittingPublisher implements SdkPublisher<AsyncRequestBody> {
private static final Logger log = Logger.loggerFor(SplittingPublisher.class);
private final AsyncRequestBody upstreamPublisher;
private final SplittingSubscriber splittingSubscriber;
private final SimplePublisher<AsyncRequestBody> downstreamPublisher = new SimplePublisher<>();
private final long chunkSizeInBytes;
private final long bufferSizeInBytes;
public SplittingPublisher(AsyncRequestBody asyncRequestBody,
AsyncRequestBodySplitConfiguration splitConfiguration) {
this.upstreamPublisher = Validate.paramNotNull(asyncRequestBody, "asyncRequestBody");
Validate.notNull(splitConfiguration, "splitConfiguration");
this.chunkSizeInBytes = splitConfiguration.chunkSizeInBytes() == null ?
AsyncRequestBodySplitConfiguration.defaultConfiguration().chunkSizeInBytes() :
splitConfiguration.chunkSizeInBytes();
this.bufferSizeInBytes = splitConfiguration.bufferSizeInBytes() == null ?
AsyncRequestBodySplitConfiguration.defaultConfiguration().bufferSizeInBytes() :
splitConfiguration.bufferSizeInBytes();
this.splittingSubscriber = new SplittingSubscriber(upstreamPublisher.contentLength().orElse(null));
if (!upstreamPublisher.contentLength().isPresent()) {
Validate.isTrue(bufferSizeInBytes >= chunkSizeInBytes,
"bufferSizeInBytes must be larger than or equal to " +
"chunkSizeInBytes if the content length is unknown");
}
}
@Override
public void subscribe(Subscriber<? super AsyncRequestBody> downstreamSubscriber) {
downstreamPublisher.subscribe(downstreamSubscriber);
upstreamPublisher.subscribe(splittingSubscriber);
}
private class SplittingSubscriber implements Subscriber<ByteBuffer> {
private Subscription upstreamSubscription;
private final Long upstreamSize;
private final AtomicInteger chunkNumber = new AtomicInteger(0);
private volatile DownstreamBody currentBody;
private final AtomicBoolean hasOpenUpstreamDemand = new AtomicBoolean(false);
private final AtomicLong dataBuffered = new AtomicLong(0);
/**
* A hint to determine whether we will exceed maxMemoryUsage by the next OnNext call.
*/
private int byteBufferSizeHint;
private volatile boolean upstreamComplete;
SplittingSubscriber(Long upstreamSize) {
this.upstreamSize = upstreamSize;
}
@Override
public void onSubscribe(Subscription s) {
this.upstreamSubscription = s;
this.currentBody =
initializeNextDownstreamBody(upstreamSize != null, calculateChunkSize(upstreamSize),
chunkNumber.get());
// We need to request subscription *after* we set currentBody because onNext could be invoked right away.
upstreamSubscription.request(1);
}
private DownstreamBody initializeNextDownstreamBody(boolean contentLengthKnown, long chunkSize, int chunkNumber) {
DownstreamBody body = new DownstreamBody(contentLengthKnown, chunkSize, chunkNumber);
if (contentLengthKnown) {
sendCurrentBody(body);
}
return body;
}
@Override
public void onNext(ByteBuffer byteBuffer) {
hasOpenUpstreamDemand.set(false);
byteBufferSizeHint = byteBuffer.remaining();
while (true) {
if (!byteBuffer.hasRemaining()) {
break;
}
int amountRemainingInChunk = amountRemainingInChunk();
// If we have fulfilled this chunk,
// complete the current body
if (amountRemainingInChunk == 0) {
completeCurrentBodyAndCreateNewIfNeeded(byteBuffer);
amountRemainingInChunk = amountRemainingInChunk();
}
// If the current ByteBuffer < this chunk, send it as-is
if (amountRemainingInChunk > byteBuffer.remaining()) {
currentBody.send(byteBuffer.duplicate());
break;
}
// If the current ByteBuffer == this chunk, send it as-is and
// complete the current body
if (amountRemainingInChunk == byteBuffer.remaining()) {
currentBody.send(byteBuffer.duplicate());
completeCurrentBodyAndCreateNewIfNeeded(byteBuffer);
break;
}
// If the current ByteBuffer > this chunk, split this ByteBuffer
ByteBuffer firstHalf = byteBuffer.duplicate();
int newLimit = firstHalf.position() + amountRemainingInChunk;
firstHalf.limit(newLimit);
byteBuffer.position(newLimit);
currentBody.send(firstHalf);
}
maybeRequestMoreUpstreamData();
}
private void completeCurrentBodyAndCreateNewIfNeeded(ByteBuffer byteBuffer) {
completeCurrentBody();
int currentChunk = chunkNumber.incrementAndGet();
boolean shouldCreateNewDownstreamRequestBody;
Long dataRemaining = totalDataRemaining();
if (upstreamSize == null) {
shouldCreateNewDownstreamRequestBody = !upstreamComplete || byteBuffer.hasRemaining();
} else {
shouldCreateNewDownstreamRequestBody = dataRemaining != null && dataRemaining > 0;
}
if (shouldCreateNewDownstreamRequestBody) {
long chunkSize = calculateChunkSize(dataRemaining);
currentBody = initializeNextDownstreamBody(upstreamSize != null, chunkSize, currentChunk);
}
}
private int amountRemainingInChunk() {
return Math.toIntExact(currentBody.maxLength - currentBody.transferredLength);
}
private void completeCurrentBody() {
log.debug(() -> "completeCurrentBody for chunk " + chunkNumber.get());
currentBody.complete();
if (upstreamSize == null) {
sendCurrentBody(currentBody);
}
}
@Override
public void onComplete() {
upstreamComplete = true;
log.trace(() -> "Received onComplete()");
completeCurrentBody();
downstreamPublisher.complete();
}
@Override
public void onError(Throwable t) {
log.trace(() -> "Received onError()", t);
downstreamPublisher.error(t);
}
private void sendCurrentBody(AsyncRequestBody body) {
downstreamPublisher.send(body).exceptionally(t -> {
downstreamPublisher.error(t);
return null;
});
}
private long calculateChunkSize(Long dataRemaining) {
// Use default chunk size if the content length is unknown
if (dataRemaining == null) {
return chunkSizeInBytes;
}
return Math.min(chunkSizeInBytes, dataRemaining);
}
private void maybeRequestMoreUpstreamData() {
long buffered = dataBuffered.get();
if (shouldRequestMoreData(buffered) &&
hasOpenUpstreamDemand.compareAndSet(false, true)) {
log.trace(() -> "Requesting more data, current data buffered: " + buffered);
upstreamSubscription.request(1);
}
}
private boolean shouldRequestMoreData(long buffered) {
return buffered == 0 || buffered + byteBufferSizeHint <= bufferSizeInBytes;
}
private Long totalDataRemaining() {
if (upstreamSize == null) {
return null;
}
return upstreamSize - (chunkNumber.get() * chunkSizeInBytes);
}
private final class DownstreamBody implements AsyncRequestBody {
/**
* The maximum length of the content this AsyncRequestBody can hold. If the upstream content length is known, this is
* the same as totalLength
*/
private final long maxLength;
private final Long totalLength;
private final SimplePublisher<ByteBuffer> delegate = new SimplePublisher<>();
private final int chunkNumber;
private final AtomicBoolean subscribeCalled = new AtomicBoolean(false);
private volatile long transferredLength = 0;
private DownstreamBody(boolean contentLengthKnown, long maxLength, int chunkNumber) {
this.totalLength = contentLengthKnown ? maxLength : null;
this.maxLength = maxLength;
this.chunkNumber = chunkNumber;
}
@Override
public Optional<Long> contentLength() {
return totalLength != null ? Optional.of(totalLength) : Optional.of(transferredLength);
}
public void send(ByteBuffer data) {
log.trace(() -> String.format("Sending bytebuffer %s to chunk %d", data, chunkNumber));
int length = data.remaining();
transferredLength += length;
addDataBuffered(length);
delegate.send(data).whenComplete((r, t) -> {
addDataBuffered(-length);
if (t != null) {
error(t);
}
});
}
public void complete() {
log.debug(() -> "Received complete() for chunk number: " + chunkNumber + " length " + transferredLength);
delegate.complete().whenComplete((r, t) -> {
if (t != null) {
error(t);
}
});
}
public void error(Throwable error) {
delegate.error(error);
}
@Override
public void subscribe(Subscriber<? super ByteBuffer> s) {
if (subscribeCalled.compareAndSet(false, true)) {
delegate.subscribe(s);
} else {
s.onSubscribe(new NoopSubscription(s));
s.onError(NonRetryableException.create(
"A retry was attempted, but AsyncRequestBody.split does not "
+ "support retries."));
}
}
private void addDataBuffered(int length) {
dataBuffered.addAndGet(length);
if (length < 0) {
maybeRequestMoreUpstreamData();
}
}
}
}
}
| 1,918 |
0 | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/ByteArrayAsyncResponseTransformer.java | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.awssdk.core.internal.async;
import static software.amazon.awssdk.utils.FunctionalUtils.invokeSafely;
import java.io.ByteArrayOutputStream;
import java.nio.ByteBuffer;
import java.util.concurrent.CompletableFuture;
import org.reactivestreams.Subscriber;
import org.reactivestreams.Subscription;
import software.amazon.awssdk.annotations.SdkInternalApi;
import software.amazon.awssdk.core.ResponseBytes;
import software.amazon.awssdk.core.async.AsyncResponseTransformer;
import software.amazon.awssdk.core.async.SdkPublisher;
import software.amazon.awssdk.utils.BinaryUtils;
/**
* Implementation of {@link AsyncResponseTransformer} that dumps content into a byte array and supports further
* conversions into types, like strings.
*
* This can be created with static methods on {@link AsyncResponseTransformer}.
*
* @param <ResponseT> Pojo response type.
* @see AsyncResponseTransformer#toBytes()
*/
@SdkInternalApi
public final class ByteArrayAsyncResponseTransformer<ResponseT> implements
AsyncResponseTransformer<ResponseT, ResponseBytes<ResponseT>> {
private volatile CompletableFuture<byte[]> cf;
private volatile ResponseT response;
@Override
public CompletableFuture<ResponseBytes<ResponseT>> prepare() {
cf = new CompletableFuture<>();
return cf.thenApply(arr -> ResponseBytes.fromByteArray(response, arr));
}
@Override
public void onResponse(ResponseT response) {
this.response = response;
}
@Override
public void onStream(SdkPublisher<ByteBuffer> publisher) {
publisher.subscribe(new BaosSubscriber(cf));
}
@Override
public void exceptionOccurred(Throwable throwable) {
cf.completeExceptionally(throwable);
}
static class BaosSubscriber implements Subscriber<ByteBuffer> {
private final CompletableFuture<byte[]> resultFuture;
private ByteArrayOutputStream baos = new ByteArrayOutputStream();
private Subscription subscription;
BaosSubscriber(CompletableFuture<byte[]> resultFuture) {
this.resultFuture = resultFuture;
}
@Override
public void onSubscribe(Subscription s) {
if (this.subscription != null) {
s.cancel();
return;
}
this.subscription = s;
subscription.request(Long.MAX_VALUE);
}
@Override
public void onNext(ByteBuffer byteBuffer) {
invokeSafely(() -> baos.write(BinaryUtils.copyBytesFrom(byteBuffer)));
subscription.request(1);
}
@Override
public void onError(Throwable throwable) {
baos = null;
resultFuture.completeExceptionally(throwable);
}
@Override
public void onComplete() {
resultFuture.complete(baos.toByteArray());
}
}
}
| 1,919 |
0 | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/async/PublisherAsyncResponseTransformer.java | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.awssdk.core.internal.async;
import java.nio.ByteBuffer;
import java.util.concurrent.CompletableFuture;
import software.amazon.awssdk.annotations.SdkInternalApi;
import software.amazon.awssdk.core.SdkResponse;
import software.amazon.awssdk.core.async.AsyncResponseTransformer;
import software.amazon.awssdk.core.async.ResponsePublisher;
import software.amazon.awssdk.core.async.SdkPublisher;
/**
* Transforms a {@link ResponseT} and {@link ByteBuffer} {@link SdkPublisher} into a {@link ResponsePublisher}.
*
* @param <ResponseT> Pojo response type.
* @see AsyncResponseTransformer#toPublisher()
*/
@SdkInternalApi
public final class PublisherAsyncResponseTransformer<ResponseT extends SdkResponse>
implements AsyncResponseTransformer<ResponseT, ResponsePublisher<ResponseT>> {
private volatile CompletableFuture<ResponsePublisher<ResponseT>> future;
private volatile ResponseT response;
@Override
public CompletableFuture<ResponsePublisher<ResponseT>> prepare() {
CompletableFuture<ResponsePublisher<ResponseT>> f = new CompletableFuture<>();
this.future = f;
return f;
}
@Override
public void onResponse(ResponseT response) {
this.response = response;
}
@Override
public void onStream(SdkPublisher<ByteBuffer> publisher) {
future.complete(new ResponsePublisher<>(response, publisher));
}
@Override
public void exceptionOccurred(Throwable error) {
future.completeExceptionally(error);
}
}
| 1,920 |
0 | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/io/AwsCompressionInputStream.java | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.awssdk.core.internal.io;
import java.io.IOException;
import java.io.InputStream;
import java.util.Arrays;
import software.amazon.awssdk.annotations.SdkInternalApi;
import software.amazon.awssdk.core.internal.compression.Compressor;
import software.amazon.awssdk.utils.Validate;
/**
* A wrapper class of InputStream that implements compression in chunks.
*/
@SdkInternalApi
public final class AwsCompressionInputStream extends AwsChunkedInputStream {
private final Compressor compressor;
private AwsCompressionInputStream(InputStream in, Compressor compressor) {
this.compressor = compressor;
if (in instanceof AwsCompressionInputStream) {
// This could happen when the request is retried.
AwsCompressionInputStream originalCompressionStream = (AwsCompressionInputStream) in;
this.is = originalCompressionStream.is;
this.underlyingStreamBuffer = originalCompressionStream.underlyingStreamBuffer;
} else {
this.is = in;
this.underlyingStreamBuffer = null;
}
}
public static Builder builder() {
return new Builder();
}
@Override
public int read(byte[] b, int off, int len) throws IOException {
abortIfNeeded();
Validate.notNull(b, "buff");
if (off < 0 || len < 0 || len > b.length - off) {
throw new IndexOutOfBoundsException();
} else if (len == 0) {
return 0;
}
if (currentChunkIterator == null || !currentChunkIterator.hasNext()) {
if (isTerminating) {
return -1;
}
isTerminating = setUpNextChunk();
}
int count = currentChunkIterator.read(b, off, len);
if (count > 0) {
isAtStart = false;
log.trace(() -> count + " byte read from the stream.");
}
return count;
}
private boolean setUpNextChunk() throws IOException {
byte[] chunkData = new byte[DEFAULT_CHUNK_SIZE];
int chunkSizeInBytes = 0;
while (chunkSizeInBytes < DEFAULT_CHUNK_SIZE) {
/** Read from the buffer of the uncompressed stream */
if (underlyingStreamBuffer != null && underlyingStreamBuffer.hasNext()) {
chunkData[chunkSizeInBytes++] = underlyingStreamBuffer.next();
} else { /** Read from the wrapped stream */
int bytesToRead = DEFAULT_CHUNK_SIZE - chunkSizeInBytes;
int count = is.read(chunkData, chunkSizeInBytes, bytesToRead);
if (count != -1) {
if (underlyingStreamBuffer != null) {
underlyingStreamBuffer.buffer(chunkData, chunkSizeInBytes, count);
}
chunkSizeInBytes += count;
} else {
break;
}
}
}
if (chunkSizeInBytes == 0) {
return true;
}
if (chunkSizeInBytes < chunkData.length) {
chunkData = Arrays.copyOf(chunkData, chunkSizeInBytes);
}
// Compress the chunk
byte[] compressedChunkData = compressor.compress(chunkData);
currentChunkIterator = new ChunkContentIterator(compressedChunkData);
return false;
}
/**
* The readlimit parameter is ignored.
*/
@Override
public void mark(int readlimit) {
abortIfNeeded();
if (!isAtStart) {
throw new UnsupportedOperationException("Compression stream only supports mark() at the start of the stream.");
}
if (is.markSupported()) {
log.debug(() -> "AwsCompressionInputStream marked at the start of the stream "
+ "(will directly mark the wrapped stream since it's mark-supported).");
is.mark(readlimit);
} else {
log.debug(() -> "AwsCompressionInputStream marked at the start of the stream "
+ "(initializing the buffer since the wrapped stream is not mark-supported).");
underlyingStreamBuffer = new UnderlyingStreamBuffer(SKIP_BUFFER_SIZE);
}
}
/**
* Reset the stream, either by resetting the wrapped stream or using the
* buffer created by this class.
*/
@Override
public void reset() throws IOException {
abortIfNeeded();
// Clear up any encoded data
currentChunkIterator = null;
// Reset the wrapped stream if it is mark-supported,
// otherwise use our buffered data.
if (is.markSupported()) {
log.debug(() -> "AwsCompressionInputStream reset "
+ "(will reset the wrapped stream because it is mark-supported).");
is.reset();
} else {
log.debug(() -> "AwsCompressionInputStream reset (will use the buffer of the decoded stream).");
Validate.notNull(underlyingStreamBuffer, "Cannot reset the stream because the mark is not set.");
underlyingStreamBuffer.startReadBuffer();
}
isAtStart = true;
isTerminating = false;
}
public static final class Builder {
InputStream inputStream;
Compressor compressor;
public AwsCompressionInputStream build() {
return new AwsCompressionInputStream(
this.inputStream, this.compressor);
}
public Builder inputStream(InputStream inputStream) {
this.inputStream = inputStream;
return this;
}
public Builder compressor(Compressor compressor) {
this.compressor = compressor;
return this;
}
}
}
| 1,921 |
0 | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/io/AwsChunkedEncodingInputStream.java | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.awssdk.core.internal.io;
import java.io.IOException;
import java.io.InputStream;
import java.nio.charset.StandardCharsets;
import java.util.Arrays;
import software.amazon.awssdk.annotations.SdkInternalApi;
import software.amazon.awssdk.core.checksums.SdkChecksum;
import software.amazon.awssdk.core.internal.chunked.AwsChunkedEncodingConfig;
import software.amazon.awssdk.utils.Validate;
/**
* A wrapper of InputStream that implements pseudo-chunked-encoding.
* Each chunk will be buffered for the calculation of the chunk signature
* which is added at the head of each chunk.<br>
* The default chunk size cannot be customized, since we need to calculate
* the expected encoded stream length before reading the wrapped stream.<br>
* This class will use the mark() & reset() of the wrapped InputStream if they
* are supported, otherwise it will create a buffer for bytes read from
* the wrapped stream.
*/
@SdkInternalApi
public abstract class AwsChunkedEncodingInputStream extends AwsChunkedInputStream {
protected static final String CRLF = "\r\n";
protected static final byte[] FINAL_CHUNK = new byte[0];
protected static final String HEADER_COLON_SEPARATOR = ":";
protected byte[] calculatedChecksum = null;
protected final String checksumHeaderForTrailer;
protected boolean isTrailingTerminated = true;
private final int chunkSize;
private final int maxBufferSize;
private final SdkChecksum sdkChecksum;
private boolean isLastTrailingCrlf;
/**
* Creates a chunked encoding input stream initialized with the originating stream. The configuration allows
* specification of the size of each chunk, as well as the buffer size. Use the same values as when
* calculating total length of the stream.
*
* @param in The original InputStream.
* @param config The configuration allows the user to customize chunk size and buffer size.
* See {@link AwsChunkedEncodingConfig} for default values.
*/
protected AwsChunkedEncodingInputStream(InputStream in,
SdkChecksum sdkChecksum, String checksumHeaderForTrailer,
AwsChunkedEncodingConfig config) {
AwsChunkedEncodingConfig awsChunkedEncodingConfig = config == null ? AwsChunkedEncodingConfig.create() : config;
int providedMaxBufferSize = awsChunkedEncodingConfig.bufferSize();
if (in instanceof AwsChunkedEncodingInputStream) {
// This could happen when the request is retried.
AwsChunkedEncodingInputStream originalChunkedStream = (AwsChunkedEncodingInputStream) in;
providedMaxBufferSize = Math.max(originalChunkedStream.maxBufferSize, providedMaxBufferSize);
is = originalChunkedStream.is;
underlyingStreamBuffer = originalChunkedStream.underlyingStreamBuffer;
} else {
is = in;
underlyingStreamBuffer = null;
}
this.chunkSize = awsChunkedEncodingConfig.chunkSize();
this.maxBufferSize = providedMaxBufferSize;
if (maxBufferSize < chunkSize) {
throw new IllegalArgumentException("Max buffer size should not be less than chunk size");
}
this.sdkChecksum = sdkChecksum;
this.checksumHeaderForTrailer = checksumHeaderForTrailer;
}
protected abstract static class Builder<T extends Builder> {
protected InputStream inputStream;
protected SdkChecksum sdkChecksum;
protected String checksumHeaderForTrailer;
protected AwsChunkedEncodingConfig awsChunkedEncodingConfig;
protected Builder() {
}
/**
* @param inputStream The original InputStream.
* @return
*/
public T inputStream(InputStream inputStream) {
this.inputStream = inputStream;
return (T) this;
}
/**
* @param awsChunkedEncodingConfig Maximum number of bytes buffered by this class.
* @return
*/
public T awsChunkedEncodingConfig(AwsChunkedEncodingConfig awsChunkedEncodingConfig) {
this.awsChunkedEncodingConfig = awsChunkedEncodingConfig;
return (T) this;
}
/**
*
* @param sdkChecksum Instance of SdkChecksum, this can be null if we do not want to calculate Checksum
* @return
*/
public T sdkChecksum(SdkChecksum sdkChecksum) {
this.sdkChecksum = sdkChecksum;
return (T) this;
}
/**
*
* @param checksumHeaderForTrailer String value of Trailer header where checksum will be updated.
* @return
*/
public T checksumHeaderForTrailer(String checksumHeaderForTrailer) {
this.checksumHeaderForTrailer = checksumHeaderForTrailer;
return (T) this;
}
}
@Override
public int read(byte[] b, int off, int len) throws IOException {
abortIfNeeded();
Validate.notNull(b, "buff");
if (off < 0 || len < 0 || len > b.length - off) {
throw new IndexOutOfBoundsException();
} else if (len == 0) {
return 0;
}
if (null == currentChunkIterator || !currentChunkIterator.hasNext()) {
if (isTerminating && isTrailingTerminated) {
return -1;
} else if (!isTerminating) {
isTerminating = setUpNextChunk();
} else {
isTrailingTerminated = setUpTrailingChunks();
}
}
int count = currentChunkIterator.read(b, off, len);
if (count > 0) {
isAtStart = false;
log.trace(() -> count + " byte read from the stream.");
}
return count;
}
private boolean setUpTrailingChunks() {
if (sdkChecksum == null) {
return true;
}
if (calculatedChecksum == null) {
calculatedChecksum = sdkChecksum.getChecksumBytes();
currentChunkIterator = new ChunkContentIterator(createChecksumChunkHeader());
return false;
} else if (!isLastTrailingCrlf) {
// Signed Payload needs Checksums to be signed at the end.
currentChunkIterator = new ChunkContentIterator(CRLF.getBytes(StandardCharsets.UTF_8));
isLastTrailingCrlf = true;
}
return true;
}
/**
* The readlimit parameter is ignored.
*/
@Override
public void mark(int readlimit) {
abortIfNeeded();
if (!isAtStart) {
throw new UnsupportedOperationException("Chunk-encoded stream only supports mark() at the start of the stream.");
}
if (sdkChecksum != null) {
sdkChecksum.mark(readlimit);
}
if (is.markSupported()) {
log.debug(() -> "AwsChunkedEncodingInputStream marked at the start of the stream "
+ "(will directly mark the wrapped stream since it's mark-supported).");
is.mark(readlimit);
} else {
log.debug(() -> "AwsChunkedEncodingInputStream marked at the start of the stream "
+ "(initializing the buffer since the wrapped stream is not mark-supported).");
underlyingStreamBuffer = new UnderlyingStreamBuffer(maxBufferSize);
}
}
/**
* Reset the stream, either by resetting the wrapped stream or using the
* buffer created by this class.
*/
@Override
public void reset() throws IOException {
abortIfNeeded();
// Clear up any encoded data
currentChunkIterator = null;
if (sdkChecksum != null) {
sdkChecksum.reset();
}
// Reset the wrapped stream if it is mark-supported,
// otherwise use our buffered data.
if (is.markSupported()) {
log.debug(() -> "AwsChunkedEncodingInputStream reset "
+ "(will reset the wrapped stream because it is mark-supported).");
is.reset();
} else {
log.debug(() -> "AwsChunkedEncodingInputStream reset (will use the buffer of the decoded stream).");
Validate.notNull(underlyingStreamBuffer, "Cannot reset the stream because the mark is not set.");
underlyingStreamBuffer.startReadBuffer();
}
isAtStart = true;
isTerminating = false;
}
/**
* Read in the next chunk of data, and create the necessary chunk extensions.
*
* @return Returns true if next chunk is the last empty chunk.
*/
private boolean setUpNextChunk() throws IOException {
byte[] chunkData = new byte[chunkSize];
int chunkSizeInBytes = 0;
while (chunkSizeInBytes < chunkSize) {
/** Read from the buffer of the decoded stream */
if (null != underlyingStreamBuffer && underlyingStreamBuffer.hasNext()) {
chunkData[chunkSizeInBytes++] = underlyingStreamBuffer.next();
} else { /** Read from the wrapped stream */
int bytesToRead = chunkSize - chunkSizeInBytes;
int count = is.read(chunkData, chunkSizeInBytes, bytesToRead);
if (count != -1) {
if (null != underlyingStreamBuffer) {
underlyingStreamBuffer.buffer(chunkData, chunkSizeInBytes, count);
}
chunkSizeInBytes += count;
} else {
break;
}
}
}
if (chunkSizeInBytes == 0) {
if (sdkChecksum != null) {
isTrailingTerminated = false;
}
byte[] finalChunk = createFinalChunk(FINAL_CHUNK);
currentChunkIterator = new ChunkContentIterator(finalChunk);
return true;
} else {
if (chunkSizeInBytes < chunkData.length) {
chunkData = Arrays.copyOf(chunkData, chunkSizeInBytes);
}
byte[] chunkContent = createChunk(chunkData);
currentChunkIterator = new ChunkContentIterator(chunkContent);
if (sdkChecksum != null) {
sdkChecksum.update(chunkData);
}
return false;
}
}
/**
* The final chunk.
*
* @param finalChunk The last byte which will be often 0 byte.
* @return Final chunk that will be appended with CRLF or any required signatures.
*/
protected abstract byte[] createFinalChunk(byte[] finalChunk);
/**
* Creates chunk for the given buffer.
* The chucks could be appended with Signatures or any additional bytes by Concrete classes.
*
* @param chunkData The chunk of original data.
* @return Chunked data which will have signature if signed or just data if unsigned.
*/
protected abstract byte[] createChunk(byte[] chunkData);
/**
* @return ChecksumChunkHeader in bytes based on the Header name field.
*/
protected abstract byte[] createChecksumChunkHeader();
}
| 1,922 |
0 | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/io/SdkLengthAwareInputStream.java | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.awssdk.core.internal.io;
import static software.amazon.awssdk.utils.NumericUtils.saturatedCast;
import java.io.FilterInputStream;
import java.io.IOException;
import java.io.InputStream;
import software.amazon.awssdk.annotations.SdkInternalApi;
import software.amazon.awssdk.utils.Logger;
import software.amazon.awssdk.utils.Validate;
/**
* An {@code InputStream} that is aware of its length. The main purpose of this class is to support truncating streams to a
* length that is shorter than the total length of the stream.
*/
@SdkInternalApi
public class SdkLengthAwareInputStream extends FilterInputStream {
private static final Logger LOG = Logger.loggerFor(SdkLengthAwareInputStream.class);
private long length;
private long remaining;
public SdkLengthAwareInputStream(InputStream in, long length) {
super(in);
this.length = Validate.isNotNegative(length, "length");
this.remaining = this.length;
}
@Override
public int read() throws IOException {
if (!hasMoreBytes()) {
LOG.debug(() -> String.format("Specified InputStream length of %d has been reached. Returning EOF.", length));
return -1;
}
int read = super.read();
if (read != -1) {
remaining--;
}
return read;
}
@Override
public int read(byte[] b, int off, int len) throws IOException {
if (!hasMoreBytes()) {
LOG.debug(() -> String.format("Specified InputStream length of %d has been reached. Returning EOF.", length));
return -1;
}
len = Math.min(len, saturatedCast(remaining));
int read = super.read(b, off, len);
if (read > 0) {
remaining -= read;
}
return read;
}
@Override
public long skip(long requestedBytesToSkip) throws IOException {
requestedBytesToSkip = Math.min(requestedBytesToSkip, remaining);
long skippedActual = super.skip(requestedBytesToSkip);
remaining -= skippedActual;
return skippedActual;
}
@Override
public int available() throws IOException {
int streamAvailable = super.available();
return Math.min(streamAvailable, saturatedCast(remaining));
}
@Override
public void mark(int readlimit) {
super.mark(readlimit);
// mark() causes reset() to change the stream's position back to the current position. Therefore, when reset() is called,
// the new length of the stream will be equal to the current value of 'remaining'.
length = remaining;
}
@Override
public void reset() throws IOException {
super.reset();
remaining = length;
}
public long remaining() {
return remaining;
}
private boolean hasMoreBytes() {
return remaining > 0;
}
}
| 1,923 |
0 | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/io/ChunkContentIterator.java | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.awssdk.core.internal.io;
import software.amazon.awssdk.annotations.SdkInternalApi;
@SdkInternalApi
class ChunkContentIterator {
private final byte[] bytes;
private int pos;
ChunkContentIterator(byte[] bytes) {
this.bytes = bytes;
}
public boolean hasNext() {
return pos < bytes.length;
}
public int read(byte[] output, int offset, int length) {
if (length == 0) {
return 0;
}
if (!hasNext()) {
return -1;
}
int remaingBytesNum = bytes.length - pos;
int bytesToRead = Math.min(remaingBytesNum, length);
System.arraycopy(bytes, pos, output, offset, bytesToRead);
pos += bytesToRead;
return bytesToRead;
}
}
| 1,924 |
0 | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/io/Releasable.java | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.awssdk.core.internal.io;
import static software.amazon.awssdk.utils.IoUtils.closeQuietly;
import java.io.Closeable;
import org.slf4j.Logger;
import software.amazon.awssdk.annotations.SdkInternalApi;
/**
* Used for releasing a resource.
* <p>
* For example, the creation of a <code>ResettableInputStream</code> would entail
* physically opening a file. If the opened file is meant to be closed only (in
* a finally block) by the very same code block that created it, then it is
* necessary that the release method must not be called while the execution is
* made in other stack frames.
*
* In such case, as other stack frames may inadvertently or indirectly call the
* close method of the stream, the creator of the stream would need to
* explicitly disable the accidental closing via
* <code>ResettableInputStream#disableClose()</code>, so that the release method
* becomes the only way to truly close the opened file.
*/
@SdkInternalApi
public interface Releasable {
/**
* Releases the allocated resource. This method should not be called except
* by the caller who allocated the resource at the very top of the call
* stack. This allows, typically, a {@link Closeable} resource to be not
* unintentionally released owing to the calling of the
* {@link Closeable#close()} methods by implementation deep down in the call
* stack.
* <p>
* For example, the creation of a <code>ResettableInputStream</code> would entail
* physically opening a file. If the opened file is meant to be closed only
* (in a finally block) by the very same code block that created it, then it
* is necessary that the release method must not be called while the
* execution is made in other stack frames.
*
* In such case, as other stack frames may inadvertently or indirectly call
* the close method of the stream, the creator of the stream would need to
* explicitly disable the accidental closing via
* <code>ResettableInputStream#disableClose()</code>, so that the release method
* becomes the only way to truly close the opened file.
*/
void release();
/**
* Releases the given {@link Closeable} especially if it was an instance of
* {@link Releasable}.
* <p>
* For example, the creation of a <code>ResettableInputStream</code> would entail
* physically opening a file. If the opened file is meant to be closed only
* (in a finally block) by the very same code block that created it, then it
* is necessary that the release method must not be called while the
* execution is made in other stack frames.
*
* In such case, as other stack frames may inadvertently or indirectly call
* the close method of the stream, the creator of the stream would need to
* explicitly disable the accidental closing via
* <code>ResettableInputStream#disableClose()</code>, so that the release method
* becomes the only way to truly close the opened file.
*/
static void release(Closeable is, Logger log) {
closeQuietly(is, log);
if (is instanceof Releasable) {
Releasable r = (Releasable) is;
r.release();
}
}
}
| 1,925 |
0 | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/io/ChecksumValidatingInputStream.java | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.awssdk.core.internal.io;
import java.io.IOException;
import java.io.InputStream;
import software.amazon.awssdk.annotations.SdkInternalApi;
import software.amazon.awssdk.core.checksums.SdkChecksum;
import software.amazon.awssdk.core.exception.SdkClientException;
import software.amazon.awssdk.http.Abortable;
import software.amazon.awssdk.utils.BinaryUtils;
import software.amazon.awssdk.utils.Validate;
/**
* Stream that will update the Checksum as the data is read.
* When end of the stream is reached the computed Checksum is validated with Expected checksum.
*/
@SdkInternalApi
public class ChecksumValidatingInputStream extends InputStream implements Abortable {
private final SdkChecksum checkSum;
private final InputStream inputStream;
private final String expectedChecksum;
private String computedChecksum = null;
private boolean endOfStream = false;
/**
* Creates an input stream using the specified Checksum, input stream, and length.
*
* @param inputStream the input stream
* @param sdkChecksum the Checksum implementation
* @param expectedChecksum the checksum value as seen un .
*/
public ChecksumValidatingInputStream(InputStream inputStream, SdkChecksum sdkChecksum, String expectedChecksum) {
this.inputStream = inputStream;
checkSum = sdkChecksum;
this.expectedChecksum = expectedChecksum;
}
/**
* Reads from the underlying stream. If the end of the stream is reached, the
* running checksum will be appended a byte at a time (1 per read call).
*
* @return byte read, if eos has been reached, -1 will be returned.
*/
@Override
public int read() throws IOException {
int read = -1;
if (!endOfStream) {
read = inputStream.read();
if (read != -1) {
checkSum.update(read);
}
if (read == -1) {
endOfStream = true;
validateAndThrow();
}
}
return read;
}
/**
* Reads up to len bytes at a time from the input stream, updates the checksum. If the end of the stream has been reached
* the checksum will be appended to the last 4 bytes.
*
* @param buf buffer to write into
* @param off offset in the buffer to write to
* @param len maximum number of bytes to attempt to read.
* @return number of bytes written into buf, otherwise -1 will be returned to indicate eos.
*/
@Override
public int read(byte[] buf, int off, int len) throws IOException {
Validate.notNull(buf, "buff");
int read = -1;
if (!endOfStream) {
read = inputStream.read(buf, off, len);
if (read != -1) {
checkSum.update(buf, off, read);
}
if (read == -1) {
endOfStream = true;
validateAndThrow();
}
}
return read;
}
/**
* Resets stream state, including the running checksum.
*/
@Override
public synchronized void reset() throws IOException {
inputStream.reset();
checkSum.reset();
}
@Override
public void abort() {
if (inputStream instanceof Abortable) {
((Abortable) inputStream).abort();
}
}
@Override
public void close() throws IOException {
inputStream.close();
}
private void validateAndThrow() {
if (computedChecksum == null) {
computedChecksum = BinaryUtils.toBase64(checkSum.getChecksumBytes());
}
if (!expectedChecksum.equals(computedChecksum)) {
throw SdkClientException.builder().message(
String.format("Data read has a different checksum than expected. Was %s, but expected %s",
computedChecksum, expectedChecksum)).build();
}
}
}
| 1,926 |
0 | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/io/AwsUnsignedChunkedEncodingInputStream.java | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.awssdk.core.internal.io;
import java.io.InputStream;
import java.nio.charset.StandardCharsets;
import software.amazon.awssdk.annotations.SdkInternalApi;
import software.amazon.awssdk.core.checksums.SdkChecksum;
import software.amazon.awssdk.core.exception.SdkClientException;
import software.amazon.awssdk.core.internal.chunked.AwsChunkedEncodingConfig;
import software.amazon.awssdk.utils.BinaryUtils;
/**
* A wrapper class of InputStream that implements chunked-encoding.
*/
@SdkInternalApi
public class AwsUnsignedChunkedEncodingInputStream extends AwsChunkedEncodingInputStream {
private AwsUnsignedChunkedEncodingInputStream(InputStream in, AwsChunkedEncodingConfig awsChunkedEncodingConfig,
SdkChecksum sdkChecksum,
String checksumHeaderForTrailer) {
super(in, sdkChecksum, checksumHeaderForTrailer, awsChunkedEncodingConfig);
}
public static Builder builder() {
return new Builder();
}
@Override
protected byte[] createFinalChunk(byte[] finalChunk) {
StringBuilder chunkHeader = new StringBuilder();
// chunk-size
chunkHeader.append(Integer.toHexString(finalChunk.length));
chunkHeader.append(CRLF);
return chunkHeader.toString().getBytes(StandardCharsets.UTF_8);
}
@Override
protected byte[] createChunk(byte[] chunkData) {
StringBuilder chunkHeader = new StringBuilder();
// chunk-size
chunkHeader.append(Integer.toHexString(chunkData.length));
chunkHeader.append(CRLF);
try {
byte[] header = chunkHeader.toString().getBytes(StandardCharsets.UTF_8);
byte[] trailer = CRLF.getBytes(StandardCharsets.UTF_8);
byte[] chunk = new byte[header.length + chunkData.length + trailer.length];
System.arraycopy(header, 0, chunk, 0, header.length);
System.arraycopy(chunkData, 0, chunk, header.length, chunkData.length);
System.arraycopy(trailer, 0,
chunk, header.length + chunkData.length,
trailer.length);
return chunk;
} catch (Exception e) {
throw SdkClientException.builder()
.message("Unable to create chunked data. " + e.getMessage())
.cause(e)
.build();
}
}
@Override
protected byte[] createChecksumChunkHeader() {
StringBuilder chunkHeader = new StringBuilder();
chunkHeader.append(checksumHeaderForTrailer)
.append(HEADER_COLON_SEPARATOR)
.append(BinaryUtils.toBase64(calculatedChecksum))
.append(CRLF);
return chunkHeader.toString().getBytes(StandardCharsets.UTF_8);
}
public static final class Builder extends AwsChunkedEncodingInputStream.Builder<Builder> {
public AwsUnsignedChunkedEncodingInputStream build() {
return new AwsUnsignedChunkedEncodingInputStream(
this.inputStream, this.awsChunkedEncodingConfig,
this.sdkChecksum, this.checksumHeaderForTrailer);
}
}
}
| 1,927 |
0 | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/io/AwsChunkedInputStream.java | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.awssdk.core.internal.io;
import java.io.IOException;
import java.io.InputStream;
import software.amazon.awssdk.annotations.SdkInternalApi;
import software.amazon.awssdk.core.io.SdkInputStream;
import software.amazon.awssdk.utils.Logger;
/**
* A wrapper of InputStream that implements streaming in chunks.
*/
@SdkInternalApi
public abstract class AwsChunkedInputStream extends SdkInputStream {
public static final int DEFAULT_CHUNK_SIZE = 128 * 1024;
protected static final int SKIP_BUFFER_SIZE = 256 * 1024;
protected static final Logger log = Logger.loggerFor(AwsChunkedInputStream.class);
protected InputStream is;
/**
* Iterator on the current chunk.
*/
protected ChunkContentIterator currentChunkIterator;
/**
* Iterator on the buffer of the underlying stream,
* Null if the wrapped stream is marksupported,
* otherwise it will be initialized when this wrapper is marked.
*/
protected UnderlyingStreamBuffer underlyingStreamBuffer;
protected boolean isAtStart = true;
protected boolean isTerminating = false;
@Override
public int read() throws IOException {
byte[] tmp = new byte[1];
int count = read(tmp, 0, 1);
if (count > 0) {
log.debug(() -> "One byte read from the stream.");
int unsignedByte = (int) tmp[0] & 0xFF;
return unsignedByte;
} else {
return count;
}
}
@Override
public long skip(long n) throws IOException {
if (n <= 0) {
return 0;
}
long remaining = n;
int toskip = (int) Math.min(SKIP_BUFFER_SIZE, n);
byte[] temp = new byte[toskip];
while (remaining > 0) {
int count = read(temp, 0, toskip);
if (count < 0) {
break;
}
remaining -= count;
}
return n - remaining;
}
/**
* @see InputStream#markSupported()
*/
@Override
public boolean markSupported() {
return true;
}
@Override
protected InputStream getWrappedInputStream() {
return is;
}
}
| 1,928 |
0 | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/io/UnderlyingStreamBuffer.java | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.awssdk.core.internal.io;
import software.amazon.awssdk.annotations.SdkInternalApi;
import software.amazon.awssdk.core.exception.SdkClientException;
import software.amazon.awssdk.utils.Logger;
@SdkInternalApi
class UnderlyingStreamBuffer {
private static final Logger log = Logger.loggerFor(UnderlyingStreamBuffer.class);
private byte[] bufferArray;
private int maxBufferSize;
private int byteBuffered;
private int pos = -1;
private boolean bufferSizeOverflow;
UnderlyingStreamBuffer(int maxBufferSize) {
bufferArray = new byte[maxBufferSize];
this.maxBufferSize = maxBufferSize;
}
public void buffer(byte read) {
pos = -1;
if (byteBuffered >= maxBufferSize) {
log.debug(() -> "Buffer size " + maxBufferSize
+ " has been exceeded and the input stream "
+ "will not be repeatable. Freeing buffer memory");
bufferSizeOverflow = true;
} else {
bufferArray[byteBuffered++] = read;
}
}
public void buffer(byte[] src, int srcPos, int length) {
pos = -1;
if (byteBuffered + length > maxBufferSize) {
log.debug(() -> "Buffer size " + maxBufferSize
+ " has been exceeded and the input stream "
+ "will not be repeatable. Freeing buffer memory");
bufferSizeOverflow = true;
} else {
System.arraycopy(src, srcPos, bufferArray, byteBuffered, length);
byteBuffered += length;
}
}
public boolean hasNext() {
return (pos != -1) && (pos < byteBuffered);
}
public byte next() {
return bufferArray[pos++];
}
public void startReadBuffer() {
if (bufferSizeOverflow) {
throw SdkClientException.builder()
.message("The input stream is not repeatable since the buffer size "
+ maxBufferSize + " has been exceeded.")
.build();
}
pos = 0;
}
}
| 1,929 |
0 | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/chunked/AwsChunkedEncodingConfig.java | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.awssdk.core.internal.chunked;
import software.amazon.awssdk.annotations.SdkInternalApi;
@SdkInternalApi
public final class AwsChunkedEncodingConfig {
private final int chunkSize;
private final int bufferSize;
private AwsChunkedEncodingConfig(BuilderImpl builder) {
this.chunkSize = builder.chunkSize;
this.bufferSize = builder.bufferSize;
}
public static AwsChunkedEncodingConfig create() {
return builder().build();
}
public static Builder builder() {
return new BuilderImpl();
}
public int chunkSize() {
return chunkSize;
}
public int bufferSize() {
return bufferSize;
}
public interface Builder {
Builder chunkSize(int chunkSize);
Builder bufferSize(int bufferSize);
AwsChunkedEncodingConfig build();
}
private static final class BuilderImpl implements Builder {
static final int DEFAULT_CHUNKED_ENCODING_ENABLED = 128 * 1024;
static final int DEFAULT_PAYLOAD_SIGNING_ENABLED = 256 * 1024;
private int chunkSize = DEFAULT_CHUNKED_ENCODING_ENABLED;
private int bufferSize = DEFAULT_PAYLOAD_SIGNING_ENABLED;
private BuilderImpl() {
}
@Override
public Builder chunkSize(int chunkSize) {
this.chunkSize = chunkSize;
return this;
}
public void setChunkSize(int chunkSize) {
chunkSize(chunkSize);
}
@Override
public Builder bufferSize(int bufferSize) {
this.bufferSize = bufferSize;
return this;
}
public void setBufferSize(int bufferSize) {
bufferSize(bufferSize);
}
@Override
public AwsChunkedEncodingConfig build() {
return new AwsChunkedEncodingConfig(this);
}
}
}
| 1,930 |
0 | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/waiters/WaiterExecutor.java | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.awssdk.core.internal.waiters;
import java.util.List;
import java.util.function.Supplier;
import software.amazon.awssdk.annotations.SdkInternalApi;
import software.amazon.awssdk.annotations.ThreadSafe;
import software.amazon.awssdk.core.exception.SdkClientException;
import software.amazon.awssdk.core.waiters.WaiterAcceptor;
import software.amazon.awssdk.core.waiters.WaiterResponse;
import software.amazon.awssdk.utils.Either;
import software.amazon.awssdk.utils.Validate;
/**
* Executes sync waiter operations
*
* @param <T> the type of the response
*/
@SdkInternalApi
@ThreadSafe
public final class WaiterExecutor<T> {
private final WaiterExecutorHelper<T> executorHelper;
public WaiterExecutor(WaiterConfiguration configuration,
List<WaiterAcceptor<? super T>> waiterAcceptors) {
Validate.paramNotNull(configuration, "configuration");
Validate.paramNotNull(waiterAcceptors, "waiterAcceptors");
this.executorHelper = new WaiterExecutorHelper<>(waiterAcceptors, configuration);
}
WaiterResponse<T> execute(Supplier<T> pollingFunction) {
int attemptNumber = 0;
long startTime = System.currentTimeMillis();
while (true) {
attemptNumber++;
Either<T, Throwable> polledResponse = pollResponse(pollingFunction);
WaiterAcceptor<? super T> waiterAcceptor = firstWaiterAcceptor(polledResponse);
switch (waiterAcceptor.waiterState()) {
case SUCCESS:
return executorHelper.createWaiterResponse(polledResponse, attemptNumber);
case RETRY:
waitToRetry(attemptNumber, startTime);
break;
case FAILURE:
throw executorHelper.waiterFailureException(waiterAcceptor);
default:
throw new UnsupportedOperationException();
}
}
}
private Either<T, Throwable> pollResponse(Supplier<T> pollingFunction) {
try {
return Either.left(pollingFunction.get());
} catch (Exception exception) {
return Either.right(exception);
}
}
private WaiterAcceptor<? super T> firstWaiterAcceptor(Either<T, Throwable> responseOrException) {
return executorHelper.firstWaiterAcceptorIfMatched(responseOrException)
.orElseThrow(() -> executorHelper.noneMatchException(responseOrException));
}
private void waitToRetry(int attemptNumber, long startTime) {
Either<Long, SdkClientException> nextDelayOrUnretryableException =
executorHelper.nextDelayOrUnretryableException(attemptNumber, startTime);
if (nextDelayOrUnretryableException.right().isPresent()) {
throw nextDelayOrUnretryableException.right().get();
}
try {
Thread.sleep(nextDelayOrUnretryableException.left().get());
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
throw SdkClientException.create("The thread got interrupted", e);
}
}
}
| 1,931 |
0 | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/waiters/WaiterConfiguration.java | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.awssdk.core.internal.waiters;
import java.time.Duration;
import java.util.Optional;
import software.amazon.awssdk.annotations.SdkInternalApi;
import software.amazon.awssdk.core.retry.backoff.BackoffStrategy;
import software.amazon.awssdk.core.retry.backoff.FixedDelayBackoffStrategy;
import software.amazon.awssdk.core.waiters.WaiterOverrideConfiguration;
/**
* Internal waiter configuration class that provides default values if not overridden.
*/
@SdkInternalApi
public final class WaiterConfiguration {
private static final int DEFAULT_MAX_ATTEMPTS = 3;
private static final BackoffStrategy DEFAULT_BACKOFF_STRATEGY = FixedDelayBackoffStrategy.create(Duration.ofSeconds(5));
private final Integer maxAttempts;
private final BackoffStrategy backoffStrategy;
private final Duration waitTimeout;
public WaiterConfiguration(WaiterOverrideConfiguration overrideConfiguration) {
Optional<WaiterOverrideConfiguration> configuration = Optional.ofNullable(overrideConfiguration);
this.backoffStrategy =
configuration.flatMap(WaiterOverrideConfiguration::backoffStrategy).orElse(DEFAULT_BACKOFF_STRATEGY);
this.waitTimeout = configuration.flatMap(WaiterOverrideConfiguration::waitTimeout).orElse(null);
this.maxAttempts = configuration.flatMap(WaiterOverrideConfiguration::maxAttempts).orElse(DEFAULT_MAX_ATTEMPTS);
}
public Duration waitTimeout() {
return waitTimeout;
}
public BackoffStrategy backoffStrategy() {
return backoffStrategy;
}
public int maxAttempts() {
return maxAttempts;
}
}
| 1,932 |
0 | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/waiters/AsyncWaiterExecutor.java | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.awssdk.core.internal.waiters;
import java.util.List;
import java.util.Optional;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionException;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
import java.util.function.Supplier;
import software.amazon.awssdk.annotations.SdkInternalApi;
import software.amazon.awssdk.annotations.ThreadSafe;
import software.amazon.awssdk.core.exception.SdkClientException;
import software.amazon.awssdk.core.waiters.WaiterAcceptor;
import software.amazon.awssdk.core.waiters.WaiterResponse;
import software.amazon.awssdk.core.waiters.WaiterState;
import software.amazon.awssdk.utils.Either;
import software.amazon.awssdk.utils.Validate;
/**
* Executes async waiter operations
*
* @param <T> the type of the response
*/
@SdkInternalApi
@ThreadSafe
public final class AsyncWaiterExecutor<T> {
private final ScheduledExecutorService executorService;
private final WaiterExecutorHelper<T> executorHelper;
public AsyncWaiterExecutor(WaiterConfiguration configuration,
List<WaiterAcceptor<? super T>> waiterAcceptors,
ScheduledExecutorService executorService) {
Validate.paramNotNull(waiterAcceptors, "waiterAcceptors");
this.executorService = Validate.paramNotNull(executorService, "executorService");
this.executorHelper = new WaiterExecutorHelper<>(waiterAcceptors, configuration);
}
/**
* Execute the provided async polling function
*/
CompletableFuture<WaiterResponse<T>> execute(Supplier<CompletableFuture<T>> asyncPollingFunction) {
CompletableFuture<WaiterResponse<T>> future = new CompletableFuture<>();
doExecute(asyncPollingFunction, future, 0, System.currentTimeMillis());
return future;
}
private void doExecute(Supplier<CompletableFuture<T>> asyncPollingFunction,
CompletableFuture<WaiterResponse<T>> future,
int attemptNumber,
long startTime) {
runAsyncPollingFunction(asyncPollingFunction, future, ++attemptNumber, startTime);
}
private void runAsyncPollingFunction(Supplier<CompletableFuture<T>> asyncPollingFunction,
CompletableFuture<WaiterResponse<T>> future,
int attemptNumber,
long startTime) {
asyncPollingFunction.get().whenComplete((response, exception) -> {
try {
Either<T, Throwable> responseOrException;
if (exception == null) {
responseOrException = Either.left(response);
} else {
if (exception instanceof CompletionException) {
responseOrException = Either.right(exception.getCause());
} else {
responseOrException = Either.right(exception);
}
}
Optional<WaiterAcceptor<? super T>> optionalWaiterAcceptor =
executorHelper.firstWaiterAcceptorIfMatched(responseOrException);
if (optionalWaiterAcceptor.isPresent()) {
WaiterAcceptor<? super T> acceptor = optionalWaiterAcceptor.get();
WaiterState state = acceptor.waiterState();
switch (state) {
case SUCCESS:
future.complete(executorHelper.createWaiterResponse(responseOrException, attemptNumber));
break;
case RETRY:
maybeRetry(asyncPollingFunction, future, attemptNumber, startTime);
break;
case FAILURE:
future.completeExceptionally(executorHelper.waiterFailureException(acceptor));
break;
default:
future.completeExceptionally(new UnsupportedOperationException());
}
} else {
Optional<Throwable> t = responseOrException.right();
if (t.isPresent() && t.get() instanceof Error) {
future.completeExceptionally(t.get());
} else {
future.completeExceptionally(executorHelper.noneMatchException(responseOrException));
}
}
} catch (Throwable t) {
Throwable cause = t instanceof CompletionException ? t.getCause() : t;
if (cause instanceof Error) {
future.completeExceptionally(cause);
} else {
future.completeExceptionally(SdkClientException.create("Encountered unexpected exception.", cause));
}
}
});
}
private void maybeRetry(Supplier<CompletableFuture<T>> asyncPollingFunction,
CompletableFuture<WaiterResponse<T>> future,
int attemptNumber,
long startTime) {
Either<Long, SdkClientException> nextDelayOrUnretryableException =
executorHelper.nextDelayOrUnretryableException(attemptNumber, startTime);
nextDelayOrUnretryableException.apply(
nextDelay -> executorService.schedule(() -> doExecute(asyncPollingFunction, future, attemptNumber, startTime),
nextDelay,
TimeUnit.MILLISECONDS),
future::completeExceptionally);
}
}
| 1,933 |
0 | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/waiters/WaiterAttribute.java | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.awssdk.core.internal.waiters;
import software.amazon.awssdk.annotations.SdkInternalApi;
import software.amazon.awssdk.utils.AttributeMap;
/**
* Key for additional attribute used in waiter classes
*
* @param <T> Type of metadata.
*/
@SdkInternalApi
public class WaiterAttribute<T> extends AttributeMap.Key<T> {
public WaiterAttribute(Class<T> valueType) {
super(valueType);
}
}
| 1,934 |
0 | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/waiters/DefaultAsyncWaiter.java | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.awssdk.core.internal.waiters;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ScheduledExecutorService;
import java.util.function.Supplier;
import software.amazon.awssdk.annotations.SdkInternalApi;
import software.amazon.awssdk.annotations.ThreadSafe;
import software.amazon.awssdk.core.waiters.AsyncWaiter;
import software.amazon.awssdk.core.waiters.WaiterAcceptor;
import software.amazon.awssdk.core.waiters.WaiterOverrideConfiguration;
import software.amazon.awssdk.core.waiters.WaiterResponse;
/**
* Default implementation of the generic {@link AsyncWaiter}.
* @param <T> the type of the response expected to return from the polling function
*/
@SdkInternalApi
@ThreadSafe
public final class DefaultAsyncWaiter<T> implements AsyncWaiter<T> {
private final ScheduledExecutorService executorService;
private final List<WaiterAcceptor<? super T>> waiterAcceptors;
private final AsyncWaiterExecutor<T> handler;
private DefaultAsyncWaiter(DefaultBuilder<T> builder) {
this.executorService = builder.scheduledExecutorService;
WaiterConfiguration configuration = new WaiterConfiguration(builder.overrideConfiguration);
this.waiterAcceptors = Collections.unmodifiableList(builder.waiterAcceptors);
this.handler = new AsyncWaiterExecutor<>(configuration, waiterAcceptors, executorService);
}
@Override
public CompletableFuture<WaiterResponse<T>> runAsync(Supplier<CompletableFuture<T>> asyncPollingFunction) {
return handler.execute(asyncPollingFunction);
}
@Override
public CompletableFuture<WaiterResponse<T>> runAsync(Supplier<CompletableFuture<T>> asyncPollingFunction,
WaiterOverrideConfiguration overrideConfig) {
return new AsyncWaiterExecutor<>(new WaiterConfiguration(overrideConfig), waiterAcceptors, executorService)
.execute(asyncPollingFunction);
}
public static <T> Builder<T> builder() {
return new DefaultBuilder<>();
}
public static final class DefaultBuilder<T> implements Builder<T> {
private List<WaiterAcceptor<? super T>> waiterAcceptors = new ArrayList<>();
private ScheduledExecutorService scheduledExecutorService;
private WaiterOverrideConfiguration overrideConfiguration;
private DefaultBuilder() {
}
@Override
public Builder<T> scheduledExecutorService(ScheduledExecutorService scheduledExecutorService) {
this.scheduledExecutorService = scheduledExecutorService;
return this;
}
@Override
public Builder<T> acceptors(List<WaiterAcceptor<? super T>> waiterAcceptors) {
this.waiterAcceptors = new ArrayList<>(waiterAcceptors);
return this;
}
@Override
public Builder<T> overrideConfiguration(WaiterOverrideConfiguration overrideConfiguration) {
this.overrideConfiguration = overrideConfiguration;
return this;
}
@Override
public Builder<T> addAcceptor(WaiterAcceptor<? super T> waiterAcceptor) {
waiterAcceptors.add(waiterAcceptor);
return this;
}
@Override
public DefaultAsyncWaiter<T> build() {
return new DefaultAsyncWaiter<>(this);
}
}
} | 1,935 |
0 | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/waiters/DefaultWaiterResponse.java | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.awssdk.core.internal.waiters;
import static software.amazon.awssdk.utils.Validate.mutuallyExclusive;
import java.util.Objects;
import software.amazon.awssdk.annotations.SdkInternalApi;
import software.amazon.awssdk.core.waiters.WaiterResponse;
import software.amazon.awssdk.utils.ToString;
import software.amazon.awssdk.utils.Validate;
/**
* The default implementation of the {@link WaiterResponse}
*/
@SdkInternalApi
public final class DefaultWaiterResponse<T> implements WaiterResponse<T> {
private final T result;
private final Throwable exception;
private final int attemptsExecuted;
private final ResponseOrException<T> matched;
private DefaultWaiterResponse(Builder<T> builder) {
mutuallyExclusive("response and exception are mutually exclusive, set only one on the Builder",
builder.response, builder.exception);
this.result = builder.response;
this.exception = builder.exception;
this.attemptsExecuted = Validate.paramNotNull(builder.attemptsExecuted, "attemptsExecuted");
Validate.isPositive(builder.attemptsExecuted, "attemptsExecuted");
matched = result != null ?
ResponseOrException.response(result) :
ResponseOrException.exception(exception);
}
public static <T> Builder<T> builder() {
return new Builder<>();
}
@Override
public ResponseOrException<T> matched() {
return matched;
}
@Override
public int attemptsExecuted() {
return attemptsExecuted;
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
DefaultWaiterResponse<?> that = (DefaultWaiterResponse<?>) o;
if (attemptsExecuted != that.attemptsExecuted) {
return false;
}
if (!Objects.equals(result, that.result)) {
return false;
}
return Objects.equals(exception, that.exception);
}
@Override
public int hashCode() {
int result1 = result != null ? result.hashCode() : 0;
result1 = 31 * result1 + (exception != null ? exception.hashCode() : 0);
result1 = 31 * result1 + attemptsExecuted;
return result1;
}
@Override
public String toString() {
ToString toString = ToString.builder("DefaultWaiterResponse")
.add("attemptsExecuted", attemptsExecuted);
matched.response().ifPresent(r -> toString.add("response", result));
matched.exception().ifPresent(r -> toString.add("exception", exception));
return toString.build();
}
public static final class Builder<T> {
private T response;
private Throwable exception;
private Integer attemptsExecuted;
private Builder() {
}
/**
* Defines the response received that has matched with the waiter success condition.
*
* @param response the response
* @return the chained builder
*/
public Builder<T> response(T response) {
this.response = response;
return this;
}
/**
* Defines the exception thrown from the waiter operation that has matched with the waiter success condition
*
* @param exception the exception
* @return the chained builder
*/
public Builder<T> exception(Throwable exception) {
this.exception = exception;
return this;
}
/**
* Defines the number of attempts executed in the waiter operation
*
* @param attemptsExecuted the number of attempts
* @return the chained builder
*/
public Builder<T> attemptsExecuted(Integer attemptsExecuted) {
this.attemptsExecuted = attemptsExecuted;
return this;
}
public WaiterResponse<T> build() {
return new DefaultWaiterResponse<>(this);
}
}
}
| 1,936 |
0 | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/waiters/DefaultWaiter.java | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.awssdk.core.internal.waiters;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.function.Supplier;
import software.amazon.awssdk.annotations.SdkInternalApi;
import software.amazon.awssdk.annotations.ThreadSafe;
import software.amazon.awssdk.core.waiters.Waiter;
import software.amazon.awssdk.core.waiters.WaiterAcceptor;
import software.amazon.awssdk.core.waiters.WaiterOverrideConfiguration;
import software.amazon.awssdk.core.waiters.WaiterResponse;
import software.amazon.awssdk.utils.Validate;
/**
* Default implementation of the generic {@link Waiter}.
* @param <T> the type of the response expected to return from the polling function
*/
@SdkInternalApi
@ThreadSafe
public final class DefaultWaiter<T> implements Waiter<T> {
private final WaiterConfiguration waiterConfiguration;
private final List<WaiterAcceptor<? super T>> waiterAcceptors;
private final WaiterExecutor<T> waiterExecutor;
private DefaultWaiter(DefaultBuilder<T> builder) {
this.waiterConfiguration = new WaiterConfiguration(builder.overrideConfiguration);
this.waiterAcceptors = Collections.unmodifiableList(builder.waiterAcceptors);
this.waiterExecutor = new WaiterExecutor<>(waiterConfiguration, waiterAcceptors);
}
@Override
public WaiterResponse<T> run(Supplier<T> pollingFunction) {
return waiterExecutor.execute(pollingFunction);
}
@Override
public WaiterResponse<T> run(Supplier<T> pollingFunction, WaiterOverrideConfiguration overrideConfiguration) {
Validate.paramNotNull(overrideConfiguration, "overrideConfiguration");
return new WaiterExecutor<>(new WaiterConfiguration(overrideConfiguration),
waiterAcceptors).execute(pollingFunction);
}
public static <T> Builder<T> builder() {
return new DefaultBuilder<>();
}
public static final class DefaultBuilder<T> implements Builder<T> {
private List<WaiterAcceptor<? super T>> waiterAcceptors = new ArrayList<>();
private WaiterOverrideConfiguration overrideConfiguration;
private DefaultBuilder() {
}
@Override
public Builder<T> acceptors(List<WaiterAcceptor<? super T>> waiterAcceptors) {
this.waiterAcceptors = new ArrayList<>(waiterAcceptors);
return this;
}
@Override
public Builder<T> overrideConfiguration(WaiterOverrideConfiguration overrideConfiguration) {
this.overrideConfiguration = overrideConfiguration;
return this;
}
@Override
public Builder<T> addAcceptor(WaiterAcceptor<? super T> waiterAcceptor) {
waiterAcceptors.add(waiterAcceptor);
return this;
}
@Override
public Waiter<T> build() {
return new DefaultWaiter<>(this);
}
}
} | 1,937 |
0 | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/waiters/ResponseOrException.java | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.awssdk.core.internal.waiters;
import java.util.Optional;
import software.amazon.awssdk.annotations.SdkPublicApi;
/**
* Represents a value that can be either a response or a Throwable
*
* @param <R> response type
*/
@SdkPublicApi
public final class ResponseOrException<R> {
private final Optional<R> response;
private final Optional<Throwable> exception;
private ResponseOrException(Optional<R> response, Optional<Throwable> exception) {
this.response = response;
this.exception = exception;
}
/**
* @return the optional response that has matched with the waiter success condition
*/
public Optional<R> response() {
return response;
}
/**
* @return the optional exception that has matched with the waiter success condition
*/
public Optional<Throwable> exception() {
return exception;
}
/**
* Create a new ResponseOrException with the response
*
* @param value response
* @param <R> Response type
*/
public static <R> ResponseOrException<R> response(R value) {
return new ResponseOrException<>(Optional.of(value), Optional.empty());
}
/**
* Create a new ResponseOrException with the exception
*
* @param value exception
* @param <R> Response type
*/
public static <R> ResponseOrException<R> exception(Throwable value) {
return new ResponseOrException<>(Optional.empty(), Optional.of(value));
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (!(o instanceof ResponseOrException)) {
return false;
}
ResponseOrException<?> either = (ResponseOrException<?>) o;
return response.equals(either.response) && exception.equals(either.exception);
}
@Override
public int hashCode() {
return 31 * response.hashCode() + exception.hashCode();
}
}
| 1,938 |
0 | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/waiters/WaiterExecutorHelper.java | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.awssdk.core.internal.waiters;
import java.time.Duration;
import java.util.List;
import java.util.Optional;
import software.amazon.awssdk.annotations.SdkInternalApi;
import software.amazon.awssdk.core.exception.SdkClientException;
import software.amazon.awssdk.core.retry.RetryPolicyContext;
import software.amazon.awssdk.core.retry.backoff.BackoffStrategy;
import software.amazon.awssdk.core.waiters.WaiterAcceptor;
import software.amazon.awssdk.core.waiters.WaiterResponse;
import software.amazon.awssdk.utils.Either;
/**
* The waiter executor helper class. Contains the logic shared by {@link WaiterExecutor} and
* {@link AsyncWaiterExecutor}
*/
@SdkInternalApi
public final class WaiterExecutorHelper<T> {
private final List<WaiterAcceptor<? super T>> waiterAcceptors;
private final BackoffStrategy backoffStrategy;
private final Duration waitTimeout;
private final int maxAttempts;
public WaiterExecutorHelper(List<WaiterAcceptor<? super T>> waiterAcceptors,
WaiterConfiguration configuration) {
this.waiterAcceptors = waiterAcceptors;
this.backoffStrategy = configuration.backoffStrategy();
this.waitTimeout = configuration.waitTimeout();
this.maxAttempts = configuration.maxAttempts();
}
public WaiterResponse<T> createWaiterResponse(Either<T, Throwable> responseOrException, int attempts) {
return responseOrException.map(
r -> DefaultWaiterResponse.<T>builder().response(r).attemptsExecuted(attempts).build(),
e -> DefaultWaiterResponse.<T>builder().exception(e).attemptsExecuted(attempts).build()
);
}
public Optional<WaiterAcceptor<? super T>> firstWaiterAcceptorIfMatched(Either<T, Throwable> responseOrException) {
return responseOrException.map(this::responseMatches, this::exceptionMatches);
}
public long computeNextDelayInMills(int attemptNumber) {
return backoffStrategy.computeDelayBeforeNextRetry(RetryPolicyContext.builder()
.retriesAttempted(attemptNumber)
.build())
.toMillis();
}
public boolean exceedsMaxWaitTime(long startTime, long nextDelayInMills) {
if (waitTimeout == null) {
return false;
}
long elapsedTime = System.currentTimeMillis() - startTime;
return elapsedTime + nextDelayInMills > waitTimeout.toMillis();
}
public Either<Long, SdkClientException> nextDelayOrUnretryableException(int attemptNumber, long startTime) {
if (attemptNumber >= maxAttempts) {
return Either.right(SdkClientException.create("The waiter has exceeded the max retry attempts: " +
maxAttempts));
}
long nextDelay = computeNextDelayInMills(attemptNumber);
if (exceedsMaxWaitTime(startTime, nextDelay)) {
return Either.right(SdkClientException.create("The waiter has exceeded the max wait time or the "
+ "next retry will exceed the max wait time + " +
waitTimeout));
}
return Either.left(nextDelay);
}
public SdkClientException noneMatchException(Either<T, Throwable> responseOrException) {
return responseOrException.map(
r -> SdkClientException.create("No acceptor was matched for the response: " + r),
t -> SdkClientException.create("An exception was thrown and did not match any "
+ "waiter acceptors", t));
}
public SdkClientException waiterFailureException(WaiterAcceptor<? super T> acceptor) {
return SdkClientException.create(acceptor.message().orElse("A waiter acceptor was matched and transitioned "
+ "the waiter to failure state"));
}
private Optional<WaiterAcceptor<? super T>> responseMatches(T response) {
return waiterAcceptors.stream()
.filter(acceptor -> acceptor.matches(response))
.findFirst();
}
private Optional<WaiterAcceptor<? super T>> exceptionMatches(Throwable exception) {
return waiterAcceptors.stream()
.filter(acceptor -> acceptor.matches(exception))
.findFirst();
}
}
| 1,939 |
0 | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/capacity/TokenBucket.java | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.awssdk.core.internal.capacity;
import java.util.Optional;
import java.util.concurrent.atomic.AtomicInteger;
import software.amazon.awssdk.annotations.SdkInternalApi;
import software.amazon.awssdk.core.retry.conditions.TokenBucketRetryCondition.Capacity;
import software.amazon.awssdk.utils.Validate;
/**
* A lock-free implementation of a token bucket. Tokens can be acquired from the bucket as long as there is sufficient capacity
* in the bucket.
*/
@SdkInternalApi
public class TokenBucket {
private final int maxCapacity;
private final AtomicInteger capacity;
/**
* Create a bucket containing the specified number of tokens.
*/
public TokenBucket(int maxCapacity) {
this.maxCapacity = maxCapacity;
this.capacity = new AtomicInteger(maxCapacity);
}
/**
* Try to acquire a certain number of tokens from this bucket. If there aren't sufficient tokens in this bucket,
* {@link Optional#empty()} is returned.
*/
public Optional<Capacity> tryAcquire(int amountToAcquire) {
Validate.isTrue(amountToAcquire >= 0, "Amount must not be negative.");
if (amountToAcquire == 0) {
return Optional.of(Capacity.builder()
.capacityAcquired(0)
.capacityRemaining(capacity.get())
.build());
}
int currentCapacity;
int newCapacity;
do {
currentCapacity = capacity.get();
newCapacity = currentCapacity - amountToAcquire;
if (newCapacity < 0) {
return Optional.empty();
}
} while (!capacity.compareAndSet(currentCapacity, newCapacity));
return Optional.of(Capacity.builder()
.capacityAcquired(amountToAcquire)
.capacityRemaining(newCapacity)
.build());
}
/**
* Release a certain number of tokens back to this bucket. If this number of tokens would exceed the maximum number of tokens
* configured for the bucket, the bucket is instead set to the maximum value and the additional tokens are discarded.
*/
public void release(int amountToRelease) {
Validate.isTrue(amountToRelease >= 0, "Amount must not be negative.");
if (amountToRelease == 0) {
return;
}
int currentCapacity;
int newCapacity;
do {
currentCapacity = capacity.get();
if (currentCapacity == maxCapacity) {
return;
}
newCapacity = Math.min(currentCapacity + amountToRelease, maxCapacity);
} while (!capacity.compareAndSet(currentCapacity, newCapacity));
}
/**
* Retrieve a snapshot of the current number of tokens in the bucket. Because this number is constantly changing, it's
* recommended to refer to the {@link Capacity#capacityRemaining()} returned by the {@link #tryAcquire(int)} method whenever
* possible.
*/
public int currentCapacity() {
return capacity.get();
}
/**
* Retrieve the maximum capacity of the bucket configured when the bucket was created.
*/
public int maxCapacity() {
return maxCapacity;
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
TokenBucket that = (TokenBucket) o;
if (maxCapacity != that.maxCapacity) {
return false;
}
return capacity.get() == that.capacity.get();
}
@Override
public int hashCode() {
int result = maxCapacity;
result = 31 * result + capacity.get();
return result;
}
}
| 1,940 |
0 | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/checksums | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/checksums/factory/SdkCrc32C.java | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.awssdk.core.internal.checksums.factory;
import java.util.zip.Checksum;
import software.amazon.awssdk.annotations.SdkInternalApi;
/*
* THIS FILE HAS BEEN MODIFIED FROM THE ORIGINAL VERSION.
*
* The code comes from PureJavaCrc32C.java in Apache Commons Codec 1.11.
* It has been modified to add a createCopy() method.
* The createCopy method is used to save current checksum state when the checksum is marked.
*/
@SdkInternalApi
public final class SdkCrc32C implements Checksum, Cloneable {
private static final int T8_0_START = 0 * 256;
private static final int T8_1_START = 1 * 256;
private static final int T8_2_START = 2 * 256;
private static final int T8_3_START = 3 * 256;
private static final int T_8_4_START = 4 * 256;
private static final int T8_5_START = 5 * 256;
private static final int T8_6_START = 6 * 256;
private static final int T8_7_START = 7 * 256;
// CRC polynomial tables generated by:
// java -cp build/test/classes/:build/classes/ \
// org.apache.hadoop.util.TestPureJavaCrc32\$Table 82F63B78
private static final int[] T = {
/* T8_0 */
0x00000000, 0xF26B8303, 0xE13B70F7, 0x1350F3F4,
0xC79A971F, 0x35F1141C, 0x26A1E7E8, 0xD4CA64EB,
0x8AD958CF, 0x78B2DBCC, 0x6BE22838, 0x9989AB3B,
0x4D43CFD0, 0xBF284CD3, 0xAC78BF27, 0x5E133C24,
0x105EC76F, 0xE235446C, 0xF165B798, 0x030E349B,
0xD7C45070, 0x25AFD373, 0x36FF2087, 0xC494A384,
0x9A879FA0, 0x68EC1CA3, 0x7BBCEF57, 0x89D76C54,
0x5D1D08BF, 0xAF768BBC, 0xBC267848, 0x4E4DFB4B,
0x20BD8EDE, 0xD2D60DDD, 0xC186FE29, 0x33ED7D2A,
0xE72719C1, 0x154C9AC2, 0x061C6936, 0xF477EA35,
0xAA64D611, 0x580F5512, 0x4B5FA6E6, 0xB93425E5,
0x6DFE410E, 0x9F95C20D, 0x8CC531F9, 0x7EAEB2FA,
0x30E349B1, 0xC288CAB2, 0xD1D83946, 0x23B3BA45,
0xF779DEAE, 0x05125DAD, 0x1642AE59, 0xE4292D5A,
0xBA3A117E, 0x4851927D, 0x5B016189, 0xA96AE28A,
0x7DA08661, 0x8FCB0562, 0x9C9BF696, 0x6EF07595,
0x417B1DBC, 0xB3109EBF, 0xA0406D4B, 0x522BEE48,
0x86E18AA3, 0x748A09A0, 0x67DAFA54, 0x95B17957,
0xCBA24573, 0x39C9C670, 0x2A993584, 0xD8F2B687,
0x0C38D26C, 0xFE53516F, 0xED03A29B, 0x1F682198,
0x5125DAD3, 0xA34E59D0, 0xB01EAA24, 0x42752927,
0x96BF4DCC, 0x64D4CECF, 0x77843D3B, 0x85EFBE38,
0xDBFC821C, 0x2997011F, 0x3AC7F2EB, 0xC8AC71E8,
0x1C661503, 0xEE0D9600, 0xFD5D65F4, 0x0F36E6F7,
0x61C69362, 0x93AD1061, 0x80FDE395, 0x72966096,
0xA65C047D, 0x5437877E, 0x4767748A, 0xB50CF789,
0xEB1FCBAD, 0x197448AE, 0x0A24BB5A, 0xF84F3859,
0x2C855CB2, 0xDEEEDFB1, 0xCDBE2C45, 0x3FD5AF46,
0x7198540D, 0x83F3D70E, 0x90A324FA, 0x62C8A7F9,
0xB602C312, 0x44694011, 0x5739B3E5, 0xA55230E6,
0xFB410CC2, 0x092A8FC1, 0x1A7A7C35, 0xE811FF36,
0x3CDB9BDD, 0xCEB018DE, 0xDDE0EB2A, 0x2F8B6829,
0x82F63B78, 0x709DB87B, 0x63CD4B8F, 0x91A6C88C,
0x456CAC67, 0xB7072F64, 0xA457DC90, 0x563C5F93,
0x082F63B7, 0xFA44E0B4, 0xE9141340, 0x1B7F9043,
0xCFB5F4A8, 0x3DDE77AB, 0x2E8E845F, 0xDCE5075C,
0x92A8FC17, 0x60C37F14, 0x73938CE0, 0x81F80FE3,
0x55326B08, 0xA759E80B, 0xB4091BFF, 0x466298FC,
0x1871A4D8, 0xEA1A27DB, 0xF94AD42F, 0x0B21572C,
0xDFEB33C7, 0x2D80B0C4, 0x3ED04330, 0xCCBBC033,
0xA24BB5A6, 0x502036A5, 0x4370C551, 0xB11B4652,
0x65D122B9, 0x97BAA1BA, 0x84EA524E, 0x7681D14D,
0x2892ED69, 0xDAF96E6A, 0xC9A99D9E, 0x3BC21E9D,
0xEF087A76, 0x1D63F975, 0x0E330A81, 0xFC588982,
0xB21572C9, 0x407EF1CA, 0x532E023E, 0xA145813D,
0x758FE5D6, 0x87E466D5, 0x94B49521, 0x66DF1622,
0x38CC2A06, 0xCAA7A905, 0xD9F75AF1, 0x2B9CD9F2,
0xFF56BD19, 0x0D3D3E1A, 0x1E6DCDEE, 0xEC064EED,
0xC38D26C4, 0x31E6A5C7, 0x22B65633, 0xD0DDD530,
0x0417B1DB, 0xF67C32D8, 0xE52CC12C, 0x1747422F,
0x49547E0B, 0xBB3FFD08, 0xA86F0EFC, 0x5A048DFF,
0x8ECEE914, 0x7CA56A17, 0x6FF599E3, 0x9D9E1AE0,
0xD3D3E1AB, 0x21B862A8, 0x32E8915C, 0xC083125F,
0x144976B4, 0xE622F5B7, 0xF5720643, 0x07198540,
0x590AB964, 0xAB613A67, 0xB831C993, 0x4A5A4A90,
0x9E902E7B, 0x6CFBAD78, 0x7FAB5E8C, 0x8DC0DD8F,
0xE330A81A, 0x115B2B19, 0x020BD8ED, 0xF0605BEE,
0x24AA3F05, 0xD6C1BC06, 0xC5914FF2, 0x37FACCF1,
0x69E9F0D5, 0x9B8273D6, 0x88D28022, 0x7AB90321,
0xAE7367CA, 0x5C18E4C9, 0x4F48173D, 0xBD23943E,
0xF36E6F75, 0x0105EC76, 0x12551F82, 0xE03E9C81,
0x34F4F86A, 0xC69F7B69, 0xD5CF889D, 0x27A40B9E,
0x79B737BA, 0x8BDCB4B9, 0x988C474D, 0x6AE7C44E,
0xBE2DA0A5, 0x4C4623A6, 0x5F16D052, 0xAD7D5351,
/* T8_1 */
0x00000000, 0x13A29877, 0x274530EE, 0x34E7A899,
0x4E8A61DC, 0x5D28F9AB, 0x69CF5132, 0x7A6DC945,
0x9D14C3B8, 0x8EB65BCF, 0xBA51F356, 0xA9F36B21,
0xD39EA264, 0xC03C3A13, 0xF4DB928A, 0xE7790AFD,
0x3FC5F181, 0x2C6769F6, 0x1880C16F, 0x0B225918,
0x714F905D, 0x62ED082A, 0x560AA0B3, 0x45A838C4,
0xA2D13239, 0xB173AA4E, 0x859402D7, 0x96369AA0,
0xEC5B53E5, 0xFFF9CB92, 0xCB1E630B, 0xD8BCFB7C,
0x7F8BE302, 0x6C297B75, 0x58CED3EC, 0x4B6C4B9B,
0x310182DE, 0x22A31AA9, 0x1644B230, 0x05E62A47,
0xE29F20BA, 0xF13DB8CD, 0xC5DA1054, 0xD6788823,
0xAC154166, 0xBFB7D911, 0x8B507188, 0x98F2E9FF,
0x404E1283, 0x53EC8AF4, 0x670B226D, 0x74A9BA1A,
0x0EC4735F, 0x1D66EB28, 0x298143B1, 0x3A23DBC6,
0xDD5AD13B, 0xCEF8494C, 0xFA1FE1D5, 0xE9BD79A2,
0x93D0B0E7, 0x80722890, 0xB4958009, 0xA737187E,
0xFF17C604, 0xECB55E73, 0xD852F6EA, 0xCBF06E9D,
0xB19DA7D8, 0xA23F3FAF, 0x96D89736, 0x857A0F41,
0x620305BC, 0x71A19DCB, 0x45463552, 0x56E4AD25,
0x2C896460, 0x3F2BFC17, 0x0BCC548E, 0x186ECCF9,
0xC0D23785, 0xD370AFF2, 0xE797076B, 0xF4359F1C,
0x8E585659, 0x9DFACE2E, 0xA91D66B7, 0xBABFFEC0,
0x5DC6F43D, 0x4E646C4A, 0x7A83C4D3, 0x69215CA4,
0x134C95E1, 0x00EE0D96, 0x3409A50F, 0x27AB3D78,
0x809C2506, 0x933EBD71, 0xA7D915E8, 0xB47B8D9F,
0xCE1644DA, 0xDDB4DCAD, 0xE9537434, 0xFAF1EC43,
0x1D88E6BE, 0x0E2A7EC9, 0x3ACDD650, 0x296F4E27,
0x53028762, 0x40A01F15, 0x7447B78C, 0x67E52FFB,
0xBF59D487, 0xACFB4CF0, 0x981CE469, 0x8BBE7C1E,
0xF1D3B55B, 0xE2712D2C, 0xD69685B5, 0xC5341DC2,
0x224D173F, 0x31EF8F48, 0x050827D1, 0x16AABFA6,
0x6CC776E3, 0x7F65EE94, 0x4B82460D, 0x5820DE7A,
0xFBC3FAF9, 0xE861628E, 0xDC86CA17, 0xCF245260,
0xB5499B25, 0xA6EB0352, 0x920CABCB, 0x81AE33BC,
0x66D73941, 0x7575A136, 0x419209AF, 0x523091D8,
0x285D589D, 0x3BFFC0EA, 0x0F186873, 0x1CBAF004,
0xC4060B78, 0xD7A4930F, 0xE3433B96, 0xF0E1A3E1,
0x8A8C6AA4, 0x992EF2D3, 0xADC95A4A, 0xBE6BC23D,
0x5912C8C0, 0x4AB050B7, 0x7E57F82E, 0x6DF56059,
0x1798A91C, 0x043A316B, 0x30DD99F2, 0x237F0185,
0x844819FB, 0x97EA818C, 0xA30D2915, 0xB0AFB162,
0xCAC27827, 0xD960E050, 0xED8748C9, 0xFE25D0BE,
0x195CDA43, 0x0AFE4234, 0x3E19EAAD, 0x2DBB72DA,
0x57D6BB9F, 0x447423E8, 0x70938B71, 0x63311306,
0xBB8DE87A, 0xA82F700D, 0x9CC8D894, 0x8F6A40E3,
0xF50789A6, 0xE6A511D1, 0xD242B948, 0xC1E0213F,
0x26992BC2, 0x353BB3B5, 0x01DC1B2C, 0x127E835B,
0x68134A1E, 0x7BB1D269, 0x4F567AF0, 0x5CF4E287,
0x04D43CFD, 0x1776A48A, 0x23910C13, 0x30339464,
0x4A5E5D21, 0x59FCC556, 0x6D1B6DCF, 0x7EB9F5B8,
0x99C0FF45, 0x8A626732, 0xBE85CFAB, 0xAD2757DC,
0xD74A9E99, 0xC4E806EE, 0xF00FAE77, 0xE3AD3600,
0x3B11CD7C, 0x28B3550B, 0x1C54FD92, 0x0FF665E5,
0x759BACA0, 0x663934D7, 0x52DE9C4E, 0x417C0439,
0xA6050EC4, 0xB5A796B3, 0x81403E2A, 0x92E2A65D,
0xE88F6F18, 0xFB2DF76F, 0xCFCA5FF6, 0xDC68C781,
0x7B5FDFFF, 0x68FD4788, 0x5C1AEF11, 0x4FB87766,
0x35D5BE23, 0x26772654, 0x12908ECD, 0x013216BA,
0xE64B1C47, 0xF5E98430, 0xC10E2CA9, 0xD2ACB4DE,
0xA8C17D9B, 0xBB63E5EC, 0x8F844D75, 0x9C26D502,
0x449A2E7E, 0x5738B609, 0x63DF1E90, 0x707D86E7,
0x0A104FA2, 0x19B2D7D5, 0x2D557F4C, 0x3EF7E73B,
0xD98EEDC6, 0xCA2C75B1, 0xFECBDD28, 0xED69455F,
0x97048C1A, 0x84A6146D, 0xB041BCF4, 0xA3E32483,
/* T8_2 */
0x00000000, 0xA541927E, 0x4F6F520D, 0xEA2EC073,
0x9EDEA41A, 0x3B9F3664, 0xD1B1F617, 0x74F06469,
0x38513EC5, 0x9D10ACBB, 0x773E6CC8, 0xD27FFEB6,
0xA68F9ADF, 0x03CE08A1, 0xE9E0C8D2, 0x4CA15AAC,
0x70A27D8A, 0xD5E3EFF4, 0x3FCD2F87, 0x9A8CBDF9,
0xEE7CD990, 0x4B3D4BEE, 0xA1138B9D, 0x045219E3,
0x48F3434F, 0xEDB2D131, 0x079C1142, 0xA2DD833C,
0xD62DE755, 0x736C752B, 0x9942B558, 0x3C032726,
0xE144FB14, 0x4405696A, 0xAE2BA919, 0x0B6A3B67,
0x7F9A5F0E, 0xDADBCD70, 0x30F50D03, 0x95B49F7D,
0xD915C5D1, 0x7C5457AF, 0x967A97DC, 0x333B05A2,
0x47CB61CB, 0xE28AF3B5, 0x08A433C6, 0xADE5A1B8,
0x91E6869E, 0x34A714E0, 0xDE89D493, 0x7BC846ED,
0x0F382284, 0xAA79B0FA, 0x40577089, 0xE516E2F7,
0xA9B7B85B, 0x0CF62A25, 0xE6D8EA56, 0x43997828,
0x37691C41, 0x92288E3F, 0x78064E4C, 0xDD47DC32,
0xC76580D9, 0x622412A7, 0x880AD2D4, 0x2D4B40AA,
0x59BB24C3, 0xFCFAB6BD, 0x16D476CE, 0xB395E4B0,
0xFF34BE1C, 0x5A752C62, 0xB05BEC11, 0x151A7E6F,
0x61EA1A06, 0xC4AB8878, 0x2E85480B, 0x8BC4DA75,
0xB7C7FD53, 0x12866F2D, 0xF8A8AF5E, 0x5DE93D20,
0x29195949, 0x8C58CB37, 0x66760B44, 0xC337993A,
0x8F96C396, 0x2AD751E8, 0xC0F9919B, 0x65B803E5,
0x1148678C, 0xB409F5F2, 0x5E273581, 0xFB66A7FF,
0x26217BCD, 0x8360E9B3, 0x694E29C0, 0xCC0FBBBE,
0xB8FFDFD7, 0x1DBE4DA9, 0xF7908DDA, 0x52D11FA4,
0x1E704508, 0xBB31D776, 0x511F1705, 0xF45E857B,
0x80AEE112, 0x25EF736C, 0xCFC1B31F, 0x6A802161,
0x56830647, 0xF3C29439, 0x19EC544A, 0xBCADC634,
0xC85DA25D, 0x6D1C3023, 0x8732F050, 0x2273622E,
0x6ED23882, 0xCB93AAFC, 0x21BD6A8F, 0x84FCF8F1,
0xF00C9C98, 0x554D0EE6, 0xBF63CE95, 0x1A225CEB,
0x8B277743, 0x2E66E53D, 0xC448254E, 0x6109B730,
0x15F9D359, 0xB0B84127, 0x5A968154, 0xFFD7132A,
0xB3764986, 0x1637DBF8, 0xFC191B8B, 0x595889F5,
0x2DA8ED9C, 0x88E97FE2, 0x62C7BF91, 0xC7862DEF,
0xFB850AC9, 0x5EC498B7, 0xB4EA58C4, 0x11ABCABA,
0x655BAED3, 0xC01A3CAD, 0x2A34FCDE, 0x8F756EA0,
0xC3D4340C, 0x6695A672, 0x8CBB6601, 0x29FAF47F,
0x5D0A9016, 0xF84B0268, 0x1265C21B, 0xB7245065,
0x6A638C57, 0xCF221E29, 0x250CDE5A, 0x804D4C24,
0xF4BD284D, 0x51FCBA33, 0xBBD27A40, 0x1E93E83E,
0x5232B292, 0xF77320EC, 0x1D5DE09F, 0xB81C72E1,
0xCCEC1688, 0x69AD84F6, 0x83834485, 0x26C2D6FB,
0x1AC1F1DD, 0xBF8063A3, 0x55AEA3D0, 0xF0EF31AE,
0x841F55C7, 0x215EC7B9, 0xCB7007CA, 0x6E3195B4,
0x2290CF18, 0x87D15D66, 0x6DFF9D15, 0xC8BE0F6B,
0xBC4E6B02, 0x190FF97C, 0xF321390F, 0x5660AB71,
0x4C42F79A, 0xE90365E4, 0x032DA597, 0xA66C37E9,
0xD29C5380, 0x77DDC1FE, 0x9DF3018D, 0x38B293F3,
0x7413C95F, 0xD1525B21, 0x3B7C9B52, 0x9E3D092C,
0xEACD6D45, 0x4F8CFF3B, 0xA5A23F48, 0x00E3AD36,
0x3CE08A10, 0x99A1186E, 0x738FD81D, 0xD6CE4A63,
0xA23E2E0A, 0x077FBC74, 0xED517C07, 0x4810EE79,
0x04B1B4D5, 0xA1F026AB, 0x4BDEE6D8, 0xEE9F74A6,
0x9A6F10CF, 0x3F2E82B1, 0xD50042C2, 0x7041D0BC,
0xAD060C8E, 0x08479EF0, 0xE2695E83, 0x4728CCFD,
0x33D8A894, 0x96993AEA, 0x7CB7FA99, 0xD9F668E7,
0x9557324B, 0x3016A035, 0xDA386046, 0x7F79F238,
0x0B899651, 0xAEC8042F, 0x44E6C45C, 0xE1A75622,
0xDDA47104, 0x78E5E37A, 0x92CB2309, 0x378AB177,
0x437AD51E, 0xE63B4760, 0x0C158713, 0xA954156D,
0xE5F54FC1, 0x40B4DDBF, 0xAA9A1DCC, 0x0FDB8FB2,
0x7B2BEBDB, 0xDE6A79A5, 0x3444B9D6, 0x91052BA8,
/* T8_3 */
0x00000000, 0xDD45AAB8, 0xBF672381, 0x62228939,
0x7B2231F3, 0xA6679B4B, 0xC4451272, 0x1900B8CA,
0xF64463E6, 0x2B01C95E, 0x49234067, 0x9466EADF,
0x8D665215, 0x5023F8AD, 0x32017194, 0xEF44DB2C,
0xE964B13D, 0x34211B85, 0x560392BC, 0x8B463804,
0x924680CE, 0x4F032A76, 0x2D21A34F, 0xF06409F7,
0x1F20D2DB, 0xC2657863, 0xA047F15A, 0x7D025BE2,
0x6402E328, 0xB9474990, 0xDB65C0A9, 0x06206A11,
0xD725148B, 0x0A60BE33, 0x6842370A, 0xB5079DB2,
0xAC072578, 0x71428FC0, 0x136006F9, 0xCE25AC41,
0x2161776D, 0xFC24DDD5, 0x9E0654EC, 0x4343FE54,
0x5A43469E, 0x8706EC26, 0xE524651F, 0x3861CFA7,
0x3E41A5B6, 0xE3040F0E, 0x81268637, 0x5C632C8F,
0x45639445, 0x98263EFD, 0xFA04B7C4, 0x27411D7C,
0xC805C650, 0x15406CE8, 0x7762E5D1, 0xAA274F69,
0xB327F7A3, 0x6E625D1B, 0x0C40D422, 0xD1057E9A,
0xABA65FE7, 0x76E3F55F, 0x14C17C66, 0xC984D6DE,
0xD0846E14, 0x0DC1C4AC, 0x6FE34D95, 0xB2A6E72D,
0x5DE23C01, 0x80A796B9, 0xE2851F80, 0x3FC0B538,
0x26C00DF2, 0xFB85A74A, 0x99A72E73, 0x44E284CB,
0x42C2EEDA, 0x9F874462, 0xFDA5CD5B, 0x20E067E3,
0x39E0DF29, 0xE4A57591, 0x8687FCA8, 0x5BC25610,
0xB4868D3C, 0x69C32784, 0x0BE1AEBD, 0xD6A40405,
0xCFA4BCCF, 0x12E11677, 0x70C39F4E, 0xAD8635F6,
0x7C834B6C, 0xA1C6E1D4, 0xC3E468ED, 0x1EA1C255,
0x07A17A9F, 0xDAE4D027, 0xB8C6591E, 0x6583F3A6,
0x8AC7288A, 0x57828232, 0x35A00B0B, 0xE8E5A1B3,
0xF1E51979, 0x2CA0B3C1, 0x4E823AF8, 0x93C79040,
0x95E7FA51, 0x48A250E9, 0x2A80D9D0, 0xF7C57368,
0xEEC5CBA2, 0x3380611A, 0x51A2E823, 0x8CE7429B,
0x63A399B7, 0xBEE6330F, 0xDCC4BA36, 0x0181108E,
0x1881A844, 0xC5C402FC, 0xA7E68BC5, 0x7AA3217D,
0x52A0C93F, 0x8FE56387, 0xEDC7EABE, 0x30824006,
0x2982F8CC, 0xF4C75274, 0x96E5DB4D, 0x4BA071F5,
0xA4E4AAD9, 0x79A10061, 0x1B838958, 0xC6C623E0,
0xDFC69B2A, 0x02833192, 0x60A1B8AB, 0xBDE41213,
0xBBC47802, 0x6681D2BA, 0x04A35B83, 0xD9E6F13B,
0xC0E649F1, 0x1DA3E349, 0x7F816A70, 0xA2C4C0C8,
0x4D801BE4, 0x90C5B15C, 0xF2E73865, 0x2FA292DD,
0x36A22A17, 0xEBE780AF, 0x89C50996, 0x5480A32E,
0x8585DDB4, 0x58C0770C, 0x3AE2FE35, 0xE7A7548D,
0xFEA7EC47, 0x23E246FF, 0x41C0CFC6, 0x9C85657E,
0x73C1BE52, 0xAE8414EA, 0xCCA69DD3, 0x11E3376B,
0x08E38FA1, 0xD5A62519, 0xB784AC20, 0x6AC10698,
0x6CE16C89, 0xB1A4C631, 0xD3864F08, 0x0EC3E5B0,
0x17C35D7A, 0xCA86F7C2, 0xA8A47EFB, 0x75E1D443,
0x9AA50F6F, 0x47E0A5D7, 0x25C22CEE, 0xF8878656,
0xE1873E9C, 0x3CC29424, 0x5EE01D1D, 0x83A5B7A5,
0xF90696D8, 0x24433C60, 0x4661B559, 0x9B241FE1,
0x8224A72B, 0x5F610D93, 0x3D4384AA, 0xE0062E12,
0x0F42F53E, 0xD2075F86, 0xB025D6BF, 0x6D607C07,
0x7460C4CD, 0xA9256E75, 0xCB07E74C, 0x16424DF4,
0x106227E5, 0xCD278D5D, 0xAF050464, 0x7240AEDC,
0x6B401616, 0xB605BCAE, 0xD4273597, 0x09629F2F,
0xE6264403, 0x3B63EEBB, 0x59416782, 0x8404CD3A,
0x9D0475F0, 0x4041DF48, 0x22635671, 0xFF26FCC9,
0x2E238253, 0xF36628EB, 0x9144A1D2, 0x4C010B6A,
0x5501B3A0, 0x88441918, 0xEA669021, 0x37233A99,
0xD867E1B5, 0x05224B0D, 0x6700C234, 0xBA45688C,
0xA345D046, 0x7E007AFE, 0x1C22F3C7, 0xC167597F,
0xC747336E, 0x1A0299D6, 0x782010EF, 0xA565BA57,
0xBC65029D, 0x6120A825, 0x0302211C, 0xDE478BA4,
0x31035088, 0xEC46FA30, 0x8E647309, 0x5321D9B1,
0x4A21617B, 0x9764CBC3, 0xF54642FA, 0x2803E842,
/* T8_4 */
0x00000000, 0x38116FAC, 0x7022DF58, 0x4833B0F4,
0xE045BEB0, 0xD854D11C, 0x906761E8, 0xA8760E44,
0xC5670B91, 0xFD76643D, 0xB545D4C9, 0x8D54BB65,
0x2522B521, 0x1D33DA8D, 0x55006A79, 0x6D1105D5,
0x8F2261D3, 0xB7330E7F, 0xFF00BE8B, 0xC711D127,
0x6F67DF63, 0x5776B0CF, 0x1F45003B, 0x27546F97,
0x4A456A42, 0x725405EE, 0x3A67B51A, 0x0276DAB6,
0xAA00D4F2, 0x9211BB5E, 0xDA220BAA, 0xE2336406,
0x1BA8B557, 0x23B9DAFB, 0x6B8A6A0F, 0x539B05A3,
0xFBED0BE7, 0xC3FC644B, 0x8BCFD4BF, 0xB3DEBB13,
0xDECFBEC6, 0xE6DED16A, 0xAEED619E, 0x96FC0E32,
0x3E8A0076, 0x069B6FDA, 0x4EA8DF2E, 0x76B9B082,
0x948AD484, 0xAC9BBB28, 0xE4A80BDC, 0xDCB96470,
0x74CF6A34, 0x4CDE0598, 0x04EDB56C, 0x3CFCDAC0,
0x51EDDF15, 0x69FCB0B9, 0x21CF004D, 0x19DE6FE1,
0xB1A861A5, 0x89B90E09, 0xC18ABEFD, 0xF99BD151,
0x37516AAE, 0x0F400502, 0x4773B5F6, 0x7F62DA5A,
0xD714D41E, 0xEF05BBB2, 0xA7360B46, 0x9F2764EA,
0xF236613F, 0xCA270E93, 0x8214BE67, 0xBA05D1CB,
0x1273DF8F, 0x2A62B023, 0x625100D7, 0x5A406F7B,
0xB8730B7D, 0x806264D1, 0xC851D425, 0xF040BB89,
0x5836B5CD, 0x6027DA61, 0x28146A95, 0x10050539,
0x7D1400EC, 0x45056F40, 0x0D36DFB4, 0x3527B018,
0x9D51BE5C, 0xA540D1F0, 0xED736104, 0xD5620EA8,
0x2CF9DFF9, 0x14E8B055, 0x5CDB00A1, 0x64CA6F0D,
0xCCBC6149, 0xF4AD0EE5, 0xBC9EBE11, 0x848FD1BD,
0xE99ED468, 0xD18FBBC4, 0x99BC0B30, 0xA1AD649C,
0x09DB6AD8, 0x31CA0574, 0x79F9B580, 0x41E8DA2C,
0xA3DBBE2A, 0x9BCAD186, 0xD3F96172, 0xEBE80EDE,
0x439E009A, 0x7B8F6F36, 0x33BCDFC2, 0x0BADB06E,
0x66BCB5BB, 0x5EADDA17, 0x169E6AE3, 0x2E8F054F,
0x86F90B0B, 0xBEE864A7, 0xF6DBD453, 0xCECABBFF,
0x6EA2D55C, 0x56B3BAF0, 0x1E800A04, 0x269165A8,
0x8EE76BEC, 0xB6F60440, 0xFEC5B4B4, 0xC6D4DB18,
0xABC5DECD, 0x93D4B161, 0xDBE70195, 0xE3F66E39,
0x4B80607D, 0x73910FD1, 0x3BA2BF25, 0x03B3D089,
0xE180B48F, 0xD991DB23, 0x91A26BD7, 0xA9B3047B,
0x01C50A3F, 0x39D46593, 0x71E7D567, 0x49F6BACB,
0x24E7BF1E, 0x1CF6D0B2, 0x54C56046, 0x6CD40FEA,
0xC4A201AE, 0xFCB36E02, 0xB480DEF6, 0x8C91B15A,
0x750A600B, 0x4D1B0FA7, 0x0528BF53, 0x3D39D0FF,
0x954FDEBB, 0xAD5EB117, 0xE56D01E3, 0xDD7C6E4F,
0xB06D6B9A, 0x887C0436, 0xC04FB4C2, 0xF85EDB6E,
0x5028D52A, 0x6839BA86, 0x200A0A72, 0x181B65DE,
0xFA2801D8, 0xC2396E74, 0x8A0ADE80, 0xB21BB12C,
0x1A6DBF68, 0x227CD0C4, 0x6A4F6030, 0x525E0F9C,
0x3F4F0A49, 0x075E65E5, 0x4F6DD511, 0x777CBABD,
0xDF0AB4F9, 0xE71BDB55, 0xAF286BA1, 0x9739040D,
0x59F3BFF2, 0x61E2D05E, 0x29D160AA, 0x11C00F06,
0xB9B60142, 0x81A76EEE, 0xC994DE1A, 0xF185B1B6,
0x9C94B463, 0xA485DBCF, 0xECB66B3B, 0xD4A70497,
0x7CD10AD3, 0x44C0657F, 0x0CF3D58B, 0x34E2BA27,
0xD6D1DE21, 0xEEC0B18D, 0xA6F30179, 0x9EE26ED5,
0x36946091, 0x0E850F3D, 0x46B6BFC9, 0x7EA7D065,
0x13B6D5B0, 0x2BA7BA1C, 0x63940AE8, 0x5B856544,
0xF3F36B00, 0xCBE204AC, 0x83D1B458, 0xBBC0DBF4,
0x425B0AA5, 0x7A4A6509, 0x3279D5FD, 0x0A68BA51,
0xA21EB415, 0x9A0FDBB9, 0xD23C6B4D, 0xEA2D04E1,
0x873C0134, 0xBF2D6E98, 0xF71EDE6C, 0xCF0FB1C0,
0x6779BF84, 0x5F68D028, 0x175B60DC, 0x2F4A0F70,
0xCD796B76, 0xF56804DA, 0xBD5BB42E, 0x854ADB82,
0x2D3CD5C6, 0x152DBA6A, 0x5D1E0A9E, 0x650F6532,
0x081E60E7, 0x300F0F4B, 0x783CBFBF, 0x402DD013,
0xE85BDE57, 0xD04AB1FB, 0x9879010F, 0xA0686EA3,
/* T8_5 */
0x00000000, 0xEF306B19, 0xDB8CA0C3, 0x34BCCBDA,
0xB2F53777, 0x5DC55C6E, 0x697997B4, 0x8649FCAD,
0x6006181F, 0x8F367306, 0xBB8AB8DC, 0x54BAD3C5,
0xD2F32F68, 0x3DC34471, 0x097F8FAB, 0xE64FE4B2,
0xC00C303E, 0x2F3C5B27, 0x1B8090FD, 0xF4B0FBE4,
0x72F90749, 0x9DC96C50, 0xA975A78A, 0x4645CC93,
0xA00A2821, 0x4F3A4338, 0x7B8688E2, 0x94B6E3FB,
0x12FF1F56, 0xFDCF744F, 0xC973BF95, 0x2643D48C,
0x85F4168D, 0x6AC47D94, 0x5E78B64E, 0xB148DD57,
0x370121FA, 0xD8314AE3, 0xEC8D8139, 0x03BDEA20,
0xE5F20E92, 0x0AC2658B, 0x3E7EAE51, 0xD14EC548,
0x570739E5, 0xB83752FC, 0x8C8B9926, 0x63BBF23F,
0x45F826B3, 0xAAC84DAA, 0x9E748670, 0x7144ED69,
0xF70D11C4, 0x183D7ADD, 0x2C81B107, 0xC3B1DA1E,
0x25FE3EAC, 0xCACE55B5, 0xFE729E6F, 0x1142F576,
0x970B09DB, 0x783B62C2, 0x4C87A918, 0xA3B7C201,
0x0E045BEB, 0xE13430F2, 0xD588FB28, 0x3AB89031,
0xBCF16C9C, 0x53C10785, 0x677DCC5F, 0x884DA746,
0x6E0243F4, 0x813228ED, 0xB58EE337, 0x5ABE882E,
0xDCF77483, 0x33C71F9A, 0x077BD440, 0xE84BBF59,
0xCE086BD5, 0x213800CC, 0x1584CB16, 0xFAB4A00F,
0x7CFD5CA2, 0x93CD37BB, 0xA771FC61, 0x48419778,
0xAE0E73CA, 0x413E18D3, 0x7582D309, 0x9AB2B810,
0x1CFB44BD, 0xF3CB2FA4, 0xC777E47E, 0x28478F67,
0x8BF04D66, 0x64C0267F, 0x507CEDA5, 0xBF4C86BC,
0x39057A11, 0xD6351108, 0xE289DAD2, 0x0DB9B1CB,
0xEBF65579, 0x04C63E60, 0x307AF5BA, 0xDF4A9EA3,
0x5903620E, 0xB6330917, 0x828FC2CD, 0x6DBFA9D4,
0x4BFC7D58, 0xA4CC1641, 0x9070DD9B, 0x7F40B682,
0xF9094A2F, 0x16392136, 0x2285EAEC, 0xCDB581F5,
0x2BFA6547, 0xC4CA0E5E, 0xF076C584, 0x1F46AE9D,
0x990F5230, 0x763F3929, 0x4283F2F3, 0xADB399EA,
0x1C08B7D6, 0xF338DCCF, 0xC7841715, 0x28B47C0C,
0xAEFD80A1, 0x41CDEBB8, 0x75712062, 0x9A414B7B,
0x7C0EAFC9, 0x933EC4D0, 0xA7820F0A, 0x48B26413,
0xCEFB98BE, 0x21CBF3A7, 0x1577387D, 0xFA475364,
0xDC0487E8, 0x3334ECF1, 0x0788272B, 0xE8B84C32,
0x6EF1B09F, 0x81C1DB86, 0xB57D105C, 0x5A4D7B45,
0xBC029FF7, 0x5332F4EE, 0x678E3F34, 0x88BE542D,
0x0EF7A880, 0xE1C7C399, 0xD57B0843, 0x3A4B635A,
0x99FCA15B, 0x76CCCA42, 0x42700198, 0xAD406A81,
0x2B09962C, 0xC439FD35, 0xF08536EF, 0x1FB55DF6,
0xF9FAB944, 0x16CAD25D, 0x22761987, 0xCD46729E,
0x4B0F8E33, 0xA43FE52A, 0x90832EF0, 0x7FB345E9,
0x59F09165, 0xB6C0FA7C, 0x827C31A6, 0x6D4C5ABF,
0xEB05A612, 0x0435CD0B, 0x308906D1, 0xDFB96DC8,
0x39F6897A, 0xD6C6E263, 0xE27A29B9, 0x0D4A42A0,
0x8B03BE0D, 0x6433D514, 0x508F1ECE, 0xBFBF75D7,
0x120CEC3D, 0xFD3C8724, 0xC9804CFE, 0x26B027E7,
0xA0F9DB4A, 0x4FC9B053, 0x7B757B89, 0x94451090,
0x720AF422, 0x9D3A9F3B, 0xA98654E1, 0x46B63FF8,
0xC0FFC355, 0x2FCFA84C, 0x1B736396, 0xF443088F,
0xD200DC03, 0x3D30B71A, 0x098C7CC0, 0xE6BC17D9,
0x60F5EB74, 0x8FC5806D, 0xBB794BB7, 0x544920AE,
0xB206C41C, 0x5D36AF05, 0x698A64DF, 0x86BA0FC6,
0x00F3F36B, 0xEFC39872, 0xDB7F53A8, 0x344F38B1,
0x97F8FAB0, 0x78C891A9, 0x4C745A73, 0xA344316A,
0x250DCDC7, 0xCA3DA6DE, 0xFE816D04, 0x11B1061D,
0xF7FEE2AF, 0x18CE89B6, 0x2C72426C, 0xC3422975,
0x450BD5D8, 0xAA3BBEC1, 0x9E87751B, 0x71B71E02,
0x57F4CA8E, 0xB8C4A197, 0x8C786A4D, 0x63480154,
0xE501FDF9, 0x0A3196E0, 0x3E8D5D3A, 0xD1BD3623,
0x37F2D291, 0xD8C2B988, 0xEC7E7252, 0x034E194B,
0x8507E5E6, 0x6A378EFF, 0x5E8B4525, 0xB1BB2E3C,
/* T8_6 */
0x00000000, 0x68032CC8, 0xD0065990, 0xB8057558,
0xA5E0C5D1, 0xCDE3E919, 0x75E69C41, 0x1DE5B089,
0x4E2DFD53, 0x262ED19B, 0x9E2BA4C3, 0xF628880B,
0xEBCD3882, 0x83CE144A, 0x3BCB6112, 0x53C84DDA,
0x9C5BFAA6, 0xF458D66E, 0x4C5DA336, 0x245E8FFE,
0x39BB3F77, 0x51B813BF, 0xE9BD66E7, 0x81BE4A2F,
0xD27607F5, 0xBA752B3D, 0x02705E65, 0x6A7372AD,
0x7796C224, 0x1F95EEEC, 0xA7909BB4, 0xCF93B77C,
0x3D5B83BD, 0x5558AF75, 0xED5DDA2D, 0x855EF6E5,
0x98BB466C, 0xF0B86AA4, 0x48BD1FFC, 0x20BE3334,
0x73767EEE, 0x1B755226, 0xA370277E, 0xCB730BB6,
0xD696BB3F, 0xBE9597F7, 0x0690E2AF, 0x6E93CE67,
0xA100791B, 0xC90355D3, 0x7106208B, 0x19050C43,
0x04E0BCCA, 0x6CE39002, 0xD4E6E55A, 0xBCE5C992,
0xEF2D8448, 0x872EA880, 0x3F2BDDD8, 0x5728F110,
0x4ACD4199, 0x22CE6D51, 0x9ACB1809, 0xF2C834C1,
0x7AB7077A, 0x12B42BB2, 0xAAB15EEA, 0xC2B27222,
0xDF57C2AB, 0xB754EE63, 0x0F519B3B, 0x6752B7F3,
0x349AFA29, 0x5C99D6E1, 0xE49CA3B9, 0x8C9F8F71,
0x917A3FF8, 0xF9791330, 0x417C6668, 0x297F4AA0,
0xE6ECFDDC, 0x8EEFD114, 0x36EAA44C, 0x5EE98884,
0x430C380D, 0x2B0F14C5, 0x930A619D, 0xFB094D55,
0xA8C1008F, 0xC0C22C47, 0x78C7591F, 0x10C475D7,
0x0D21C55E, 0x6522E996, 0xDD279CCE, 0xB524B006,
0x47EC84C7, 0x2FEFA80F, 0x97EADD57, 0xFFE9F19F,
0xE20C4116, 0x8A0F6DDE, 0x320A1886, 0x5A09344E,
0x09C17994, 0x61C2555C, 0xD9C72004, 0xB1C40CCC,
0xAC21BC45, 0xC422908D, 0x7C27E5D5, 0x1424C91D,
0xDBB77E61, 0xB3B452A9, 0x0BB127F1, 0x63B20B39,
0x7E57BBB0, 0x16549778, 0xAE51E220, 0xC652CEE8,
0x959A8332, 0xFD99AFFA, 0x459CDAA2, 0x2D9FF66A,
0x307A46E3, 0x58796A2B, 0xE07C1F73, 0x887F33BB,
0xF56E0EF4, 0x9D6D223C, 0x25685764, 0x4D6B7BAC,
0x508ECB25, 0x388DE7ED, 0x808892B5, 0xE88BBE7D,
0xBB43F3A7, 0xD340DF6F, 0x6B45AA37, 0x034686FF,
0x1EA33676, 0x76A01ABE, 0xCEA56FE6, 0xA6A6432E,
0x6935F452, 0x0136D89A, 0xB933ADC2, 0xD130810A,
0xCCD53183, 0xA4D61D4B, 0x1CD36813, 0x74D044DB,
0x27180901, 0x4F1B25C9, 0xF71E5091, 0x9F1D7C59,
0x82F8CCD0, 0xEAFBE018, 0x52FE9540, 0x3AFDB988,
0xC8358D49, 0xA036A181, 0x1833D4D9, 0x7030F811,
0x6DD54898, 0x05D66450, 0xBDD31108, 0xD5D03DC0,
0x8618701A, 0xEE1B5CD2, 0x561E298A, 0x3E1D0542,
0x23F8B5CB, 0x4BFB9903, 0xF3FEEC5B, 0x9BFDC093,
0x546E77EF, 0x3C6D5B27, 0x84682E7F, 0xEC6B02B7,
0xF18EB23E, 0x998D9EF6, 0x2188EBAE, 0x498BC766,
0x1A438ABC, 0x7240A674, 0xCA45D32C, 0xA246FFE4,
0xBFA34F6D, 0xD7A063A5, 0x6FA516FD, 0x07A63A35,
0x8FD9098E, 0xE7DA2546, 0x5FDF501E, 0x37DC7CD6,
0x2A39CC5F, 0x423AE097, 0xFA3F95CF, 0x923CB907,
0xC1F4F4DD, 0xA9F7D815, 0x11F2AD4D, 0x79F18185,
0x6414310C, 0x0C171DC4, 0xB412689C, 0xDC114454,
0x1382F328, 0x7B81DFE0, 0xC384AAB8, 0xAB878670,
0xB66236F9, 0xDE611A31, 0x66646F69, 0x0E6743A1,
0x5DAF0E7B, 0x35AC22B3, 0x8DA957EB, 0xE5AA7B23,
0xF84FCBAA, 0x904CE762, 0x2849923A, 0x404ABEF2,
0xB2828A33, 0xDA81A6FB, 0x6284D3A3, 0x0A87FF6B,
0x17624FE2, 0x7F61632A, 0xC7641672, 0xAF673ABA,
0xFCAF7760, 0x94AC5BA8, 0x2CA92EF0, 0x44AA0238,
0x594FB2B1, 0x314C9E79, 0x8949EB21, 0xE14AC7E9,
0x2ED97095, 0x46DA5C5D, 0xFEDF2905, 0x96DC05CD,
0x8B39B544, 0xE33A998C, 0x5B3FECD4, 0x333CC01C,
0x60F48DC6, 0x08F7A10E, 0xB0F2D456, 0xD8F1F89E,
0xC5144817, 0xAD1764DF, 0x15121187, 0x7D113D4F,
/* T8_7 */
0x00000000, 0x493C7D27, 0x9278FA4E, 0xDB448769,
0x211D826D, 0x6821FF4A, 0xB3657823, 0xFA590504,
0x423B04DA, 0x0B0779FD, 0xD043FE94, 0x997F83B3,
0x632686B7, 0x2A1AFB90, 0xF15E7CF9, 0xB86201DE,
0x847609B4, 0xCD4A7493, 0x160EF3FA, 0x5F328EDD,
0xA56B8BD9, 0xEC57F6FE, 0x37137197, 0x7E2F0CB0,
0xC64D0D6E, 0x8F717049, 0x5435F720, 0x1D098A07,
0xE7508F03, 0xAE6CF224, 0x7528754D, 0x3C14086A,
0x0D006599, 0x443C18BE, 0x9F789FD7, 0xD644E2F0,
0x2C1DE7F4, 0x65219AD3, 0xBE651DBA, 0xF759609D,
0x4F3B6143, 0x06071C64, 0xDD439B0D, 0x947FE62A,
0x6E26E32E, 0x271A9E09, 0xFC5E1960, 0xB5626447,
0x89766C2D, 0xC04A110A, 0x1B0E9663, 0x5232EB44,
0xA86BEE40, 0xE1579367, 0x3A13140E, 0x732F6929,
0xCB4D68F7, 0x827115D0, 0x593592B9, 0x1009EF9E,
0xEA50EA9A, 0xA36C97BD, 0x782810D4, 0x31146DF3,
0x1A00CB32, 0x533CB615, 0x8878317C, 0xC1444C5B,
0x3B1D495F, 0x72213478, 0xA965B311, 0xE059CE36,
0x583BCFE8, 0x1107B2CF, 0xCA4335A6, 0x837F4881,
0x79264D85, 0x301A30A2, 0xEB5EB7CB, 0xA262CAEC,
0x9E76C286, 0xD74ABFA1, 0x0C0E38C8, 0x453245EF,
0xBF6B40EB, 0xF6573DCC, 0x2D13BAA5, 0x642FC782,
0xDC4DC65C, 0x9571BB7B, 0x4E353C12, 0x07094135,
0xFD504431, 0xB46C3916, 0x6F28BE7F, 0x2614C358,
0x1700AEAB, 0x5E3CD38C, 0x857854E5, 0xCC4429C2,
0x361D2CC6, 0x7F2151E1, 0xA465D688, 0xED59ABAF,
0x553BAA71, 0x1C07D756, 0xC743503F, 0x8E7F2D18,
0x7426281C, 0x3D1A553B, 0xE65ED252, 0xAF62AF75,
0x9376A71F, 0xDA4ADA38, 0x010E5D51, 0x48322076,
0xB26B2572, 0xFB575855, 0x2013DF3C, 0x692FA21B,
0xD14DA3C5, 0x9871DEE2, 0x4335598B, 0x0A0924AC,
0xF05021A8, 0xB96C5C8F, 0x6228DBE6, 0x2B14A6C1,
0x34019664, 0x7D3DEB43, 0xA6796C2A, 0xEF45110D,
0x151C1409, 0x5C20692E, 0x8764EE47, 0xCE589360,
0x763A92BE, 0x3F06EF99, 0xE44268F0, 0xAD7E15D7,
0x572710D3, 0x1E1B6DF4, 0xC55FEA9D, 0x8C6397BA,
0xB0779FD0, 0xF94BE2F7, 0x220F659E, 0x6B3318B9,
0x916A1DBD, 0xD856609A, 0x0312E7F3, 0x4A2E9AD4,
0xF24C9B0A, 0xBB70E62D, 0x60346144, 0x29081C63,
0xD3511967, 0x9A6D6440, 0x4129E329, 0x08159E0E,
0x3901F3FD, 0x703D8EDA, 0xAB7909B3, 0xE2457494,
0x181C7190, 0x51200CB7, 0x8A648BDE, 0xC358F6F9,
0x7B3AF727, 0x32068A00, 0xE9420D69, 0xA07E704E,
0x5A27754A, 0x131B086D, 0xC85F8F04, 0x8163F223,
0xBD77FA49, 0xF44B876E, 0x2F0F0007, 0x66337D20,
0x9C6A7824, 0xD5560503, 0x0E12826A, 0x472EFF4D,
0xFF4CFE93, 0xB67083B4, 0x6D3404DD, 0x240879FA,
0xDE517CFE, 0x976D01D9, 0x4C2986B0, 0x0515FB97,
0x2E015D56, 0x673D2071, 0xBC79A718, 0xF545DA3F,
0x0F1CDF3B, 0x4620A21C, 0x9D642575, 0xD4585852,
0x6C3A598C, 0x250624AB, 0xFE42A3C2, 0xB77EDEE5,
0x4D27DBE1, 0x041BA6C6, 0xDF5F21AF, 0x96635C88,
0xAA7754E2, 0xE34B29C5, 0x380FAEAC, 0x7133D38B,
0x8B6AD68F, 0xC256ABA8, 0x19122CC1, 0x502E51E6,
0xE84C5038, 0xA1702D1F, 0x7A34AA76, 0x3308D751,
0xC951D255, 0x806DAF72, 0x5B29281B, 0x1215553C,
0x230138CF, 0x6A3D45E8, 0xB179C281, 0xF845BFA6,
0x021CBAA2, 0x4B20C785, 0x906440EC, 0xD9583DCB,
0x613A3C15, 0x28064132, 0xF342C65B, 0xBA7EBB7C,
0x4027BE78, 0x091BC35F, 0xD25F4436, 0x9B633911,
0xA777317B, 0xEE4B4C5C, 0x350FCB35, 0x7C33B612,
0x866AB316, 0xCF56CE31, 0x14124958, 0x5D2E347F,
0xE54C35A1, 0xAC704886, 0x7734CFEF, 0x3E08B2C8,
0xC451B7CC, 0x8D6DCAEB, 0x56294D82, 0x1F1530A5
};
/**
* the current CRC value, bit-flipped
*/
private int crc;
private SdkCrc32C() {
reset();
}
private SdkCrc32C(int crc) {
this.crc = crc;
}
public static SdkCrc32C create() {
return new SdkCrc32C();
}
@Override
public long getValue() {
long ret = crc;
return (~ret) & 0xffffffffL;
}
@Override
public void reset() {
crc = 0xffffffff;
}
@Override
public void update(byte[] b, int off, int len) {
int localCrc = crc;
while (len > 7) {
int c0 = (b[off + 0] ^ localCrc) & 0xff;
localCrc >>>= 8;
int c1 = (b[off + 1] ^ (localCrc)) & 0xff;
localCrc >>>= 8;
int c2 = (b[off + 2] ^ (localCrc)) & 0xff;
localCrc >>>= 8;
int c3 = (b[off + 3] ^ (localCrc)) & 0xff;
localCrc = (T[T8_7_START + c0] ^ T[T8_6_START + c1]) ^
(T[T8_5_START + c2] ^ T[T_8_4_START + c3]);
int c4 = b[off + 4] & 0xff;
int c5 = b[off + 5] & 0xff;
int c6 = b[off + 6] & 0xff;
int c7 = b[off + 7] & 0xff;
localCrc ^= (T[T8_3_START + c4] ^ T[T8_2_START + c5]) ^
(T[T8_1_START + c6] ^ T[T8_0_START + c7]);
off += 8;
len -= 8;
}
/* loop unroll - duff's device style */
for (int index = 0; index < len; index++) {
localCrc = (localCrc >>> 8) ^ T[T8_0_START + ((localCrc ^ b[off++]) & 0xff)];
}
// Publish crc out to object
crc = localCrc;
}
@Override
public void update(int b) {
crc = (crc >>> 8) ^ T[T8_0_START + ((crc ^ b) & 0xff)];
}
@Override
public Object clone() {
return new SdkCrc32C(crc);
}
}
| 1,941 |
0 | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/checksums | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/checksums/factory/SdkCrc32.java | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.awssdk.core.internal.checksums.factory;
import java.util.zip.Checksum;
import software.amazon.awssdk.annotations.SdkInternalApi;
/*
* THIS FILE HAS BEEN MODIFIED FROM THE ORIGINAL VERSION.
*
* The code comes from PureJavaCrc32.java in Apache Commons Codec 1.11.
* It has been modified to add a createCopy() method.
* The createCopy method is used to save current c checksum state when the checksum is marked.
*/
@SdkInternalApi
public final class SdkCrc32 implements Checksum, Cloneable {
/*
* CRC-32 lookup tables generated by the polynomial 0xEDB88320.
* See also TestPureJavaCrc32.Table.
*/
private static final int[] T = {
/* T8_0 */
0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA,
0x076DC419, 0x706AF48F, 0xE963A535, 0x9E6495A3,
0x0EDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988,
0x09B64C2B, 0x7EB17CBD, 0xE7B82D07, 0x90BF1D91,
0x1DB71064, 0x6AB020F2, 0xF3B97148, 0x84BE41DE,
0x1ADAD47D, 0x6DDDE4EB, 0xF4D4B551, 0x83D385C7,
0x136C9856, 0x646BA8C0, 0xFD62F97A, 0x8A65C9EC,
0x14015C4F, 0x63066CD9, 0xFA0F3D63, 0x8D080DF5,
0x3B6E20C8, 0x4C69105E, 0xD56041E4, 0xA2677172,
0x3C03E4D1, 0x4B04D447, 0xD20D85FD, 0xA50AB56B,
0x35B5A8FA, 0x42B2986C, 0xDBBBC9D6, 0xACBCF940,
0x32D86CE3, 0x45DF5C75, 0xDCD60DCF, 0xABD13D59,
0x26D930AC, 0x51DE003A, 0xC8D75180, 0xBFD06116,
0x21B4F4B5, 0x56B3C423, 0xCFBA9599, 0xB8BDA50F,
0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924,
0x2F6F7C87, 0x58684C11, 0xC1611DAB, 0xB6662D3D,
0x76DC4190, 0x01DB7106, 0x98D220BC, 0xEFD5102A,
0x71B18589, 0x06B6B51F, 0x9FBFE4A5, 0xE8B8D433,
0x7807C9A2, 0x0F00F934, 0x9609A88E, 0xE10E9818,
0x7F6A0DBB, 0x086D3D2D, 0x91646C97, 0xE6635C01,
0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E,
0x6C0695ED, 0x1B01A57B, 0x8208F4C1, 0xF50FC457,
0x65B0D9C6, 0x12B7E950, 0x8BBEB8EA, 0xFCB9887C,
0x62DD1DDF, 0x15DA2D49, 0x8CD37CF3, 0xFBD44C65,
0x4DB26158, 0x3AB551CE, 0xA3BC0074, 0xD4BB30E2,
0x4ADFA541, 0x3DD895D7, 0xA4D1C46D, 0xD3D6F4FB,
0x4369E96A, 0x346ED9FC, 0xAD678846, 0xDA60B8D0,
0x44042D73, 0x33031DE5, 0xAA0A4C5F, 0xDD0D7CC9,
0x5005713C, 0x270241AA, 0xBE0B1010, 0xC90C2086,
0x5768B525, 0x206F85B3, 0xB966D409, 0xCE61E49F,
0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4,
0x59B33D17, 0x2EB40D81, 0xB7BD5C3B, 0xC0BA6CAD,
0xEDB88320, 0x9ABFB3B6, 0x03B6E20C, 0x74B1D29A,
0xEAD54739, 0x9DD277AF, 0x04DB2615, 0x73DC1683,
0xE3630B12, 0x94643B84, 0x0D6D6A3E, 0x7A6A5AA8,
0xE40ECF0B, 0x9309FF9D, 0x0A00AE27, 0x7D079EB1,
0xF00F9344, 0x8708A3D2, 0x1E01F268, 0x6906C2FE,
0xF762575D, 0x806567CB, 0x196C3671, 0x6E6B06E7,
0xFED41B76, 0x89D32BE0, 0x10DA7A5A, 0x67DD4ACC,
0xF9B9DF6F, 0x8EBEEFF9, 0x17B7BE43, 0x60B08ED5,
0xD6D6A3E8, 0xA1D1937E, 0x38D8C2C4, 0x4FDFF252,
0xD1BB67F1, 0xA6BC5767, 0x3FB506DD, 0x48B2364B,
0xD80D2BDA, 0xAF0A1B4C, 0x36034AF6, 0x41047A60,
0xDF60EFC3, 0xA867DF55, 0x316E8EEF, 0x4669BE79,
0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236,
0xCC0C7795, 0xBB0B4703, 0x220216B9, 0x5505262F,
0xC5BA3BBE, 0xB2BD0B28, 0x2BB45A92, 0x5CB36A04,
0xC2D7FFA7, 0xB5D0CF31, 0x2CD99E8B, 0x5BDEAE1D,
0x9B64C2B0, 0xEC63F226, 0x756AA39C, 0x026D930A,
0x9C0906A9, 0xEB0E363F, 0x72076785, 0x05005713,
0x95BF4A82, 0xE2B87A14, 0x7BB12BAE, 0x0CB61B38,
0x92D28E9B, 0xE5D5BE0D, 0x7CDCEFB7, 0x0BDBDF21,
0x86D3D2D4, 0xF1D4E242, 0x68DDB3F8, 0x1FDA836E,
0x81BE16CD, 0xF6B9265B, 0x6FB077E1, 0x18B74777,
0x88085AE6, 0xFF0F6A70, 0x66063BCA, 0x11010B5C,
0x8F659EFF, 0xF862AE69, 0x616BFFD3, 0x166CCF45,
0xA00AE278, 0xD70DD2EE, 0x4E048354, 0x3903B3C2,
0xA7672661, 0xD06016F7, 0x4969474D, 0x3E6E77DB,
0xAED16A4A, 0xD9D65ADC, 0x40DF0B66, 0x37D83BF0,
0xA9BCAE53, 0xDEBB9EC5, 0x47B2CF7F, 0x30B5FFE9,
0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6,
0xBAD03605, 0xCDD70693, 0x54DE5729, 0x23D967BF,
0xB3667A2E, 0xC4614AB8, 0x5D681B02, 0x2A6F2B94,
0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D,
/* T8_1 */
0x00000000, 0x191B3141, 0x32366282, 0x2B2D53C3,
0x646CC504, 0x7D77F445, 0x565AA786, 0x4F4196C7,
0xC8D98A08, 0xD1C2BB49, 0xFAEFE88A, 0xE3F4D9CB,
0xACB54F0C, 0xB5AE7E4D, 0x9E832D8E, 0x87981CCF,
0x4AC21251, 0x53D92310, 0x78F470D3, 0x61EF4192,
0x2EAED755, 0x37B5E614, 0x1C98B5D7, 0x05838496,
0x821B9859, 0x9B00A918, 0xB02DFADB, 0xA936CB9A,
0xE6775D5D, 0xFF6C6C1C, 0xD4413FDF, 0xCD5A0E9E,
0x958424A2, 0x8C9F15E3, 0xA7B24620, 0xBEA97761,
0xF1E8E1A6, 0xE8F3D0E7, 0xC3DE8324, 0xDAC5B265,
0x5D5DAEAA, 0x44469FEB, 0x6F6BCC28, 0x7670FD69,
0x39316BAE, 0x202A5AEF, 0x0B07092C, 0x121C386D,
0xDF4636F3, 0xC65D07B2, 0xED705471, 0xF46B6530,
0xBB2AF3F7, 0xA231C2B6, 0x891C9175, 0x9007A034,
0x179FBCFB, 0x0E848DBA, 0x25A9DE79, 0x3CB2EF38,
0x73F379FF, 0x6AE848BE, 0x41C51B7D, 0x58DE2A3C,
0xF0794F05, 0xE9627E44, 0xC24F2D87, 0xDB541CC6,
0x94158A01, 0x8D0EBB40, 0xA623E883, 0xBF38D9C2,
0x38A0C50D, 0x21BBF44C, 0x0A96A78F, 0x138D96CE,
0x5CCC0009, 0x45D73148, 0x6EFA628B, 0x77E153CA,
0xBABB5D54, 0xA3A06C15, 0x888D3FD6, 0x91960E97,
0xDED79850, 0xC7CCA911, 0xECE1FAD2, 0xF5FACB93,
0x7262D75C, 0x6B79E61D, 0x4054B5DE, 0x594F849F,
0x160E1258, 0x0F152319, 0x243870DA, 0x3D23419B,
0x65FD6BA7, 0x7CE65AE6, 0x57CB0925, 0x4ED03864,
0x0191AEA3, 0x188A9FE2, 0x33A7CC21, 0x2ABCFD60,
0xAD24E1AF, 0xB43FD0EE, 0x9F12832D, 0x8609B26C,
0xC94824AB, 0xD05315EA, 0xFB7E4629, 0xE2657768,
0x2F3F79F6, 0x362448B7, 0x1D091B74, 0x04122A35,
0x4B53BCF2, 0x52488DB3, 0x7965DE70, 0x607EEF31,
0xE7E6F3FE, 0xFEFDC2BF, 0xD5D0917C, 0xCCCBA03D,
0x838A36FA, 0x9A9107BB, 0xB1BC5478, 0xA8A76539,
0x3B83984B, 0x2298A90A, 0x09B5FAC9, 0x10AECB88,
0x5FEF5D4F, 0x46F46C0E, 0x6DD93FCD, 0x74C20E8C,
0xF35A1243, 0xEA412302, 0xC16C70C1, 0xD8774180,
0x9736D747, 0x8E2DE606, 0xA500B5C5, 0xBC1B8484,
0x71418A1A, 0x685ABB5B, 0x4377E898, 0x5A6CD9D9,
0x152D4F1E, 0x0C367E5F, 0x271B2D9C, 0x3E001CDD,
0xB9980012, 0xA0833153, 0x8BAE6290, 0x92B553D1,
0xDDF4C516, 0xC4EFF457, 0xEFC2A794, 0xF6D996D5,
0xAE07BCE9, 0xB71C8DA8, 0x9C31DE6B, 0x852AEF2A,
0xCA6B79ED, 0xD37048AC, 0xF85D1B6F, 0xE1462A2E,
0x66DE36E1, 0x7FC507A0, 0x54E85463, 0x4DF36522,
0x02B2F3E5, 0x1BA9C2A4, 0x30849167, 0x299FA026,
0xE4C5AEB8, 0xFDDE9FF9, 0xD6F3CC3A, 0xCFE8FD7B,
0x80A96BBC, 0x99B25AFD, 0xB29F093E, 0xAB84387F,
0x2C1C24B0, 0x350715F1, 0x1E2A4632, 0x07317773,
0x4870E1B4, 0x516BD0F5, 0x7A468336, 0x635DB277,
0xCBFAD74E, 0xD2E1E60F, 0xF9CCB5CC, 0xE0D7848D,
0xAF96124A, 0xB68D230B, 0x9DA070C8, 0x84BB4189,
0x03235D46, 0x1A386C07, 0x31153FC4, 0x280E0E85,
0x674F9842, 0x7E54A903, 0x5579FAC0, 0x4C62CB81,
0x8138C51F, 0x9823F45E, 0xB30EA79D, 0xAA1596DC,
0xE554001B, 0xFC4F315A, 0xD7626299, 0xCE7953D8,
0x49E14F17, 0x50FA7E56, 0x7BD72D95, 0x62CC1CD4,
0x2D8D8A13, 0x3496BB52, 0x1FBBE891, 0x06A0D9D0,
0x5E7EF3EC, 0x4765C2AD, 0x6C48916E, 0x7553A02F,
0x3A1236E8, 0x230907A9, 0x0824546A, 0x113F652B,
0x96A779E4, 0x8FBC48A5, 0xA4911B66, 0xBD8A2A27,
0xF2CBBCE0, 0xEBD08DA1, 0xC0FDDE62, 0xD9E6EF23,
0x14BCE1BD, 0x0DA7D0FC, 0x268A833F, 0x3F91B27E,
0x70D024B9, 0x69CB15F8, 0x42E6463B, 0x5BFD777A,
0xDC656BB5, 0xC57E5AF4, 0xEE530937, 0xF7483876,
0xB809AEB1, 0xA1129FF0, 0x8A3FCC33, 0x9324FD72,
/* T8_2 */
0x00000000, 0x01C26A37, 0x0384D46E, 0x0246BE59,
0x0709A8DC, 0x06CBC2EB, 0x048D7CB2, 0x054F1685,
0x0E1351B8, 0x0FD13B8F, 0x0D9785D6, 0x0C55EFE1,
0x091AF964, 0x08D89353, 0x0A9E2D0A, 0x0B5C473D,
0x1C26A370, 0x1DE4C947, 0x1FA2771E, 0x1E601D29,
0x1B2F0BAC, 0x1AED619B, 0x18ABDFC2, 0x1969B5F5,
0x1235F2C8, 0x13F798FF, 0x11B126A6, 0x10734C91,
0x153C5A14, 0x14FE3023, 0x16B88E7A, 0x177AE44D,
0x384D46E0, 0x398F2CD7, 0x3BC9928E, 0x3A0BF8B9,
0x3F44EE3C, 0x3E86840B, 0x3CC03A52, 0x3D025065,
0x365E1758, 0x379C7D6F, 0x35DAC336, 0x3418A901,
0x3157BF84, 0x3095D5B3, 0x32D36BEA, 0x331101DD,
0x246BE590, 0x25A98FA7, 0x27EF31FE, 0x262D5BC9,
0x23624D4C, 0x22A0277B, 0x20E69922, 0x2124F315,
0x2A78B428, 0x2BBADE1F, 0x29FC6046, 0x283E0A71,
0x2D711CF4, 0x2CB376C3, 0x2EF5C89A, 0x2F37A2AD,
0x709A8DC0, 0x7158E7F7, 0x731E59AE, 0x72DC3399,
0x7793251C, 0x76514F2B, 0x7417F172, 0x75D59B45,
0x7E89DC78, 0x7F4BB64F, 0x7D0D0816, 0x7CCF6221,
0x798074A4, 0x78421E93, 0x7A04A0CA, 0x7BC6CAFD,
0x6CBC2EB0, 0x6D7E4487, 0x6F38FADE, 0x6EFA90E9,
0x6BB5866C, 0x6A77EC5B, 0x68315202, 0x69F33835,
0x62AF7F08, 0x636D153F, 0x612BAB66, 0x60E9C151,
0x65A6D7D4, 0x6464BDE3, 0x662203BA, 0x67E0698D,
0x48D7CB20, 0x4915A117, 0x4B531F4E, 0x4A917579,
0x4FDE63FC, 0x4E1C09CB, 0x4C5AB792, 0x4D98DDA5,
0x46C49A98, 0x4706F0AF, 0x45404EF6, 0x448224C1,
0x41CD3244, 0x400F5873, 0x4249E62A, 0x438B8C1D,
0x54F16850, 0x55330267, 0x5775BC3E, 0x56B7D609,
0x53F8C08C, 0x523AAABB, 0x507C14E2, 0x51BE7ED5,
0x5AE239E8, 0x5B2053DF, 0x5966ED86, 0x58A487B1,
0x5DEB9134, 0x5C29FB03, 0x5E6F455A, 0x5FAD2F6D,
0xE1351B80, 0xE0F771B7, 0xE2B1CFEE, 0xE373A5D9,
0xE63CB35C, 0xE7FED96B, 0xE5B86732, 0xE47A0D05,
0xEF264A38, 0xEEE4200F, 0xECA29E56, 0xED60F461,
0xE82FE2E4, 0xE9ED88D3, 0xEBAB368A, 0xEA695CBD,
0xFD13B8F0, 0xFCD1D2C7, 0xFE976C9E, 0xFF5506A9,
0xFA1A102C, 0xFBD87A1B, 0xF99EC442, 0xF85CAE75,
0xF300E948, 0xF2C2837F, 0xF0843D26, 0xF1465711,
0xF4094194, 0xF5CB2BA3, 0xF78D95FA, 0xF64FFFCD,
0xD9785D60, 0xD8BA3757, 0xDAFC890E, 0xDB3EE339,
0xDE71F5BC, 0xDFB39F8B, 0xDDF521D2, 0xDC374BE5,
0xD76B0CD8, 0xD6A966EF, 0xD4EFD8B6, 0xD52DB281,
0xD062A404, 0xD1A0CE33, 0xD3E6706A, 0xD2241A5D,
0xC55EFE10, 0xC49C9427, 0xC6DA2A7E, 0xC7184049,
0xC25756CC, 0xC3953CFB, 0xC1D382A2, 0xC011E895,
0xCB4DAFA8, 0xCA8FC59F, 0xC8C97BC6, 0xC90B11F1,
0xCC440774, 0xCD866D43, 0xCFC0D31A, 0xCE02B92D,
0x91AF9640, 0x906DFC77, 0x922B422E, 0x93E92819,
0x96A63E9C, 0x976454AB, 0x9522EAF2, 0x94E080C5,
0x9FBCC7F8, 0x9E7EADCF, 0x9C381396, 0x9DFA79A1,
0x98B56F24, 0x99770513, 0x9B31BB4A, 0x9AF3D17D,
0x8D893530, 0x8C4B5F07, 0x8E0DE15E, 0x8FCF8B69,
0x8A809DEC, 0x8B42F7DB, 0x89044982, 0x88C623B5,
0x839A6488, 0x82580EBF, 0x801EB0E6, 0x81DCDAD1,
0x8493CC54, 0x8551A663, 0x8717183A, 0x86D5720D,
0xA9E2D0A0, 0xA820BA97, 0xAA6604CE, 0xABA46EF9,
0xAEEB787C, 0xAF29124B, 0xAD6FAC12, 0xACADC625,
0xA7F18118, 0xA633EB2F, 0xA4755576, 0xA5B73F41,
0xA0F829C4, 0xA13A43F3, 0xA37CFDAA, 0xA2BE979D,
0xB5C473D0, 0xB40619E7, 0xB640A7BE, 0xB782CD89,
0xB2CDDB0C, 0xB30FB13B, 0xB1490F62, 0xB08B6555,
0xBBD72268, 0xBA15485F, 0xB853F606, 0xB9919C31,
0xBCDE8AB4, 0xBD1CE083, 0xBF5A5EDA, 0xBE9834ED,
/* T8_3 */
0x00000000, 0xB8BC6765, 0xAA09C88B, 0x12B5AFEE,
0x8F629757, 0x37DEF032, 0x256B5FDC, 0x9DD738B9,
0xC5B428EF, 0x7D084F8A, 0x6FBDE064, 0xD7018701,
0x4AD6BFB8, 0xF26AD8DD, 0xE0DF7733, 0x58631056,
0x5019579F, 0xE8A530FA, 0xFA109F14, 0x42ACF871,
0xDF7BC0C8, 0x67C7A7AD, 0x75720843, 0xCDCE6F26,
0x95AD7F70, 0x2D111815, 0x3FA4B7FB, 0x8718D09E,
0x1ACFE827, 0xA2738F42, 0xB0C620AC, 0x087A47C9,
0xA032AF3E, 0x188EC85B, 0x0A3B67B5, 0xB28700D0,
0x2F503869, 0x97EC5F0C, 0x8559F0E2, 0x3DE59787,
0x658687D1, 0xDD3AE0B4, 0xCF8F4F5A, 0x7733283F,
0xEAE41086, 0x525877E3, 0x40EDD80D, 0xF851BF68,
0xF02BF8A1, 0x48979FC4, 0x5A22302A, 0xE29E574F,
0x7F496FF6, 0xC7F50893, 0xD540A77D, 0x6DFCC018,
0x359FD04E, 0x8D23B72B, 0x9F9618C5, 0x272A7FA0,
0xBAFD4719, 0x0241207C, 0x10F48F92, 0xA848E8F7,
0x9B14583D, 0x23A83F58, 0x311D90B6, 0x89A1F7D3,
0x1476CF6A, 0xACCAA80F, 0xBE7F07E1, 0x06C36084,
0x5EA070D2, 0xE61C17B7, 0xF4A9B859, 0x4C15DF3C,
0xD1C2E785, 0x697E80E0, 0x7BCB2F0E, 0xC377486B,
0xCB0D0FA2, 0x73B168C7, 0x6104C729, 0xD9B8A04C,
0x446F98F5, 0xFCD3FF90, 0xEE66507E, 0x56DA371B,
0x0EB9274D, 0xB6054028, 0xA4B0EFC6, 0x1C0C88A3,
0x81DBB01A, 0x3967D77F, 0x2BD27891, 0x936E1FF4,
0x3B26F703, 0x839A9066, 0x912F3F88, 0x299358ED,
0xB4446054, 0x0CF80731, 0x1E4DA8DF, 0xA6F1CFBA,
0xFE92DFEC, 0x462EB889, 0x549B1767, 0xEC277002,
0x71F048BB, 0xC94C2FDE, 0xDBF98030, 0x6345E755,
0x6B3FA09C, 0xD383C7F9, 0xC1366817, 0x798A0F72,
0xE45D37CB, 0x5CE150AE, 0x4E54FF40, 0xF6E89825,
0xAE8B8873, 0x1637EF16, 0x048240F8, 0xBC3E279D,
0x21E91F24, 0x99557841, 0x8BE0D7AF, 0x335CB0CA,
0xED59B63B, 0x55E5D15E, 0x47507EB0, 0xFFEC19D5,
0x623B216C, 0xDA874609, 0xC832E9E7, 0x708E8E82,
0x28ED9ED4, 0x9051F9B1, 0x82E4565F, 0x3A58313A,
0xA78F0983, 0x1F336EE6, 0x0D86C108, 0xB53AA66D,
0xBD40E1A4, 0x05FC86C1, 0x1749292F, 0xAFF54E4A,
0x322276F3, 0x8A9E1196, 0x982BBE78, 0x2097D91D,
0x78F4C94B, 0xC048AE2E, 0xD2FD01C0, 0x6A4166A5,
0xF7965E1C, 0x4F2A3979, 0x5D9F9697, 0xE523F1F2,
0x4D6B1905, 0xF5D77E60, 0xE762D18E, 0x5FDEB6EB,
0xC2098E52, 0x7AB5E937, 0x680046D9, 0xD0BC21BC,
0x88DF31EA, 0x3063568F, 0x22D6F961, 0x9A6A9E04,
0x07BDA6BD, 0xBF01C1D8, 0xADB46E36, 0x15080953,
0x1D724E9A, 0xA5CE29FF, 0xB77B8611, 0x0FC7E174,
0x9210D9CD, 0x2AACBEA8, 0x38191146, 0x80A57623,
0xD8C66675, 0x607A0110, 0x72CFAEFE, 0xCA73C99B,
0x57A4F122, 0xEF189647, 0xFDAD39A9, 0x45115ECC,
0x764DEE06, 0xCEF18963, 0xDC44268D, 0x64F841E8,
0xF92F7951, 0x41931E34, 0x5326B1DA, 0xEB9AD6BF,
0xB3F9C6E9, 0x0B45A18C, 0x19F00E62, 0xA14C6907,
0x3C9B51BE, 0x842736DB, 0x96929935, 0x2E2EFE50,
0x2654B999, 0x9EE8DEFC, 0x8C5D7112, 0x34E11677,
0xA9362ECE, 0x118A49AB, 0x033FE645, 0xBB838120,
0xE3E09176, 0x5B5CF613, 0x49E959FD, 0xF1553E98,
0x6C820621, 0xD43E6144, 0xC68BCEAA, 0x7E37A9CF,
0xD67F4138, 0x6EC3265D, 0x7C7689B3, 0xC4CAEED6,
0x591DD66F, 0xE1A1B10A, 0xF3141EE4, 0x4BA87981,
0x13CB69D7, 0xAB770EB2, 0xB9C2A15C, 0x017EC639,
0x9CA9FE80, 0x241599E5, 0x36A0360B, 0x8E1C516E,
0x866616A7, 0x3EDA71C2, 0x2C6FDE2C, 0x94D3B949,
0x090481F0, 0xB1B8E695, 0xA30D497B, 0x1BB12E1E,
0x43D23E48, 0xFB6E592D, 0xE9DBF6C3, 0x516791A6,
0xCCB0A91F, 0x740CCE7A, 0x66B96194, 0xDE0506F1,
/* T8_4 */
0x00000000, 0x3D6029B0, 0x7AC05360, 0x47A07AD0,
0xF580A6C0, 0xC8E08F70, 0x8F40F5A0, 0xB220DC10,
0x30704BC1, 0x0D106271, 0x4AB018A1, 0x77D03111,
0xC5F0ED01, 0xF890C4B1, 0xBF30BE61, 0x825097D1,
0x60E09782, 0x5D80BE32, 0x1A20C4E2, 0x2740ED52,
0x95603142, 0xA80018F2, 0xEFA06222, 0xD2C04B92,
0x5090DC43, 0x6DF0F5F3, 0x2A508F23, 0x1730A693,
0xA5107A83, 0x98705333, 0xDFD029E3, 0xE2B00053,
0xC1C12F04, 0xFCA106B4, 0xBB017C64, 0x866155D4,
0x344189C4, 0x0921A074, 0x4E81DAA4, 0x73E1F314,
0xF1B164C5, 0xCCD14D75, 0x8B7137A5, 0xB6111E15,
0x0431C205, 0x3951EBB5, 0x7EF19165, 0x4391B8D5,
0xA121B886, 0x9C419136, 0xDBE1EBE6, 0xE681C256,
0x54A11E46, 0x69C137F6, 0x2E614D26, 0x13016496,
0x9151F347, 0xAC31DAF7, 0xEB91A027, 0xD6F18997,
0x64D15587, 0x59B17C37, 0x1E1106E7, 0x23712F57,
0x58F35849, 0x659371F9, 0x22330B29, 0x1F532299,
0xAD73FE89, 0x9013D739, 0xD7B3ADE9, 0xEAD38459,
0x68831388, 0x55E33A38, 0x124340E8, 0x2F236958,
0x9D03B548, 0xA0639CF8, 0xE7C3E628, 0xDAA3CF98,
0x3813CFCB, 0x0573E67B, 0x42D39CAB, 0x7FB3B51B,
0xCD93690B, 0xF0F340BB, 0xB7533A6B, 0x8A3313DB,
0x0863840A, 0x3503ADBA, 0x72A3D76A, 0x4FC3FEDA,
0xFDE322CA, 0xC0830B7A, 0x872371AA, 0xBA43581A,
0x9932774D, 0xA4525EFD, 0xE3F2242D, 0xDE920D9D,
0x6CB2D18D, 0x51D2F83D, 0x167282ED, 0x2B12AB5D,
0xA9423C8C, 0x9422153C, 0xD3826FEC, 0xEEE2465C,
0x5CC29A4C, 0x61A2B3FC, 0x2602C92C, 0x1B62E09C,
0xF9D2E0CF, 0xC4B2C97F, 0x8312B3AF, 0xBE729A1F,
0x0C52460F, 0x31326FBF, 0x7692156F, 0x4BF23CDF,
0xC9A2AB0E, 0xF4C282BE, 0xB362F86E, 0x8E02D1DE,
0x3C220DCE, 0x0142247E, 0x46E25EAE, 0x7B82771E,
0xB1E6B092, 0x8C869922, 0xCB26E3F2, 0xF646CA42,
0x44661652, 0x79063FE2, 0x3EA64532, 0x03C66C82,
0x8196FB53, 0xBCF6D2E3, 0xFB56A833, 0xC6368183,
0x74165D93, 0x49767423, 0x0ED60EF3, 0x33B62743,
0xD1062710, 0xEC660EA0, 0xABC67470, 0x96A65DC0,
0x248681D0, 0x19E6A860, 0x5E46D2B0, 0x6326FB00,
0xE1766CD1, 0xDC164561, 0x9BB63FB1, 0xA6D61601,
0x14F6CA11, 0x2996E3A1, 0x6E369971, 0x5356B0C1,
0x70279F96, 0x4D47B626, 0x0AE7CCF6, 0x3787E546,
0x85A73956, 0xB8C710E6, 0xFF676A36, 0xC2074386,
0x4057D457, 0x7D37FDE7, 0x3A978737, 0x07F7AE87,
0xB5D77297, 0x88B75B27, 0xCF1721F7, 0xF2770847,
0x10C70814, 0x2DA721A4, 0x6A075B74, 0x576772C4,
0xE547AED4, 0xD8278764, 0x9F87FDB4, 0xA2E7D404,
0x20B743D5, 0x1DD76A65, 0x5A7710B5, 0x67173905,
0xD537E515, 0xE857CCA5, 0xAFF7B675, 0x92979FC5,
0xE915E8DB, 0xD475C16B, 0x93D5BBBB, 0xAEB5920B,
0x1C954E1B, 0x21F567AB, 0x66551D7B, 0x5B3534CB,
0xD965A31A, 0xE4058AAA, 0xA3A5F07A, 0x9EC5D9CA,
0x2CE505DA, 0x11852C6A, 0x562556BA, 0x6B457F0A,
0x89F57F59, 0xB49556E9, 0xF3352C39, 0xCE550589,
0x7C75D999, 0x4115F029, 0x06B58AF9, 0x3BD5A349,
0xB9853498, 0x84E51D28, 0xC34567F8, 0xFE254E48,
0x4C059258, 0x7165BBE8, 0x36C5C138, 0x0BA5E888,
0x28D4C7DF, 0x15B4EE6F, 0x521494BF, 0x6F74BD0F,
0xDD54611F, 0xE03448AF, 0xA794327F, 0x9AF41BCF,
0x18A48C1E, 0x25C4A5AE, 0x6264DF7E, 0x5F04F6CE,
0xED242ADE, 0xD044036E, 0x97E479BE, 0xAA84500E,
0x4834505D, 0x755479ED, 0x32F4033D, 0x0F942A8D,
0xBDB4F69D, 0x80D4DF2D, 0xC774A5FD, 0xFA148C4D,
0x78441B9C, 0x4524322C, 0x028448FC, 0x3FE4614C,
0x8DC4BD5C, 0xB0A494EC, 0xF704EE3C, 0xCA64C78C,
/* T8_5 */
0x00000000, 0xCB5CD3A5, 0x4DC8A10B, 0x869472AE,
0x9B914216, 0x50CD91B3, 0xD659E31D, 0x1D0530B8,
0xEC53826D, 0x270F51C8, 0xA19B2366, 0x6AC7F0C3,
0x77C2C07B, 0xBC9E13DE, 0x3A0A6170, 0xF156B2D5,
0x03D6029B, 0xC88AD13E, 0x4E1EA390, 0x85427035,
0x9847408D, 0x531B9328, 0xD58FE186, 0x1ED33223,
0xEF8580F6, 0x24D95353, 0xA24D21FD, 0x6911F258,
0x7414C2E0, 0xBF481145, 0x39DC63EB, 0xF280B04E,
0x07AC0536, 0xCCF0D693, 0x4A64A43D, 0x81387798,
0x9C3D4720, 0x57619485, 0xD1F5E62B, 0x1AA9358E,
0xEBFF875B, 0x20A354FE, 0xA6372650, 0x6D6BF5F5,
0x706EC54D, 0xBB3216E8, 0x3DA66446, 0xF6FAB7E3,
0x047A07AD, 0xCF26D408, 0x49B2A6A6, 0x82EE7503,
0x9FEB45BB, 0x54B7961E, 0xD223E4B0, 0x197F3715,
0xE82985C0, 0x23755665, 0xA5E124CB, 0x6EBDF76E,
0x73B8C7D6, 0xB8E41473, 0x3E7066DD, 0xF52CB578,
0x0F580A6C, 0xC404D9C9, 0x4290AB67, 0x89CC78C2,
0x94C9487A, 0x5F959BDF, 0xD901E971, 0x125D3AD4,
0xE30B8801, 0x28575BA4, 0xAEC3290A, 0x659FFAAF,
0x789ACA17, 0xB3C619B2, 0x35526B1C, 0xFE0EB8B9,
0x0C8E08F7, 0xC7D2DB52, 0x4146A9FC, 0x8A1A7A59,
0x971F4AE1, 0x5C439944, 0xDAD7EBEA, 0x118B384F,
0xE0DD8A9A, 0x2B81593F, 0xAD152B91, 0x6649F834,
0x7B4CC88C, 0xB0101B29, 0x36846987, 0xFDD8BA22,
0x08F40F5A, 0xC3A8DCFF, 0x453CAE51, 0x8E607DF4,
0x93654D4C, 0x58399EE9, 0xDEADEC47, 0x15F13FE2,
0xE4A78D37, 0x2FFB5E92, 0xA96F2C3C, 0x6233FF99,
0x7F36CF21, 0xB46A1C84, 0x32FE6E2A, 0xF9A2BD8F,
0x0B220DC1, 0xC07EDE64, 0x46EAACCA, 0x8DB67F6F,
0x90B34FD7, 0x5BEF9C72, 0xDD7BEEDC, 0x16273D79,
0xE7718FAC, 0x2C2D5C09, 0xAAB92EA7, 0x61E5FD02,
0x7CE0CDBA, 0xB7BC1E1F, 0x31286CB1, 0xFA74BF14,
0x1EB014D8, 0xD5ECC77D, 0x5378B5D3, 0x98246676,
0x852156CE, 0x4E7D856B, 0xC8E9F7C5, 0x03B52460,
0xF2E396B5, 0x39BF4510, 0xBF2B37BE, 0x7477E41B,
0x6972D4A3, 0xA22E0706, 0x24BA75A8, 0xEFE6A60D,
0x1D661643, 0xD63AC5E6, 0x50AEB748, 0x9BF264ED,
0x86F75455, 0x4DAB87F0, 0xCB3FF55E, 0x006326FB,
0xF135942E, 0x3A69478B, 0xBCFD3525, 0x77A1E680,
0x6AA4D638, 0xA1F8059D, 0x276C7733, 0xEC30A496,
0x191C11EE, 0xD240C24B, 0x54D4B0E5, 0x9F886340,
0x828D53F8, 0x49D1805D, 0xCF45F2F3, 0x04192156,
0xF54F9383, 0x3E134026, 0xB8873288, 0x73DBE12D,
0x6EDED195, 0xA5820230, 0x2316709E, 0xE84AA33B,
0x1ACA1375, 0xD196C0D0, 0x5702B27E, 0x9C5E61DB,
0x815B5163, 0x4A0782C6, 0xCC93F068, 0x07CF23CD,
0xF6999118, 0x3DC542BD, 0xBB513013, 0x700DE3B6,
0x6D08D30E, 0xA65400AB, 0x20C07205, 0xEB9CA1A0,
0x11E81EB4, 0xDAB4CD11, 0x5C20BFBF, 0x977C6C1A,
0x8A795CA2, 0x41258F07, 0xC7B1FDA9, 0x0CED2E0C,
0xFDBB9CD9, 0x36E74F7C, 0xB0733DD2, 0x7B2FEE77,
0x662ADECF, 0xAD760D6A, 0x2BE27FC4, 0xE0BEAC61,
0x123E1C2F, 0xD962CF8A, 0x5FF6BD24, 0x94AA6E81,
0x89AF5E39, 0x42F38D9C, 0xC467FF32, 0x0F3B2C97,
0xFE6D9E42, 0x35314DE7, 0xB3A53F49, 0x78F9ECEC,
0x65FCDC54, 0xAEA00FF1, 0x28347D5F, 0xE368AEFA,
0x16441B82, 0xDD18C827, 0x5B8CBA89, 0x90D0692C,
0x8DD55994, 0x46898A31, 0xC01DF89F, 0x0B412B3A,
0xFA1799EF, 0x314B4A4A, 0xB7DF38E4, 0x7C83EB41,
0x6186DBF9, 0xAADA085C, 0x2C4E7AF2, 0xE712A957,
0x15921919, 0xDECECABC, 0x585AB812, 0x93066BB7,
0x8E035B0F, 0x455F88AA, 0xC3CBFA04, 0x089729A1,
0xF9C19B74, 0x329D48D1, 0xB4093A7F, 0x7F55E9DA,
0x6250D962, 0xA90C0AC7, 0x2F987869, 0xE4C4ABCC,
/* T8_6 */
0x00000000, 0xA6770BB4, 0x979F1129, 0x31E81A9D,
0xF44F2413, 0x52382FA7, 0x63D0353A, 0xC5A73E8E,
0x33EF4E67, 0x959845D3, 0xA4705F4E, 0x020754FA,
0xC7A06A74, 0x61D761C0, 0x503F7B5D, 0xF64870E9,
0x67DE9CCE, 0xC1A9977A, 0xF0418DE7, 0x56368653,
0x9391B8DD, 0x35E6B369, 0x040EA9F4, 0xA279A240,
0x5431D2A9, 0xF246D91D, 0xC3AEC380, 0x65D9C834,
0xA07EF6BA, 0x0609FD0E, 0x37E1E793, 0x9196EC27,
0xCFBD399C, 0x69CA3228, 0x582228B5, 0xFE552301,
0x3BF21D8F, 0x9D85163B, 0xAC6D0CA6, 0x0A1A0712,
0xFC5277FB, 0x5A257C4F, 0x6BCD66D2, 0xCDBA6D66,
0x081D53E8, 0xAE6A585C, 0x9F8242C1, 0x39F54975,
0xA863A552, 0x0E14AEE6, 0x3FFCB47B, 0x998BBFCF,
0x5C2C8141, 0xFA5B8AF5, 0xCBB39068, 0x6DC49BDC,
0x9B8CEB35, 0x3DFBE081, 0x0C13FA1C, 0xAA64F1A8,
0x6FC3CF26, 0xC9B4C492, 0xF85CDE0F, 0x5E2BD5BB,
0x440B7579, 0xE27C7ECD, 0xD3946450, 0x75E36FE4,
0xB044516A, 0x16335ADE, 0x27DB4043, 0x81AC4BF7,
0x77E43B1E, 0xD19330AA, 0xE07B2A37, 0x460C2183,
0x83AB1F0D, 0x25DC14B9, 0x14340E24, 0xB2430590,
0x23D5E9B7, 0x85A2E203, 0xB44AF89E, 0x123DF32A,
0xD79ACDA4, 0x71EDC610, 0x4005DC8D, 0xE672D739,
0x103AA7D0, 0xB64DAC64, 0x87A5B6F9, 0x21D2BD4D,
0xE47583C3, 0x42028877, 0x73EA92EA, 0xD59D995E,
0x8BB64CE5, 0x2DC14751, 0x1C295DCC, 0xBA5E5678,
0x7FF968F6, 0xD98E6342, 0xE86679DF, 0x4E11726B,
0xB8590282, 0x1E2E0936, 0x2FC613AB, 0x89B1181F,
0x4C162691, 0xEA612D25, 0xDB8937B8, 0x7DFE3C0C,
0xEC68D02B, 0x4A1FDB9F, 0x7BF7C102, 0xDD80CAB6,
0x1827F438, 0xBE50FF8C, 0x8FB8E511, 0x29CFEEA5,
0xDF879E4C, 0x79F095F8, 0x48188F65, 0xEE6F84D1,
0x2BC8BA5F, 0x8DBFB1EB, 0xBC57AB76, 0x1A20A0C2,
0x8816EAF2, 0x2E61E146, 0x1F89FBDB, 0xB9FEF06F,
0x7C59CEE1, 0xDA2EC555, 0xEBC6DFC8, 0x4DB1D47C,
0xBBF9A495, 0x1D8EAF21, 0x2C66B5BC, 0x8A11BE08,
0x4FB68086, 0xE9C18B32, 0xD82991AF, 0x7E5E9A1B,
0xEFC8763C, 0x49BF7D88, 0x78576715, 0xDE206CA1,
0x1B87522F, 0xBDF0599B, 0x8C184306, 0x2A6F48B2,
0xDC27385B, 0x7A5033EF, 0x4BB82972, 0xEDCF22C6,
0x28681C48, 0x8E1F17FC, 0xBFF70D61, 0x198006D5,
0x47ABD36E, 0xE1DCD8DA, 0xD034C247, 0x7643C9F3,
0xB3E4F77D, 0x1593FCC9, 0x247BE654, 0x820CEDE0,
0x74449D09, 0xD23396BD, 0xE3DB8C20, 0x45AC8794,
0x800BB91A, 0x267CB2AE, 0x1794A833, 0xB1E3A387,
0x20754FA0, 0x86024414, 0xB7EA5E89, 0x119D553D,
0xD43A6BB3, 0x724D6007, 0x43A57A9A, 0xE5D2712E,
0x139A01C7, 0xB5ED0A73, 0x840510EE, 0x22721B5A,
0xE7D525D4, 0x41A22E60, 0x704A34FD, 0xD63D3F49,
0xCC1D9F8B, 0x6A6A943F, 0x5B828EA2, 0xFDF58516,
0x3852BB98, 0x9E25B02C, 0xAFCDAAB1, 0x09BAA105,
0xFFF2D1EC, 0x5985DA58, 0x686DC0C5, 0xCE1ACB71,
0x0BBDF5FF, 0xADCAFE4B, 0x9C22E4D6, 0x3A55EF62,
0xABC30345, 0x0DB408F1, 0x3C5C126C, 0x9A2B19D8,
0x5F8C2756, 0xF9FB2CE2, 0xC813367F, 0x6E643DCB,
0x982C4D22, 0x3E5B4696, 0x0FB35C0B, 0xA9C457BF,
0x6C636931, 0xCA146285, 0xFBFC7818, 0x5D8B73AC,
0x03A0A617, 0xA5D7ADA3, 0x943FB73E, 0x3248BC8A,
0xF7EF8204, 0x519889B0, 0x6070932D, 0xC6079899,
0x304FE870, 0x9638E3C4, 0xA7D0F959, 0x01A7F2ED,
0xC400CC63, 0x6277C7D7, 0x539FDD4A, 0xF5E8D6FE,
0x647E3AD9, 0xC209316D, 0xF3E12BF0, 0x55962044,
0x90311ECA, 0x3646157E, 0x07AE0FE3, 0xA1D90457,
0x579174BE, 0xF1E67F0A, 0xC00E6597, 0x66796E23,
0xA3DE50AD, 0x05A95B19, 0x34414184, 0x92364A30,
/* T8_7 */
0x00000000, 0xCCAA009E, 0x4225077D, 0x8E8F07E3,
0x844A0EFA, 0x48E00E64, 0xC66F0987, 0x0AC50919,
0xD3E51BB5, 0x1F4F1B2B, 0x91C01CC8, 0x5D6A1C56,
0x57AF154F, 0x9B0515D1, 0x158A1232, 0xD92012AC,
0x7CBB312B, 0xB01131B5, 0x3E9E3656, 0xF23436C8,
0xF8F13FD1, 0x345B3F4F, 0xBAD438AC, 0x767E3832,
0xAF5E2A9E, 0x63F42A00, 0xED7B2DE3, 0x21D12D7D,
0x2B142464, 0xE7BE24FA, 0x69312319, 0xA59B2387,
0xF9766256, 0x35DC62C8, 0xBB53652B, 0x77F965B5,
0x7D3C6CAC, 0xB1966C32, 0x3F196BD1, 0xF3B36B4F,
0x2A9379E3, 0xE639797D, 0x68B67E9E, 0xA41C7E00,
0xAED97719, 0x62737787, 0xECFC7064, 0x205670FA,
0x85CD537D, 0x496753E3, 0xC7E85400, 0x0B42549E,
0x01875D87, 0xCD2D5D19, 0x43A25AFA, 0x8F085A64,
0x562848C8, 0x9A824856, 0x140D4FB5, 0xD8A74F2B,
0xD2624632, 0x1EC846AC, 0x9047414F, 0x5CED41D1,
0x299DC2ED, 0xE537C273, 0x6BB8C590, 0xA712C50E,
0xADD7CC17, 0x617DCC89, 0xEFF2CB6A, 0x2358CBF4,
0xFA78D958, 0x36D2D9C6, 0xB85DDE25, 0x74F7DEBB,
0x7E32D7A2, 0xB298D73C, 0x3C17D0DF, 0xF0BDD041,
0x5526F3C6, 0x998CF358, 0x1703F4BB, 0xDBA9F425,
0xD16CFD3C, 0x1DC6FDA2, 0x9349FA41, 0x5FE3FADF,
0x86C3E873, 0x4A69E8ED, 0xC4E6EF0E, 0x084CEF90,
0x0289E689, 0xCE23E617, 0x40ACE1F4, 0x8C06E16A,
0xD0EBA0BB, 0x1C41A025, 0x92CEA7C6, 0x5E64A758,
0x54A1AE41, 0x980BAEDF, 0x1684A93C, 0xDA2EA9A2,
0x030EBB0E, 0xCFA4BB90, 0x412BBC73, 0x8D81BCED,
0x8744B5F4, 0x4BEEB56A, 0xC561B289, 0x09CBB217,
0xAC509190, 0x60FA910E, 0xEE7596ED, 0x22DF9673,
0x281A9F6A, 0xE4B09FF4, 0x6A3F9817, 0xA6959889,
0x7FB58A25, 0xB31F8ABB, 0x3D908D58, 0xF13A8DC6,
0xFBFF84DF, 0x37558441, 0xB9DA83A2, 0x7570833C,
0x533B85DA, 0x9F918544, 0x111E82A7, 0xDDB48239,
0xD7718B20, 0x1BDB8BBE, 0x95548C5D, 0x59FE8CC3,
0x80DE9E6F, 0x4C749EF1, 0xC2FB9912, 0x0E51998C,
0x04949095, 0xC83E900B, 0x46B197E8, 0x8A1B9776,
0x2F80B4F1, 0xE32AB46F, 0x6DA5B38C, 0xA10FB312,
0xABCABA0B, 0x6760BA95, 0xE9EFBD76, 0x2545BDE8,
0xFC65AF44, 0x30CFAFDA, 0xBE40A839, 0x72EAA8A7,
0x782FA1BE, 0xB485A120, 0x3A0AA6C3, 0xF6A0A65D,
0xAA4DE78C, 0x66E7E712, 0xE868E0F1, 0x24C2E06F,
0x2E07E976, 0xE2ADE9E8, 0x6C22EE0B, 0xA088EE95,
0x79A8FC39, 0xB502FCA7, 0x3B8DFB44, 0xF727FBDA,
0xFDE2F2C3, 0x3148F25D, 0xBFC7F5BE, 0x736DF520,
0xD6F6D6A7, 0x1A5CD639, 0x94D3D1DA, 0x5879D144,
0x52BCD85D, 0x9E16D8C3, 0x1099DF20, 0xDC33DFBE,
0x0513CD12, 0xC9B9CD8C, 0x4736CA6F, 0x8B9CCAF1,
0x8159C3E8, 0x4DF3C376, 0xC37CC495, 0x0FD6C40B,
0x7AA64737, 0xB60C47A9, 0x3883404A, 0xF42940D4,
0xFEEC49CD, 0x32464953, 0xBCC94EB0, 0x70634E2E,
0xA9435C82, 0x65E95C1C, 0xEB665BFF, 0x27CC5B61,
0x2D095278, 0xE1A352E6, 0x6F2C5505, 0xA386559B,
0x061D761C, 0xCAB77682, 0x44387161, 0x889271FF,
0x825778E6, 0x4EFD7878, 0xC0727F9B, 0x0CD87F05,
0xD5F86DA9, 0x19526D37, 0x97DD6AD4, 0x5B776A4A,
0x51B26353, 0x9D1863CD, 0x1397642E, 0xDF3D64B0,
0x83D02561, 0x4F7A25FF, 0xC1F5221C, 0x0D5F2282,
0x079A2B9B, 0xCB302B05, 0x45BF2CE6, 0x89152C78,
0x50353ED4, 0x9C9F3E4A, 0x121039A9, 0xDEBA3937,
0xD47F302E, 0x18D530B0, 0x965A3753, 0x5AF037CD,
0xFF6B144A, 0x33C114D4, 0xBD4E1337, 0x71E413A9,
0x7B211AB0, 0xB78B1A2E, 0x39041DCD, 0xF5AE1D53,
0x2C8E0FFF, 0xE0240F61, 0x6EAB0882, 0xA201081C,
0xA8C40105, 0x646E019B, 0xEAE10678, 0x264B06E6
};
/**
* the current CRC value, bit-flipped
*/
private int crc;
private SdkCrc32() {
reset();
}
private SdkCrc32(int crc) {
this.crc = crc;
}
public static SdkCrc32 create() {
return new SdkCrc32();
}
@Override
public long getValue() {
return (~crc) & 0xffffffffL;
}
@Override
public void reset() {
crc = 0xffffffff;
}
@Override
public void update(byte[] b, int offset, int len) {
int localCrc = crc;
int remainder = len & 0x7;
int i = offset;
for (int end = offset + len - remainder; i < end; i += 8) {
int x = localCrc ^
((((b[i] << 24) >>> 24) + ((b[i + 1] << 24) >>> 16)) +
(((b[i + 2] << 24) >>> 8) + (b[i + 3] << 24)));
localCrc = ((T[((x << 24) >>> 24) + 0x700] ^ T[((x << 16) >>> 24) + 0x600]) ^
(T[((x << 8) >>> 24) + 0x500] ^ T[(x >>> 24) + 0x400])) ^
((T[((b[i + 4] << 24) >>> 24) + 0x300] ^ T[((b[i + 5] << 24) >>> 24) + 0x200]) ^
(T[((b[i + 6] << 24) >>> 24) + 0x100] ^ T[((b[i + 7] << 24) >>> 24)]));
}
/* loop unroll - duff's device style */
for (int index = 0; index < remainder; index++) {
localCrc = (localCrc >>> 8) ^ T[((localCrc ^ b[i++]) << 24) >>> 24];
}
// Publish crc out to object
crc = localCrc;
}
@Override
public void update(int b) {
crc = (crc >>> 8) ^ T[(((crc ^ b) << 24) >>> 24)];
}
@Override
public Object clone() {
return new SdkCrc32(crc);
}
} | 1,942 |
0 | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/checksums | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/checksums/factory/CrtBasedChecksumProvider.java | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.awssdk.core.internal.checksums.factory;
import java.util.Optional;
import java.util.zip.Checksum;
import software.amazon.awssdk.annotations.SdkInternalApi;
import software.amazon.awssdk.core.internal.util.ClassLoaderHelper;
import software.amazon.awssdk.utils.Lazy;
import software.amazon.awssdk.utils.Logger;
/**
* Class to load the Crt based checksum from aws-crt-java library if it is present in class path.
*/
@SdkInternalApi
public final class CrtBasedChecksumProvider {
public static final Logger LOG = Logger.loggerFor(CrtBasedChecksumProvider.class);
private static final String CRT_CLASSPATH_FOR_CRC32C = "software.amazon.awssdk.crt.checksums.CRC32C";
private static final String CRT_CLASSPATH_FOR_CRC32 = "software.amazon.awssdk.crt.checksums.CRC32";
private static final Lazy<Optional<Class<?>>> CRT_CRC32_CLASS_LOADER =
new Lazy<>(() -> initializeCrtChecksumClass(CRT_CLASSPATH_FOR_CRC32));
private static final Lazy<Optional<Class<?>>> CRT_CRC32_C_CLASS_LOADER =
new Lazy<>(() -> initializeCrtChecksumClass(CRT_CLASSPATH_FOR_CRC32C));
private CrtBasedChecksumProvider() {
}
public static Checksum createCrc32() {
return createCrtBasedChecksum(CRT_CRC32_CLASS_LOADER);
}
public static Checksum createCrc32C() {
return createCrtBasedChecksum(CRT_CRC32_C_CLASS_LOADER);
}
private static Checksum createCrtBasedChecksum(Lazy<Optional<Class<?>>> lazyClassLoader) {
return lazyClassLoader.getValue().map(
checksumClass -> {
try {
return (Checksum) checksumClass.getDeclaredConstructor().newInstance();
} catch (ReflectiveOperationException e) {
return null;
}
}).orElse(null);
}
private static Optional<Class<?>> initializeCrtChecksumClass(String classPath) {
try {
return Optional.of(ClassLoaderHelper.loadClass(classPath, false));
} catch (ClassNotFoundException e) {
LOG.debug(() -> "Cannot find the " + classPath + " class."
+ " To invoke a request that requires a CRT based checksums.", e);
return Optional.empty();
}
}
}
| 1,943 |
0 | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http/TransformingAsyncResponseHandler.java | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.awssdk.core.internal.http;
import java.util.concurrent.CompletableFuture;
import software.amazon.awssdk.annotations.SdkInternalApi;
import software.amazon.awssdk.http.async.SdkAsyncHttpResponseHandler;
/**
* A response handler that returns a transformed response.
*
* @param <ResultT> The type of the result.
*/
@SdkInternalApi
public interface TransformingAsyncResponseHandler<ResultT> extends SdkAsyncHttpResponseHandler {
/**
* Return the future holding the transformed response.
* <p>
* This method is guaranteed to be called before the request is executed, and before {@link
* SdkAsyncHttpResponseHandler#onHeaders(software.amazon.awssdk.http.SdkHttpResponse)} is signaled.
*
* @return The future holding the transformed response.
*/
CompletableFuture<ResultT> prepare();
}
| 1,944 |
0 | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http/StreamManagingStage.java | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.awssdk.core.internal.http;
import static software.amazon.awssdk.utils.FunctionalUtils.invokeSafely;
import java.io.InputStream;
import software.amazon.awssdk.annotations.SdkInternalApi;
import software.amazon.awssdk.core.Response;
import software.amazon.awssdk.core.internal.http.pipeline.RequestPipeline;
import software.amazon.awssdk.core.io.ReleasableInputStream;
import software.amazon.awssdk.http.ContentStreamProvider;
import software.amazon.awssdk.http.SdkHttpFullRequest;
import software.amazon.awssdk.utils.Logger;
/**
* Adds additional wrapping around the request {@link ContentStreamProvider}.
* <p>
* Currently, it ensures that the stream returned by the provider is not closeable.
*
* @param <OutputT> Type of unmarshalled response
*/
@SdkInternalApi
public final class StreamManagingStage<OutputT> implements RequestPipeline<SdkHttpFullRequest, Response<OutputT>> {
private static final Logger log = Logger.loggerFor(StreamManagingStage.class);
private final RequestPipeline<SdkHttpFullRequest, Response<OutputT>> wrapped;
public StreamManagingStage(RequestPipeline<SdkHttpFullRequest, Response<OutputT>> wrapped) {
this.wrapped = wrapped;
}
@Override
public Response<OutputT> execute(SdkHttpFullRequest request, RequestExecutionContext context) throws Exception {
ClosingStreamProvider toBeClosed = null;
if (request.contentStreamProvider().isPresent()) {
toBeClosed = createManagedProvider(request.contentStreamProvider().get());
request = request.toBuilder().contentStreamProvider(toBeClosed).build();
}
try {
InterruptMonitor.checkInterrupted();
return wrapped.execute(request, context);
} finally {
if (toBeClosed != null) {
toBeClosed.closeCurrentStream();
}
}
}
private static ClosingStreamProvider createManagedProvider(ContentStreamProvider contentStreamProvider) {
return new ClosingStreamProvider(contentStreamProvider);
}
private static class ClosingStreamProvider implements ContentStreamProvider {
private final ContentStreamProvider wrapped;
private InputStream currentStream;
ClosingStreamProvider(ContentStreamProvider wrapped) {
this.wrapped = wrapped;
}
@Override
public InputStream newStream() {
currentStream = wrapped.newStream();
return ReleasableInputStream.wrap(currentStream).disableClose();
}
void closeCurrentStream() {
if (currentStream != null) {
invokeSafely(currentStream::close);
currentStream = null;
}
}
}
}
| 1,945 |
0 | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http/HttpClientDependencies.java | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.awssdk.core.internal.http;
import static software.amazon.awssdk.utils.Validate.paramNotNull;
import java.util.function.Consumer;
import software.amazon.awssdk.annotations.SdkInternalApi;
import software.amazon.awssdk.core.client.config.SdkClientConfiguration;
import software.amazon.awssdk.core.internal.http.pipeline.RequestPipeline;
import software.amazon.awssdk.core.internal.http.pipeline.RequestPipelineBuilder;
import software.amazon.awssdk.core.internal.retry.ClockSkewAdjuster;
import software.amazon.awssdk.utils.SdkAutoCloseable;
/**
* Client scoped dependencies of {@link AmazonSyncHttpClient} and {@link AmazonAsyncHttpClient}.
* May be injected into constructors of {@link RequestPipeline} implementations by {@link RequestPipelineBuilder}.
*/
@SdkInternalApi
public final class HttpClientDependencies implements SdkAutoCloseable {
/**
* Time offset may be mutated by {@link RequestPipeline} implementations if a clock skew is detected.
*/
private final SdkClientTime sdkClientTime;
private final ClockSkewAdjuster clockSkewAdjuster;
private final SdkClientConfiguration clientConfiguration;
private HttpClientDependencies(Builder builder) {
this.sdkClientTime = builder.sdkClientTime != null ? builder.sdkClientTime : new SdkClientTime();
this.clockSkewAdjuster = builder.clockSkewAdjuster != null ? builder.clockSkewAdjuster : new ClockSkewAdjuster();
this.clientConfiguration = paramNotNull(builder.clientConfiguration, "ClientConfiguration");
}
public static Builder builder() {
return new Builder();
}
public SdkClientConfiguration clientConfiguration() {
return clientConfiguration;
}
/**
* @return The adjuster used for adjusting the {@link #timeOffset} for this client.
*/
public ClockSkewAdjuster clockSkewAdjuster() {
return clockSkewAdjuster;
}
/**
* @return Current time offset. This is mutable and should not be cached.
*/
public int timeOffset() {
return sdkClientTime.getTimeOffset();
}
/**
* Updates the time offset of the client as well as the global time offset.
*/
public void updateTimeOffset(int timeOffset) {
sdkClientTime.setTimeOffset(timeOffset);
}
public Builder toBuilder() {
return new Builder(this);
}
@Override
public void close() {
this.clientConfiguration.close();
}
/**
* Builder for {@link HttpClientDependencies}.
*/
public static class Builder {
private SdkClientTime sdkClientTime;
private ClockSkewAdjuster clockSkewAdjuster;
private SdkClientConfiguration clientConfiguration;
private Builder() {
}
private Builder(HttpClientDependencies from) {
this.sdkClientTime = from.sdkClientTime;
this.clientConfiguration = from.clientConfiguration;
this.clockSkewAdjuster = from.clockSkewAdjuster;
}
public Builder clockSkewAdjuster(ClockSkewAdjuster clockSkewAdjuster) {
this.clockSkewAdjuster = clockSkewAdjuster;
return this;
}
public Builder clientConfiguration(SdkClientConfiguration clientConfiguration) {
this.clientConfiguration = clientConfiguration;
return this;
}
public Builder clientConfiguration(Consumer<SdkClientConfiguration.Builder> clientConfiguration) {
SdkClientConfiguration.Builder c = SdkClientConfiguration.builder();
clientConfiguration.accept(c);
clientConfiguration(c.build());
return this;
}
public HttpClientDependencies build() {
return new HttpClientDependencies(this);
}
}
}
| 1,946 |
0 | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http/InterruptMonitor.java | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.awssdk.core.internal.http;
import software.amazon.awssdk.annotations.SdkInternalApi;
import software.amazon.awssdk.core.exception.SdkInterruptedException;
import software.amazon.awssdk.http.SdkHttpFullResponse;
/**
* A set of utilities for monitoring the status of the currently-executing SDK thread. This is useful for periodically checking
* whether our thread has been interrupted so that we can abort execution of a request.
*/
@SdkInternalApi
public final class InterruptMonitor {
private InterruptMonitor() {
}
/**
* Check if the thread has been interrupted. If so throw an {@link InterruptedException}.
* Long running tasks should be periodically checked if the current thread has been
* interrupted and handle it appropriately
*
* @throws InterruptedException If thread has been interrupted
*/
public static void checkInterrupted() throws InterruptedException {
if (Thread.interrupted()) {
throw new SdkInterruptedException();
}
}
/**
* Check if the thread has been interrupted. If so throw an {@link InterruptedException}.
* Long running tasks should be periodically checked if the current thread has been
* interrupted and handle it appropriately
*
* @param response Response to be closed before returning control to the caller to avoid
* leaking the connection.
* @throws InterruptedException If thread has been interrupted
*/
public static void checkInterrupted(SdkHttpFullResponse response) throws InterruptedException {
if (Thread.interrupted()) {
throw new SdkInterruptedException(response);
}
}
}
| 1,947 |
0 | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http/CombinedResponseHandler.java | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.awssdk.core.internal.http;
import static software.amazon.awssdk.core.SdkStandardLogger.logRequestId;
import java.io.IOException;
import java.util.Optional;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import software.amazon.awssdk.annotations.SdkInternalApi;
import software.amazon.awssdk.core.Response;
import software.amazon.awssdk.core.exception.RetryableException;
import software.amazon.awssdk.core.exception.SdkClientException;
import software.amazon.awssdk.core.exception.SdkException;
import software.amazon.awssdk.core.http.HttpResponseHandler;
import software.amazon.awssdk.core.interceptor.ExecutionAttributes;
import software.amazon.awssdk.http.SdkHttpFullResponse;
import software.amazon.awssdk.utils.IoUtils;
/**
* Unmarshalls an HTTP response into either a successful response POJO, or into a (possibly modeled) exception based
* on the status code of the HTTP response. Returns a wrapper {@link Response} object which may contain either the
* unmarshalled success POJO, or the unmarshalled exception. Can be used with streaming or non-streaming requests.
*
* @param <OutputT> Type of successful unmarshalled POJO.
*/
@SdkInternalApi
public class CombinedResponseHandler<OutputT> implements HttpResponseHandler<Response<OutputT>> {
private static final Logger log = LoggerFactory.getLogger(CombinedResponseHandler.class);
private final HttpResponseHandler<OutputT> successResponseHandler;
private final HttpResponseHandler<? extends SdkException> errorResponseHandler;
public CombinedResponseHandler(HttpResponseHandler<OutputT> successResponseHandler,
HttpResponseHandler<? extends SdkException> errorResponseHandler) {
this.successResponseHandler = successResponseHandler;
this.errorResponseHandler = errorResponseHandler;
}
@Override
public Response<OutputT> handle(SdkHttpFullResponse httpResponse, ExecutionAttributes executionAttributes)
throws Exception {
boolean didRequestFail = true;
try {
Response<OutputT> response = handleResponse(httpResponse, executionAttributes);
didRequestFail = !response.isSuccess();
return response;
} finally {
closeInputStreamIfNeeded(httpResponse, didRequestFail);
}
}
private Response<OutputT> handleResponse(SdkHttpFullResponse httpResponse,
ExecutionAttributes executionAttributes)
throws IOException, InterruptedException {
logRequestId(httpResponse);
if (httpResponse.isSuccessful()) {
OutputT response = handleSuccessResponse(httpResponse, executionAttributes);
return Response.<OutputT>builder().httpResponse(httpResponse)
.response(response)
.isSuccess(true)
.build();
} else {
return Response.<OutputT>builder().httpResponse(httpResponse)
.exception(handleErrorResponse(httpResponse, executionAttributes))
.isSuccess(false)
.build();
}
}
/**
* Handles a successful response from a service call by unmarshalling the results using the
* specified response handler.
*
* @return The contents of the response, unmarshalled using the specified response handler.
* @throws IOException If any problems were encountered reading the response contents from
* the HTTP method object.
*/
private OutputT handleSuccessResponse(SdkHttpFullResponse httpResponse, ExecutionAttributes executionAttributes)
throws IOException, InterruptedException {
try {
return successResponseHandler.handle(httpResponse, executionAttributes);
} catch (IOException | InterruptedException | RetryableException e) {
throw e;
} catch (Exception e) {
if (e instanceof SdkException && ((SdkException) e).retryable()) {
throw (SdkException) e;
}
String errorMessage =
"Unable to unmarshall response (" + e.getMessage() + "). Response Code: "
+ httpResponse.statusCode() + ", Response Text: " + httpResponse.statusText().orElse(null);
throw SdkClientException.builder().message(errorMessage).cause(e).build();
}
}
/**
* Responsible for handling an error response, including unmarshalling the error response
* into the most specific exception type possible, and throwing the exception.
*
* @throws IOException If any problems are encountering reading the error response.
*/
private SdkException handleErrorResponse(SdkHttpFullResponse httpResponse,
ExecutionAttributes executionAttributes)
throws IOException, InterruptedException {
try {
SdkException exception = errorResponseHandler.handle(httpResponse, executionAttributes);
exception.fillInStackTrace();
return exception;
} catch (InterruptedException | IOException e) {
throw e;
} catch (Exception e) {
String errorMessage = String.format("Unable to unmarshall error response (%s). " +
"Response Code: %d, Response Text: %s", e.getMessage(),
httpResponse.statusCode(), httpResponse.statusText().orElse("null"));
throw SdkClientException.builder().message(errorMessage).cause(e).build();
}
}
/**
* Close the input stream if required.
*/
private void closeInputStreamIfNeeded(SdkHttpFullResponse httpResponse,
boolean didRequestFail) {
// Always close on failed requests. Close on successful requests unless it needs connection left open
if (didRequestFail || !successResponseHandler.needsConnectionLeftOpen()) {
Optional.ofNullable(httpResponse)
.flatMap(SdkHttpFullResponse::content) // If no content, no need to close
.ifPresent(s -> IoUtils.closeQuietly(s, log));
}
}
}
| 1,948 |
0 | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http/SdkClientTime.java | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.awssdk.core.internal.http;
import software.amazon.awssdk.annotations.SdkInternalApi;
import software.amazon.awssdk.core.SdkGlobalTime;
import software.amazon.awssdk.core.internal.http.pipeline.RequestPipeline;
/**
* Used for clock skew adjustment between the client JVM where the SDK is run, and the server side. This class mirrors
* {@link SdkGlobalTime} but it's local to the current client and only accessed internally by {@link HttpClientDependencies}.
*/
@SdkInternalApi
public final class SdkClientTime {
/**
* Time offset may be mutated by {@link RequestPipeline} implementations if a clock skew is detected.
*/
private volatile int timeOffset = SdkGlobalTime.getGlobalTimeOffset();
/**
* Gets the latest recorded time offset.
*/
public int getTimeOffset() {
return timeOffset;
}
/**
* Sets the latest recorded time offset.
*/
public void setTimeOffset(int timeOffset) {
this.timeOffset = timeOffset;
SdkGlobalTime.setGlobalTimeOffset(timeOffset);
}
}
| 1,949 |
0 | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http/RequestExecutionContext.java | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.awssdk.core.internal.http;
import software.amazon.awssdk.annotations.SdkInternalApi;
import software.amazon.awssdk.core.RequestOverrideConfiguration;
import software.amazon.awssdk.core.SdkRequest;
import software.amazon.awssdk.core.SdkRequestOverrideConfiguration;
import software.amazon.awssdk.core.async.AsyncRequestBody;
import software.amazon.awssdk.core.http.ExecutionContext;
import software.amazon.awssdk.core.interceptor.ExecutionAttributes;
import software.amazon.awssdk.core.interceptor.ExecutionInterceptorChain;
import software.amazon.awssdk.core.interceptor.SdkExecutionAttribute;
import software.amazon.awssdk.core.internal.http.pipeline.RequestPipeline;
import software.amazon.awssdk.core.internal.http.timers.TimeoutTracker;
import software.amazon.awssdk.core.signer.Signer;
import software.amazon.awssdk.metrics.MetricCollector;
import software.amazon.awssdk.utils.Validate;
/**
* Request scoped dependencies and context for an execution of a request by {@link AmazonSyncHttpClient} or
* {@link AmazonAsyncHttpClient}.
* Provided to the {@link RequestPipeline#execute(Object, RequestExecutionContext)} method.
*/
@SdkInternalApi
public final class RequestExecutionContext {
private static final RequestOverrideConfiguration EMPTY_CONFIG = SdkRequestOverrideConfiguration.builder().build();
private AsyncRequestBody requestProvider;
private final SdkRequest originalRequest;
private final ExecutionContext executionContext;
private TimeoutTracker apiCallTimeoutTracker;
private TimeoutTracker apiCallAttemptTimeoutTracker;
private MetricCollector attemptMetricCollector;
private RequestExecutionContext(Builder builder) {
this.requestProvider = builder.requestProvider;
this.originalRequest = Validate.paramNotNull(builder.originalRequest, "originalRequest");
this.executionContext = Validate.paramNotNull(builder.executionContext, "executionContext");
}
/**
* Create a {@link Builder}, used to create a {@link RequestExecutionContext}.
*/
public static Builder builder() {
return new Builder();
}
public AsyncRequestBody requestProvider() {
return requestProvider;
}
/**
* @return Execution interceptors to hook into execution lifecycle.
*/
public ExecutionInterceptorChain interceptorChain() {
return executionContext.interceptorChain();
}
public ExecutionAttributes executionAttributes() {
return executionContext.executionAttributes();
}
public ExecutionContext executionContext() {
return executionContext;
}
public SdkRequest originalRequest() {
return originalRequest;
}
public RequestOverrideConfiguration requestConfig() {
return originalRequest.overrideConfiguration()
// ugly but needed to avoid capture of capture and creating a type mismatch
.map(c -> (RequestOverrideConfiguration) c)
.orElse(EMPTY_CONFIG);
}
/**
* @return SignerProvider used to obtain an instance of a {@link Signer}.
*/
public Signer signer() {
return executionContext.signer();
}
/**
* @return Tracker task for the {@link TimeoutTracker}.
*/
public TimeoutTracker apiCallTimeoutTracker() {
return apiCallTimeoutTracker;
}
/**
* Sets the tracker task for the . Should
* be called once per request lifecycle.
*/
public void apiCallTimeoutTracker(TimeoutTracker timeoutTracker) {
this.apiCallTimeoutTracker = timeoutTracker;
}
public TimeoutTracker apiCallAttemptTimeoutTracker() {
return apiCallAttemptTimeoutTracker;
}
public void apiCallAttemptTimeoutTracker(TimeoutTracker timeoutTracker) {
this.apiCallAttemptTimeoutTracker = timeoutTracker;
}
public MetricCollector attemptMetricCollector() {
return attemptMetricCollector;
}
public void attemptMetricCollector(MetricCollector metricCollector) {
executionAttributes().putAttribute(SdkExecutionAttribute.API_CALL_ATTEMPT_METRIC_COLLECTOR, metricCollector);
this.attemptMetricCollector = metricCollector;
}
/**
* Sets the request body provider.
* Used for transforming the original body provider to sign events for
* event stream operations that support signing.
*/
public void requestProvider(AsyncRequestBody publisher) {
requestProvider = publisher;
}
/**
* An SDK-internal implementation of {@link Builder}.
*/
public static final class Builder {
private AsyncRequestBody requestProvider;
private SdkRequest originalRequest;
private ExecutionContext executionContext;
public Builder requestProvider(AsyncRequestBody requestProvider) {
this.requestProvider = requestProvider;
return this;
}
public Builder originalRequest(SdkRequest originalRequest) {
this.originalRequest = originalRequest;
return this;
}
public Builder executionContext(ExecutionContext executionContext) {
this.executionContext = executionContext;
return this;
}
public RequestExecutionContext build() {
return new RequestExecutionContext(this);
}
}
}
| 1,950 |
0 | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http/IdempotentAsyncResponseHandler.java | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.awssdk.core.internal.http;
import java.nio.ByteBuffer;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.atomic.AtomicReference;
import java.util.function.BiPredicate;
import java.util.function.Supplier;
import org.reactivestreams.Publisher;
import software.amazon.awssdk.annotations.SdkInternalApi;
import software.amazon.awssdk.annotations.ThreadSafe;
import software.amazon.awssdk.http.SdkHttpResponse;
/**
* Wrapper for a {@link TransformingAsyncResponseHandler} that allows attachment to an external scope and given a way
* of evaluating whether that scope has changed or not will only allow prepare() to be called on its delegate once
* per state change and will cache and reserve the future that is returned by the delegate the rest of the time.
* <p>
* One application of this wrapper is to ensure that prepare() is not called on the underlying response handler more
* than once per retry no matter where or how many times its invoked.
* <p>
* This class is asserted to be thread-safe and it should be fine to have multiple threads call prepare()
* simultaneously.
*
* @param <T> The type of the wrapped {@link TransformingAsyncResponseHandler}
* @param <R> The type of the object used to determine scope.
*/
@SdkInternalApi
@ThreadSafe
public class IdempotentAsyncResponseHandler<T, R> implements TransformingAsyncResponseHandler<T> {
private final Supplier<R> newScopeSupplier;
private final BiPredicate<R, R> newScopeInRangePredicate;
private final TransformingAsyncResponseHandler<T> wrappedHandler;
// Taking advantage of the volatile properties of AtomicReference
private final AtomicReference<R> cachedScope = new AtomicReference<>();
private final AtomicReference<CompletableFuture<T>> cachedPreparedFuture = new AtomicReference<>();
private IdempotentAsyncResponseHandler(TransformingAsyncResponseHandler<T> wrappedHandler,
Supplier<R> newScopeSupplier,
BiPredicate<R, R> newScopeInRangePredicate) {
this.newScopeSupplier = newScopeSupplier;
this.newScopeInRangePredicate = newScopeInRangePredicate;
this.wrappedHandler = wrappedHandler;
}
/**
* Creates a new wrapped {@link TransformingAsyncResponseHandler}
* @param wrappedHandler A different handler to wrap.
* @param preparedScopeSupplier A function that retrieves the current scope to determine if a new future can be
* prepared.
* @param scopeInRangePredicate A predicate that can be used to test the cached scope against the newly retrieved
* scope to determine if a new future can be prepared.
* @param <T> The type of the wrapped {@link TransformingAsyncResponseHandler}
* @param <R> The type of the object used to determine scope.
*/
public static <T, R> IdempotentAsyncResponseHandler<T, R> create(
TransformingAsyncResponseHandler<T> wrappedHandler,
Supplier<R> preparedScopeSupplier,
BiPredicate<R, R> scopeInRangePredicate) {
return new IdempotentAsyncResponseHandler<>(wrappedHandler,
preparedScopeSupplier,
scopeInRangePredicate);
}
@Override
public CompletableFuture<T> prepare() {
// Test if the new scope is in range of the cached scope; if not delegate and cache result and new scope
if (cachedPreparedFuture.get() == null ||
!newScopeInRangePredicate.test(newScopeSupplier.get(), cachedScope.get())) {
synchronized (this) {
// The scope needs to be queried and tested again in case it was changed by another thread
R newScope = newScopeSupplier.get();
if (cachedPreparedFuture.get() == null || !newScopeInRangePredicate.test(newScope, cachedScope.get())) {
cachedPreparedFuture.set(this.wrappedHandler.prepare());
cachedScope.set(newScope);
}
}
}
return cachedPreparedFuture.get();
}
@Override
public void onHeaders(SdkHttpResponse headers) {
this.wrappedHandler.onHeaders(headers);
}
@Override
public void onStream(Publisher<ByteBuffer> stream) {
this.wrappedHandler.onStream(stream);
}
@Override
public void onError(Throwable error) {
this.wrappedHandler.onError(error);
}
}
| 1,951 |
0 | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http/AmazonSyncHttpClient.java | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.awssdk.core.internal.http;
import java.util.function.Consumer;
import software.amazon.awssdk.annotations.SdkInternalApi;
import software.amazon.awssdk.annotations.ThreadSafe;
import software.amazon.awssdk.core.ClientType;
import software.amazon.awssdk.core.Response;
import software.amazon.awssdk.core.SdkRequest;
import software.amazon.awssdk.core.client.config.SdkClientConfiguration;
import software.amazon.awssdk.core.exception.SdkClientException;
import software.amazon.awssdk.core.http.ExecutionContext;
import software.amazon.awssdk.core.http.HttpResponseHandler;
import software.amazon.awssdk.core.interceptor.ExecutionAttributes;
import software.amazon.awssdk.core.internal.http.pipeline.RequestPipelineBuilder;
import software.amazon.awssdk.core.internal.http.pipeline.stages.AfterExecutionInterceptorsStage;
import software.amazon.awssdk.core.internal.http.pipeline.stages.AfterTransmissionExecutionInterceptorsStage;
import software.amazon.awssdk.core.internal.http.pipeline.stages.ApiCallAttemptMetricCollectionStage;
import software.amazon.awssdk.core.internal.http.pipeline.stages.ApiCallAttemptTimeoutTrackingStage;
import software.amazon.awssdk.core.internal.http.pipeline.stages.ApiCallMetricCollectionStage;
import software.amazon.awssdk.core.internal.http.pipeline.stages.ApiCallTimeoutTrackingStage;
import software.amazon.awssdk.core.internal.http.pipeline.stages.ApplyTransactionIdStage;
import software.amazon.awssdk.core.internal.http.pipeline.stages.ApplyUserAgentStage;
import software.amazon.awssdk.core.internal.http.pipeline.stages.BeforeTransmissionExecutionInterceptorsStage;
import software.amazon.awssdk.core.internal.http.pipeline.stages.BeforeUnmarshallingExecutionInterceptorsStage;
import software.amazon.awssdk.core.internal.http.pipeline.stages.CompressRequestStage;
import software.amazon.awssdk.core.internal.http.pipeline.stages.ExecutionFailureExceptionReportingStage;
import software.amazon.awssdk.core.internal.http.pipeline.stages.HandleResponseStage;
import software.amazon.awssdk.core.internal.http.pipeline.stages.HttpChecksumStage;
import software.amazon.awssdk.core.internal.http.pipeline.stages.MakeHttpRequestStage;
import software.amazon.awssdk.core.internal.http.pipeline.stages.MakeRequestImmutableStage;
import software.amazon.awssdk.core.internal.http.pipeline.stages.MakeRequestMutableStage;
import software.amazon.awssdk.core.internal.http.pipeline.stages.MergeCustomHeadersStage;
import software.amazon.awssdk.core.internal.http.pipeline.stages.MergeCustomQueryParamsStage;
import software.amazon.awssdk.core.internal.http.pipeline.stages.QueryParametersToBodyStage;
import software.amazon.awssdk.core.internal.http.pipeline.stages.RetryableStage;
import software.amazon.awssdk.core.internal.http.pipeline.stages.SigningStage;
import software.amazon.awssdk.core.internal.http.pipeline.stages.TimeoutExceptionHandlingStage;
import software.amazon.awssdk.core.internal.http.pipeline.stages.UnwrapResponseContainer;
import software.amazon.awssdk.http.SdkHttpFullRequest;
import software.amazon.awssdk.http.SdkHttpFullResponse;
import software.amazon.awssdk.utils.SdkAutoCloseable;
@ThreadSafe
@SdkInternalApi
// TODO come up with better name
public final class AmazonSyncHttpClient implements SdkAutoCloseable {
private final HttpClientDependencies httpClientDependencies;
public AmazonSyncHttpClient(SdkClientConfiguration clientConfiguration) {
this.httpClientDependencies = HttpClientDependencies.builder()
.clientConfiguration(clientConfiguration)
.build();
}
/**
* Shuts down this HTTP client object, releasing any resources that might be held open. This is
* an optional method, and callers are not expected to call it, but can if they want to
* explicitly release any open resources. Once a client has been shutdown, it cannot be used to
* make more requests.
*/
@Override
public void close() {
httpClientDependencies.close();
}
/**
* @return A builder used to configure and execute a HTTP request.
*/
public RequestExecutionBuilder requestExecutionBuilder() {
return new RequestExecutionBuilderImpl()
.httpClientDependencies(httpClientDependencies);
}
/**
* Interface to configure a request execution and execute the request.
*/
public interface RequestExecutionBuilder {
/**
* Fluent setter for {@link SdkHttpFullRequest}
*
* @param request Request object
* @return This builder for method chaining.
*/
RequestExecutionBuilder request(SdkHttpFullRequest request);
RequestExecutionBuilder originalRequest(SdkRequest originalRequest);
/**
* Fluent setter for the execution context
*
* @param executionContext Execution context
* @return This builder for method chaining.
*/
RequestExecutionBuilder executionContext(ExecutionContext executionContext);
RequestExecutionBuilder httpClientDependencies(HttpClientDependencies httpClientDependencies);
HttpClientDependencies httpClientDependencies();
default RequestExecutionBuilder httpClientDependencies(Consumer<HttpClientDependencies.Builder> mutator) {
HttpClientDependencies.Builder builder = httpClientDependencies().toBuilder();
mutator.accept(builder);
return httpClientDependencies(builder.build());
}
/**
* Executes the request with the given configuration.
*
* @param combinedResponseHandler response handler: converts an http request into a decorated Response object
* of the appropriate type.
* @param <OutputT> Result type
* @return Unmarshalled result type.
*/
<OutputT> OutputT execute(HttpResponseHandler<Response<OutputT>> combinedResponseHandler);
}
private static class NoOpResponseHandler<T> implements HttpResponseHandler<T> {
@Override
public T handle(SdkHttpFullResponse response, ExecutionAttributes executionAttributes) {
return null;
}
@Override
public boolean needsConnectionLeftOpen() {
return false;
}
}
private static class RequestExecutionBuilderImpl implements RequestExecutionBuilder {
private HttpClientDependencies httpClientDependencies;
private SdkHttpFullRequest request;
private SdkRequest originalRequest;
private ExecutionContext executionContext;
@Override
// This is duplicating information in the interceptor context. Can they be consolidated?
public RequestExecutionBuilder request(SdkHttpFullRequest request) {
this.request = request;
return this;
}
@Override
public RequestExecutionBuilder originalRequest(SdkRequest originalRequest) {
this.originalRequest = originalRequest;
return this;
}
@Override
public RequestExecutionBuilder executionContext(ExecutionContext executionContext) {
this.executionContext = executionContext;
return this;
}
@Override
public RequestExecutionBuilder httpClientDependencies(HttpClientDependencies httpClientDependencies) {
this.httpClientDependencies = httpClientDependencies;
return this;
}
@Override
public HttpClientDependencies httpClientDependencies() {
return this.httpClientDependencies;
}
@Override
public <OutputT> OutputT execute(HttpResponseHandler<Response<OutputT>> responseHandler) {
// TODO: We currently have two ways of passing messages to the HTTP client: through the request or through the
// execution interceptor context. We should combine these two methods when we refactor the way request execution
// contexts work.
if (request != null && executionContext != null) {
executionContext.interceptorContext(
executionContext.interceptorContext().copy(ib -> ib.httpRequest(request)));
}
try {
return RequestPipelineBuilder
// Start of mutating request
.first(RequestPipelineBuilder
.first(MakeRequestMutableStage::new)
.then(ApplyTransactionIdStage::new)
.then(ApplyUserAgentStage::new)
.then(MergeCustomHeadersStage::new)
.then(MergeCustomQueryParamsStage::new)
.then(QueryParametersToBodyStage::new)
.then(() -> new CompressRequestStage(httpClientDependencies))
.then(() -> new HttpChecksumStage(ClientType.SYNC))
.then(MakeRequestImmutableStage::new)
// End of mutating request
.then(RequestPipelineBuilder
.first(SigningStage::new)
.then(BeforeTransmissionExecutionInterceptorsStage::new)
.then(MakeHttpRequestStage::new)
.then(AfterTransmissionExecutionInterceptorsStage::new)
.then(BeforeUnmarshallingExecutionInterceptorsStage::new)
.then(() -> new HandleResponseStage<>(responseHandler))
.wrappedWith(ApiCallAttemptTimeoutTrackingStage::new)
.wrappedWith(TimeoutExceptionHandlingStage::new)
.wrappedWith((deps, wrapped) -> new ApiCallAttemptMetricCollectionStage<>(wrapped))
.wrappedWith(RetryableStage::new)::build)
.wrappedWith(StreamManagingStage::new)
.wrappedWith(ApiCallTimeoutTrackingStage::new)::build)
.wrappedWith((deps, wrapped) -> new ApiCallMetricCollectionStage<>(wrapped))
.then(() -> new UnwrapResponseContainer<>())
.then(() -> new AfterExecutionInterceptorsStage<>())
.wrappedWith(ExecutionFailureExceptionReportingStage::new)
.build(httpClientDependencies)
.execute(request, createRequestExecutionDependencies());
} catch (RuntimeException e) {
throw e;
} catch (Exception e) {
throw SdkClientException.builder().cause(e).build();
}
}
private RequestExecutionContext createRequestExecutionDependencies() {
return RequestExecutionContext.builder()
.originalRequest(originalRequest)
.executionContext(executionContext)
.build();
}
}
}
| 1,952 |
0 | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http/AmazonAsyncHttpClient.java | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.awssdk.core.internal.http;
import static software.amazon.awssdk.core.internal.http.pipeline.RequestPipelineBuilder.async;
import java.util.concurrent.CompletableFuture;
import java.util.function.Consumer;
import software.amazon.awssdk.annotations.SdkInternalApi;
import software.amazon.awssdk.annotations.ThreadSafe;
import software.amazon.awssdk.core.ClientType;
import software.amazon.awssdk.core.Response;
import software.amazon.awssdk.core.SdkRequest;
import software.amazon.awssdk.core.async.AsyncRequestBody;
import software.amazon.awssdk.core.client.config.SdkClientConfiguration;
import software.amazon.awssdk.core.exception.SdkClientException;
import software.amazon.awssdk.core.http.ExecutionContext;
import software.amazon.awssdk.core.internal.http.pipeline.RequestPipelineBuilder;
import software.amazon.awssdk.core.internal.http.pipeline.stages.AfterExecutionInterceptorsStage;
import software.amazon.awssdk.core.internal.http.pipeline.stages.ApplyTransactionIdStage;
import software.amazon.awssdk.core.internal.http.pipeline.stages.ApplyUserAgentStage;
import software.amazon.awssdk.core.internal.http.pipeline.stages.AsyncApiCallAttemptMetricCollectionStage;
import software.amazon.awssdk.core.internal.http.pipeline.stages.AsyncApiCallMetricCollectionStage;
import software.amazon.awssdk.core.internal.http.pipeline.stages.AsyncApiCallTimeoutTrackingStage;
import software.amazon.awssdk.core.internal.http.pipeline.stages.AsyncBeforeTransmissionExecutionInterceptorsStage;
import software.amazon.awssdk.core.internal.http.pipeline.stages.AsyncExecutionFailureExceptionReportingStage;
import software.amazon.awssdk.core.internal.http.pipeline.stages.AsyncRetryableStage;
import software.amazon.awssdk.core.internal.http.pipeline.stages.AsyncSigningStage;
import software.amazon.awssdk.core.internal.http.pipeline.stages.CompressRequestStage;
import software.amazon.awssdk.core.internal.http.pipeline.stages.HttpChecksumStage;
import software.amazon.awssdk.core.internal.http.pipeline.stages.MakeAsyncHttpRequestStage;
import software.amazon.awssdk.core.internal.http.pipeline.stages.MakeRequestImmutableStage;
import software.amazon.awssdk.core.internal.http.pipeline.stages.MakeRequestMutableStage;
import software.amazon.awssdk.core.internal.http.pipeline.stages.MergeCustomHeadersStage;
import software.amazon.awssdk.core.internal.http.pipeline.stages.MergeCustomQueryParamsStage;
import software.amazon.awssdk.core.internal.http.pipeline.stages.QueryParametersToBodyStage;
import software.amazon.awssdk.core.internal.http.pipeline.stages.UnwrapResponseContainer;
import software.amazon.awssdk.core.internal.util.ThrowableUtils;
import software.amazon.awssdk.http.SdkHttpFullRequest;
import software.amazon.awssdk.utils.SdkAutoCloseable;
@ThreadSafe
@SdkInternalApi
//TODO: come up with better name
public final class AmazonAsyncHttpClient implements SdkAutoCloseable {
private final HttpClientDependencies httpClientDependencies;
public AmazonAsyncHttpClient(SdkClientConfiguration clientConfiguration) {
this.httpClientDependencies = HttpClientDependencies.builder()
.clientConfiguration(clientConfiguration)
.build();
}
/**
* Shuts down this HTTP client object, releasing any resources that might be held open. This is
* an optional method, and callers are not expected to call it, but can if they want to
* explicitly release any open resources. Once a client has been shutdown, it cannot be used to
* make more requests.
*/
@Override
public void close() {
httpClientDependencies.close();
}
/**
* @return A builder used to configure and execute a HTTP request.
*/
public RequestExecutionBuilder requestExecutionBuilder() {
return new RequestExecutionBuilderImpl()
.httpClientDependencies(httpClientDependencies);
}
/**
* Interface to configure a request execution and execute the request.
*/
public interface RequestExecutionBuilder {
/**
* Fluent setter for {@link AsyncRequestBody}
*
* @param requestProvider Request provider object
* @return This builder for method chaining.
*/
RequestExecutionBuilder requestProvider(AsyncRequestBody requestProvider);
/**
* Fluent setter for {@link SdkHttpFullRequest}
*
* @param request Request object
* @return This builder for method chaining.
*/
RequestExecutionBuilder request(SdkHttpFullRequest request);
/**
* Fluent setter for the execution context
*
* @param executionContext Execution context
* @return This builder for method chaining.
*/
RequestExecutionBuilder executionContext(ExecutionContext executionContext);
/**
* Fluent setter for {@link SdkRequest}
*
* @param originalRequest Request object
* @return This builder for method chaining.
*/
RequestExecutionBuilder originalRequest(SdkRequest originalRequest);
RequestExecutionBuilder httpClientDependencies(HttpClientDependencies httpClientDependencies);
HttpClientDependencies httpClientDependencies();
default RequestExecutionBuilder httpClientDependencies(Consumer<HttpClientDependencies.Builder> mutator) {
HttpClientDependencies.Builder builder = httpClientDependencies().toBuilder();
mutator.accept(builder);
return httpClientDependencies(builder.build());
}
/**
* Executes the request with the given configuration.
*
* @param responseHandler Response handler that outputs the actual result type which is
* preferred going forward.
* @param <OutputT> Result type
* @return Unmarshalled result type.
*/
<OutputT> CompletableFuture<OutputT> execute(TransformingAsyncResponseHandler<Response<OutputT>> responseHandler);
}
private static class RequestExecutionBuilderImpl implements RequestExecutionBuilder {
private HttpClientDependencies httpClientDependencies;
private AsyncRequestBody requestProvider;
private SdkHttpFullRequest request;
private SdkRequest originalRequest;
private ExecutionContext executionContext;
@Override
public RequestExecutionBuilder httpClientDependencies(HttpClientDependencies httpClientDependencies) {
this.httpClientDependencies = httpClientDependencies;
return this;
}
@Override
public HttpClientDependencies httpClientDependencies() {
return httpClientDependencies;
}
@Override
public RequestExecutionBuilder requestProvider(AsyncRequestBody requestProvider) {
this.requestProvider = requestProvider;
return this;
}
@Override
public RequestExecutionBuilder request(SdkHttpFullRequest request) {
this.request = request;
return this;
}
@Override
public RequestExecutionBuilder executionContext(
ExecutionContext executionContext) {
this.executionContext = executionContext;
return this;
}
@Override
public RequestExecutionBuilder originalRequest(SdkRequest originalRequest) {
this.originalRequest = originalRequest;
return this;
}
@Override
public <OutputT> CompletableFuture<OutputT> execute(
TransformingAsyncResponseHandler<Response<OutputT>> responseHandler) {
try {
return RequestPipelineBuilder
.first(RequestPipelineBuilder
.first(MakeRequestMutableStage::new)
.then(ApplyTransactionIdStage::new)
.then(ApplyUserAgentStage::new)
.then(MergeCustomHeadersStage::new)
.then(MergeCustomQueryParamsStage::new)
.then(QueryParametersToBodyStage::new)
.then(() -> new CompressRequestStage(httpClientDependencies))
.then(() -> new HttpChecksumStage(ClientType.ASYNC))
.then(MakeRequestImmutableStage::new)
.then(RequestPipelineBuilder
.first(AsyncSigningStage::new)
.then(AsyncBeforeTransmissionExecutionInterceptorsStage::new)
.then(d -> new MakeAsyncHttpRequestStage<>(responseHandler, d))
.wrappedWith(AsyncApiCallAttemptMetricCollectionStage::new)
.wrappedWith((deps, wrapped) -> new AsyncRetryableStage<>(responseHandler, deps, wrapped))
.then(async(() -> new UnwrapResponseContainer<>()))
.then(async(() -> new AfterExecutionInterceptorsStage<>()))
.wrappedWith(AsyncExecutionFailureExceptionReportingStage::new)
.wrappedWith(AsyncApiCallTimeoutTrackingStage::new)
.wrappedWith(AsyncApiCallMetricCollectionStage::new)::build)::build)
.build(httpClientDependencies)
.execute(request, createRequestExecutionDependencies());
} catch (RuntimeException e) {
throw ThrowableUtils.asSdkException(e);
} catch (Exception e) {
throw SdkClientException.builder().cause(e).build();
}
}
private RequestExecutionContext createRequestExecutionDependencies() {
return RequestExecutionContext.builder()
.requestProvider(requestProvider)
.originalRequest(originalRequest)
.executionContext(executionContext)
.build();
}
}
}
| 1,953 |
0 | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http/pipeline/RequestToResponsePipeline.java | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.awssdk.core.internal.http.pipeline;
import software.amazon.awssdk.annotations.SdkInternalApi;
import software.amazon.awssdk.core.Response;
import software.amazon.awssdk.http.SdkHttpFullRequest;
@SdkInternalApi
public interface RequestToResponsePipeline<OutputT>
extends RequestPipeline<SdkHttpFullRequest, Response<OutputT>> {
}
| 1,954 |
0 | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http/pipeline/RequestPipeline.java | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.awssdk.core.internal.http.pipeline;
import java.util.function.BiFunction;
import software.amazon.awssdk.annotations.SdkInternalApi;
import software.amazon.awssdk.core.internal.http.RequestExecutionContext;
/**
* Represents a series of transformations when executing a SDK request.
*
* @param <InputT> Source type, provided as input param to pipeline.
* @param <OutputT> Output type returned by the pipeline.
*/
@SdkInternalApi
public interface RequestPipeline<InputT, OutputT> {
/**
* Execute the pipeline with the given input.
*
* @param input Input to pipeline.
* @param context Context containing both request dependencies, and a container for any mutable state that must be shared
* between stages.
* @return Output of pipeline.
* @throws Exception If any error occurs. This will be thrown out of the pipeline, if exceptions must be handled see
* {@link RequestPipelineBuilder#wrappedWith(BiFunction)}.
*/
OutputT execute(InputT input, RequestExecutionContext context) throws Exception;
}
| 1,955 |
0 | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http/pipeline/MutableRequestToRequestPipeline.java | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.awssdk.core.internal.http.pipeline;
import software.amazon.awssdk.annotations.SdkInternalApi;
import software.amazon.awssdk.http.SdkHttpFullRequest;
/**
* Pipeline stage that takes in a mutable {@link SdkHttpFullRequest.Builder} and returns the same builder. Useful
* for long chains of mutating stages where going to and from builder each stage is inefficient.
*/
@SdkInternalApi
public interface MutableRequestToRequestPipeline
extends RequestPipeline<SdkHttpFullRequest.Builder, SdkHttpFullRequest.Builder> {
}
| 1,956 |
0 | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http/pipeline/RequestToRequestPipeline.java | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.awssdk.core.internal.http.pipeline;
import software.amazon.awssdk.annotations.SdkInternalApi;
import software.amazon.awssdk.http.SdkHttpFullRequest;
/**
* Pipeline stage that is a transformation on an immutable {@link SdkHttpFullRequest}.
*/
@SdkInternalApi
public interface RequestToRequestPipeline extends RequestPipeline<SdkHttpFullRequest, SdkHttpFullRequest> {
}
| 1,957 |
0 | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http/pipeline/RequestPipelineBuilder.java | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.awssdk.core.internal.http.pipeline;
import static software.amazon.awssdk.utils.FunctionalUtils.safeFunction;
import static software.amazon.awssdk.utils.FunctionalUtils.toFunction;
import java.util.concurrent.CompletableFuture;
import java.util.function.BiFunction;
import java.util.function.Function;
import java.util.function.Supplier;
import software.amazon.awssdk.annotations.Immutable;
import software.amazon.awssdk.annotations.SdkInternalApi;
import software.amazon.awssdk.core.internal.http.HttpClientDependencies;
import software.amazon.awssdk.core.internal.http.RequestExecutionContext;
import software.amazon.awssdk.utils.CompletableFutureUtils;
/**
* Builder for a {@link RequestPipeline}.
*
* @param <InputT> Currently configured input type to the {@link RequestPipeline}.
* @param <OutputT> Currently configured output type to the {@link RequestPipeline}.
*/
@Immutable
@SdkInternalApi
public final class RequestPipelineBuilder<InputT, OutputT> {
private final Function<HttpClientDependencies, RequestPipeline<InputT, OutputT>> pipelineFactory;
private RequestPipelineBuilder(Function<HttpClientDependencies, RequestPipeline<InputT, OutputT>> pipelineFactory) {
this.pipelineFactory = pipelineFactory;
}
/**
* Factory method to create a {@link RequestPipelineBuilder} with an initial pipeline stage. Stages in this pipeline will only
* be able to accept an {@link HttpClientDependencies} or {@link HttpClientDependencies}.
*
* @param pipelineFactory Factory that can produce a {@link RequestPipeline}. Should take an {@link HttpClientDependencies}
* object as the first parameter to the factory method.
* @param <InputT> Input type of pipeline
* @param <OutputT> Output type of pipeline.
* @return RequestPipelineBuilder composed of that initial stage.
* @see #build(HttpClientDependencies)
*/
public static <InputT, OutputT> RequestPipelineBuilder<InputT, OutputT> first(
Function<HttpClientDependencies, RequestPipeline<InputT, OutputT>> pipelineFactory) {
return new RequestPipelineBuilder<>(pipelineFactory);
}
/**
* Factory method to create a {@link RequestPipelineBuilder} with an initial pipeline stage. Stages in this pipeline will only
* be able to accept an {@link HttpClientDependencies} or {@link HttpClientDependencies}.
*
* @param pipelineFactory Factory that can produce a {@link RequestPipeline}. Use this overload when the factory does not
* need {@link HttpClientDependencies} and should instead take no arguments.
* @param <InputT> Input type of pipeline
* @param <OutputT> Output type of pipeline.
* @return RequestPipelineBuilder composed of that initial stage.
* @see #build(HttpClientDependencies)
*/
public static <InputT, OutputT> RequestPipelineBuilder<InputT, OutputT> first(
Supplier<RequestPipeline<InputT, OutputT>> pipelineFactory) {
return new RequestPipelineBuilder<>(d -> pipelineFactory.get());
}
/**
* Factory method to chain the current {@link RequestPipelineBuilder} with another pipeline stage. The new stage's input type
* must match the current stage's output type. The new stage may define a new output type (if it's transforming the type) or
* may define the same output type as the current stage.
*
* @param pipelineFactory Factory that can produce a {@link RequestPipeline}. Should take an {@link HttpClientDependencies}
* object as the first parameter to the factory method.
* @param <NewOutputT> New output type of pipeline
* @return A new RequestPipelineBuilder composed of the previous stages and the new stage.
* @see #build(HttpClientDependencies)
*/
public <NewOutputT> RequestPipelineBuilder<InputT, NewOutputT> then(
Function<HttpClientDependencies, RequestPipeline<OutputT, NewOutputT>> pipelineFactory) {
return new RequestPipelineBuilder<>(r -> new ComposingRequestPipelineStage<>(this.pipelineFactory.apply(r),
pipelineFactory.apply(r)));
}
/**
* Convert a synchronous {@link RequestPipeline} factory into a factory that produces a version of the RequestPipeline
* that accepts a CompletableFuture and returns a CompletableFuture.
*
* @param pipelineFactory the delegate pipeline factory to wrap
* @param <InputT> the input type of the original {@link RequestPipeline}
* @param <OutputT> the return type of the original {@link RequestPipeline}
* @return the wrapped {@link RequestPipeline} factory
*/
@SuppressWarnings("unchecked")
public static <InputT, OutputT>
Function<HttpClientDependencies, RequestPipeline<CompletableFuture<InputT>, CompletableFuture<OutputT>>>
async(Function<HttpClientDependencies, RequestPipeline<InputT, OutputT>> pipelineFactory) {
return httpClientDependencies -> new AsyncRequestPipelineWrapper(pipelineFactory.apply(httpClientDependencies));
}
/**
* A version of {@link #async(Function)} that takes a {@link Supplier}
*
* @see #async(Supplier)
*/
public static <InputT, OutputT>
Function<HttpClientDependencies, RequestPipeline<CompletableFuture<InputT>, CompletableFuture<OutputT>>>
async(Supplier<RequestPipeline<InputT, OutputT>> pipelineFactory) {
return async(toFunction(pipelineFactory));
}
/**
* Factory method to chain the current {@link RequestPipelineBuilder} with another pipeline stage. The new stage's input type
* must match the current stage's output type. The new stage may define a new output type (if it's transforming the type) or
* may define the same output type as the current stage.
*
* @param pipelineFactory Factory that can produce a {@link RequestPipeline}. Use this overload when the factory does not
* need {@link HttpClientDependencies} and should instead take no arguments.
* @param <NewOutputT> New output type of pipeline
* @return A new RequestPipelineBuilder composed of the previous stages and the new stage.
* @see #build(HttpClientDependencies)
*/
public <NewOutputT> RequestPipelineBuilder<InputT, NewOutputT> then(
Supplier<RequestPipeline<OutputT, NewOutputT>> pipelineFactory) {
return new RequestPipelineBuilder<>(r -> new ComposingRequestPipelineStage<>(this.pipelineFactory.apply(r),
pipelineFactory.get()));
}
/**
* Factory method to wrap the current {@link RequestPipelineBuilder} with another pipeline stage. The argument to wrap is a
* factory that takes an {@link HttpClientDependencies} object and a inner {@link RequestPipeline} (the current one being
* built) as arguments and produces a new {@link RequestPipeline} for the wrapper. The wrapper may have entirely different
* input and output types, typically it will have the same however.
*
* @param wrappedFactory {@link BiFunction} factory that can produce a {@link RequestPipeline}. The arguments to the factory
* will be {@link HttpClientDependencies} and an inner {@link RequestPipeline}.
* @param <NewOutputT> New output type of pipeline
* @return A new RequestPipelineBuilder that wraps around the pipeline currently being constructed.
* @see #build(HttpClientDependencies)
*/
public <NewInputT, NewOutputT> RequestPipelineBuilder<NewInputT, NewOutputT> wrappedWith(
BiFunction<HttpClientDependencies, RequestPipeline<InputT, OutputT>,
RequestPipeline<NewInputT, NewOutputT>> wrappedFactory) {
return new RequestPipelineBuilder<>(r -> wrappedFactory.apply(r, this.pipelineFactory.apply(r)));
}
/**
* Factory method to wrap the current {@link RequestPipelineBuilder} with another pipeline stage. The argument is a
* factory that takes an inner {@link RequestPipeline} (the current one being built) as an argument and produces a new {@link
* RequestPipeline} for the wrapper. The wrapper may have entirely different input and output types, typically it will have
* the same however.
*
* @param wrappedFactory {@link Function} factory that can produce a {@link RequestPipeline}. The argument to the factory
* will be an inner {@link RequestPipeline}.
* @param <NewOutputT> New output type of pipeline
* @return A new RequestPipelineBuilder that wraps around the pipeline currently being constructed.
* @see #build(HttpClientDependencies)
*/
public <NewInputT, NewOutputT> RequestPipelineBuilder<NewInputT, NewOutputT> wrappedWith(
Function<RequestPipeline<InputT, OutputT>,
RequestPipeline<NewInputT, NewOutputT>> wrappedFactory) {
return new RequestPipelineBuilder<>(d -> wrappedFactory.apply(this.pipelineFactory.apply(d)));
}
/**
* Construct the {@link RequestPipeline} with the currently configured stages.
*
* @param dependencies {@link HttpClientDependencies} to supply to factory methods that are interested in it.
* @return Constructed {@link RequestPipeline}.
* @see RequestPipeline#execute(Object, RequestExecutionContext)
*/
public RequestPipeline<InputT, OutputT> build(HttpClientDependencies dependencies) {
return pipelineFactory.apply(dependencies);
}
/**
* Chains two {@link RequestPipeline}'s together.
*
* @param <InputT> Input of first pipeline.
* @param <MiddleT> Output of first pipeline and input to second.
* @param <OutputT> Output of second pipeline.
*/
private static class ComposingRequestPipelineStage<InputT, MiddleT, OutputT> implements RequestPipeline<InputT, OutputT> {
private final RequestPipeline<InputT, MiddleT> first;
private final RequestPipeline<MiddleT, OutputT> second;
private ComposingRequestPipelineStage(RequestPipeline<InputT, MiddleT> first, RequestPipeline<MiddleT, OutputT> second) {
this.first = first;
this.second = second;
}
@Override
public OutputT execute(InputT in, RequestExecutionContext context) throws Exception {
return second.execute(first.execute(in, context), context);
}
}
/**
* Converts a synchronous {@link RequestPipeline} into one that accepts and returns a CompletableFuture
*
* @param <InputT> The input type expected by the delegate RequestPipeline
* @param <OutputT> The output type produced by the delegate RequestPipeline
*/
private static class AsyncRequestPipelineWrapper<InputT, OutputT>
implements RequestPipeline<CompletableFuture<InputT>, CompletableFuture<OutputT>> {
private final RequestPipeline<InputT, OutputT> delegate;
private AsyncRequestPipelineWrapper(RequestPipeline<InputT, OutputT> delegate) {
this.delegate = delegate;
}
@Override
public CompletableFuture<OutputT> execute(CompletableFuture<InputT> inputFuture, RequestExecutionContext context)
throws Exception {
CompletableFuture<OutputT> outputFuture =
inputFuture.thenApply(safeFunction(input -> delegate.execute(input, context)));
return CompletableFutureUtils.forwardExceptionTo(outputFuture, inputFuture);
}
}
}
| 1,958 |
0 | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http/pipeline | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http/pipeline/stages/QueryParametersToBodyStage.java | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.awssdk.core.internal.http.pipeline.stages;
import static java.util.Collections.singletonList;
import static software.amazon.awssdk.utils.StringUtils.lowerCase;
import java.io.ByteArrayInputStream;
import java.nio.charset.StandardCharsets;
import software.amazon.awssdk.annotations.SdkInternalApi;
import software.amazon.awssdk.core.SdkProtocolMetadata;
import software.amazon.awssdk.core.interceptor.SdkInternalExecutionAttribute;
import software.amazon.awssdk.core.internal.http.RequestExecutionContext;
import software.amazon.awssdk.core.internal.http.pipeline.MutableRequestToRequestPipeline;
import software.amazon.awssdk.http.SdkHttpFullRequest;
import software.amazon.awssdk.http.SdkHttpMethod;
/**
* Modifies an HTTP request by moving query parameters to the body under the following conditions:
* - It is a POST request
* - There is no content stream provider
* - There are query parameters to transfer
*/
@SdkInternalApi
public class QueryParametersToBodyStage implements MutableRequestToRequestPipeline {
private static final String DEFAULT_CONTENT_TYPE = "application/x-www-form-urlencoded; charset=" +
lowerCase(StandardCharsets.UTF_8.toString());
@Override
public SdkHttpFullRequest.Builder execute(SdkHttpFullRequest.Builder request, RequestExecutionContext context)
throws Exception {
if (shouldPutParamsInBody(request.build(), context)) {
return changeQueryParametersToFormData(request.build()).toBuilder();
}
return request;
}
private boolean shouldPutParamsInBody(SdkHttpFullRequest request, RequestExecutionContext context) {
SdkProtocolMetadata protocolMetadata =
context.executionAttributes().getAttribute(SdkInternalExecutionAttribute.PROTOCOL_METADATA);
if (protocolMetadata == null) {
return false;
}
String protocol = protocolMetadata.serviceProtocol();
boolean isQueryProtocol = "query".equalsIgnoreCase(protocol) || "ec2".equalsIgnoreCase(protocol);
return isQueryProtocol &&
request.method() == SdkHttpMethod.POST &&
!request.contentStreamProvider().isPresent() &&
request.numRawQueryParameters() > 0;
}
private SdkHttpFullRequest changeQueryParametersToFormData(SdkHttpFullRequest request) {
byte[] params = request.encodedQueryParametersAsFormData().orElse("")
.getBytes(StandardCharsets.UTF_8);
return request.toBuilder().clearQueryParameters()
.contentStreamProvider(() -> new ByteArrayInputStream(params))
.putHeader("Content-Length", singletonList(String.valueOf(params.length)))
.putHeader("Content-Type", singletonList(DEFAULT_CONTENT_TYPE))
.build();
}
}
| 1,959 |
0 | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http/pipeline | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http/pipeline/stages/BeforeUnmarshallingExecutionInterceptorsStage.java | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.awssdk.core.internal.http.pipeline.stages;
import software.amazon.awssdk.annotations.SdkInternalApi;
import software.amazon.awssdk.core.interceptor.ExecutionInterceptor;
import software.amazon.awssdk.core.internal.http.InterruptMonitor;
import software.amazon.awssdk.core.internal.http.RequestExecutionContext;
import software.amazon.awssdk.core.internal.http.pipeline.RequestPipeline;
import software.amazon.awssdk.http.SdkHttpFullRequest;
import software.amazon.awssdk.http.SdkHttpFullResponse;
import software.amazon.awssdk.http.SdkHttpResponse;
import software.amazon.awssdk.utils.Pair;
/**
* Invoke the {@link ExecutionInterceptor#beforeUnmarshalling} callback to allow for pre-processing on the {@link SdkHttpResponse}
* before it is handed off to the unmarshaller.
*/
@SdkInternalApi
public class BeforeUnmarshallingExecutionInterceptorsStage
implements RequestPipeline<Pair<SdkHttpFullRequest, SdkHttpFullResponse>, SdkHttpFullResponse> {
@Override
public SdkHttpFullResponse execute(Pair<SdkHttpFullRequest, SdkHttpFullResponse> input,
RequestExecutionContext context) throws Exception {
context.interceptorChain().beforeUnmarshalling(context.executionContext().interceptorContext(),
context.executionAttributes());
InterruptMonitor.checkInterrupted(input.right());
return input.right();
}
}
| 1,960 |
0 | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http/pipeline | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http/pipeline/stages/BeforeTransmissionExecutionInterceptorsStage.java | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.awssdk.core.internal.http.pipeline.stages;
import software.amazon.awssdk.annotations.SdkInternalApi;
import software.amazon.awssdk.core.internal.http.InterruptMonitor;
import software.amazon.awssdk.core.internal.http.RequestExecutionContext;
import software.amazon.awssdk.core.internal.http.pipeline.RequestToRequestPipeline;
import software.amazon.awssdk.http.SdkHttpFullRequest;
@SdkInternalApi
public class BeforeTransmissionExecutionInterceptorsStage implements RequestToRequestPipeline {
@Override
public SdkHttpFullRequest execute(SdkHttpFullRequest input, RequestExecutionContext context) throws Exception {
InterruptMonitor.checkInterrupted();
context.interceptorChain().beforeTransmission(context.executionContext().interceptorContext(),
context.executionAttributes());
return input;
}
}
| 1,961 |
0 | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http/pipeline | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http/pipeline/stages/AsyncBeforeTransmissionExecutionInterceptorsStage.java | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.awssdk.core.internal.http.pipeline.stages;
import java.util.concurrent.CompletableFuture;
import software.amazon.awssdk.annotations.SdkInternalApi;
import software.amazon.awssdk.core.internal.http.RequestExecutionContext;
import software.amazon.awssdk.core.internal.http.pipeline.RequestPipeline;
import software.amazon.awssdk.http.SdkHttpFullRequest;
import software.amazon.awssdk.utils.CompletableFutureUtils;
@SdkInternalApi
public class AsyncBeforeTransmissionExecutionInterceptorsStage implements
RequestPipeline<CompletableFuture<SdkHttpFullRequest>, CompletableFuture<SdkHttpFullRequest>> {
@Override
public CompletableFuture<SdkHttpFullRequest> execute(CompletableFuture<SdkHttpFullRequest> input,
RequestExecutionContext context) throws Exception {
CompletableFuture<SdkHttpFullRequest> future = new CompletableFuture<>();
input.whenComplete((r, t) -> {
if (t != null) {
future.completeExceptionally(t);
return;
}
try {
context.interceptorChain().beforeTransmission(context.executionContext().interceptorContext(),
context.executionAttributes());
future.complete(r);
} catch (Throwable interceptorException) {
future.completeExceptionally(interceptorException);
}
});
return CompletableFutureUtils.forwardExceptionTo(future, input);
}
}
| 1,962 |
0 | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http/pipeline | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http/pipeline/stages/ApiCallAttemptTimeoutTrackingStage.java | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.awssdk.core.internal.http.pipeline.stages;
import static software.amazon.awssdk.core.internal.http.timers.TimerUtils.resolveTimeoutInMillis;
import static software.amazon.awssdk.core.internal.http.timers.TimerUtils.timeSyncTaskIfNeeded;
import static software.amazon.awssdk.utils.FunctionalUtils.invokeSafely;
import java.time.Duration;
import java.util.concurrent.ScheduledExecutorService;
import software.amazon.awssdk.annotations.SdkInternalApi;
import software.amazon.awssdk.core.Response;
import software.amazon.awssdk.core.client.config.SdkClientOption;
import software.amazon.awssdk.core.exception.AbortedException;
import software.amazon.awssdk.core.exception.ApiCallAttemptTimeoutException;
import software.amazon.awssdk.core.exception.ApiCallTimeoutException;
import software.amazon.awssdk.core.exception.SdkInterruptedException;
import software.amazon.awssdk.core.internal.http.HttpClientDependencies;
import software.amazon.awssdk.core.internal.http.RequestExecutionContext;
import software.amazon.awssdk.core.internal.http.pipeline.RequestPipeline;
import software.amazon.awssdk.core.internal.http.pipeline.RequestToResponsePipeline;
import software.amazon.awssdk.core.internal.http.timers.SyncTimeoutTask;
import software.amazon.awssdk.core.internal.http.timers.TimeoutTracker;
import software.amazon.awssdk.http.SdkHttpFullRequest;
/**
* Wrapper around a {@link RequestPipeline} to manage the api call attempt timeout feature.
*/
@SdkInternalApi
public final class ApiCallAttemptTimeoutTrackingStage<OutputT> implements RequestToResponsePipeline<OutputT> {
private final RequestPipeline<SdkHttpFullRequest, Response<OutputT>> wrapped;
private final Duration apiCallAttemptTimeout;
private final ScheduledExecutorService timeoutExecutor;
public ApiCallAttemptTimeoutTrackingStage(HttpClientDependencies dependencies,
RequestPipeline<SdkHttpFullRequest,
Response<OutputT>> wrapped) {
this.wrapped = wrapped;
this.timeoutExecutor = dependencies.clientConfiguration().option(SdkClientOption.SCHEDULED_EXECUTOR_SERVICE);
this.apiCallAttemptTimeout = dependencies.clientConfiguration().option(SdkClientOption.API_CALL_ATTEMPT_TIMEOUT);
}
/**
* Start and end api call attempt timer around the execution of the api call attempt. It's important
* that the client execution task is canceled before the InterruptedException is handled by the wrapped
* {@link RequestPipeline#execute} call so the interrupt status doesn't leak out to the callers code.
*/
@Override
public Response<OutputT> execute(SdkHttpFullRequest request, RequestExecutionContext context) throws Exception {
try {
long timeoutInMillis = resolveTimeoutInMillis(context.requestConfig()::apiCallAttemptTimeout, apiCallAttemptTimeout);
TimeoutTracker timeoutTracker = timeSyncTaskIfNeeded(timeoutExecutor, timeoutInMillis, Thread.currentThread());
Response<OutputT> response;
try {
context.apiCallAttemptTimeoutTracker(timeoutTracker);
response = wrapped.execute(request, context);
} finally {
// Cancel the timeout tracker, guaranteeing that if it hasn't already executed and set this thread's
// interrupt flag, it won't do so later. Every code path executed after this line *must* call
// timeoutTracker.hasExecuted() and appropriately clear the interrupt flag if it returns true.
timeoutTracker.cancel();
}
if (timeoutTracker.hasExecuted()) {
// The timeout tracker executed before the call to cancel(), which means it set this thread's interrupt
// flag. However, the execute() call returned before we raised an InterruptedException, so just clear
// the interrupt flag and return the result we got back.
Thread.interrupted();
}
return response;
} catch (Exception e) {
throw translatePipelineException(context, e);
}
}
/**
* Take the given exception thrown from the wrapped pipeline and return a more appropriate
* timeout related exception based on its type and the the execution status.
*
* @param context The execution context.
* @param e The exception thrown from the inner pipeline.
* @return The translated exception.
*/
private Exception translatePipelineException(RequestExecutionContext context, Exception e) {
if (e instanceof InterruptedException) {
return handleInterruptedException(context, (InterruptedException) e);
}
// Timeout tracker finished and interrupted this thread after wrapped.execute() last checked the interrupt flag,
// but before we called timeoutTracker.cancel(). Note that if hasExecuted() returns true, its guaranteed that
// the timeout tracker has set the interrupt flag, and if it returns false, it guarantees that it did not and
// will never set the interrupt flag.
if (context.apiCallAttemptTimeoutTracker().hasExecuted()) {
// Clear the interrupt flag. Since we already have an exception from the call, which may contain information
// that's useful to the caller, just return that instead of an ApiCallTimeoutException.
Thread.interrupted();
}
return e;
}
/**
* Determine if an interrupted exception is caused by the api call timeout task
* interrupting the current thread or some other task interrupting the thread for another
* purpose.
*
* @return {@link ApiCallTimeoutException} if the {@link InterruptedException} was
* caused by the {@link SyncTimeoutTask}. Otherwise re-interrupts the current thread
* and returns a {@link AbortedException} wrapping an {@link InterruptedException}
*/
private RuntimeException handleInterruptedException(RequestExecutionContext context, InterruptedException e) {
if (e instanceof SdkInterruptedException) {
((SdkInterruptedException) e).getResponseStream().ifPresent(r -> invokeSafely(r::close));
}
if (context.apiCallAttemptTimeoutTracker().hasExecuted()) {
// Clear the interrupt status
Thread.interrupted();
return generateApiCallAttemptTimeoutException(context);
}
Thread.currentThread().interrupt();
return AbortedException.create("Thread was interrupted", e);
}
private ApiCallAttemptTimeoutException generateApiCallAttemptTimeoutException(RequestExecutionContext context) {
return ApiCallAttemptTimeoutException.create(
resolveTimeoutInMillis(context.requestConfig()::apiCallAttemptTimeout, apiCallAttemptTimeout));
}
}
| 1,963 |
0 | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http/pipeline | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http/pipeline/stages/ApiCallAttemptMetricCollectionStage.java | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.awssdk.core.internal.http.pipeline.stages;
import static software.amazon.awssdk.core.internal.util.MetricUtils.collectHttpMetrics;
import static software.amazon.awssdk.core.internal.util.MetricUtils.createAttemptMetricsCollector;
import java.time.Duration;
import software.amazon.awssdk.annotations.SdkInternalApi;
import software.amazon.awssdk.core.Response;
import software.amazon.awssdk.core.internal.http.RequestExecutionContext;
import software.amazon.awssdk.core.internal.http.pipeline.RequestPipeline;
import software.amazon.awssdk.core.internal.http.pipeline.RequestToResponsePipeline;
import software.amazon.awssdk.core.internal.http.pipeline.stages.utils.RetryableStageHelper;
import software.amazon.awssdk.core.internal.metrics.SdkErrorType;
import software.amazon.awssdk.core.metrics.CoreMetric;
import software.amazon.awssdk.http.SdkHttpFullRequest;
import software.amazon.awssdk.metrics.MetricCollector;
/**
* Wrapper pipeline that initializes and tracks the API call attempt metric collection. This wrapper and any wrapped
* stages will track API call attempt metrics.
*/
@SdkInternalApi
public final class ApiCallAttemptMetricCollectionStage<OutputT> implements RequestToResponsePipeline<OutputT> {
private final RequestPipeline<SdkHttpFullRequest, Response<OutputT>> wrapped;
public ApiCallAttemptMetricCollectionStage(RequestPipeline<SdkHttpFullRequest, Response<OutputT>> wrapped) {
this.wrapped = wrapped;
}
@Override
public Response<OutputT> execute(SdkHttpFullRequest input, RequestExecutionContext context) throws Exception {
MetricCollector apiCallAttemptMetrics = createAttemptMetricsCollector(context);
context.attemptMetricCollector(apiCallAttemptMetrics);
reportBackoffDelay(context);
try {
Response<OutputT> response = wrapped.execute(input, context);
collectHttpMetrics(apiCallAttemptMetrics, response.httpResponse());
if (!Boolean.TRUE.equals(response.isSuccess()) && response.exception() != null) {
reportErrorType(context, response.exception());
}
return response;
} catch (Exception e) {
reportErrorType(context, e);
throw e;
}
}
private void reportBackoffDelay(RequestExecutionContext context) {
Duration lastBackoffDelay = context.executionAttributes().getAttribute(RetryableStageHelper.LAST_BACKOFF_DELAY_DURATION);
if (lastBackoffDelay != null) {
context.attemptMetricCollector().reportMetric(CoreMetric.BACKOFF_DELAY_DURATION, lastBackoffDelay);
}
}
private void reportErrorType(RequestExecutionContext context, Exception e) {
context.attemptMetricCollector().reportMetric(CoreMetric.ERROR_TYPE, SdkErrorType.fromException(e).toString());
}
}
| 1,964 |
0 | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http/pipeline | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http/pipeline/stages/MakeHttpRequestStage.java | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.awssdk.core.internal.http.pipeline.stages;
import java.time.Duration;
import software.amazon.awssdk.annotations.SdkInternalApi;
import software.amazon.awssdk.core.client.config.SdkClientOption;
import software.amazon.awssdk.core.internal.http.HttpClientDependencies;
import software.amazon.awssdk.core.internal.http.InterruptMonitor;
import software.amazon.awssdk.core.internal.http.RequestExecutionContext;
import software.amazon.awssdk.core.internal.http.pipeline.RequestPipeline;
import software.amazon.awssdk.core.internal.util.MetricUtils;
import software.amazon.awssdk.core.metrics.CoreMetric;
import software.amazon.awssdk.http.ExecutableHttpRequest;
import software.amazon.awssdk.http.HttpExecuteRequest;
import software.amazon.awssdk.http.HttpExecuteResponse;
import software.amazon.awssdk.http.SdkHttpClient;
import software.amazon.awssdk.http.SdkHttpFullRequest;
import software.amazon.awssdk.http.SdkHttpFullResponse;
import software.amazon.awssdk.metrics.MetricCollector;
import software.amazon.awssdk.utils.Pair;
/**
* Delegate to the HTTP implementation to make an HTTP request and receive the response.
*/
@SdkInternalApi
public class MakeHttpRequestStage
implements RequestPipeline<SdkHttpFullRequest, Pair<SdkHttpFullRequest, SdkHttpFullResponse>> {
private final SdkHttpClient sdkHttpClient;
public MakeHttpRequestStage(HttpClientDependencies dependencies) {
this.sdkHttpClient = dependencies.clientConfiguration().option(SdkClientOption.SYNC_HTTP_CLIENT);
}
/**
* Returns the response from executing one httpClientSettings request; or null for retry.
*/
@Override
public Pair<SdkHttpFullRequest, SdkHttpFullResponse> execute(SdkHttpFullRequest request,
RequestExecutionContext context) throws Exception {
InterruptMonitor.checkInterrupted();
HttpExecuteResponse executeResponse = executeHttpRequest(request, context);
// TODO: Plumb through ExecuteResponse instead
SdkHttpFullResponse httpResponse = (SdkHttpFullResponse) executeResponse.httpResponse();
return Pair.of(request, httpResponse.toBuilder().content(executeResponse.responseBody().orElse(null)).build());
}
private HttpExecuteResponse executeHttpRequest(SdkHttpFullRequest request, RequestExecutionContext context) throws Exception {
MetricCollector attemptMetricCollector = context.attemptMetricCollector();
MetricCollector httpMetricCollector = MetricUtils.createHttpMetricsCollector(context);
ExecutableHttpRequest requestCallable = sdkHttpClient
.prepareRequest(HttpExecuteRequest.builder()
.request(request)
.metricCollector(httpMetricCollector)
.contentStreamProvider(request.contentStreamProvider().orElse(null))
.build());
context.apiCallTimeoutTracker().abortable(requestCallable);
context.apiCallAttemptTimeoutTracker().abortable(requestCallable);
Pair<HttpExecuteResponse, Duration> measuredExecute = MetricUtils.measureDurationUnsafe(requestCallable);
attemptMetricCollector.reportMetric(CoreMetric.SERVICE_CALL_DURATION, measuredExecute.right());
return measuredExecute.left();
}
}
| 1,965 |
0 | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http/pipeline | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http/pipeline/stages/AsyncExecutionFailureExceptionReportingStage.java | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.awssdk.core.internal.http.pipeline.stages;
import static software.amazon.awssdk.core.internal.http.pipeline.stages.utils.ExceptionReportingUtils.reportFailureToInterceptors;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionException;
import software.amazon.awssdk.annotations.SdkInternalApi;
import software.amazon.awssdk.core.internal.http.RequestExecutionContext;
import software.amazon.awssdk.core.internal.http.pipeline.RequestPipeline;
import software.amazon.awssdk.core.internal.util.ThrowableUtils;
import software.amazon.awssdk.http.SdkHttpFullRequest;
import software.amazon.awssdk.utils.CompletableFutureUtils;
@SdkInternalApi
public final class AsyncExecutionFailureExceptionReportingStage<OutputT>
implements RequestPipeline<SdkHttpFullRequest, CompletableFuture<OutputT>> {
private final RequestPipeline<SdkHttpFullRequest, CompletableFuture<OutputT>> wrapped;
public AsyncExecutionFailureExceptionReportingStage(RequestPipeline<SdkHttpFullRequest, CompletableFuture<OutputT>> wrapped) {
this.wrapped = wrapped;
}
@Override
public CompletableFuture<OutputT> execute(SdkHttpFullRequest input, RequestExecutionContext context) throws Exception {
CompletableFuture<OutputT> wrappedExecute = wrapped.execute(input, context);
CompletableFuture<OutputT> executeFuture = wrappedExecute.handle((o, t) -> {
if (t != null) {
Throwable toReport = t;
if (toReport instanceof CompletionException) {
toReport = toReport.getCause();
}
toReport = reportFailureToInterceptors(context, toReport);
throw CompletableFutureUtils.errorAsCompletionException(ThrowableUtils.asSdkException(toReport));
} else {
return o;
}
});
return CompletableFutureUtils.forwardExceptionTo(executeFuture, wrappedExecute);
}
}
| 1,966 |
0 | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http/pipeline | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http/pipeline/stages/ApiCallMetricCollectionStage.java | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.awssdk.core.internal.http.pipeline.stages;
import java.time.Duration;
import software.amazon.awssdk.annotations.SdkInternalApi;
import software.amazon.awssdk.core.Response;
import software.amazon.awssdk.core.internal.http.RequestExecutionContext;
import software.amazon.awssdk.core.internal.http.pipeline.RequestPipeline;
import software.amazon.awssdk.core.internal.http.pipeline.RequestToResponsePipeline;
import software.amazon.awssdk.core.internal.util.MetricUtils;
import software.amazon.awssdk.core.metrics.CoreMetric;
import software.amazon.awssdk.http.SdkHttpFullRequest;
import software.amazon.awssdk.metrics.MetricCollector;
/**
* Wrapper pipeline that tracks the {@link CoreMetric#API_CALL_DURATION} metric.
*/
@SdkInternalApi
public class ApiCallMetricCollectionStage<OutputT> implements RequestToResponsePipeline<OutputT> {
private final RequestPipeline<SdkHttpFullRequest, Response<OutputT>> wrapped;
public ApiCallMetricCollectionStage(RequestPipeline<SdkHttpFullRequest, Response<OutputT>> wrapped) {
this.wrapped = wrapped;
}
@Override
public Response<OutputT> execute(SdkHttpFullRequest input, RequestExecutionContext context) throws Exception {
MetricCollector metricCollector = context.executionContext().metricCollector();
MetricUtils.collectServiceEndpointMetrics(metricCollector, input);
// Note: at this point, any exception, even a service exception, will
// be thrown from the wrapped pipeline so we can't use
// MetricUtil.measureDuration()
long callStart = System.nanoTime();
try {
return wrapped.execute(input, context);
} finally {
long d = System.nanoTime() - callStart;
metricCollector.reportMetric(CoreMetric.API_CALL_DURATION, Duration.ofNanos(d));
}
}
}
| 1,967 |
0 | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http/pipeline | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http/pipeline/stages/MakeAsyncHttpRequestStage.java | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.awssdk.core.internal.http.pipeline.stages;
import static software.amazon.awssdk.core.interceptor.SdkInternalExecutionAttribute.SDK_HTTP_EXECUTION_ATTRIBUTES;
import static software.amazon.awssdk.core.internal.http.timers.TimerUtils.resolveTimeoutInMillis;
import static software.amazon.awssdk.http.Header.CONTENT_LENGTH;
import java.nio.ByteBuffer;
import java.time.Duration;
import java.util.Optional;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.Executor;
import java.util.concurrent.ScheduledExecutorService;
import java.util.function.Supplier;
import org.reactivestreams.Subscriber;
import software.amazon.awssdk.annotations.SdkInternalApi;
import software.amazon.awssdk.core.Response;
import software.amazon.awssdk.core.async.AsyncRequestBody;
import software.amazon.awssdk.core.client.config.SdkAdvancedAsyncClientOption;
import software.amazon.awssdk.core.client.config.SdkClientOption;
import software.amazon.awssdk.core.exception.ApiCallAttemptTimeoutException;
import software.amazon.awssdk.core.exception.SdkClientException;
import software.amazon.awssdk.core.interceptor.ExecutionAttributes;
import software.amazon.awssdk.core.interceptor.SdkInternalExecutionAttribute;
import software.amazon.awssdk.core.internal.http.HttpClientDependencies;
import software.amazon.awssdk.core.internal.http.RequestExecutionContext;
import software.amazon.awssdk.core.internal.http.TransformingAsyncResponseHandler;
import software.amazon.awssdk.core.internal.http.async.SimpleHttpContentPublisher;
import software.amazon.awssdk.core.internal.http.pipeline.RequestPipeline;
import software.amazon.awssdk.core.internal.http.timers.TimeoutTracker;
import software.amazon.awssdk.core.internal.http.timers.TimerUtils;
import software.amazon.awssdk.core.internal.util.MetricUtils;
import software.amazon.awssdk.core.metrics.CoreMetric;
import software.amazon.awssdk.http.SdkHttpFullRequest;
import software.amazon.awssdk.http.SdkHttpMethod;
import software.amazon.awssdk.http.async.AsyncExecuteRequest;
import software.amazon.awssdk.http.async.SdkAsyncHttpClient;
import software.amazon.awssdk.http.async.SdkHttpContentPublisher;
import software.amazon.awssdk.metrics.MetricCollector;
import software.amazon.awssdk.utils.CompletableFutureUtils;
import software.amazon.awssdk.utils.Logger;
/**
* Delegate to the HTTP implementation to make an HTTP request and receive the response.
*/
@SdkInternalApi
public final class MakeAsyncHttpRequestStage<OutputT>
implements RequestPipeline<CompletableFuture<SdkHttpFullRequest>, CompletableFuture<Response<OutputT>>> {
private static final Logger log = Logger.loggerFor(MakeAsyncHttpRequestStage.class);
private final SdkAsyncHttpClient sdkAsyncHttpClient;
private final TransformingAsyncResponseHandler<Response<OutputT>> responseHandler;
private final Executor futureCompletionExecutor;
private final ScheduledExecutorService timeoutExecutor;
private final Duration apiCallAttemptTimeout;
public MakeAsyncHttpRequestStage(TransformingAsyncResponseHandler<Response<OutputT>> responseHandler,
HttpClientDependencies dependencies) {
this.responseHandler = responseHandler;
this.futureCompletionExecutor =
dependencies.clientConfiguration().option(SdkAdvancedAsyncClientOption.FUTURE_COMPLETION_EXECUTOR);
this.sdkAsyncHttpClient = dependencies.clientConfiguration().option(SdkClientOption.ASYNC_HTTP_CLIENT);
this.apiCallAttemptTimeout = dependencies.clientConfiguration().option(SdkClientOption.API_CALL_ATTEMPT_TIMEOUT);
this.timeoutExecutor = dependencies.clientConfiguration().option(SdkClientOption.SCHEDULED_EXECUTOR_SERVICE);
}
@Override
public CompletableFuture<Response<OutputT>> execute(CompletableFuture<SdkHttpFullRequest> requestFuture,
RequestExecutionContext context) {
CompletableFuture<Response<OutputT>> toReturn = new CompletableFuture<>();
// Setup the cancellations. If the caller fails to provide a request, forward the exception to the future we
// return
CompletableFutureUtils.forwardExceptionTo(requestFuture, toReturn);
// On the other hand, if the future we return is completed exceptionally, throw the exception back up to the
// request future
CompletableFutureUtils.forwardExceptionTo(toReturn, requestFuture);
requestFuture.thenAccept(request -> {
// At this point, we have a request that we're ready to execute; we do everything in a try-catch in case the
// method call to executeHttpRequest throws directly
try {
CompletableFuture<Response<OutputT>> executeFuture = executeHttpRequest(request, context);
executeFuture.whenComplete((r, t) -> {
if (t != null) {
toReturn.completeExceptionally(t);
} else {
toReturn.complete(r);
}
});
// Similar to cancelling the request future, but we've now started the request execution, so if our
// returned future gets an exception, forward to the HTTP execution future
CompletableFutureUtils.forwardExceptionTo(toReturn, executeFuture);
} catch (Throwable t) {
toReturn.completeExceptionally(t);
}
});
return toReturn;
}
private CompletableFuture<Response<OutputT>> executeHttpRequest(SdkHttpFullRequest request,
RequestExecutionContext context) {
CompletableFuture<Response<OutputT>> responseFuture = new CompletableFuture<>();
CompletableFuture<Response<OutputT>> responseHandlerFuture = responseHandler.prepare();
SdkHttpContentPublisher requestProvider = context.requestProvider() == null
? new SimpleHttpContentPublisher(request)
: new SdkHttpContentPublisherAdapter(context.requestProvider());
// Set content length if it hasn't been set already.
SdkHttpFullRequest requestWithContentLength = getRequestWithContentLength(request, requestProvider);
MetricCollector httpMetricCollector = MetricUtils.createHttpMetricsCollector(context);
AsyncExecuteRequest.Builder executeRequestBuilder = AsyncExecuteRequest.builder()
.request(requestWithContentLength)
.requestContentPublisher(requestProvider)
.responseHandler(responseHandler)
.fullDuplex(isFullDuplex(context.executionAttributes()))
.metricCollector(httpMetricCollector);
if (context.executionAttributes().getAttribute(SDK_HTTP_EXECUTION_ATTRIBUTES) != null) {
executeRequestBuilder.httpExecutionAttributes(
context.executionAttributes()
.getAttribute(SDK_HTTP_EXECUTION_ATTRIBUTES));
}
CompletableFuture<Void> httpClientFuture = doExecuteHttpRequest(context, executeRequestBuilder.build());
TimeoutTracker timeoutTracker = setupAttemptTimer(responseFuture, context);
context.apiCallAttemptTimeoutTracker(timeoutTracker);
// Forward the cancellation
responseFuture.whenComplete((r, t) -> {
if (t != null) {
httpClientFuture.completeExceptionally(t);
}
});
// Attempt to offload the completion of the future returned from this
// stage onto the future completion executor
CompletableFuture<Void> asyncComplete =
responseHandlerFuture.handleAsync((r, t) -> {
completeResponseFuture(responseFuture, r, t);
return null;
},
futureCompletionExecutor);
// It's possible the async execution above fails. If so, log a warning,
// and just complete it synchronously.
asyncComplete.whenComplete((ignored, asyncCompleteError) -> {
if (asyncCompleteError != null) {
log.debug(() -> String.format("Could not complete the service call future on the provided "
+ "FUTURE_COMPLETION_EXECUTOR. The future will be completed synchronously by thread"
+ " %s. This may be an indication that the executor is being overwhelmed by too"
+ " many requests, and it may negatively affect performance. Consider changing "
+ "the configuration of the executor to accommodate the load through the client.",
Thread.currentThread().getName()),
asyncCompleteError);
responseHandlerFuture.whenComplete((r, t) -> completeResponseFuture(responseFuture, r, t));
}
});
return responseFuture;
}
private CompletableFuture<Void> doExecuteHttpRequest(RequestExecutionContext context, AsyncExecuteRequest executeRequest) {
MetricCollector metricCollector = context.attemptMetricCollector();
long callStart = System.nanoTime();
CompletableFuture<Void> httpClientFuture = sdkAsyncHttpClient.execute(executeRequest);
CompletableFuture<Void> result = httpClientFuture.whenComplete((r, t) -> {
long duration = System.nanoTime() - callStart;
metricCollector.reportMetric(CoreMetric.SERVICE_CALL_DURATION, Duration.ofNanos(duration));
});
// Make sure failures on the result future are forwarded to the http client future.
CompletableFutureUtils.forwardExceptionTo(result, httpClientFuture);
return result;
}
private boolean isFullDuplex(ExecutionAttributes executionAttributes) {
return executionAttributes.getAttribute(SdkInternalExecutionAttribute.IS_FULL_DUPLEX) != null &&
executionAttributes.getAttribute(SdkInternalExecutionAttribute.IS_FULL_DUPLEX);
}
private SdkHttpFullRequest getRequestWithContentLength(SdkHttpFullRequest request, SdkHttpContentPublisher requestProvider) {
if (shouldSetContentLength(request, requestProvider)) {
return request.toBuilder()
.putHeader(CONTENT_LENGTH, String.valueOf(requestProvider.contentLength().get()))
.build();
}
return request;
}
private boolean shouldSetContentLength(SdkHttpFullRequest request, SdkHttpContentPublisher requestProvider) {
if (request.method() == SdkHttpMethod.GET || request.method() == SdkHttpMethod.HEAD ||
request.firstMatchingHeader(CONTENT_LENGTH).isPresent()) {
return false;
}
return Optional.ofNullable(requestProvider).flatMap(SdkHttpContentPublisher::contentLength).isPresent();
}
private TimeoutTracker setupAttemptTimer(CompletableFuture<Response<OutputT>> executeFuture, RequestExecutionContext ctx) {
long timeoutMillis = resolveTimeoutInMillis(ctx.requestConfig()::apiCallAttemptTimeout, apiCallAttemptTimeout);
Supplier<SdkClientException> exceptionSupplier = () -> ApiCallAttemptTimeoutException.create(timeoutMillis);
return TimerUtils.timeAsyncTaskIfNeeded(executeFuture,
timeoutExecutor,
exceptionSupplier,
timeoutMillis);
}
private void completeResponseFuture(CompletableFuture<Response<OutputT>> responseFuture, Response<OutputT> r, Throwable t) {
if (t == null) {
responseFuture.complete(r);
} else {
responseFuture.completeExceptionally(t);
}
}
/**
* When an operation has a streaming input, the customer must supply an {@link AsyncRequestBody} to
* provide the request content in a non-blocking manner. This adapts that interface to the
* {@link SdkHttpContentPublisher} which the HTTP client SPI expects.
*/
private static final class SdkHttpContentPublisherAdapter implements SdkHttpContentPublisher {
private final AsyncRequestBody asyncRequestBody;
private SdkHttpContentPublisherAdapter(AsyncRequestBody asyncRequestBody) {
this.asyncRequestBody = asyncRequestBody;
}
@Override
public Optional<Long> contentLength() {
return asyncRequestBody.contentLength();
}
@Override
public void subscribe(Subscriber<? super ByteBuffer> s) {
asyncRequestBody.subscribe(s);
}
}
}
| 1,968 |
0 | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http/pipeline | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http/pipeline/stages/MergeCustomQueryParamsStage.java | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.awssdk.core.internal.http.pipeline.stages;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import software.amazon.awssdk.annotations.SdkInternalApi;
import software.amazon.awssdk.core.internal.http.RequestExecutionContext;
import software.amazon.awssdk.core.internal.http.pipeline.MutableRequestToRequestPipeline;
import software.amazon.awssdk.http.SdkHttpFullRequest;
import software.amazon.awssdk.utils.CollectionUtils;
/**
* Merge customer supplied query params into the marshalled request.
*/
@SdkInternalApi
public class MergeCustomQueryParamsStage implements MutableRequestToRequestPipeline {
@Override
public SdkHttpFullRequest.Builder execute(SdkHttpFullRequest.Builder request, RequestExecutionContext context)
throws Exception {
return request.rawQueryParameters(mergeParams(request, context));
}
private Map<String, List<String>> mergeParams(SdkHttpFullRequest.Builder request, RequestExecutionContext context) {
Map<String, List<String>> merged = new LinkedHashMap<>(request.numRawQueryParameters());
request.forEachRawQueryParameter(merged::put);
context.requestConfig().rawQueryParameters()
.forEach((key, val) -> merged.put(key, CollectionUtils.mergeLists(merged.get(key), val)));
return merged;
}
}
| 1,969 |
0 | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http/pipeline | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http/pipeline/stages/ExecutionFailureExceptionReportingStage.java | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.awssdk.core.internal.http.pipeline.stages;
import static software.amazon.awssdk.core.internal.http.pipeline.stages.utils.ExceptionReportingUtils.reportFailureToInterceptors;
import static software.amazon.awssdk.core.internal.util.ThrowableUtils.failure;
import software.amazon.awssdk.annotations.SdkInternalApi;
import software.amazon.awssdk.core.internal.http.RequestExecutionContext;
import software.amazon.awssdk.core.internal.http.pipeline.RequestPipeline;
import software.amazon.awssdk.http.SdkHttpFullRequest;
@SdkInternalApi
public final class ExecutionFailureExceptionReportingStage<OutputT> implements RequestPipeline<SdkHttpFullRequest, OutputT> {
private final RequestPipeline<SdkHttpFullRequest, OutputT> wrapped;
public ExecutionFailureExceptionReportingStage(RequestPipeline<SdkHttpFullRequest, OutputT> wrapped) {
this.wrapped = wrapped;
}
@Override
public OutputT execute(SdkHttpFullRequest input, RequestExecutionContext context) throws Exception {
try {
return wrapped.execute(input, context);
} catch (Exception e) {
Throwable throwable = reportFailureToInterceptors(context, e);
throw failure(throwable);
}
}
}
| 1,970 |
0 | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http/pipeline | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http/pipeline/stages/CompressRequestStage.java | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.awssdk.core.internal.http.pipeline.stages;
import static software.amazon.awssdk.core.client.config.SdkClientOption.COMPRESSION_CONFIGURATION;
import java.io.IOException;
import java.io.InputStream;
import java.io.UncheckedIOException;
import java.util.List;
import java.util.Locale;
import java.util.Optional;
import software.amazon.awssdk.annotations.SdkInternalApi;
import software.amazon.awssdk.core.CompressionConfiguration;
import software.amazon.awssdk.core.RequestOverrideConfiguration;
import software.amazon.awssdk.core.SdkBytes;
import software.amazon.awssdk.core.exception.SdkClientException;
import software.amazon.awssdk.core.interceptor.ExecutionAttributes;
import software.amazon.awssdk.core.interceptor.SdkInternalExecutionAttribute;
import software.amazon.awssdk.core.internal.async.CompressionAsyncRequestBody;
import software.amazon.awssdk.core.internal.compression.Compressor;
import software.amazon.awssdk.core.internal.compression.CompressorType;
import software.amazon.awssdk.core.internal.http.HttpClientDependencies;
import software.amazon.awssdk.core.internal.http.RequestExecutionContext;
import software.amazon.awssdk.core.internal.http.pipeline.MutableRequestToRequestPipeline;
import software.amazon.awssdk.core.internal.sync.CompressionContentStreamProvider;
import software.amazon.awssdk.http.ContentStreamProvider;
import software.amazon.awssdk.http.SdkHttpFullRequest;
import software.amazon.awssdk.utils.IoUtils;
/**
* Compress requests whose operations are marked with the "requestCompression" C2J trait.
*/
@SdkInternalApi
public class CompressRequestStage implements MutableRequestToRequestPipeline {
public static final int DEFAULT_MIN_COMPRESSION_SIZE = 10_240;
private static final int MIN_COMPRESSION_SIZE_LIMIT = 10_485_760;
private final CompressionConfiguration compressionConfig;
public CompressRequestStage(HttpClientDependencies dependencies) {
compressionConfig = dependencies.clientConfiguration().option(COMPRESSION_CONFIGURATION);
}
@Override
public SdkHttpFullRequest.Builder execute(SdkHttpFullRequest.Builder input, RequestExecutionContext context)
throws Exception {
if (!shouldCompress(input, context)) {
return input;
}
Compressor compressor = resolveCompressorType(context.executionAttributes());
if (!isStreaming(context)) {
compressEntirePayload(input, compressor);
updateContentEncodingHeader(input, compressor);
updateContentLengthHeader(input);
return input;
}
if (!isTransferEncodingChunked(input)) {
return input;
}
if (context.requestProvider() == null) {
input.contentStreamProvider(new CompressionContentStreamProvider(input.contentStreamProvider(), compressor));
} else {
context.requestProvider(CompressionAsyncRequestBody.builder()
.asyncRequestBody(context.requestProvider())
.compressor(compressor)
.build());
}
updateContentEncodingHeader(input, compressor);
return input;
}
private boolean shouldCompress(SdkHttpFullRequest.Builder input, RequestExecutionContext context) {
if (context.executionAttributes().getAttribute(SdkInternalExecutionAttribute.REQUEST_COMPRESSION) == null) {
return false;
}
if (resolveCompressorType(context.executionAttributes()) == null) {
return false;
}
if (!resolveRequestCompressionEnabled(context)) {
return false;
}
if (isStreaming(context)) {
return true;
}
if (input.contentStreamProvider() == null) {
return false;
}
return isRequestSizeWithinThreshold(input, context);
}
private boolean isStreaming(RequestExecutionContext context) {
return context.executionAttributes().getAttribute(SdkInternalExecutionAttribute.REQUEST_COMPRESSION).isStreaming();
}
private void compressEntirePayload(SdkHttpFullRequest.Builder input, Compressor compressor) {
ContentStreamProvider wrappedProvider = input.contentStreamProvider();
ContentStreamProvider compressedStreamProvider = () -> compressor.compress(wrappedProvider.newStream());
input.contentStreamProvider(compressedStreamProvider);
}
private void updateContentEncodingHeader(SdkHttpFullRequest.Builder input,
Compressor compressor) {
if (input.firstMatchingHeader("Content-encoding").isPresent()) {
input.appendHeader("Content-encoding", compressor.compressorType());
} else {
input.putHeader("Content-encoding", compressor.compressorType());
}
}
private void updateContentLengthHeader(SdkHttpFullRequest.Builder input) {
InputStream inputStream = input.contentStreamProvider().newStream();
try {
byte[] bytes = IoUtils.toByteArray(inputStream);
String length = String.valueOf(bytes.length);
input.putHeader("Content-Length", length);
} catch (IOException e) {
throw new UncheckedIOException(e);
}
}
private boolean isTransferEncodingChunked(SdkHttpFullRequest.Builder input) {
return input.firstMatchingHeader("Transfer-Encoding")
.map(headerValue -> headerValue.equals("chunked"))
.orElse(false);
}
private Compressor resolveCompressorType(ExecutionAttributes executionAttributes) {
List<String> encodings =
executionAttributes.getAttribute(SdkInternalExecutionAttribute.REQUEST_COMPRESSION).getEncodings();
for (String encoding: encodings) {
encoding = encoding.toLowerCase(Locale.ROOT);
if (CompressorType.isSupported(encoding)) {
return CompressorType.of(encoding).newCompressor();
}
}
return null;
}
private boolean resolveRequestCompressionEnabled(RequestExecutionContext context) {
Optional<Boolean> requestCompressionEnabledRequestLevel =
context.originalRequest().overrideConfiguration()
.flatMap(RequestOverrideConfiguration::compressionConfiguration)
.map(CompressionConfiguration::requestCompressionEnabled);
if (requestCompressionEnabledRequestLevel.isPresent()) {
return requestCompressionEnabledRequestLevel.get();
}
Boolean isEnabled = compressionConfig.requestCompressionEnabled();
if (isEnabled != null) {
return isEnabled;
}
return true;
}
private boolean isRequestSizeWithinThreshold(SdkHttpFullRequest.Builder input, RequestExecutionContext context) {
int minimumCompressionThreshold = resolveMinCompressionSize(context);
validateMinCompressionSizeInput(minimumCompressionThreshold);
int requestSize = SdkBytes.fromInputStream(input.contentStreamProvider().newStream()).asByteArray().length;
return requestSize >= minimumCompressionThreshold;
}
private int resolveMinCompressionSize(RequestExecutionContext context) {
Optional<Integer> minimumCompressionSizeRequestLevel =
context.originalRequest().overrideConfiguration()
.flatMap(RequestOverrideConfiguration::compressionConfiguration)
.map(CompressionConfiguration::minimumCompressionThresholdInBytes);
if (minimumCompressionSizeRequestLevel.isPresent()) {
return minimumCompressionSizeRequestLevel.get();
}
Integer threshold = compressionConfig.minimumCompressionThresholdInBytes();
if (threshold != null) {
return threshold;
}
return DEFAULT_MIN_COMPRESSION_SIZE;
}
private void validateMinCompressionSizeInput(int minCompressionSize) {
if (!(minCompressionSize >= 0 && minCompressionSize <= MIN_COMPRESSION_SIZE_LIMIT)) {
throw SdkClientException.create("The minimum compression size must be non-negative with a maximum value of "
+ "10485760.", new IllegalArgumentException());
}
}
}
| 1,971 |
0 | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http/pipeline | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http/pipeline/stages/MakeRequestMutableStage.java | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.awssdk.core.internal.http.pipeline.stages;
import software.amazon.awssdk.annotations.SdkInternalApi;
import software.amazon.awssdk.core.internal.http.RequestExecutionContext;
import software.amazon.awssdk.core.internal.http.pipeline.RequestPipeline;
import software.amazon.awssdk.http.SdkHttpFullRequest;
@SdkInternalApi
public class MakeRequestMutableStage implements RequestPipeline<SdkHttpFullRequest, SdkHttpFullRequest.Builder> {
@Override
public SdkHttpFullRequest.Builder execute(SdkHttpFullRequest input, RequestExecutionContext context) throws Exception {
return input.toBuilder();
}
}
| 1,972 |
0 | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http/pipeline | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http/pipeline/stages/AfterExecutionInterceptorsStage.java | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.awssdk.core.internal.http.pipeline.stages;
import software.amazon.awssdk.annotations.SdkInternalApi;
import software.amazon.awssdk.core.internal.http.RequestExecutionContext;
import software.amazon.awssdk.core.internal.http.pipeline.RequestPipeline;
@SdkInternalApi
public class AfterExecutionInterceptorsStage<OutputT> implements RequestPipeline<OutputT, OutputT> {
@Override
public OutputT execute(OutputT input, RequestExecutionContext context) throws Exception {
context.interceptorChain().afterExecution(context.executionContext().interceptorContext(),
context.executionAttributes());
return input;
}
}
| 1,973 |
0 | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http/pipeline | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http/pipeline/stages/AsyncApiCallMetricCollectionStage.java | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.awssdk.core.internal.http.pipeline.stages;
import java.time.Duration;
import java.util.concurrent.CompletableFuture;
import software.amazon.awssdk.annotations.SdkInternalApi;
import software.amazon.awssdk.core.internal.http.RequestExecutionContext;
import software.amazon.awssdk.core.internal.http.pipeline.RequestPipeline;
import software.amazon.awssdk.core.internal.util.MetricUtils;
import software.amazon.awssdk.core.metrics.CoreMetric;
import software.amazon.awssdk.http.SdkHttpFullRequest;
import software.amazon.awssdk.metrics.MetricCollector;
import software.amazon.awssdk.utils.CompletableFutureUtils;
/**
* Wrapper pipeline that tracks the {@link CoreMetric#API_CALL_DURATION} metric.
*/
@SdkInternalApi
public final class AsyncApiCallMetricCollectionStage<OutputT> implements RequestPipeline<SdkHttpFullRequest,
CompletableFuture<OutputT>> {
private final RequestPipeline<SdkHttpFullRequest, CompletableFuture<OutputT>> wrapped;
public AsyncApiCallMetricCollectionStage(RequestPipeline<SdkHttpFullRequest, CompletableFuture<OutputT>> wrapped) {
this.wrapped = wrapped;
}
@Override
public CompletableFuture<OutputT> execute(SdkHttpFullRequest input, RequestExecutionContext context) throws Exception {
MetricCollector metricCollector = context.executionContext().metricCollector();
MetricUtils.collectServiceEndpointMetrics(metricCollector, input);
CompletableFuture<OutputT> future = new CompletableFuture<>();
long callStart = System.nanoTime();
CompletableFuture<OutputT> executeFuture = wrapped.execute(input, context);
executeFuture.whenComplete((r, t) -> {
long duration = System.nanoTime() - callStart;
metricCollector.reportMetric(CoreMetric.API_CALL_DURATION, Duration.ofNanos(duration));
if (t != null) {
future.completeExceptionally(t);
} else {
future.complete(r);
}
});
return CompletableFutureUtils.forwardExceptionTo(future, executeFuture);
}
}
| 1,974 |
0 | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http/pipeline | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http/pipeline/stages/HandleResponseStage.java | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.awssdk.core.internal.http.pipeline.stages;
import software.amazon.awssdk.annotations.SdkInternalApi;
import software.amazon.awssdk.core.Response;
import software.amazon.awssdk.core.http.HttpResponseHandler;
import software.amazon.awssdk.core.internal.http.RequestExecutionContext;
import software.amazon.awssdk.core.internal.http.pipeline.RequestPipeline;
import software.amazon.awssdk.http.SdkHttpFullResponse;
/**
* Pipeline stage that executes an {@link HttpResponseHandler} to transform the response into a {@link Response}
* object that contains a flag indicating success of failure and an unmarshalled response object or exception as
* appropriate.
*/
@SdkInternalApi
public class HandleResponseStage<OutputT> implements RequestPipeline<SdkHttpFullResponse, Response<OutputT>> {
private final HttpResponseHandler<Response<OutputT>> responseHandler;
public HandleResponseStage(HttpResponseHandler<Response<OutputT>> responseHandler) {
this.responseHandler = responseHandler;
}
@Override
public Response<OutputT> execute(SdkHttpFullResponse httpResponse, RequestExecutionContext context) throws Exception {
return responseHandler.handle(httpResponse, context.executionAttributes());
}
}
| 1,975 |
0 | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http/pipeline | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http/pipeline/stages/AsyncApiCallTimeoutTrackingStage.java | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.awssdk.core.internal.http.pipeline.stages;
import static software.amazon.awssdk.core.internal.http.timers.TimerUtils.resolveTimeoutInMillis;
import static software.amazon.awssdk.core.internal.http.timers.TimerUtils.timeAsyncTaskIfNeeded;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ScheduledExecutorService;
import java.util.function.Supplier;
import software.amazon.awssdk.annotations.SdkInternalApi;
import software.amazon.awssdk.core.client.config.SdkClientConfiguration;
import software.amazon.awssdk.core.client.config.SdkClientOption;
import software.amazon.awssdk.core.exception.ApiCallTimeoutException;
import software.amazon.awssdk.core.exception.SdkClientException;
import software.amazon.awssdk.core.internal.http.HttpClientDependencies;
import software.amazon.awssdk.core.internal.http.RequestExecutionContext;
import software.amazon.awssdk.core.internal.http.pipeline.RequestPipeline;
import software.amazon.awssdk.core.internal.http.timers.TimeoutTracker;
import software.amazon.awssdk.http.SdkHttpFullRequest;
import software.amazon.awssdk.utils.CompletableFutureUtils;
@SdkInternalApi
public class AsyncApiCallTimeoutTrackingStage<OutputT>
implements RequestPipeline<SdkHttpFullRequest, CompletableFuture<OutputT>> {
private final RequestPipeline<SdkHttpFullRequest, CompletableFuture<OutputT>> requestPipeline;
private final SdkClientConfiguration clientConfig;
private final ScheduledExecutorService scheduledExecutor;
public AsyncApiCallTimeoutTrackingStage(HttpClientDependencies dependencies,
RequestPipeline<SdkHttpFullRequest, CompletableFuture<OutputT>> requestPipeline) {
this.requestPipeline = requestPipeline;
this.scheduledExecutor = dependencies.clientConfiguration().option(SdkClientOption.SCHEDULED_EXECUTOR_SERVICE);
this.clientConfig = dependencies.clientConfiguration();
}
@Override
public CompletableFuture<OutputT> execute(SdkHttpFullRequest input, RequestExecutionContext context) throws Exception {
CompletableFuture<OutputT> future = new CompletableFuture<>();
long apiCallTimeoutInMillis = resolveTimeoutInMillis(() -> context.requestConfig().apiCallTimeout(),
clientConfig.option(SdkClientOption.API_CALL_TIMEOUT));
Supplier<SdkClientException> exceptionSupplier = () -> ApiCallTimeoutException.create(apiCallTimeoutInMillis);
TimeoutTracker timeoutTracker = timeAsyncTaskIfNeeded(future,
scheduledExecutor,
exceptionSupplier,
apiCallTimeoutInMillis);
context.apiCallTimeoutTracker(timeoutTracker);
CompletableFuture<OutputT> executeFuture = requestPipeline.execute(input, context);
executeFuture.whenComplete((r, t) -> {
if (t != null) {
future.completeExceptionally(t);
} else {
future.complete(r);
}
});
return CompletableFutureUtils.forwardExceptionTo(future, executeFuture);
}
}
| 1,976 |
0 | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http/pipeline | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http/pipeline/stages/UnwrapResponseContainer.java | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.awssdk.core.internal.http.pipeline.stages;
import software.amazon.awssdk.annotations.SdkInternalApi;
import software.amazon.awssdk.core.Response;
import software.amazon.awssdk.core.internal.http.RequestExecutionContext;
import software.amazon.awssdk.core.internal.http.pipeline.RequestPipeline;
/**
* Unwrap a {@link Response} container to just the POJO result. If we've gotten this far
* then the Response container can only be a success response, otherwise the exception would have
* been thrown out of the pipeline.
*
* @param <OutputT> POJO result type.
*/
@SdkInternalApi
public class UnwrapResponseContainer<OutputT> implements RequestPipeline<Response<OutputT>, OutputT> {
@Override
public OutputT execute(Response<OutputT> input, RequestExecutionContext context) throws Exception {
return input.response();
}
}
| 1,977 |
0 | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http/pipeline | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http/pipeline/stages/SigningStage.java | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.awssdk.core.internal.http.pipeline.stages;
import java.time.Clock;
import java.time.Duration;
import java.util.concurrent.CompletableFuture;
import software.amazon.awssdk.annotations.SdkInternalApi;
import software.amazon.awssdk.core.SelectedAuthScheme;
import software.amazon.awssdk.core.http.ExecutionContext;
import software.amazon.awssdk.core.interceptor.ExecutionAttributes;
import software.amazon.awssdk.core.interceptor.SdkExecutionAttribute;
import software.amazon.awssdk.core.interceptor.SdkInternalExecutionAttribute;
import software.amazon.awssdk.core.internal.http.HttpClientDependencies;
import software.amazon.awssdk.core.internal.http.InterruptMonitor;
import software.amazon.awssdk.core.internal.http.RequestExecutionContext;
import software.amazon.awssdk.core.internal.http.pipeline.RequestToRequestPipeline;
import software.amazon.awssdk.core.internal.util.MetricUtils;
import software.amazon.awssdk.core.metrics.CoreMetric;
import software.amazon.awssdk.core.signer.Signer;
import software.amazon.awssdk.http.SdkHttpFullRequest;
import software.amazon.awssdk.http.SdkHttpRequest;
import software.amazon.awssdk.http.auth.spi.scheme.AuthSchemeOption;
import software.amazon.awssdk.http.auth.spi.signer.HttpSigner;
import software.amazon.awssdk.http.auth.spi.signer.SignRequest;
import software.amazon.awssdk.http.auth.spi.signer.SignedRequest;
import software.amazon.awssdk.identity.spi.Identity;
import software.amazon.awssdk.metrics.MetricCollector;
import software.amazon.awssdk.utils.CompletableFutureUtils;
import software.amazon.awssdk.utils.Logger;
import software.amazon.awssdk.utils.Pair;
/**
* Sign the marshalled request (if applicable).
*/
// TODO how does signing work with a request provider
@SdkInternalApi
public class SigningStage implements RequestToRequestPipeline {
private static final Logger log = Logger.loggerFor(SigningStage.class);
private final HttpClientDependencies dependencies;
public SigningStage(HttpClientDependencies dependencies) {
this.dependencies = dependencies;
}
/**
* Returns the response from executing one httpClientSettings request; or null for retry.
*/
@Override
public SdkHttpFullRequest execute(SdkHttpFullRequest request, RequestExecutionContext context) throws Exception {
InterruptMonitor.checkInterrupted();
updateHttpRequestInInterceptorContext(request, context.executionContext());
// Whether pre / post SRA, if old Signer is setup in context, that's the one to use
if (context.signer() != null) {
return signRequest(request, context);
}
// else if AUTH_SCHEMES != null (implies SRA), use SelectedAuthScheme
if (context.executionAttributes().getAttribute(SdkInternalExecutionAttribute.AUTH_SCHEMES) != null) {
SelectedAuthScheme<?> selectedAuthScheme =
context.executionAttributes().getAttribute(SdkInternalExecutionAttribute.SELECTED_AUTH_SCHEME);
log.debug(() -> String.format("Using SelectedAuthScheme: %s", selectedAuthScheme.authSchemeOption().schemeId()));
return sraSignRequest(request, context, selectedAuthScheme);
}
// else, this implies pre SRA client, with authType=None, so don't need to do anything
return request;
}
private <T extends Identity> SdkHttpFullRequest sraSignRequest(SdkHttpFullRequest request,
RequestExecutionContext context,
SelectedAuthScheme<T> selectedAuthScheme) {
adjustForClockSkew(context.executionAttributes());
CompletableFuture<? extends T> identityFuture = selectedAuthScheme.identity();
T identity = CompletableFutureUtils.joinLikeSync(identityFuture);
Pair<SdkHttpFullRequest, Duration> measuredSign = MetricUtils.measureDuration(
() -> doSraSign(request, selectedAuthScheme, identity));
context.attemptMetricCollector().reportMetric(CoreMetric.SIGNING_DURATION, measuredSign.right());
SdkHttpFullRequest signedRequest = measuredSign.left();
updateHttpRequestInInterceptorContext(signedRequest, context.executionContext());
return signedRequest;
}
private <T extends Identity> SdkHttpFullRequest doSraSign(SdkHttpFullRequest request,
SelectedAuthScheme<T> selectedAuthScheme,
T identity) {
SignRequest.Builder<T> signRequestBuilder = SignRequest
.builder(identity)
.putProperty(HttpSigner.SIGNING_CLOCK, signingClock())
.request(request)
.payload(request.contentStreamProvider().orElse(null));
AuthSchemeOption authSchemeOption = selectedAuthScheme.authSchemeOption();
authSchemeOption.forEachSignerProperty(signRequestBuilder::putProperty);
HttpSigner<T> signer = selectedAuthScheme.signer();
SignedRequest signedRequest = signer.sign(signRequestBuilder.build());
return toSdkHttpFullRequest(signedRequest);
}
private SdkHttpFullRequest toSdkHttpFullRequest(SignedRequest signedRequest) {
SdkHttpRequest request = signedRequest.request();
return SdkHttpFullRequest.builder()
.contentStreamProvider(signedRequest.payload().orElse(null))
.protocol(request.protocol())
.method(request.method())
.host(request.host())
.port(request.port())
.encodedPath(request.encodedPath())
.applyMutation(r -> request.forEachHeader(r::putHeader))
.applyMutation(r -> request.forEachRawQueryParameter(r::putRawQueryParameter))
.build();
}
/**
* Sign the request if the signer if provided and credentials are present.
*/
private SdkHttpFullRequest signRequest(SdkHttpFullRequest request, RequestExecutionContext context) {
Signer signer = context.signer();
MetricCollector metricCollector = context.attemptMetricCollector();
adjustForClockSkew(context.executionAttributes());
Pair<SdkHttpFullRequest, Duration> measuredSign = MetricUtils.measureDuration(
() -> signer.sign(request, context.executionAttributes()));
metricCollector.reportMetric(CoreMetric.SIGNING_DURATION, measuredSign.right());
SdkHttpFullRequest signedRequest = measuredSign.left();
updateHttpRequestInInterceptorContext(signedRequest, context.executionContext());
return signedRequest;
}
/**
* TODO: Remove when we stop having two copies of the request.
*/
private void updateHttpRequestInInterceptorContext(SdkHttpFullRequest request, ExecutionContext executionContext) {
executionContext.interceptorContext(executionContext.interceptorContext().copy(b -> b.httpRequest(request)));
}
/**
* Returns the {@link Clock} used for signing that already accounts for clock skew when detected by the retryable stage.
*/
private Clock signingClock() {
int offsetInSeconds = dependencies.timeOffset();
return Clock.offset(Clock.systemUTC(), Duration.ofSeconds(-offsetInSeconds));
}
/**
* Always use the client level timeOffset.
*/
private void adjustForClockSkew(ExecutionAttributes attributes) {
attributes.putAttribute(SdkExecutionAttribute.TIME_OFFSET, dependencies.timeOffset());
}
}
| 1,978 |
0 | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http/pipeline | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http/pipeline/stages/AsyncSigningStage.java | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.awssdk.core.internal.http.pipeline.stages;
import java.nio.ByteBuffer;
import java.time.Clock;
import java.time.Duration;
import java.util.Optional;
import java.util.concurrent.CompletableFuture;
import org.reactivestreams.Publisher;
import software.amazon.awssdk.annotations.SdkInternalApi;
import software.amazon.awssdk.core.SelectedAuthScheme;
import software.amazon.awssdk.core.async.AsyncRequestBody;
import software.amazon.awssdk.core.http.ExecutionContext;
import software.amazon.awssdk.core.interceptor.ExecutionAttributes;
import software.amazon.awssdk.core.interceptor.SdkExecutionAttribute;
import software.amazon.awssdk.core.interceptor.SdkInternalExecutionAttribute;
import software.amazon.awssdk.core.internal.http.HttpClientDependencies;
import software.amazon.awssdk.core.internal.http.RequestExecutionContext;
import software.amazon.awssdk.core.internal.http.pipeline.RequestPipeline;
import software.amazon.awssdk.core.internal.util.MetricUtils;
import software.amazon.awssdk.core.metrics.CoreMetric;
import software.amazon.awssdk.core.signer.AsyncRequestBodySigner;
import software.amazon.awssdk.core.signer.AsyncSigner;
import software.amazon.awssdk.core.signer.Signer;
import software.amazon.awssdk.http.SdkHttpFullRequest;
import software.amazon.awssdk.http.SdkHttpRequest;
import software.amazon.awssdk.http.auth.spi.scheme.AuthSchemeOption;
import software.amazon.awssdk.http.auth.spi.signer.AsyncSignRequest;
import software.amazon.awssdk.http.auth.spi.signer.AsyncSignedRequest;
import software.amazon.awssdk.http.auth.spi.signer.BaseSignedRequest;
import software.amazon.awssdk.http.auth.spi.signer.HttpSigner;
import software.amazon.awssdk.http.auth.spi.signer.SignRequest;
import software.amazon.awssdk.http.auth.spi.signer.SignedRequest;
import software.amazon.awssdk.identity.spi.Identity;
import software.amazon.awssdk.metrics.MetricCollector;
import software.amazon.awssdk.utils.Logger;
@SdkInternalApi
public class AsyncSigningStage implements RequestPipeline<SdkHttpFullRequest,
CompletableFuture<SdkHttpFullRequest>> {
private static final Logger log = Logger.loggerFor(AsyncSigningStage.class);
private final HttpClientDependencies dependencies;
public AsyncSigningStage(HttpClientDependencies dependencies) {
this.dependencies = dependencies;
}
/**
* Returns the response from executing one httpClientSettings request; or null for retry.
*/
@Override
public CompletableFuture<SdkHttpFullRequest> execute(SdkHttpFullRequest request, RequestExecutionContext context)
throws Exception {
updateHttpRequestInInterceptorContext(request, context.executionContext());
// Whether pre / post SRA, if old Signer is setup in context, that's the one to use
if (context.signer() != null) {
return signRequest(request, context);
}
// else if AUTH_SCHEMES != null (implies SRA), use SelectedAuthScheme
if (context.executionAttributes().getAttribute(SdkInternalExecutionAttribute.AUTH_SCHEMES) != null) {
SelectedAuthScheme<?> selectedAuthScheme =
context.executionAttributes().getAttribute(SdkInternalExecutionAttribute.SELECTED_AUTH_SCHEME);
log.debug(() -> String.format("Using SelectedAuthScheme: %s", selectedAuthScheme.authSchemeOption().schemeId()));
return sraSignRequest(request, context, selectedAuthScheme);
}
// else, this implies pre SRA client with authType=None, so don't need to do anything
return CompletableFuture.completedFuture(request);
}
private <T extends Identity> CompletableFuture<SdkHttpFullRequest> sraSignRequest(SdkHttpFullRequest request,
RequestExecutionContext context,
SelectedAuthScheme<T> selectedAuthScheme) {
adjustForClockSkew(context.executionAttributes());
CompletableFuture<? extends T> identityFuture = selectedAuthScheme.identity();
return identityFuture.thenCompose(identity -> {
CompletableFuture<SdkHttpFullRequest> signedRequestFuture = MetricUtils.reportDuration(
() -> doSraSign(request, context, selectedAuthScheme, identity),
context.attemptMetricCollector(),
CoreMetric.SIGNING_DURATION);
return signedRequestFuture.thenApply(r -> {
updateHttpRequestInInterceptorContext(r, context.executionContext());
return r;
});
});
}
private <T extends Identity> CompletableFuture<SdkHttpFullRequest> doSraSign(SdkHttpFullRequest request,
RequestExecutionContext context,
SelectedAuthScheme<T> selectedAuthScheme,
T identity) {
AuthSchemeOption authSchemeOption = selectedAuthScheme.authSchemeOption();
HttpSigner<T> signer = selectedAuthScheme.signer();
if (context.requestProvider() == null) {
SignRequest.Builder<T> signRequestBuilder = SignRequest
.builder(identity)
.putProperty(HttpSigner.SIGNING_CLOCK, signingClock())
.request(request)
.payload(request.contentStreamProvider().orElse(null));
authSchemeOption.forEachSignerProperty(signRequestBuilder::putProperty);
SignedRequest signedRequest = signer.sign(signRequestBuilder.build());
return CompletableFuture.completedFuture(toSdkHttpFullRequest(signedRequest));
}
AsyncSignRequest.Builder<T> signRequestBuilder = AsyncSignRequest
.builder(identity)
.putProperty(HttpSigner.SIGNING_CLOCK, signingClock())
.request(request)
.payload(context.requestProvider());
authSchemeOption.forEachSignerProperty(signRequestBuilder::putProperty);
CompletableFuture<AsyncSignedRequest> signedRequestFuture = signer.signAsync(signRequestBuilder.build());
return signedRequestFuture.thenCompose(signedRequest -> {
SdkHttpFullRequest result = toSdkHttpFullRequest(signedRequest);
updateAsyncRequestBodyInContexts(context, signedRequest);
return CompletableFuture.completedFuture(result);
});
}
private static void updateAsyncRequestBodyInContexts(RequestExecutionContext context, AsyncSignedRequest signedRequest) {
AsyncRequestBody newAsyncRequestBody;
Optional<Publisher<ByteBuffer>> optionalPayload = signedRequest.payload();
if (optionalPayload.isPresent()) {
Publisher<ByteBuffer> signedPayload = optionalPayload.get();
if (signedPayload instanceof AsyncRequestBody) {
newAsyncRequestBody = (AsyncRequestBody) signedPayload;
} else {
newAsyncRequestBody = AsyncRequestBody.fromPublisher(signedPayload);
}
} else {
newAsyncRequestBody = null;
}
context.requestProvider(newAsyncRequestBody);
ExecutionContext executionContext = context.executionContext();
executionContext.interceptorContext(executionContext.interceptorContext()
.copy(b -> b.asyncRequestBody(newAsyncRequestBody)));
}
private SdkHttpFullRequest toSdkHttpFullRequest(SignedRequest signedRequest) {
return toSdkHttpFullRequestBuilder(signedRequest).contentStreamProvider(signedRequest.payload().orElse(null)).build();
}
private SdkHttpFullRequest toSdkHttpFullRequest(AsyncSignedRequest signedRequest) {
SdkHttpRequest request = signedRequest.request();
if (request instanceof SdkHttpFullRequest) {
return (SdkHttpFullRequest) request;
}
return toSdkHttpFullRequestBuilder(signedRequest).build();
}
private SdkHttpFullRequest.Builder toSdkHttpFullRequestBuilder(BaseSignedRequest<?> baseSignedRequest) {
SdkHttpRequest request = baseSignedRequest.request();
return SdkHttpFullRequest.builder()
.protocol(request.protocol())
.method(request.method())
.host(request.host())
.port(request.port())
.encodedPath(request.encodedPath())
.applyMutation(r -> request.forEachHeader(r::putHeader))
.applyMutation(r -> request.forEachRawQueryParameter(r::putRawQueryParameter));
}
/**
* Sign the request if the signer is provided and credentials are present.
*/
private CompletableFuture<SdkHttpFullRequest> signRequest(SdkHttpFullRequest request,
RequestExecutionContext context) {
Signer signer = context.signer();
MetricCollector metricCollector = context.attemptMetricCollector();
adjustForClockSkew(context.executionAttributes());
AsyncSigner asyncSigner = asAsyncSigner(signer, context);
long signingStart = System.nanoTime();
CompletableFuture<SdkHttpFullRequest> signedRequestFuture = asyncSigner.sign(request, context.requestProvider(),
context.executionAttributes());
signedRequestFuture.whenComplete((r, t) ->
metricCollector.reportMetric(CoreMetric.SIGNING_DURATION,
Duration.ofNanos(System.nanoTime() - signingStart)));
return signedRequestFuture.thenApply(r -> {
updateHttpRequestInInterceptorContext(r, context.executionContext());
return r;
});
}
/**
* TODO: Remove when we stop having two copies of the request.
*/
private void updateHttpRequestInInterceptorContext(SdkHttpFullRequest request, ExecutionContext executionContext) {
executionContext.interceptorContext(executionContext.interceptorContext().copy(b -> b.httpRequest(request)));
}
/**
* Returns the {@link Clock} used for signing that already accounts for clock skew when detected by the retryable stage.
*/
private Clock signingClock() {
int offsetInSeconds = dependencies.timeOffset();
return Clock.offset(Clock.systemUTC(), Duration.ofSeconds(-offsetInSeconds));
}
/**
* Always use the client level timeOffset.
*/
private void adjustForClockSkew(ExecutionAttributes attributes) {
attributes.putAttribute(SdkExecutionAttribute.TIME_OFFSET, dependencies.timeOffset());
}
/**
* Simple method to adapt a sync Signer to an AsyncSigner if necessary to make the signing code path a little cleaner
*/
private AsyncSigner asAsyncSigner(Signer signer, RequestExecutionContext context) {
if (signer instanceof AsyncSigner) {
return (AsyncSigner) signer;
}
return (request, requestBody, executionAttributes) -> {
SdkHttpFullRequest signedRequest = signer.sign(request, executionAttributes);
if (signer instanceof AsyncRequestBodySigner) {
//Transform request body provider with signing operator
AsyncRequestBody transformedRequestProvider =
((AsyncRequestBodySigner) signer)
.signAsyncRequestBody(signedRequest, context.requestProvider(),
context.executionAttributes());
context.requestProvider(transformedRequestProvider);
}
return CompletableFuture.completedFuture(signedRequest);
};
}
}
| 1,979 |
0 | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http/pipeline | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http/pipeline/stages/AsyncApiCallAttemptMetricCollectionStage.java | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.awssdk.core.internal.http.pipeline.stages;
import static software.amazon.awssdk.core.internal.util.MetricUtils.collectHttpMetrics;
import static software.amazon.awssdk.core.internal.util.MetricUtils.createAttemptMetricsCollector;
import java.time.Duration;
import java.util.concurrent.CompletableFuture;
import software.amazon.awssdk.annotations.SdkInternalApi;
import software.amazon.awssdk.core.Response;
import software.amazon.awssdk.core.internal.http.RequestExecutionContext;
import software.amazon.awssdk.core.internal.http.pipeline.RequestPipeline;
import software.amazon.awssdk.core.internal.http.pipeline.stages.utils.RetryableStageHelper;
import software.amazon.awssdk.core.internal.metrics.SdkErrorType;
import software.amazon.awssdk.core.metrics.CoreMetric;
import software.amazon.awssdk.http.SdkHttpFullRequest;
import software.amazon.awssdk.metrics.MetricCollector;
import software.amazon.awssdk.utils.CompletableFutureUtils;
/**
* Wrapper pipeline that initializes and tracks the API call attempt metric collection. This wrapper and any wrapped
* stages will track API call attempt metrics.
*/
@SdkInternalApi
public final class AsyncApiCallAttemptMetricCollectionStage<OutputT> implements RequestPipeline<SdkHttpFullRequest,
CompletableFuture<Response<OutputT>>> {
private final RequestPipeline<SdkHttpFullRequest, CompletableFuture<Response<OutputT>>> wrapped;
public AsyncApiCallAttemptMetricCollectionStage(RequestPipeline<SdkHttpFullRequest,
CompletableFuture<Response<OutputT>>> wrapped) {
this.wrapped = wrapped;
}
@Override
public CompletableFuture<Response<OutputT>> execute(SdkHttpFullRequest input,
RequestExecutionContext context) throws Exception {
MetricCollector apiCallAttemptMetrics = createAttemptMetricsCollector(context);
context.attemptMetricCollector(apiCallAttemptMetrics);
reportBackoffDelay(context);
CompletableFuture<Response<OutputT>> executeFuture = wrapped.execute(input, context);
CompletableFuture<Response<OutputT>> metricsCollectedFuture = executeFuture.whenComplete((r, t) -> {
if (t == null) {
collectHttpMetrics(apiCallAttemptMetrics, r.httpResponse());
}
if (t != null) {
reportErrorType(context, t.getCause());
} else if (!Boolean.TRUE.equals(r.isSuccess()) && r.exception() != null) {
reportErrorType(context, r.exception());
}
});
CompletableFutureUtils.forwardExceptionTo(metricsCollectedFuture, executeFuture);
return metricsCollectedFuture;
}
private void reportBackoffDelay(RequestExecutionContext context) {
Duration lastBackoffDelay = context.executionAttributes().getAttribute(RetryableStageHelper.LAST_BACKOFF_DELAY_DURATION);
if (lastBackoffDelay != null) {
context.attemptMetricCollector().reportMetric(CoreMetric.BACKOFF_DELAY_DURATION, lastBackoffDelay);
}
}
private void reportErrorType(RequestExecutionContext context, Throwable t) {
context.attemptMetricCollector().reportMetric(CoreMetric.ERROR_TYPE, SdkErrorType.fromException(t).toString());
}
}
| 1,980 |
0 | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http/pipeline | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http/pipeline/stages/MakeRequestImmutableStage.java | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.awssdk.core.internal.http.pipeline.stages;
import software.amazon.awssdk.annotations.SdkInternalApi;
import software.amazon.awssdk.core.internal.http.RequestExecutionContext;
import software.amazon.awssdk.core.internal.http.pipeline.RequestPipeline;
import software.amazon.awssdk.http.SdkHttpFullRequest;
@SdkInternalApi
public class MakeRequestImmutableStage implements RequestPipeline<SdkHttpFullRequest.Builder, SdkHttpFullRequest> {
@Override
public SdkHttpFullRequest execute(SdkHttpFullRequest.Builder input, RequestExecutionContext context) throws Exception {
return input.build();
}
}
| 1,981 |
0 | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http/pipeline | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http/pipeline/stages/AfterTransmissionExecutionInterceptorsStage.java | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.awssdk.core.internal.http.pipeline.stages;
import software.amazon.awssdk.annotations.SdkInternalApi;
import software.amazon.awssdk.core.interceptor.InterceptorContext;
import software.amazon.awssdk.core.internal.http.InterruptMonitor;
import software.amazon.awssdk.core.internal.http.RequestExecutionContext;
import software.amazon.awssdk.core.internal.http.pipeline.RequestPipeline;
import software.amazon.awssdk.http.AbortableInputStream;
import software.amazon.awssdk.http.SdkHttpFullRequest;
import software.amazon.awssdk.http.SdkHttpFullResponse;
import software.amazon.awssdk.utils.Pair;
@SdkInternalApi
public class AfterTransmissionExecutionInterceptorsStage
implements RequestPipeline<Pair<SdkHttpFullRequest, SdkHttpFullResponse>, Pair<SdkHttpFullRequest, SdkHttpFullResponse>> {
@Override
public Pair<SdkHttpFullRequest, SdkHttpFullResponse> execute(Pair<SdkHttpFullRequest, SdkHttpFullResponse> input,
RequestExecutionContext context) throws Exception {
InterruptMonitor.checkInterrupted(input.right());
// Update interceptor context
InterceptorContext interceptorContext =
context.executionContext().interceptorContext().copy(b -> b.httpResponse(input.right())
.responseBody(input.right()
.content()
.orElse(null)));
// interceptors.afterTransmission
context.interceptorChain().afterTransmission(interceptorContext, context.executionAttributes());
// interceptors.modifyHttpResponse
interceptorContext = context.interceptorChain().modifyHttpResponse(interceptorContext, context.executionAttributes());
// Store updated context
context.executionContext().interceptorContext(interceptorContext);
InterruptMonitor.checkInterrupted((SdkHttpFullResponse) interceptorContext.httpResponse());
SdkHttpFullResponse response = (SdkHttpFullResponse) interceptorContext.httpResponse();
if (interceptorContext.responseBody().isPresent()) {
response = response.toBuilder().content(AbortableInputStream.create(interceptorContext.responseBody().get())).build();
}
return Pair.of(input.left(), response);
}
}
| 1,982 |
0 | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http/pipeline | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http/pipeline/stages/AsyncRetryableStage.java | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.awssdk.core.internal.http.pipeline.stages;
import static java.util.concurrent.TimeUnit.MILLISECONDS;
import java.io.IOException;
import java.time.Duration;
import java.util.OptionalDouble;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ScheduledExecutorService;
import software.amazon.awssdk.annotations.SdkInternalApi;
import software.amazon.awssdk.annotations.SdkTestInternalApi;
import software.amazon.awssdk.core.Response;
import software.amazon.awssdk.core.async.AsyncRequestBody;
import software.amazon.awssdk.core.client.config.SdkClientOption;
import software.amazon.awssdk.core.exception.SdkClientException;
import software.amazon.awssdk.core.exception.SdkException;
import software.amazon.awssdk.core.internal.http.HttpClientDependencies;
import software.amazon.awssdk.core.internal.http.RequestExecutionContext;
import software.amazon.awssdk.core.internal.http.TransformingAsyncResponseHandler;
import software.amazon.awssdk.core.internal.http.pipeline.RequestPipeline;
import software.amazon.awssdk.core.internal.http.pipeline.stages.utils.RetryableStageHelper;
import software.amazon.awssdk.core.internal.retry.RateLimitingTokenBucket;
import software.amazon.awssdk.http.SdkHttpFullRequest;
import software.amazon.awssdk.utils.CompletableFutureUtils;
/**
* Wrapper around the pipeline for a single request to provide retry, clockskew and request throttling functionality.
*/
@SdkInternalApi
public final class AsyncRetryableStage<OutputT> implements RequestPipeline<SdkHttpFullRequest,
CompletableFuture<Response<OutputT>>> {
private final TransformingAsyncResponseHandler<Response<OutputT>> responseHandler;
private final RequestPipeline<SdkHttpFullRequest, CompletableFuture<Response<OutputT>>> requestPipeline;
private final ScheduledExecutorService scheduledExecutor;
private final HttpClientDependencies dependencies;
private final RateLimitingTokenBucket rateLimitingTokenBucket;
public AsyncRetryableStage(TransformingAsyncResponseHandler<Response<OutputT>> responseHandler,
HttpClientDependencies dependencies,
RequestPipeline<SdkHttpFullRequest, CompletableFuture<Response<OutputT>>> requestPipeline) {
this.responseHandler = responseHandler;
this.dependencies = dependencies;
this.scheduledExecutor = dependencies.clientConfiguration().option(SdkClientOption.SCHEDULED_EXECUTOR_SERVICE);
this.rateLimitingTokenBucket = new RateLimitingTokenBucket();
this.requestPipeline = requestPipeline;
}
@SdkTestInternalApi
public AsyncRetryableStage(TransformingAsyncResponseHandler<Response<OutputT>> responseHandler,
HttpClientDependencies dependencies,
RequestPipeline<SdkHttpFullRequest, CompletableFuture<Response<OutputT>>> requestPipeline,
RateLimitingTokenBucket rateLimitingTokenBucket) {
this.responseHandler = responseHandler;
this.dependencies = dependencies;
this.scheduledExecutor = dependencies.clientConfiguration().option(SdkClientOption.SCHEDULED_EXECUTOR_SERVICE);
this.requestPipeline = requestPipeline;
this.rateLimitingTokenBucket = rateLimitingTokenBucket;
}
@Override
public CompletableFuture<Response<OutputT>> execute(SdkHttpFullRequest request,
RequestExecutionContext context) throws Exception {
return new RetryingExecutor(request, context).execute();
}
private class RetryingExecutor {
private final AsyncRequestBody originalRequestBody;
private final RequestExecutionContext context;
private final RetryableStageHelper retryableStageHelper;
private RetryingExecutor(SdkHttpFullRequest request, RequestExecutionContext context) {
this.originalRequestBody = context.requestProvider();
this.context = context;
this.retryableStageHelper = new RetryableStageHelper(request, context, rateLimitingTokenBucket, dependencies);
}
public CompletableFuture<Response<OutputT>> execute() throws Exception {
CompletableFuture<Response<OutputT>> future = new CompletableFuture<>();
maybeAttemptExecute(future);
return future;
}
public void maybeAttemptExecute(CompletableFuture<Response<OutputT>> future) {
retryableStageHelper.startingAttempt();
if (!retryableStageHelper.retryPolicyAllowsRetry()) {
future.completeExceptionally(retryableStageHelper.retryPolicyDisallowedRetryException());
return;
}
if (retryableStageHelper.getAttemptNumber() > 1) {
// We failed the last attempt, but will retry. The response handler wants to know when that happens.
responseHandler.onError(retryableStageHelper.getLastException());
// Reset the request provider to the original one before retries, in case it was modified downstream.
context.requestProvider(originalRequestBody);
}
Duration backoffDelay = retryableStageHelper.getBackoffDelay();
OptionalDouble tokenAcquireTimeSeconds = retryableStageHelper.getSendTokenNonBlocking();
if (!tokenAcquireTimeSeconds.isPresent()) {
String errorMessage = "Unable to acquire a send token immediately without waiting. This indicates that ADAPTIVE "
+ "retry mode is enabled, fast fail rate limiting is enabled, and that rate limiting is "
+ "engaged because of prior throttled requests. The request will not be executed.";
future.completeExceptionally(SdkClientException.create(errorMessage));
return;
}
long tokenAcquireTimeMillis = (long) (tokenAcquireTimeSeconds.getAsDouble() * 1000);
if (!backoffDelay.isZero()) {
retryableStageHelper.logBackingOff(backoffDelay);
}
long totalDelayMillis = backoffDelay.toMillis() + tokenAcquireTimeMillis;
if (totalDelayMillis > 0) {
scheduledExecutor.schedule(() -> attemptExecute(future), totalDelayMillis, MILLISECONDS);
} else {
attemptExecute(future);
}
}
private void attemptExecute(CompletableFuture<Response<OutputT>> future) {
CompletableFuture<Response<OutputT>> responseFuture;
try {
retryableStageHelper.logSendingRequest();
responseFuture = requestPipeline.execute(retryableStageHelper.requestToSend(), context);
// If the result future fails, go ahead and fail the response future.
CompletableFutureUtils.forwardExceptionTo(future, responseFuture);
} catch (SdkException | IOException e) {
maybeRetryExecute(future, e);
return;
} catch (Throwable e) {
future.completeExceptionally(e);
return;
}
responseFuture.whenComplete((response, exception) -> {
if (exception != null) {
if (exception instanceof Exception) {
maybeRetryExecute(future, (Exception) exception);
} else {
future.completeExceptionally(exception);
}
return;
}
retryableStageHelper.setLastResponse(response.httpResponse());
if (!response.isSuccess()) {
retryableStageHelper.adjustClockIfClockSkew(response);
maybeRetryExecute(future, response.exception());
return;
}
retryableStageHelper.updateClientSendingRateForSuccessResponse();
retryableStageHelper.attemptSucceeded();
future.complete(response);
});
}
private void maybeRetryExecute(CompletableFuture<Response<OutputT>> future, Exception exception) {
retryableStageHelper.setLastException(exception);
retryableStageHelper.updateClientSendingRateForErrorResponse();
maybeAttemptExecute(future);
}
}
}
| 1,983 |
0 | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http/pipeline | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http/pipeline/stages/TimeoutExceptionHandlingStage.java | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.awssdk.core.internal.http.pipeline.stages;
import static software.amazon.awssdk.core.internal.http.timers.TimerUtils.resolveTimeoutInMillis;
import static software.amazon.awssdk.utils.FunctionalUtils.invokeSafely;
import java.io.IOException;
import software.amazon.awssdk.annotations.SdkInternalApi;
import software.amazon.awssdk.core.Response;
import software.amazon.awssdk.core.client.config.ClientOverrideConfiguration;
import software.amazon.awssdk.core.client.config.SdkClientOption;
import software.amazon.awssdk.core.exception.AbortedException;
import software.amazon.awssdk.core.exception.ApiCallAttemptTimeoutException;
import software.amazon.awssdk.core.exception.SdkClientException;
import software.amazon.awssdk.core.exception.SdkInterruptedException;
import software.amazon.awssdk.core.internal.http.HttpClientDependencies;
import software.amazon.awssdk.core.internal.http.RequestExecutionContext;
import software.amazon.awssdk.core.internal.http.pipeline.RequestPipeline;
import software.amazon.awssdk.core.internal.http.pipeline.RequestToResponsePipeline;
import software.amazon.awssdk.http.SdkHttpFullRequest;
/**
* Check if an {@link Exception} is caused by either ApiCallTimeout or ApiAttemptTimeout and translate that
* exception to a more appropriate timeout related exception so that it can be handled in other stages.
*/
@SdkInternalApi
public final class TimeoutExceptionHandlingStage<OutputT> implements RequestToResponsePipeline<OutputT> {
private final HttpClientDependencies dependencies;
private final RequestPipeline<SdkHttpFullRequest, Response<OutputT>> requestPipeline;
public TimeoutExceptionHandlingStage(HttpClientDependencies dependencies, RequestPipeline<SdkHttpFullRequest,
Response<OutputT>> requestPipeline) {
this.dependencies = dependencies;
this.requestPipeline = requestPipeline;
}
/**
* Translate an {@link Exception} caused by timeout based on the following criteria:
*
* <ul>
* <li>If the {@link Exception} is caused by {@link ClientOverrideConfiguration#apiCallTimeout}, translates it to
* {@link InterruptedException} so it can be handled
* appropriately in {@link ApiCallTimeoutTrackingStage}. </li>
* <li>
* If it is caused by {@link ClientOverrideConfiguration#apiCallAttemptTimeout()}, clear the interrupt status,
* translates it to {@link ApiCallAttemptTimeoutException} so that it might be retried
* in {@link RetryableStage}
* </li>
* </ul>
*
* <p>
* ApiCallTimeout takes precedence because it is not retryable.
*
* @param request the request
* @param context Context containing both request dependencies, and a container for any mutable state that must be shared
* between stages.
* @return the response
* @throws Exception the translated exception or the original exception
*/
@Override
public Response<OutputT> execute(SdkHttpFullRequest request, RequestExecutionContext context) throws Exception {
try {
return requestPipeline.execute(request, context);
} catch (Exception e) {
throw translatePipelineException(context, e);
}
}
/**
* Take the given exception thrown from the wrapped pipeline and return a more appropriate
* timeout related exception based on its type and the the execution status.
*
* @param context The execution context.
* @param e The exception thrown from the inner pipeline.
* @return The translated exception.
*/
private Exception translatePipelineException(RequestExecutionContext context, Exception e) {
if (e instanceof InterruptedException || e instanceof IOException ||
e instanceof AbortedException || Thread.currentThread().isInterrupted()
|| (e instanceof SdkClientException && isCausedByApiCallAttemptTimeout(context))) {
return handleTimeoutCausedException(context, e);
}
return e;
}
private Exception handleTimeoutCausedException(RequestExecutionContext context, Exception e) {
if (e instanceof SdkInterruptedException) {
((SdkInterruptedException) e).getResponseStream().ifPresent(r -> invokeSafely(r::close));
}
if (isCausedByApiCallTimeout(context)) {
return new InterruptedException();
}
if (isCausedByApiCallAttemptTimeout(context)) {
// Clear the interrupt status
Thread.interrupted();
return generateApiCallAttemptTimeoutException(context);
}
if (e instanceof InterruptedException) {
Thread.currentThread().interrupt();
return AbortedException.create("Thread was interrupted", e);
}
return e;
}
/**
* Detects if the exception thrown was triggered by the api call attempt timeout.
*
* @param context {@link RequestExecutionContext} object.
* @return True if the exception was caused by the attempt timeout, false if not.
*/
private boolean isCausedByApiCallAttemptTimeout(RequestExecutionContext context) {
return context.apiCallAttemptTimeoutTracker().hasExecuted();
}
/**
* Detects if the exception thrown was triggered by the api call timeout.
*
* @param context {@link RequestExecutionContext} object.
* @return True if the exception was caused by the call timeout, false if not.
*/
private boolean isCausedByApiCallTimeout(RequestExecutionContext context) {
return context.apiCallTimeoutTracker().hasExecuted();
}
private ApiCallAttemptTimeoutException generateApiCallAttemptTimeoutException(RequestExecutionContext context) {
return ApiCallAttemptTimeoutException.create(
resolveTimeoutInMillis(context.requestConfig()::apiCallAttemptTimeout,
dependencies.clientConfiguration().option(SdkClientOption.API_CALL_ATTEMPT_TIMEOUT)));
}
}
| 1,984 |
0 | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http/pipeline | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http/pipeline/stages/ApplyTransactionIdStage.java | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.awssdk.core.internal.http.pipeline.stages;
import java.util.Random;
import java.util.UUID;
import software.amazon.awssdk.annotations.SdkInternalApi;
import software.amazon.awssdk.core.internal.http.InterruptMonitor;
import software.amazon.awssdk.core.internal.http.RequestExecutionContext;
import software.amazon.awssdk.core.internal.http.pipeline.MutableRequestToRequestPipeline;
import software.amazon.awssdk.http.SdkHttpFullRequest;
/**
* Generates a unique identifier for the request that is consistent across retries.
*/
@SdkInternalApi
public class ApplyTransactionIdStage implements MutableRequestToRequestPipeline {
public static final String HEADER_SDK_TRANSACTION_ID = "amz-sdk-invocation-id";
/**
* Used to generate UUID's for client transaction id. This gives a higher probability of id
* clashes but is more performant then using {@link UUID#randomUUID()} which uses SecureRandom
* internally.
**/
private final Random random = new Random();
@Override
public SdkHttpFullRequest.Builder execute(SdkHttpFullRequest.Builder request, RequestExecutionContext context)
throws Exception {
InterruptMonitor.checkInterrupted();
return request.putHeader(HEADER_SDK_TRANSACTION_ID, new UUID(random.nextLong(), random.nextLong()).toString());
}
}
| 1,985 |
0 | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http/pipeline | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http/pipeline/stages/ApplyUserAgentStage.java | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.awssdk.core.internal.http.pipeline.stages;
import java.util.List;
import software.amazon.awssdk.annotations.SdkInternalApi;
import software.amazon.awssdk.core.ApiName;
import software.amazon.awssdk.core.ClientType;
import software.amazon.awssdk.core.SdkSystemSetting;
import software.amazon.awssdk.core.client.config.SdkAdvancedClientOption;
import software.amazon.awssdk.core.client.config.SdkClientConfiguration;
import software.amazon.awssdk.core.client.config.SdkClientOption;
import software.amazon.awssdk.core.internal.http.HttpClientDependencies;
import software.amazon.awssdk.core.internal.http.RequestExecutionContext;
import software.amazon.awssdk.core.internal.http.pipeline.MutableRequestToRequestPipeline;
import software.amazon.awssdk.core.retry.RetryPolicy;
import software.amazon.awssdk.core.util.SdkUserAgent;
import software.amazon.awssdk.http.SdkHttpClient;
import software.amazon.awssdk.http.SdkHttpFullRequest;
import software.amazon.awssdk.http.async.SdkAsyncHttpClient;
import software.amazon.awssdk.utils.Logger;
import software.amazon.awssdk.utils.StringUtils;
import software.amazon.awssdk.utils.http.SdkHttpUtils;
/**
* Apply any custom user agent supplied, otherwise instrument the user agent with info about the SDK and environment.
*/
@SdkInternalApi
public class ApplyUserAgentStage implements MutableRequestToRequestPipeline {
private static final Logger log = Logger.loggerFor(ApplyUserAgentStage.class);
private static final String COMMA = ", ";
private static final String SPACE = " ";
private static final String IO = "io";
private static final String HTTP = "http";
private static final String CONFIG = "cfg";
private static final String RETRY_MODE = "retry-mode";
private static final String AWS_EXECUTION_ENV_PREFIX = "exec-env/";
private static final String HEADER_USER_AGENT = "User-Agent";
private final SdkClientConfiguration clientConfig;
public ApplyUserAgentStage(HttpClientDependencies dependencies) {
this.clientConfig = dependencies.clientConfiguration();
}
public static String resolveClientUserAgent(String userAgentPrefix,
String internalUserAgent,
ClientType clientType,
SdkHttpClient syncHttpClient,
SdkAsyncHttpClient asyncHttpClient,
RetryPolicy retryPolicy) {
String awsExecutionEnvironment = SdkSystemSetting.AWS_EXECUTION_ENV.getStringValue().orElse(null);
StringBuilder userAgent = new StringBuilder(128);
userAgent.append(StringUtils.trimToEmpty(userAgentPrefix));
String systemUserAgent = SdkUserAgent.create().userAgent();
if (!systemUserAgent.equals(userAgentPrefix)) {
userAgent.append(COMMA).append(systemUserAgent);
}
String trimmedInternalUserAgent = StringUtils.trimToEmpty(internalUserAgent);
if (!trimmedInternalUserAgent.isEmpty()) {
userAgent.append(SPACE).append(trimmedInternalUserAgent);
}
if (!StringUtils.isEmpty(awsExecutionEnvironment)) {
userAgent.append(SPACE).append(AWS_EXECUTION_ENV_PREFIX).append(awsExecutionEnvironment.trim());
}
if (clientType == null) {
clientType = ClientType.UNKNOWN;
}
userAgent.append(SPACE)
.append(IO)
.append("/")
.append(StringUtils.lowerCase(clientType.name()));
userAgent.append(SPACE)
.append(HTTP)
.append("/")
.append(SdkHttpUtils.urlEncode(clientName(clientType, syncHttpClient, asyncHttpClient)));
String retryMode = retryPolicy.retryMode().toString();
userAgent.append(SPACE)
.append(CONFIG)
.append("/")
.append(RETRY_MODE)
.append("/")
.append(StringUtils.lowerCase(retryMode));
return userAgent.toString();
}
@Override
public SdkHttpFullRequest.Builder execute(SdkHttpFullRequest.Builder request, RequestExecutionContext context)
throws Exception {
return request.putHeader(HEADER_USER_AGENT, getUserAgent(clientConfig, context.requestConfig().apiNames()));
}
private String getUserAgent(SdkClientConfiguration config, List<ApiName> requestApiNames) {
String clientUserAgent = clientConfig.option(SdkClientOption.CLIENT_USER_AGENT);
if (clientUserAgent == null) {
log.warn(() -> "Client user agent configuration is missing, so request user agent will be incomplete.");
clientUserAgent = "";
}
StringBuilder userAgent = new StringBuilder(clientUserAgent);
if (!requestApiNames.isEmpty()) {
requestApiNames.forEach(apiName -> {
userAgent.append(SPACE).append(apiName.name()).append("/").append(apiName.version());
});
}
String userDefinedSuffix = config.option(SdkAdvancedClientOption.USER_AGENT_SUFFIX);
if (!StringUtils.isEmpty(userDefinedSuffix)) {
userAgent.append(COMMA).append(userDefinedSuffix.trim());
}
return userAgent.toString();
}
private static String clientName(ClientType clientType, SdkHttpClient syncHttpClient, SdkAsyncHttpClient asyncHttpClient) {
if (clientType == ClientType.SYNC) {
return syncHttpClient == null ? "null" : syncHttpClient.clientName();
}
if (clientType == ClientType.ASYNC) {
return asyncHttpClient == null ? "null" : asyncHttpClient.clientName();
}
return ClientType.UNKNOWN.name();
}
}
| 1,986 |
0 | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http/pipeline | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http/pipeline/stages/ApiCallTimeoutTrackingStage.java | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.awssdk.core.internal.http.pipeline.stages;
import static software.amazon.awssdk.core.internal.http.timers.TimerUtils.resolveTimeoutInMillis;
import static software.amazon.awssdk.core.internal.http.timers.TimerUtils.timeSyncTaskIfNeeded;
import static software.amazon.awssdk.utils.FunctionalUtils.invokeSafely;
import java.time.Duration;
import java.util.concurrent.ScheduledExecutorService;
import software.amazon.awssdk.annotations.SdkInternalApi;
import software.amazon.awssdk.core.Response;
import software.amazon.awssdk.core.client.config.SdkClientConfiguration;
import software.amazon.awssdk.core.client.config.SdkClientOption;
import software.amazon.awssdk.core.exception.AbortedException;
import software.amazon.awssdk.core.exception.ApiCallTimeoutException;
import software.amazon.awssdk.core.exception.SdkInterruptedException;
import software.amazon.awssdk.core.internal.http.HttpClientDependencies;
import software.amazon.awssdk.core.internal.http.RequestExecutionContext;
import software.amazon.awssdk.core.internal.http.pipeline.RequestPipeline;
import software.amazon.awssdk.core.internal.http.pipeline.RequestToResponsePipeline;
import software.amazon.awssdk.core.internal.http.timers.SyncTimeoutTask;
import software.amazon.awssdk.core.internal.http.timers.TimeoutTracker;
import software.amazon.awssdk.http.SdkHttpFullRequest;
/**
* Wrapper around a {@link RequestPipeline} to manage the api call timeout feature.
*/
@SdkInternalApi
public final class ApiCallTimeoutTrackingStage<OutputT> implements RequestToResponsePipeline<OutputT> {
private final RequestPipeline<SdkHttpFullRequest, Response<OutputT>> wrapped;
private final SdkClientConfiguration clientConfig;
private final ScheduledExecutorService timeoutExecutor;
private final Duration apiCallTimeout;
public ApiCallTimeoutTrackingStage(HttpClientDependencies dependencies,
RequestPipeline<SdkHttpFullRequest, Response<OutputT>> wrapped) {
this.wrapped = wrapped;
this.clientConfig = dependencies.clientConfiguration();
this.timeoutExecutor = dependencies.clientConfiguration().option(SdkClientOption.SCHEDULED_EXECUTOR_SERVICE);
this.apiCallTimeout = clientConfig.option(SdkClientOption.API_CALL_TIMEOUT);
}
@Override
public Response<OutputT> execute(SdkHttpFullRequest request, RequestExecutionContext context) throws Exception {
try {
return executeWithTimer(request, context);
} catch (Exception e) {
throw translatePipelineException(context, e);
}
}
/**
* Start and end client execution timer around the execution of the request. It's important
* that the client execution task is canceled before the InterruptedException is handled by
* {@link ApiCallTimeoutTrackingStage#wrapped#execute(SdkHttpFullRequest)} so the interrupt status
* doesn't leak out to the callers code
*/
private Response<OutputT> executeWithTimer(SdkHttpFullRequest request, RequestExecutionContext context) throws Exception {
long timeoutInMillis = resolveTimeoutInMillis(context.requestConfig()::apiCallTimeout, apiCallTimeout);
TimeoutTracker timeoutTracker = timeSyncTaskIfNeeded(timeoutExecutor, timeoutInMillis, Thread.currentThread());
Response<OutputT> response;
try {
context.apiCallTimeoutTracker(timeoutTracker);
response = wrapped.execute(request, context);
} finally {
// Cancel the timeout tracker, guaranteeing that if it hasn't already executed and set this thread's
// interrupt flag, it won't do so later. Every code path executed after this line *must* call
// timeoutTracker.hasExecuted() and appropriately clear the interrupt flag if it returns true.
timeoutTracker.cancel();
}
if (timeoutTracker.hasExecuted()) {
// The timeout tracker executed before the call to cancel(), which means it set this thread's interrupt
// flag. However, the execute() call returned before we raised an InterruptedException, so just clear the
// interrupt flag and return the result we got back.
Thread.interrupted();
}
return response;
}
/**
* Take the given exception thrown from the wrapped pipeline and return a more appropriate
* timeout related exception based on its type and the the execution status.
*
* @param context The execution context.
* @param e The exception thrown from the inner pipeline.
* @return The translated exception.
*/
private Exception translatePipelineException(RequestExecutionContext context, Exception e) {
if (e instanceof InterruptedException) {
return handleInterruptedException(context, (InterruptedException) e);
}
// Timeout tracker finished and interrupted this thread after wrapped.execute() last checked the interrupt flag,
// but before we called timeoutTracker.cancel(). Note that if hasExecuted() returns true, its guaranteed that
// the timeout tracker has set the interrupt flag, and if it returns false, it guarantees that it did not and
// will never set the interrupt flag.
if (apiCallTimerExecuted(context)) {
// Clear the interrupt flag. Since we already have an exception from the call, which may contain information
// that's useful to the caller, just return that instead of an ApiCallTimeoutException.
Thread.interrupted();
}
return e;
}
/**
* Determine if an interrupted exception is caused by the api call timeout task
* interrupting the current thread or some other task interrupting the thread for another
* purpose.
*
* @return {@link ApiCallTimeoutException} if the {@link InterruptedException} was
* caused by the {@link SyncTimeoutTask}. Otherwise re-interrupts the current thread
* and returns a {@link AbortedException} wrapping an {@link InterruptedException}
*/
private RuntimeException handleInterruptedException(RequestExecutionContext context, InterruptedException e) {
if (e instanceof SdkInterruptedException) {
((SdkInterruptedException) e).getResponseStream().ifPresent(r -> invokeSafely(r::close));
}
if (apiCallTimerExecuted(context)) {
// Clear the interrupt status
Thread.interrupted();
return generateApiCallTimeoutException(context);
}
Thread.currentThread().interrupt();
return AbortedException.create("Thread was interrupted", e);
}
private static boolean apiCallTimerExecuted(RequestExecutionContext context) {
return context.apiCallTimeoutTracker() != null && context.apiCallTimeoutTracker().hasExecuted();
}
private ApiCallTimeoutException generateApiCallTimeoutException(RequestExecutionContext context) {
return ApiCallTimeoutException.create(
resolveTimeoutInMillis(context.requestConfig()::apiCallTimeout, apiCallTimeout));
}
}
| 1,987 |
0 | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http/pipeline | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http/pipeline/stages/HttpChecksumStage.java | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.awssdk.core.internal.http.pipeline.stages;
import static software.amazon.awssdk.core.HttpChecksumConstant.AWS_CHUNKED_HEADER;
import static software.amazon.awssdk.core.HttpChecksumConstant.CONTENT_SHA_256_FOR_UNSIGNED_TRAILER;
import static software.amazon.awssdk.core.HttpChecksumConstant.DEFAULT_ASYNC_CHUNK_SIZE;
import static software.amazon.awssdk.core.HttpChecksumConstant.SIGNING_METHOD;
import static software.amazon.awssdk.core.interceptor.SdkInternalExecutionAttribute.AUTH_SCHEMES;
import static software.amazon.awssdk.core.internal.io.AwsChunkedEncodingInputStream.DEFAULT_CHUNK_SIZE;
import static software.amazon.awssdk.core.internal.util.ChunkContentUtils.calculateChecksumTrailerLength;
import static software.amazon.awssdk.core.internal.util.ChunkContentUtils.calculateStreamContentLength;
import static software.amazon.awssdk.core.internal.util.HttpChecksumResolver.getResolvedChecksumSpecs;
import static software.amazon.awssdk.http.Header.CONTENT_LENGTH;
import java.io.IOException;
import java.io.InputStream;
import java.io.UncheckedIOException;
import software.amazon.awssdk.annotations.SdkInternalApi;
import software.amazon.awssdk.core.ClientType;
import software.amazon.awssdk.core.HttpChecksumConstant;
import software.amazon.awssdk.core.checksums.ChecksumSpecs;
import software.amazon.awssdk.core.checksums.SdkChecksum;
import software.amazon.awssdk.core.interceptor.InterceptorContext;
import software.amazon.awssdk.core.interceptor.SdkInternalExecutionAttribute;
import software.amazon.awssdk.core.internal.async.ChecksumCalculatingAsyncRequestBody;
import software.amazon.awssdk.core.internal.http.RequestExecutionContext;
import software.amazon.awssdk.core.internal.http.pipeline.MutableRequestToRequestPipeline;
import software.amazon.awssdk.core.internal.io.AwsUnsignedChunkedEncodingInputStream;
import software.amazon.awssdk.core.internal.util.HttpChecksumUtils;
import software.amazon.awssdk.http.ContentStreamProvider;
import software.amazon.awssdk.http.Header;
import software.amazon.awssdk.http.SdkHttpFullRequest;
import software.amazon.awssdk.utils.BinaryUtils;
import software.amazon.awssdk.utils.IoUtils;
import software.amazon.awssdk.utils.Md5Utils;
/**
* Stage to implement the "httpChecksum" and "httpChecksumRequired" C2J traits, and flexible checksums.
*/
@SdkInternalApi
public class HttpChecksumStage implements MutableRequestToRequestPipeline {
private final ClientType clientType;
public HttpChecksumStage(ClientType clientType) {
this.clientType = clientType;
}
@Override
public SdkHttpFullRequest.Builder execute(SdkHttpFullRequest.Builder request, RequestExecutionContext context)
throws Exception {
if (md5ChecksumRequired(request, context)) {
addMd5ChecksumInHeader(request);
return request;
}
ChecksumSpecs resolvedChecksumSpecs = getResolvedChecksumSpecs(context.executionAttributes());
if (flexibleChecksumInTrailerRequired(context, resolvedChecksumSpecs)) {
addFlexibleChecksumInTrailer(request, context, resolvedChecksumSpecs);
return request;
}
// If SRA is enabled, skip flexible checksum in header, since it is handled by SRA signer
if (sraSigningEnabled(context)) {
return request;
}
if (flexibleChecksumInHeaderRequired(context, resolvedChecksumSpecs)) {
addFlexibleChecksumInHeader(request, context, resolvedChecksumSpecs);
return request;
}
return request;
}
private boolean md5ChecksumRequired(SdkHttpFullRequest.Builder request, RequestExecutionContext context) {
boolean isHttpChecksumRequired =
context.executionAttributes().getAttribute(SdkInternalExecutionAttribute.HTTP_CHECKSUM_REQUIRED) != null ||
HttpChecksumUtils.isMd5ChecksumRequired(context.executionAttributes());
boolean requestAlreadyHasMd5 = request.firstMatchingHeader(Header.CONTENT_MD5).isPresent();
if (!isHttpChecksumRequired || requestAlreadyHasMd5) {
return false;
}
if (context.requestProvider() != null) {
throw new IllegalArgumentException("This operation requires a content-MD5 checksum, but one cannot be calculated "
+ "for non-blocking content.");
}
return context.executionContext().interceptorContext().requestBody().isPresent();
}
/**
* Implements the "httpChecksumRequired" C2J trait. Operations with that trait applied will automatically include a
* "Content-MD5" header, containing a checksum of the payload.
*
* <p>This is NOT supported for asynchronous HTTP content, which is currently only used for streaming upload operations.
* If such operations are added in the future, we'll have to find a way to support them in a non-blocking manner. That will
* likely require interface changes of some sort, because it's not currently possible to do a non-blocking update to
* request headers.
*
* <p>
* Calculates the MD5 checksum of the provided request (and base64 encodes it), and adds the header to the request.
*
* <p>Note: This assumes that the content stream provider can create multiple new streams. If it only supports one (e.g. with
* an input stream that doesn't support mark/reset), we could consider buffering the content in memory here and updating the
* request body to use that buffered content. We obviously don't want to do that for giant streams, so we haven't opted to do
* that yet.
*/
private void addMd5ChecksumInHeader(SdkHttpFullRequest.Builder request) {
try {
String payloadMd5 = Md5Utils.md5AsBase64(request.contentStreamProvider().newStream());
request.putHeader(Header.CONTENT_MD5, payloadMd5);
} catch (IOException e) {
throw new UncheckedIOException(e);
}
}
private boolean flexibleChecksumInTrailerRequired(RequestExecutionContext context, ChecksumSpecs checksumSpecs) {
// If SRA is enabled and it's sync client, skip flexible checksum trailer, since it is handled in SRA signer
if (sraSigningEnabled(context) && clientType == ClientType.SYNC) {
return false;
}
boolean hasRequestBody = true;
if (clientType == ClientType.SYNC) {
hasRequestBody = context.executionContext().interceptorContext().requestBody().isPresent();
} else if (clientType == ClientType.ASYNC) {
hasRequestBody = context.executionContext().interceptorContext().asyncRequestBody().isPresent();
}
boolean isContentStreaming = context.executionContext().interceptorContext().requestBody()
.map(requestBody -> requestBody.contentStreamProvider() != null).orElse(false);
return checksumSpecs != null
&& checksumSpecs.headerName() != null
&& HttpChecksumUtils.isTrailerBasedChecksumForClientType(
context.executionAttributes(),
context.executionContext().interceptorContext().httpRequest(),
clientType, checksumSpecs, hasRequestBody, isContentStreaming);
}
private static boolean sraSigningEnabled(RequestExecutionContext context) {
return context.executionAttributes().getAttribute(AUTH_SCHEMES) != null;
}
/**
* Adds flexible checksum to trailers.
*
* <p>The flexible checksum is added only if the following conditions are met:
* <ol>
* <li>Checksum is not already calculated.</li>
* <li>Unsigned payload.</li>
* <li>Request has streaming payload.</li>
* <li>Request has the algorithm checksum mentioned.</li>
* </ol>
*/
private void addFlexibleChecksumInTrailer(SdkHttpFullRequest.Builder request, RequestExecutionContext context,
ChecksumSpecs checksumSpecs) {
long originalContentLength = 0;
int chunkSize = 0;
if (clientType == ClientType.SYNC) {
request.contentStreamProvider(new ChecksumCalculatingStreamProvider(request.contentStreamProvider(), checksumSpecs));
originalContentLength =
context.executionContext().interceptorContext().requestBody().get().optionalContentLength().orElse(0L);
chunkSize = DEFAULT_CHUNK_SIZE;
} else if (clientType == ClientType.ASYNC) {
if (context.requestProvider() != null) {
context.requestProvider(ChecksumCalculatingAsyncRequestBody.builder()
.asyncRequestBody(context.requestProvider())
.algorithm(checksumSpecs.algorithm())
.trailerHeader(checksumSpecs.headerName()).build());
originalContentLength =
context.executionContext().interceptorContext().asyncRequestBody().get().contentLength().orElse(0L);
chunkSize = DEFAULT_ASYNC_CHUNK_SIZE;
}
}
long checksumContentLength = calculateChecksumTrailerLength(checksumSpecs.algorithm(), checksumSpecs.headerName());
long contentLen = checksumContentLength + calculateStreamContentLength(originalContentLength, chunkSize);
request.putHeader(HttpChecksumConstant.HEADER_FOR_TRAILER_REFERENCE, checksumSpecs.headerName())
.appendHeader("Content-encoding", AWS_CHUNKED_HEADER)
.putHeader("x-amz-content-sha256", CONTENT_SHA_256_FOR_UNSIGNED_TRAILER)
.putHeader("x-amz-decoded-content-length", Long.toString(originalContentLength))
.putHeader(CONTENT_LENGTH, Long.toString(contentLen));
}
private boolean flexibleChecksumInHeaderRequired(RequestExecutionContext context, ChecksumSpecs headerChecksumSpecs) {
if (!context.executionContext().interceptorContext().requestBody().isPresent()) {
return false;
}
InterceptorContext interceptorContext = context.executionContext().interceptorContext();
boolean isContentStreaming = context.executionContext().interceptorContext().requestBody()
.map(requestBody -> requestBody.contentStreamProvider() != null).orElse(false);
return headerChecksumSpecs != null &&
headerChecksumSpecs.algorithm() != null &&
!HttpChecksumUtils.isHttpChecksumPresent(interceptorContext.httpRequest(), headerChecksumSpecs) &&
HttpChecksumUtils.isUnsignedPayload(
context.executionAttributes().getAttribute(SIGNING_METHOD), interceptorContext.httpRequest().protocol(),
isContentStreaming) &&
!headerChecksumSpecs.isRequestStreaming();
}
/**
* Implements the "HttpChecksum" C2J trait for a request.
* HttpChecksum is added in the header only in following cases:
* <ol>
* <li>Non-streaming payload and Unsigned Payload </li>
* <li>Non-streaming payload and Header-based Signing auth</li>
* <li>Streaming payload and Header-based Signing auth</li>
* </ol>
* This stage will inject the Http checksum only for case 1 as above i.e. for unsigned payloads.
* For the other two cases, the http checksum will be injected by the signers.
*
* <p>
* Calculates the checksum of the provided request (and base64 encodes it), and adds the header to the request.
*
* <p>Note: This assumes that the content stream provider can create multiple new streams. If it only supports one (e.g. with
* an input stream that doesn't support mark/reset), we could consider buffering the content in memory here and updating the
* request body to use that buffered content. We obviously don't want to do that for giant streams, so we haven't opted to do
* that yet.
*/
private void addFlexibleChecksumInHeader(SdkHttpFullRequest.Builder request, RequestExecutionContext context,
ChecksumSpecs checksumSpecs) {
try {
String payloadChecksum = BinaryUtils.toBase64(HttpChecksumUtils.computeChecksum(
context.executionContext().interceptorContext().requestBody().get().contentStreamProvider().newStream(),
checksumSpecs.algorithm()));
request.putHeader(checksumSpecs.headerName(), payloadChecksum);
} catch (IOException e) {
throw new UncheckedIOException(e);
}
}
static final class ChecksumCalculatingStreamProvider implements ContentStreamProvider {
private final ContentStreamProvider underlyingInputStreamProvider;
private final String checksumHeaderForTrailer;
private final ChecksumSpecs checksumSpecs;
private InputStream currentStream;
private SdkChecksum sdkChecksum;
ChecksumCalculatingStreamProvider(ContentStreamProvider underlyingInputStreamProvider,
ChecksumSpecs checksumSpecs) {
this.underlyingInputStreamProvider = underlyingInputStreamProvider;
this.sdkChecksum = SdkChecksum.forAlgorithm(checksumSpecs.algorithm());
this.checksumHeaderForTrailer = checksumSpecs.headerName();
this.checksumSpecs = checksumSpecs;
}
@Override
public InputStream newStream() {
closeCurrentStream();
currentStream = AwsUnsignedChunkedEncodingInputStream.builder()
.inputStream(underlyingInputStreamProvider.newStream())
.sdkChecksum(sdkChecksum)
.checksumHeaderForTrailer(checksumHeaderForTrailer)
.build();
return currentStream;
}
private void closeCurrentStream() {
sdkChecksum = SdkChecksum.forAlgorithm(checksumSpecs.algorithm());
if (currentStream != null) {
IoUtils.closeQuietly(currentStream, null);
currentStream = null;
}
}
}
}
| 1,988 |
0 | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http/pipeline | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http/pipeline/stages/MergeCustomHeadersStage.java | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.awssdk.core.internal.http.pipeline.stages;
import java.util.List;
import java.util.Map;
import software.amazon.awssdk.annotations.SdkInternalApi;
import software.amazon.awssdk.core.client.config.SdkClientConfiguration;
import software.amazon.awssdk.core.client.config.SdkClientOption;
import software.amazon.awssdk.core.internal.http.HttpClientDependencies;
import software.amazon.awssdk.core.internal.http.RequestExecutionContext;
import software.amazon.awssdk.core.internal.http.pipeline.MutableRequestToRequestPipeline;
import software.amazon.awssdk.http.SdkHttpFullRequest;
import software.amazon.awssdk.utils.http.SdkHttpUtils;
/**
* Merge customer supplied headers into the marshalled request.
*/
@SdkInternalApi
public class MergeCustomHeadersStage implements MutableRequestToRequestPipeline {
private final SdkClientConfiguration config;
public MergeCustomHeadersStage(HttpClientDependencies dependencies) {
this.config = dependencies.clientConfiguration();
}
@Override
public SdkHttpFullRequest.Builder execute(SdkHttpFullRequest.Builder request, RequestExecutionContext context)
throws Exception {
addOverrideHeaders(request,
config.option(SdkClientOption.ADDITIONAL_HTTP_HEADERS),
context.requestConfig().headers());
return request;
}
@SafeVarargs
private final void addOverrideHeaders(SdkHttpFullRequest.Builder request,
Map<String, List<String>>... overrideHeaders) {
for (Map<String, List<String>> overrideHeader : overrideHeaders) {
overrideHeader.forEach((headerName, headerValues) -> {
if (SdkHttpUtils.isSingleHeader(headerName)) {
request.removeHeader(headerName);
}
headerValues.forEach(v -> request.appendHeader(headerName, v));
});
}
}
}
| 1,989 |
0 | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http/pipeline | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http/pipeline/stages/RetryableStage.java | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.awssdk.core.internal.http.pipeline.stages;
import java.io.IOException;
import java.time.Duration;
import java.util.concurrent.TimeUnit;
import software.amazon.awssdk.annotations.SdkInternalApi;
import software.amazon.awssdk.annotations.SdkTestInternalApi;
import software.amazon.awssdk.core.Response;
import software.amazon.awssdk.core.exception.SdkException;
import software.amazon.awssdk.core.internal.http.HttpClientDependencies;
import software.amazon.awssdk.core.internal.http.RequestExecutionContext;
import software.amazon.awssdk.core.internal.http.pipeline.RequestPipeline;
import software.amazon.awssdk.core.internal.http.pipeline.RequestToResponsePipeline;
import software.amazon.awssdk.core.internal.http.pipeline.stages.utils.RetryableStageHelper;
import software.amazon.awssdk.core.internal.retry.RateLimitingTokenBucket;
import software.amazon.awssdk.http.SdkHttpFullRequest;
/**
* Wrapper around the pipeline for a single request to provide retry, clock-skew and request throttling functionality.
*/
@SdkInternalApi
public final class RetryableStage<OutputT> implements RequestToResponsePipeline<OutputT> {
private final RequestPipeline<SdkHttpFullRequest, Response<OutputT>> requestPipeline;
private final HttpClientDependencies dependencies;
private final RateLimitingTokenBucket rateLimitingTokenBucket;
public RetryableStage(HttpClientDependencies dependencies,
RequestPipeline<SdkHttpFullRequest, Response<OutputT>> requestPipeline) {
this.dependencies = dependencies;
this.requestPipeline = requestPipeline;
this.rateLimitingTokenBucket = null;
}
@SdkTestInternalApi
public RetryableStage(HttpClientDependencies dependencies,
RequestPipeline<SdkHttpFullRequest, Response<OutputT>> requestPipeline,
RateLimitingTokenBucket rateLimitingTokenBucket) {
this.dependencies = dependencies;
this.requestPipeline = requestPipeline;
this.rateLimitingTokenBucket = rateLimitingTokenBucket;
}
@Override
public Response<OutputT> execute(SdkHttpFullRequest request, RequestExecutionContext context) throws Exception {
RetryableStageHelper retryableStageHelper = new RetryableStageHelper(request, context, rateLimitingTokenBucket,
dependencies);
while (true) {
retryableStageHelper.startingAttempt();
if (!retryableStageHelper.retryPolicyAllowsRetry()) {
throw retryableStageHelper.retryPolicyDisallowedRetryException();
}
retryableStageHelper.getSendToken();
Duration backoffDelay = retryableStageHelper.getBackoffDelay();
if (!backoffDelay.isZero()) {
retryableStageHelper.logBackingOff(backoffDelay);
TimeUnit.MILLISECONDS.sleep(backoffDelay.toMillis());
}
Response<OutputT> response;
try {
retryableStageHelper.logSendingRequest();
response = requestPipeline.execute(retryableStageHelper.requestToSend(), context);
} catch (SdkException | IOException e) {
retryableStageHelper.setLastException(e);
retryableStageHelper.updateClientSendingRateForErrorResponse();
continue;
}
retryableStageHelper.setLastResponse(response.httpResponse());
if (!response.isSuccess()) {
retryableStageHelper.adjustClockIfClockSkew(response);
retryableStageHelper.setLastException(response.exception());
retryableStageHelper.updateClientSendingRateForErrorResponse();
continue;
}
retryableStageHelper.updateClientSendingRateForSuccessResponse();
retryableStageHelper.attemptSucceeded();
return response;
}
}
}
| 1,990 |
0 | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http/pipeline/stages | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http/pipeline/stages/utils/RetryableStageHelper.java | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.awssdk.core.internal.http.pipeline.stages.utils;
import java.time.Duration;
import java.util.ArrayList;
import java.util.List;
import java.util.OptionalDouble;
import java.util.concurrent.CompletionException;
import software.amazon.awssdk.annotations.SdkInternalApi;
import software.amazon.awssdk.core.Response;
import software.amazon.awssdk.core.SdkStandardLogger;
import software.amazon.awssdk.core.client.config.SdkClientOption;
import software.amazon.awssdk.core.exception.NonRetryableException;
import software.amazon.awssdk.core.exception.SdkClientException;
import software.amazon.awssdk.core.exception.SdkException;
import software.amazon.awssdk.core.interceptor.ExecutionAttribute;
import software.amazon.awssdk.core.internal.InternalCoreExecutionAttribute;
import software.amazon.awssdk.core.internal.http.HttpClientDependencies;
import software.amazon.awssdk.core.internal.http.RequestExecutionContext;
import software.amazon.awssdk.core.internal.http.pipeline.stages.AsyncRetryableStage;
import software.amazon.awssdk.core.internal.http.pipeline.stages.RetryableStage;
import software.amazon.awssdk.core.internal.retry.ClockSkewAdjuster;
import software.amazon.awssdk.core.internal.retry.RateLimitingTokenBucket;
import software.amazon.awssdk.core.metrics.CoreMetric;
import software.amazon.awssdk.core.retry.RetryMode;
import software.amazon.awssdk.core.retry.RetryPolicy;
import software.amazon.awssdk.core.retry.RetryPolicyContext;
import software.amazon.awssdk.core.retry.RetryUtils;
import software.amazon.awssdk.http.SdkHttpFullRequest;
import software.amazon.awssdk.http.SdkHttpResponse;
/**
* Contains the logic shared by {@link RetryableStage} and {@link AsyncRetryableStage} when querying and interacting with a
* {@link RetryPolicy}.
*/
@SdkInternalApi
public class RetryableStageHelper {
public static final String SDK_RETRY_INFO_HEADER = "amz-sdk-request";
public static final ExecutionAttribute<Duration> LAST_BACKOFF_DELAY_DURATION =
new ExecutionAttribute<>("LastBackoffDuration");
private final SdkHttpFullRequest request;
private final RequestExecutionContext context;
private final RetryPolicy retryPolicy;
private final RateLimitingTokenBucket rateLimitingTokenBucket;
private final HttpClientDependencies dependencies;
private final List<String> exceptionMessageHistory = new ArrayList<>();
private int attemptNumber = 0;
private SdkHttpResponse lastResponse = null;
private SdkException lastException = null;
public RetryableStageHelper(SdkHttpFullRequest request,
RequestExecutionContext context,
RateLimitingTokenBucket rateLimitingTokenBucket,
HttpClientDependencies dependencies) {
this.request = request;
this.context = context;
this.retryPolicy = dependencies.clientConfiguration().option(SdkClientOption.RETRY_POLICY);
this.dependencies = dependencies;
if (rateLimitingTokenBucket != null) {
this.rateLimitingTokenBucket = rateLimitingTokenBucket;
} else if (isRateLimitingEnabled()) {
this.rateLimitingTokenBucket = new RateLimitingTokenBucket();
} else {
this.rateLimitingTokenBucket = null;
}
}
/**
* Invoke when starting a request attempt, before querying the retry policy.
*/
public void startingAttempt() {
++attemptNumber;
context.executionAttributes().putAttribute(InternalCoreExecutionAttribute.EXECUTION_ATTEMPT, attemptNumber);
}
/**
* Returns true if the retry policy allows this attempt. This will always return true if the current attempt is not a retry
* (i.e. it's the first request in the execution).
*/
public boolean retryPolicyAllowsRetry() {
if (isInitialAttempt()) {
return true;
}
if (lastException instanceof NonRetryableException) {
return false;
}
RetryPolicyContext context = retryPolicyContext(true);
boolean willRetry = retryPolicy.aggregateRetryCondition().shouldRetry(context);
if (!willRetry) {
retryPolicy.aggregateRetryCondition().requestWillNotBeRetried(context);
}
return willRetry;
}
/**
* Return the exception that should be thrown, because the retry policy did not allow the request to be retried.
*/
public SdkException retryPolicyDisallowedRetryException() {
context.executionContext().metricCollector().reportMetric(CoreMetric.RETRY_COUNT, retriesAttemptedSoFar(true));
for (int i = 0; i < exceptionMessageHistory.size() - 1; i++) {
SdkClientException pastException =
SdkClientException.builder()
.message("Request attempt " + (i + 1) + " failure: " + exceptionMessageHistory.get(i))
.writableStackTrace(false)
.build();
lastException.addSuppressed(pastException);
}
return lastException;
}
/**
* Get the amount of time that the request should be delayed before being sent. This may be {@link Duration#ZERO}, such as
* for the first request in the request series.
*/
public Duration getBackoffDelay() {
Duration result;
if (isInitialAttempt()) {
result = Duration.ZERO;
} else {
RetryPolicyContext context = retryPolicyContext(true);
if (RetryUtils.isThrottlingException(lastException)) {
result = retryPolicy.throttlingBackoffStrategy().computeDelayBeforeNextRetry(context);
} else {
result = retryPolicy.backoffStrategy().computeDelayBeforeNextRetry(context);
}
}
context.executionAttributes().putAttribute(LAST_BACKOFF_DELAY_DURATION, result);
return result;
}
/**
* Log a message to the user at the debug level to indicate how long we will wait before retrying the request.
*/
public void logBackingOff(Duration backoffDelay) {
SdkStandardLogger.REQUEST_LOGGER.debug(() -> "Retryable error detected. Will retry in " +
backoffDelay.toMillis() + "ms. Request attempt number " +
attemptNumber, lastException);
}
/**
* Retrieve the request to send to the service, including any detailed retry information headers.
*/
public SdkHttpFullRequest requestToSend() {
return request.toBuilder()
.putHeader(SDK_RETRY_INFO_HEADER, "attempt=" + attemptNumber + "; max=" + (retryPolicy.numRetries() + 1))
.build();
}
/**
* Log a message to the user at the debug level to indicate that we are sending the request to the service.
*/
public void logSendingRequest() {
SdkStandardLogger.REQUEST_LOGGER.debug(() -> (isInitialAttempt() ? "Sending" : "Retrying") + " Request: " + request);
}
/**
* Adjust the client-side clock skew if the provided response indicates that there is a large skew between the client and
* service. This will allow a retried request to be signed with what is likely to be a more accurate time.
*/
public void adjustClockIfClockSkew(Response<?> response) {
ClockSkewAdjuster clockSkewAdjuster = dependencies.clockSkewAdjuster();
if (!response.isSuccess() && clockSkewAdjuster.shouldAdjust(response.exception())) {
dependencies.updateTimeOffset(clockSkewAdjuster.getAdjustmentInSeconds(response.httpResponse()));
}
}
/**
* Notify the retry policy that the request attempt succeeded.
*/
public void attemptSucceeded() {
retryPolicy.aggregateRetryCondition().requestSucceeded(retryPolicyContext(false));
context.executionContext().metricCollector().reportMetric(CoreMetric.RETRY_COUNT, retriesAttemptedSoFar(false));
}
/**
* Retrieve the current attempt number, updated whenever {@link #startingAttempt()} is invoked.
*/
public int getAttemptNumber() {
return attemptNumber;
}
/**
* Retrieve the last call failure exception encountered by this execution, updated whenever {@link #setLastException} is
* invoked.
*/
public SdkException getLastException() {
return lastException;
}
/**
* Update the {@link #getLastException()} value for this helper. This will be used to determine whether the request should
* be retried.
*/
public void setLastException(Throwable lastException) {
if (lastException instanceof CompletionException) {
setLastException(lastException.getCause());
} else if (lastException instanceof SdkException) {
this.lastException = (SdkException) lastException;
exceptionMessageHistory.add(this.lastException.getMessage());
} else {
this.lastException = SdkClientException.create("Unable to execute HTTP request: " + lastException.getMessage(),
lastException);
exceptionMessageHistory.add(this.lastException.getMessage());
}
}
/**
* Set the last HTTP response returned by the service. This will be used to determine whether the request should be retried.
*/
public void setLastResponse(SdkHttpResponse lastResponse) {
this.lastResponse = lastResponse;
}
/**
* Whether rate limiting is enabled. Only {@link RetryMode#ADAPTIVE} enables rate limiting.
*/
private boolean isRateLimitingEnabled() {
return retryPolicy.retryMode() == RetryMode.ADAPTIVE;
}
/**
* Whether rate limiting should fast fail.
*/
public boolean isFastFailRateLimiting() {
return Boolean.TRUE.equals(retryPolicy.isFastFailRateLimiting());
}
public boolean isLastExceptionThrottlingException() {
if (lastException == null) {
return false;
}
return RetryUtils.isThrottlingException(lastException);
}
/**
* Acquire a send token from the rate limiter. Returns immediately if rate limiting is not enabled.
*/
public void getSendToken() {
if (!isRateLimitingEnabled()) {
return;
}
boolean acquired = rateLimitingTokenBucket.acquire(1.0, isFastFailRateLimiting());
if (!acquired) {
String errorMessage = "Unable to acquire a send token immediately without waiting. This indicates that ADAPTIVE "
+ "retry mode is enabled, fast fail rate limiting is enabled, and that rate limiting is "
+ "engaged because of prior throttled requests. The request will not be executed.";
throw SdkClientException.create(errorMessage);
}
}
/**
* Acquire a send token from the rate limiter in a non blocking manner. See
* {@link RateLimitingTokenBucket#acquireNonBlocking(double, boolean)} for documentation on how to interpret the returned
* value.
*/
public OptionalDouble getSendTokenNonBlocking() {
if (!isRateLimitingEnabled()) {
return OptionalDouble.of(0.0);
}
return rateLimitingTokenBucket.acquireNonBlocking(1.0, isFastFailRateLimiting());
}
/**
* Conditionally updates the sending rate of the rate limiter when an error response is received. This operation is a noop
* if rate limiting is not enabled.
*/
public void updateClientSendingRateForErrorResponse() {
if (!isRateLimitingEnabled()) {
return;
}
// Only throttling errors affect the sending rate. For non error
// responses, they're handled by
// updateClientSendingRateForSuccessResponse()
if (isLastExceptionThrottlingException()) {
rateLimitingTokenBucket.updateClientSendingRate(true);
}
}
/**
* Conditionally updates the sending rate of the rate limiter when an error response is received. This operation is a noop
* if rate limiting is not enabled.
*/
public void updateClientSendingRateForSuccessResponse() {
if (!isRateLimitingEnabled()) {
return;
}
rateLimitingTokenBucket.updateClientSendingRate(false);
}
private boolean isInitialAttempt() {
return attemptNumber == 1;
}
private RetryPolicyContext retryPolicyContext(boolean isBeforeAttemptSent) {
return RetryPolicyContext.builder()
.request(request)
.originalRequest(context.originalRequest())
.exception(lastException)
.retriesAttempted(retriesAttemptedSoFar(isBeforeAttemptSent))
.executionAttributes(context.executionAttributes())
.httpStatusCode(lastResponse == null ? null : lastResponse.statusCode())
.build();
}
/**
* Retrieve the number of retries sent so far in the request execution. This depends on whether or not we've actually
* sent the request yet during this attempt.
*
* Assuming we're executing attempt 3, the number of retries attempted varies based on whether the request has been sent to
* the service yet. Before we send the request, the number of retries is 1 (from attempt 2). After we send the request, the
* number of retries is 2 (from attempt 2 and attempt 3).
*/
private int retriesAttemptedSoFar(boolean isBeforeAttemptSent) {
return Math.max(0, isBeforeAttemptSent ? attemptNumber - 2 : attemptNumber - 1);
}
}
| 1,991 |
0 | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http/pipeline/stages | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http/pipeline/stages/utils/ExceptionReportingUtils.java | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.awssdk.core.internal.http.pipeline.stages.utils;
import software.amazon.awssdk.annotations.SdkInternalApi;
import software.amazon.awssdk.core.internal.http.RequestExecutionContext;
import software.amazon.awssdk.core.internal.interceptor.DefaultFailedExecutionContext;
import software.amazon.awssdk.utils.Logger;
@SdkInternalApi
public final class ExceptionReportingUtils {
private static final Logger log = Logger.loggerFor(ExceptionReportingUtils.class);
private ExceptionReportingUtils() {
}
/**
* Report the failure to the execution interceptors. Swallow any exceptions thrown from the interceptor since
* we don't want to replace the execution failure.
*
* @param context The execution context.
* @param failure The execution failure.
*/
public static Throwable reportFailureToInterceptors(RequestExecutionContext context, Throwable failure) {
DefaultFailedExecutionContext modifiedContext = runModifyException(context, failure);
try {
context.interceptorChain().onExecutionFailure(modifiedContext, context.executionAttributes());
} catch (Exception exception) {
log.warn(() -> "Interceptor chain threw an error from onExecutionFailure().", exception);
}
return modifiedContext.exception();
}
private static DefaultFailedExecutionContext runModifyException(RequestExecutionContext context, Throwable e) {
DefaultFailedExecutionContext failedContext =
DefaultFailedExecutionContext.builder()
.interceptorContext(context.executionContext().interceptorContext())
.exception(e).build();
return context.interceptorChain().modifyException(failedContext, context.executionAttributes());
}
}
| 1,992 |
0 | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http/timers/NoOpTimeoutTracker.java | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.awssdk.core.internal.http.timers;
import software.amazon.awssdk.annotations.SdkInternalApi;
import software.amazon.awssdk.http.Abortable;
/**
* A no op implementation of {@link TimeoutTracker}.
*/
@SdkInternalApi
public final class NoOpTimeoutTracker implements TimeoutTracker {
public static final NoOpTimeoutTracker INSTANCE = new NoOpTimeoutTracker();
private NoOpTimeoutTracker() {
}
@Override
public boolean hasExecuted() {
return false;
}
@Override
public boolean isEnabled() {
return false;
}
@Override
public void cancel() {
}
@Override
public void abortable(Abortable abortable) {
}
}
| 1,993 |
0 | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http/timers/TimerUtils.java | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.awssdk.core.internal.http.timers;
import java.time.Duration;
import java.util.Optional;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;
import java.util.function.Supplier;
import software.amazon.awssdk.annotations.SdkInternalApi;
import software.amazon.awssdk.core.exception.SdkClientException;
import software.amazon.awssdk.utils.OptionalUtils;
@SdkInternalApi
public final class TimerUtils {
private TimerUtils() {
}
/**
* Schedule a {@link TimeoutTask} and exceptional completes a {@link CompletableFuture} with the provide exception
* if not otherwise completed before the given timeout.
*
* @param completableFuture the completableFuture to be timed
* @param timeoutExecutor the executor to execute the {@link TimeoutTask}
* @param exceptionSupplier the exception to thrown after timeout
* @param timeoutInMills the timeout in milliseconds.
* @param <T> the type of the {@link CompletableFuture}
* @return a {@link TimeoutTracker}
*/
public static <T> TimeoutTracker timeAsyncTaskIfNeeded(CompletableFuture<T> completableFuture,
ScheduledExecutorService timeoutExecutor,
Supplier<SdkClientException> exceptionSupplier,
long timeoutInMills) {
if (timeoutInMills <= 0) {
return NoOpTimeoutTracker.INSTANCE;
}
TimeoutTask timeoutTask = new AsyncTimeoutTask(completableFuture, exceptionSupplier);
ScheduledFuture<?> scheduledFuture =
timeoutExecutor.schedule(timeoutTask,
timeoutInMills,
TimeUnit.MILLISECONDS);
TimeoutTracker timeoutTracker = new ApiCallTimeoutTracker(timeoutTask, scheduledFuture);
completableFuture.whenComplete((o, t) -> timeoutTracker.cancel());
return timeoutTracker;
}
/**
* Schedule a {@link TimeoutTask} that aborts the task if not otherwise completed before the given timeout.
*
* @param timeoutExecutor the executor to execute the {@link TimeoutTask}
* @param timeoutInMills the timeout in milliseconds.
* @param threadToInterrupt the thread to interrupt
* @return a {@link TimeoutTracker}
*/
public static TimeoutTracker timeSyncTaskIfNeeded(ScheduledExecutorService timeoutExecutor,
long timeoutInMills,
Thread threadToInterrupt) {
if (timeoutInMills <= 0) {
return NoOpTimeoutTracker.INSTANCE;
}
SyncTimeoutTask timeoutTask = new SyncTimeoutTask(threadToInterrupt);
ScheduledFuture<?> scheduledFuture =
timeoutExecutor.schedule(timeoutTask,
timeoutInMills,
TimeUnit.MILLISECONDS);
return new ApiCallTimeoutTracker(timeoutTask, scheduledFuture);
}
public static long resolveTimeoutInMillis(Supplier<Optional<Duration>> supplier, Duration fallback) {
return OptionalUtils.firstPresent(supplier.get(), () -> fallback)
.map(Duration::toMillis)
.orElse(0L);
}
}
| 1,994 |
0 | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http/timers/AsyncTimeoutTask.java | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.awssdk.core.internal.http.timers;
import java.util.concurrent.CompletableFuture;
import java.util.function.Supplier;
import software.amazon.awssdk.annotations.SdkInternalApi;
import software.amazon.awssdk.core.exception.SdkClientException;
import software.amazon.awssdk.utils.Logger;
import software.amazon.awssdk.utils.Validate;
/**
* Implementation of {@link TimeoutTask} for asynchronous operations to be scheduled to fail
* the {@link CompletableFuture} and abort the asynchronous requests.
*/
@SdkInternalApi
public final class AsyncTimeoutTask implements TimeoutTask {
private static final Logger log = Logger.loggerFor(AsyncTimeoutTask.class);
private final Supplier<SdkClientException> exception;
private volatile boolean hasExecuted;
private final CompletableFuture<?> completableFuture;
/**
* Constructs a new {@link AsyncTimeoutTask}.
*
* @param completableFuture the {@link CompletableFuture} to fail
* @param exceptionSupplier the exceptionSupplier to thrown
*/
public AsyncTimeoutTask(CompletableFuture<?> completableFuture, Supplier<SdkClientException> exceptionSupplier) {
this.completableFuture = Validate.paramNotNull(completableFuture, "completableFuture");
this.exception = Validate.paramNotNull(exceptionSupplier, "exceptionSupplier");
}
@Override
public void run() {
hasExecuted = true;
if (!completableFuture.isDone()) {
completableFuture.completeExceptionally(exception.get());
}
}
@Override
public boolean hasExecuted() {
return hasExecuted;
}
}
| 1,995 |
0 | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http/timers/TimeoutTask.java | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.awssdk.core.internal.http.timers;
import software.amazon.awssdk.annotations.SdkInternalApi;
import software.amazon.awssdk.http.Abortable;
@SdkInternalApi
public interface TimeoutTask extends Runnable {
/**
* @param abortable the abortable request
*/
default void abortable(Abortable abortable) {
}
default void cancel() {
}
/**
* @return True if timeout task has executed. False otherwise
*/
boolean hasExecuted();
}
| 1,996 |
0 | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http/timers/ApiCallTimeoutTracker.java | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.awssdk.core.internal.http.timers;
import java.util.concurrent.ScheduledFuture;
import software.amazon.awssdk.annotations.SdkInternalApi;
import software.amazon.awssdk.http.Abortable;
import software.amazon.awssdk.utils.Validate;
/**
* Api Call Timeout Tracker to track the {@link TimeoutTask} and the {@link ScheduledFuture}.
*/
@SdkInternalApi
public final class ApiCallTimeoutTracker implements TimeoutTracker {
private final TimeoutTask timeoutTask;
private final ScheduledFuture<?> future;
public ApiCallTimeoutTracker(TimeoutTask timeout, ScheduledFuture<?> future) {
this.timeoutTask = Validate.paramNotNull(timeout, "timeoutTask");
this.future = Validate.paramNotNull(future, "scheduledFuture");
}
@Override
public boolean hasExecuted() {
return timeoutTask.hasExecuted();
}
@Override
public boolean isEnabled() {
return true;
}
@Override
public void cancel() {
// Best-effort attempt to ensure that if the future hasn't started running already, don't run it.
future.cancel(false);
// Ensure that if the future hasn't executed its timeout logic already, it won't do so.
timeoutTask.cancel();
}
@Override
public void abortable(Abortable abortable) {
timeoutTask.abortable(abortable);
}
}
| 1,997 |
0 | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http/timers/SyncTimeoutTask.java | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.awssdk.core.internal.http.timers;
import software.amazon.awssdk.annotations.SdkInternalApi;
import software.amazon.awssdk.http.Abortable;
import software.amazon.awssdk.utils.Validate;
/**
* {@link TimeoutTask} to be scheduled for synchronous operations.
*/
@SdkInternalApi
public final class SyncTimeoutTask implements TimeoutTask {
private final Thread threadToInterrupt;
private volatile boolean hasExecuted;
private volatile boolean isCancelled;
// Synchronize calls to run(), cancel(), and hasExecuted().
private final Object lock = new Object();
private Abortable abortable;
SyncTimeoutTask(Thread threadToInterrupt) {
this.threadToInterrupt = Validate.paramNotNull(threadToInterrupt, "threadToInterrupt");
}
@Override
public void abortable(Abortable abortable) {
this.abortable = abortable;
}
/**
* Runs this task. If cancel() was called prior to this invocation, has no side effects. Otherwise, behaves with the
* following post-conditions: (1) threadToInterrupt's interrupt flag is set to true (unless a concurrent process
* clears it); (2) hasExecuted() will return true.
*
* Note that run(), cancel(), and hasExecuted() behave atomically - calls to these methods operate with strict
* happens-before relationships to one another.
*/
@Override
public void run() {
synchronized (this.lock) {
if (isCancelled) {
return;
}
hasExecuted = true;
threadToInterrupt.interrupt();
if (abortable != null) {
abortable.abort();
}
}
}
/**
* Cancels this task. Once this returns, it's guaranteed that hasExecuted() will not change its value, and that this
* task won't interrupt the threadToInterrupt this task was created with.
*/
@Override
public void cancel() {
synchronized (this.lock) {
isCancelled = true;
}
}
/**
* Returns whether this task has finished executing its timeout behavior. The interrupt flag set by this task will
* only be set if hasExecuted() returns true, and is guaranteed not to be set at the time hasExecuted() returns
* false.
*/
@Override
public boolean hasExecuted() {
synchronized (this.lock) {
return hasExecuted;
}
}
}
| 1,998 |
0 | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http | Create_ds/aws-sdk-java-v2/core/sdk-core/src/main/java/software/amazon/awssdk/core/internal/http/timers/TimeoutTracker.java | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
package software.amazon.awssdk.core.internal.http.timers;
import java.util.concurrent.ScheduledFuture;
import software.amazon.awssdk.annotations.SdkInternalApi;
import software.amazon.awssdk.http.Abortable;
/**
* Tracker task to track the {@link TimeoutTask} and the {@link ScheduledFuture} that
* schedules the timeout task.
*/
@SdkInternalApi
public interface TimeoutTracker {
/**
* @return True if timeout task has been executed. False otherwise
*/
boolean hasExecuted();
/**
* @return True if the timer task has been scheduled. False if the timeout is
* disabled for this request
*/
boolean isEnabled();
/**
* cancel the {@link ScheduledFuture}
*/
void cancel();
/**
* Sets the abortable task to be aborted by {@link TimeoutTask}
*
* @param abortable the abortable task
*/
void abortable(Abortable abortable);
}
| 1,999 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.