Java ClientConfiguration.setProtocol方法代码示例

import com.amazonaws.ClientConfiguration; //导入方法依赖的package包/类
@Bean
public ClientConfiguration awsClientConfig(final ProxyDetails proxyDetails) {
    ClientConfiguration clientConfig = new ClientConfiguration();

    if (useProxy) {
        clientConfig.setProxyHost(clientProxyHost);
        clientConfig.setProxyPort(clientProxyPort);
    } else if(proxyDetails != null) {
        clientConfig.setProxyHost(proxyDetails.getHost());
        clientConfig.setProxyPort(proxyDetails.getPort());
    }

    clientConfig.setProtocol(Protocol.valueOf(clientProtocol.toUpperCase()));
    clientConfig.setConnectionTimeout(clientConnectionTimeout);
    clientConfig.setMaxErrorRetry(clientMaxErrorRetry);

    return clientConfig;
}
 

import com.amazonaws.ClientConfiguration; //导入方法依赖的package包/类
@Override
public AmazonS3Client load(S3ClientKey clientKey) throws Exception {
  logger.debug("Opening S3 client connection for {}", clientKey);
  ClientConfiguration clientConf = new ClientConfiguration();
  clientConf.setProtocol(clientKey.isSecure ? Protocol.HTTPS : Protocol.HTTP);
  // Proxy settings (if configured)
  clientConf.setProxyHost(clientKey.s3Config.get(Constants.PROXY_HOST));
  if (clientKey.s3Config.get(Constants.PROXY_PORT) != null) {
    clientConf.setProxyPort(Integer.valueOf(clientKey.s3Config.get(Constants.PROXY_PORT)));
  }
  clientConf.setProxyDomain(clientKey.s3Config.get(Constants.PROXY_DOMAIN));
  clientConf.setProxyUsername(clientKey.s3Config.get(Constants.PROXY_USERNAME));
  clientConf.setProxyPassword(clientKey.s3Config.get(Constants.PROXY_PASSWORD));
  clientConf.setProxyWorkstation(clientKey.s3Config.get(Constants.PROXY_WORKSTATION));

  if (clientKey.accessKey == null){
    return new AmazonS3Client(new AnonymousAWSCredentialsProvider(), clientConf);
  } else {
    return new AmazonS3Client(new BasicAWSCredentials(clientKey.accessKey, clientKey.secretKey), clientConf);
  }
}
 

import com.amazonaws.ClientConfiguration; //导入方法依赖的package包/类
/**
 * S3 储存客户端
 *
 * @return 客户端
 */
@Bean
@ConditionalOnProperty(value = "bigbug.storage.s3.enable", havingValue = "true")
AmazonS3Client amazonS3Client() {
    ClientConfiguration clientConfig = new ClientConfiguration();
    clientConfig.setProtocol(Protocol.HTTP);

    BasicAWSCredentials basicAWSCredentials =
            new BasicAWSCredentials(
                    storageProperties.getStorage().getS3().getAccessKey(),
                    storageProperties.getStorage().getS3().getSecretKey());

    return (AmazonS3Client) AmazonS3ClientBuilder.standard()
            .withClientConfiguration(clientConfig)
            .withEndpointConfiguration(
                    new AwsClientBuilder.EndpointConfiguration(
                            storageProperties.getStorage().getS3().getEndpoint(), Regions.DEFAULT_REGION.getName()))
            .withCredentials(new AWSStaticCredentialsProvider(basicAWSCredentials))
            .build();
}
 

