Refine search
client = new AmazonS3Client(provider, clientConfiguration); S3ClientOptions clientOptions = new S3ClientOptions(); clientOptions.setPathStyleAccess(true); client.setS3ClientOptions(clientOptions);
public URL getPreSignedUrl(long attachmentId, HttpMethod method, boolean unaccelerated) { AmazonS3 client = new AmazonS3Client(credentials); GeneratePresignedUrlRequest request = new GeneratePresignedUrlRequest(bucket, String.valueOf(attachmentId), method); request.setExpiration(new Date(System.currentTimeMillis() + DURATION)); request.setContentType("application/octet-stream"); if (unaccelerated) { client.setS3ClientOptions(S3ClientOptions.builder().setPathStyleAccess(true).build()); } else { client.setS3ClientOptions(S3ClientOptions.builder().setAccelerateModeEnabled(true).build()); } return client.generatePresignedUrl(request); }
private S3RequestEndpointResolver buildEndpointResolver(ServiceEndpointBuilder serviceEndpointBuilder, String bucketName, String key) { return new S3RequestEndpointResolver(serviceEndpointBuilder, clientOptions.isPathStyleAccess(), bucketName, key); }
protected <X extends AmazonWebServiceRequest> Request<X> createRequest(String bucketName, String key, X originalRequest, HttpMethodName httpMethod, URI endpoint) { // If the underlying AmazonS3Client has enabled accelerate mode and the original // request operation is accelerate mode supported, then the request will use the // s3-accelerate endpoint to performe the operations. if (clientOptions.isAccelerateModeEnabled() && !(originalRequest instanceof S3AccelerateUnsupported)) { if (clientOptions.isDualstackEnabled()) { endpoint = RuntimeHttpUtils.toUri(Constants.S3_ACCELERATE_DUALSTACK_HOSTNAME, clientConfiguration); } else { endpoint = RuntimeHttpUtils.toUri(Constants.S3_ACCELERATE_HOSTNAME, clientConfiguration); } } Request<X> request = new DefaultRequest<X>(originalRequest, Constants.S3_SERVICE_DISPLAY_NAME); request.setHttpMethod(httpMethod); request.addHandlerContext(S3HandlerContextKeys.IS_CHUNKED_ENCODING_DISABLED, Boolean.valueOf(clientOptions.isChunkedEncodingDisabled())); request.addHandlerContext(S3HandlerContextKeys.IS_PAYLOAD_SIGNING_ENABLED, Boolean.valueOf(clientOptions.isPayloadSigningEnabled())); resolveRequestEndpoint(request, bucketName, key, endpoint); request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion()); request.addHandlerContext(HandlerContextKey.SERVICE_ID, SERVICE_ID); return request; }
private ServiceEndpointBuilder getBuilder(URI endpoint, String protocol, boolean useDefaultBuilder) { if(clientOptions.isDualstackEnabled() && !clientOptions.isAccelerateModeEnabled()) { return new DualstackEndpointBuilder(getServiceNameIntern(), protocol, getRegion().toAWSRegion()); } else { if(useDefaultBuilder) { return new DefaultServiceEndpointBuilder(getServiceName(), protocol); } else { return new IdentityEndpointBuilder(endpoint); } } }
private void initalizeEndpointOverride(final ProcessContext context, final AmazonS3Client s3) { // if ENDPOINT_OVERRIDE is set, use PathStyleAccess if(StringUtils.trimToEmpty(context.getProperty(ENDPOINT_OVERRIDE).evaluateAttributeExpressions().getValue()).isEmpty() == false){ final S3ClientOptions s3Options = new S3ClientOptions(); s3Options.setPathStyleAccess(true); s3.setS3ClientOptions(s3Options); } }
AmazonS3Client client = new AmazonS3Client(getCredentialsProvider(), clientConfig); if (endpoint != null && !"".equals(endpoint)) { S3ClientOptions s3ClientOptions = new S3ClientOptions(); s3ClientOptions.setPathStyleAccess(true); client.setS3ClientOptions(s3ClientOptions); client.setEndpoint(endpoint); if (!client.doesBucketExist(bucket)) {
AmazonS3Client amazonS3Client = new AmazonS3Client(credentials, clientConf); amazonS3Client.setEndpoint(conf.get(PropertyKey.UNDERFS_S3_ENDPOINT)); S3ClientOptions clientOptions = S3ClientOptions.builder().setPathStyleAccess(true).build(); amazonS3Client.setS3ClientOptions(clientOptions);
S3ClientOptions clientOptions = new S3ClientOptions(); clientOptions.setPathStyleAccess(false); this.amazonS3Client = new AmazonS3Client(credentials, clientConfig); if (StringUtils.isNotEmpty(s3ReaderConfiguration.getRegion())) { this.amazonS3Client.setRegion(Region.getRegion(Regions.fromName(s3ReaderConfiguration.getRegion()))); this.amazonS3Client.setS3ClientOptions(clientOptions);
public static AmazonS3 s3client(Map<String, String> config) { // Use default credentials provider that looks in Env + Java properties + profile + instance role AmazonS3 s3Client = new AmazonS3Client(); // If worker config sets explicit endpoint override (e.g. for testing) use that String s3Endpoint = config.get("s3.endpoint"); if (s3Endpoint != null && !Objects.equals(s3Endpoint, "")) { s3Client.setEndpoint(s3Endpoint); } Boolean s3PathStyle = Boolean.parseBoolean(config.get("s3.path_style")); if (s3PathStyle) { s3Client.setS3ClientOptions(new S3ClientOptions().withPathStyleAccess(true)); } return s3Client; }
private AmazonS3Client getAmazonS3Client(BackupRestoreContext ctx) throws URISyntaxException { final String accessKey = ctx.getAccountId(); final String secretKey = ctx.getSecretKey(); String endpoint = getEndpoint(ctx); LOGGER.info("endpoint: {}", endpoint); final BasicAWSCredentials basicAWSCredentials = new BasicAWSCredentials(accessKey, secretKey); final AmazonS3Client amazonS3Client = new AmazonS3Client(basicAWSCredentials); amazonS3Client.setEndpoint(endpoint); if (ctx.usesEmc()) { final S3ClientOptions options = new S3ClientOptions(); options.setPathStyleAccess(true); amazonS3Client.setS3ClientOptions(options); } return amazonS3Client; }
@Override public void prepare(Object configurationObject) { lineWriterUtil = LineReadWriteUtil.getInstance(s3WriterConfiguration); // Connect to S3 synchronized (this) { try { // if the user has chosen to not set the object mapper, then set a default object mapper for them. if (this.objectMapper == null) { this.objectMapper = StreamsJacksonMapper.getInstance(); } // Create the credentials Object if (this.amazonS3Client == null) { AWSCredentials credentials = new BasicAWSCredentials(s3WriterConfiguration.getKey(), s3WriterConfiguration.getSecretKey()); ClientConfiguration clientConfig = new ClientConfiguration(); clientConfig.setProtocol(Protocol.valueOf(s3WriterConfiguration.getProtocol().toString())); // We do not want path style access S3ClientOptions clientOptions = new S3ClientOptions(); clientOptions.setPathStyleAccess(false); this.amazonS3Client = new AmazonS3Client(credentials, clientConfig); if (StringUtils.isNotEmpty(s3WriterConfiguration.getRegion())) { this.amazonS3Client.setRegion(Region.getRegion(Regions.fromName(s3WriterConfiguration.getRegion()))); } this.amazonS3Client.setS3ClientOptions(clientOptions); } } catch (Exception ex) { LOGGER.error("Exception while preparing the S3 client: {}", ex); } Preconditions.checkArgument(this.amazonS3Client != null); } }
static AmazonS3Client configureClient(AmazonS3Client s3Client) { if (System.getProperty(S3_REGION) != null) { String region = System.getProperty(S3_REGION); Log.debug("S3 region specified: ", region); s3Client.setRegion(RegionUtils.getRegion(region)); } // Region overrides end-point settings if (System.getProperty(S3_END_POINT) != null) { String endPoint = System.getProperty(S3_END_POINT); Log.debug("S3 endpoint specified: ", endPoint); s3Client.setEndpoint(endPoint); } if (System.getProperty(S3_ENABLE_PATH_STYLE) != null && Boolean.valueOf(System.getProperty(S3_ENABLE_PATH_STYLE))) { Log.debug("S3 path style access enabled"); S3ClientOptions sco = new S3ClientOptions(); sco.setPathStyleAccess(true); s3Client.setS3ClientOptions(sco); } return s3Client; }
S3ClientOptions clientOptions = new S3ClientOptions(); if (pathStyleAccess.isPresent()) { clientOptions.setPathStyleAccess(pathStyleAccess.get()); s3Client.setS3ClientOptions(clientOptions); .run(s -> { try { return Optional.of(s3Client.getObjectMetadata(req));
URI uri = clientOptions.isAccelerateModeEnabled() ? endpoint : request.getEndpoint(); final Signer signer = getSignerByURI(uri); if (!isSignerOverridden()) { if ((signer instanceof AWSS3V4Signer) && bucketRegionShouldBeCached(request)) {
final URI uri = clientOptions.isAccelerateModeEnabled() ? endpoint : request.getEndpoint(); final Signer signer = getSignerByURI(uri); if (!isSignerOverridden()) { if ((signer instanceof AWSS3V4Signer) && noExplicitRegionProvided(request)) {
void setBinaryTransferAccelerationEnabled(boolean enabled) { if (enabled) { // verify acceleration is enabled on the bucket BucketAccelerateConfiguration accelerateConfig = s3service.getBucketAccelerateConfiguration(new GetBucketAccelerateConfigurationRequest(bucket)); if (accelerateConfig.isAccelerateEnabled()) { // If transfer acceleration is enabled for presigned URIs, we need a separate AmazonS3Client // instance with the acceleration mode enabled, because we don't want the requests from the // data store itself to S3 to use acceleration s3PresignService = Utils.openService(properties); s3PresignService.setS3ClientOptions(S3ClientOptions.builder().setAccelerateModeEnabled(true).build()); LOG.info("S3 Transfer Acceleration enabled for presigned URIs."); } else { LOG.warn("S3 Transfer Acceleration is not enabled on the bucket {}. Will create normal, non-accelerated presigned URIs.", bucket, S3Constants.PRESIGNED_URI_ENABLE_ACCELERATION); } } else { s3PresignService = s3service; } }
public S3ClientOptions build() { if (pathStyleAccess && accelerateModeEnabled) { throw new SdkClientException("Both accelerate mode and path style access are being enabled either through " + "S3ClientOptions or AmazonS3ClientBuilder. These options are mutually exclusive " + "and cannot be enabled together. Please disable one of them"); } return new S3ClientOptions(pathStyleAccess, chunkedEncodingDisabled, accelerateModeEnabled, payloadSigningEnabled, dualstackEnabled, forceGlobalBucketAccessEnabled); } /**
protected S3ClientOptions resolveS3ClientOptions() { final S3ClientOptions.Builder builder = S3ClientOptions.builder(); if (Boolean.TRUE.equals(this.chunkedEncodingDisabled)) { builder.disableChunkedEncoding(); } if (this.payloadSigningEnabled != null) { builder.setPayloadSigningEnabled(this.payloadSigningEnabled); } if (this.accelerateModeEnabled != null) { builder.setAccelerateModeEnabled(this.accelerateModeEnabled); } if (this.pathStyleAccessEnabled != null) { builder.setPathStyleAccess(this.pathStyleAccessEnabled); } if(Boolean.TRUE.equals(this.dualstackEnabled)) { builder.enableDualstack(); } if(Boolean.TRUE.equals(this.forceGlobalBucketAccessEnabled)) { builder.enableForceGlobalBucketAccess(); } return builder.build(); } }
@Test public void testBuilder() { S3ClientOptions options = S3ClientOptions.builder().setAccelerateModeEnabled(true) .setPathStyleAccess(true).build(); assertTrue(options.isAccelerateModeEnabled()); assertTrue(options.isPathStyleAccess()); } }