import com.amazonaws.ClientConfiguration; //导入方法依赖的package包/类
protected static ClientConfiguration buildConfiguration(Logger logger, Settings settings) {
    ClientConfiguration clientConfiguration = new ClientConfiguration();
    // the response metadata cache is only there for diagnostics purposes,
    // but can force objects from every response to the old generation.
    clientConfiguration.setResponseMetadataCacheSize(0);
    clientConfiguration.setProtocol(CLOUD_EC2.PROTOCOL_SETTING.get(settings));

    if (PROXY_HOST_SETTING.exists(settings) || CLOUD_EC2.PROXY_HOST_SETTING.exists(settings)) {
        String proxyHost = CLOUD_EC2.PROXY_HOST_SETTING.get(settings);
        Integer proxyPort = CLOUD_EC2.PROXY_PORT_SETTING.get(settings);
        String proxyUsername = CLOUD_EC2.PROXY_USERNAME_SETTING.get(settings);
        String proxyPassword = CLOUD_EC2.PROXY_PASSWORD_SETTING.get(settings);

        clientConfiguration
            .withProxyHost(proxyHost)
            .withProxyPort(proxyPort)
            .withProxyUsername(proxyUsername)
            .withProxyPassword(proxyPassword);
    }

    // #155: we might have 3rd party users using older EC2 API version
    String awsSigner = CLOUD_EC2.SIGNER_SETTING.get(settings);
    if (Strings.hasText(awsSigner)) {
        logger.debug("using AWS API signer [{}]", awsSigner);
        AwsSigner.configureSigner(awsSigner, clientConfiguration);
    }

    // Increase the number of retries in case of 5xx API responses
    final Random rand = Randomness.get();
    RetryPolicy retryPolicy = new RetryPolicy(
        RetryPolicy.RetryCondition.NO_RETRY_CONDITION,
        new RetryPolicy.BackoffStrategy() {
            @Override
            public long delayBeforeNextRetry(AmazonWebServiceRequest originalRequest,
                                             AmazonClientException exception,
                                             int retriesAttempted) {
                // with 10 retries the max delay time is 320s/320000ms (10 * 2^5 * 1 * 1000)
                logger.warn("EC2 API request failed, retry again. Reason was:", exception);
                return 1000L * (long) (10d * Math.pow(2, retriesAttempted / 2.0d) * (1.0d + rand.nextDouble()));
            }
        },
        10,
        false);
    clientConfiguration.setRetryPolicy(retryPolicy);
    clientConfiguration.setSocketTimeout((int) CLOUD_EC2.READ_TIMEOUT.get(settings).millis());

    return clientConfiguration;
}
 

import com.amazonaws.ClientConfiguration; //导入方法依赖的package包/类
@Bean
public ClientConfiguration awsClientConfig() {
    ClientConfiguration clientConfig = new ClientConfiguration();

    if (useProxy) {
        clientConfig.setProxyHost(clientProxyHost);
        clientConfig.setProxyPort(clientProxyPort);
    }

    clientConfig.setProtocol(Protocol.valueOf(clientProtocol.toUpperCase()));
    clientConfig.setConnectionTimeout(clientConnectionTimeout);
    clientConfig.setMaxErrorRetry(clientMaxErrorRetry);

    return clientConfig;
}
 

import com.amazonaws.ClientConfiguration; //导入方法依赖的package包/类
protected static AmazonS3 createS3(String accessKey, String secretKey) {
  AWSCredentials credentials = new BasicAWSCredentials(accessKey, secretKey);
  ClientConfiguration clientConfig = new ClientConfiguration();
  clientConfig.setProtocol(Protocol.HTTP);
  clientConfig.withSignerOverride("S3SignerType");
  //noinspection deprecation
  AmazonS3 s3 = new AmazonS3Client(credentials, clientConfig);
  s3.setEndpoint(s3Endpoint);
  return s3;
}
 

import com.amazonaws.ClientConfiguration; //导入方法依赖的package包/类
static ClientConfiguration buildConfiguration(Logger logger, Settings repositorySettings, Settings settings,
                                                     String clientName, Integer maxRetries, String endpoint,
                                                     boolean useThrottleRetries) {
    ClientConfiguration clientConfiguration = new ClientConfiguration();
    // the response metadata cache is only there for diagnostics purposes,
    // but can force objects from every response to the old generation.
    clientConfiguration.setResponseMetadataCacheSize(0);
    Protocol protocol = getConfigValue(repositorySettings, settings, clientName, S3Repository.PROTOCOL_SETTING,
                                       S3Repository.Repository.PROTOCOL_SETTING, S3Repository.Repositories.PROTOCOL_SETTING);
    clientConfiguration.setProtocol(protocol);

    String proxyHost = getConfigValue(null, settings, clientName,
                                      S3Repository.PROXY_HOST_SETTING, null, CLOUD_S3.PROXY_HOST_SETTING);
    if (Strings.hasText(proxyHost)) {
        Integer proxyPort = getConfigValue(null, settings, clientName,
                                           S3Repository.PROXY_PORT_SETTING, null, CLOUD_S3.PROXY_PORT_SETTING);
        try (SecureString proxyUsername = getConfigValue(null, settings, clientName,
                                                         S3Repository.PROXY_USERNAME_SETTING, null, CLOUD_S3.PROXY_USERNAME_SETTING);
             SecureString proxyPassword = getConfigValue(null, settings, clientName,
                                                         S3Repository.PROXY_PASSWORD_SETTING, null, CLOUD_S3.PROXY_PASSWORD_SETTING)) {

            clientConfiguration
                .withProxyHost(proxyHost)
                .withProxyPort(proxyPort)
                .withProxyUsername(proxyUsername.toString())
                .withProxyPassword(proxyPassword.toString());
        }
    }

    if (maxRetries != null) {
        // If not explicitly set, default to 3 with exponential backoff policy
        clientConfiguration.setMaxErrorRetry(maxRetries);
    }
    clientConfiguration.setUseThrottleRetries(useThrottleRetries);

    // #155: we might have 3rd party users using older S3 API version
    String awsSigner = CLOUD_S3.SIGNER_SETTING.get(settings);
    if (Strings.hasText(awsSigner)) {
        logger.debug("using AWS API signer [{}]", awsSigner);
        AwsSigner.configureSigner(awsSigner, clientConfiguration, endpoint);
    }

    TimeValue readTimeout = getConfigValue(null, settings, clientName,
                                           S3Repository.READ_TIMEOUT_SETTING, null, CLOUD_S3.READ_TIMEOUT);
    clientConfiguration.setSocketTimeout((int)readTimeout.millis());

    return clientConfiguration;
}
 

import com.amazonaws.ClientConfiguration; //导入方法依赖的package包/类
/**
 * Gets configured AmazonS3 client instance. Does not perform actual request until first remote data is needed
 */
private AmazonS3 getClient() {

    if (s3Client != null) {
        return s3Client; // already cached
    }

    ClientConfiguration config = new ClientConfiguration();
    if (endpoint != null && endpoint.startsWith("https://")) {
        config.setProtocol(Protocol.HTTPS);
    } else {
        config.setProtocol(Protocol.HTTP);
    }

    BasicAWSCredentials creds = new BasicAWSCredentials(accessKey, secretKey);
    if (LOG.isDebugEnabled()) {
        LOG.debug("Creating S3 client to " + ( (endpoint == null)
                                                                  ? "default Amazon"
                                                                  : endpoint)
                  + " endpoint with access key " + accessKey);
    }

    if (this.endpoint != null) {
        if (region == null || region.trim().length() == 0) {
            region = Regions.DEFAULT_REGION.name();
        }
        s3Client = AmazonS3ClientBuilder.standard()
                                        .withCredentials(new AWSStaticCredentialsProvider(creds))
                                        .withEndpointConfiguration(new EndpointConfiguration(endpoint, region))
                                        .withClientConfiguration(config)
                                        .withPathStyleAccessEnabled(true)
                                        .build();
    } else {
        s3Client = AmazonS3ClientBuilder.standard()
                                        .withCredentials(new AWSStaticCredentialsProvider(creds))
                                        .withClientConfiguration(config)
                                        .withPathStyleAccessEnabled(true)
                                        .build();
    }
    return s3Client;
}