Refine search
@Override public ClientConfiguration getAWSClientConfig() { ClientConfiguration awsClientConfig = new ClientConfiguration(); awsClientConfig.setProxyHost(proxyHost); awsClientConfig.setProxyPort(proxyPort); if ( proxyUsername != null ) { awsClientConfig.setProxyUsername(proxyUsername); } if ( proxyPassword != null ) { awsClientConfig.setProxyPassword(proxyPassword); } return awsClientConfig; }
/** * Constructs a new asynchronous client to invoke service methods on Amazon Snowball. A credentials provider chain * will be used that searches for credentials in this order: * <ul> * <li>Environment Variables - AWS_ACCESS_KEY_ID and AWS_SECRET_KEY</li> * <li>Java System Properties - aws.accessKeyId and aws.secretKey</li> * <li>Credential profiles file at the default location (~/.aws/credentials) shared by all AWS SDKs and the AWS CLI</li> * <li>Instance profile credentials delivered through the Amazon EC2 metadata service</li> * </ul> * <p> * Asynchronous methods are delegated to a fixed-size thread pool containing a number of threads equal to the * maximum number of concurrent connections configured via {@code ClientConfiguration.getMaxConnections()}. * * @param clientConfiguration * The client configuration options controlling how this client connects to Amazon Snowball (ex: proxy * settings, retry counts, etc). * * @see com.amazonaws.auth.DefaultAWSCredentialsProviderChain * @see java.util.concurrent.Executors#newFixedThreadPool(int) * @deprecated use {@link AmazonSnowballAsyncClientBuilder#withClientConfiguration(ClientConfiguration)} */ @Deprecated public AmazonSnowballAsyncClient(ClientConfiguration clientConfiguration) { this(DefaultAWSCredentialsProviderChain.getInstance(), clientConfiguration, newFixedThreadPool(clientConfiguration.getMaxConnections())); }
static ClientConfiguration s3ClientCfg() { ClientConfiguration cfg = new ClientConfiguration(); Properties prop = System.getProperties(); if( prop.containsKey(S3_SOCKET_TIMEOUT_PROP) ) cfg.setSocketTimeout(Integer.getInteger(S3_SOCKET_TIMEOUT_PROP)); if( prop.containsKey(S3_CONNECTION_TIMEOUT_PROP) ) cfg.setConnectionTimeout(Integer .getInteger(S3_CONNECTION_TIMEOUT_PROP)); if( prop.containsKey(S3_MAX_ERROR_RETRY_PROP) ) cfg.setMaxErrorRetry(Integer.getInteger(S3_MAX_ERROR_RETRY_PROP)); if( prop.containsKey(S3_MAX_HTTP_CONNECTIONS_PROP) ) cfg.setMaxConnections(Integer .getInteger(S3_MAX_HTTP_CONNECTIONS_PROP)); cfg.setProtocol(Protocol.HTTP); return cfg; }
/** * Builds a {@link ClientConfiguration} instance with configuration values * tailored towards clients operating in the same AWS region as the service * endpoint they call. Timeouts in in-region optimized configurations are * generally set much lower than the client standard configuration. * * @return constructed {@link ClientConfiguration} with in-region optimized configuration */ protected ClientConfiguration getInRegionOptimizedConfig() { return new ClientConfiguration().withConnectionTimeout(1000); }
/** * Factory method for Simple Workflow's default {@link ClientConfiguration} */ public static ClientConfiguration swfDefault() { return new ClientConfiguration().withMaxConnections(1000).withSocketTimeout(90000); }
/** * Factory method for DynamoDB's default {@link ClientConfiguration} */ public static ClientConfiguration dynamoDefault() { return new ClientConfiguration().withRetryPolicy(PredefinedRetryPolicies.DYNAMODB_DEFAULT); }
/** * Constructs a new asynchronous client to invoke service methods on Amazon Cognito Identity using the provided AWS * account credentials provider and client configuration options. * <p> * Asynchronous methods are delegated to a fixed-size thread pool containing a number of threads equal to the * maximum number of concurrent connections configured via {@code ClientConfiguration.getMaxConnections()}. * * @param awsCredentialsProvider * The AWS credentials provider which will provide credentials to authenticate requests with AWS services. * @param clientConfiguration * Client configuration options (ex: max retry limit, proxy settings, etc). * * @see com.amazonaws.auth.DefaultAWSCredentialsProviderChain * @see java.util.concurrent.Executors#newFixedThreadPool(int) * @deprecated use {@link AmazonCognitoIdentityAsyncClientBuilder#withCredentials(AWSCredentialsProvider)} and * {@link AmazonCognitoIdentityAsyncClientBuilder#withClientConfiguration(ClientConfiguration)} */ @Deprecated public AmazonCognitoIdentityAsyncClient(AWSCredentialsProvider awsCredentialsProvider, ClientConfiguration clientConfiguration) { this(awsCredentialsProvider, clientConfiguration, newFixedThreadPool(clientConfiguration.getMaxConnections())); }
ClientConfiguration c = new ClientConfiguration(); c.withConnectionTimeout(1); assertEquals(c.getConnectionTimeout(), 1); c.setConnectionTimeout(1); assertEquals(c.getConnectionTimeout(), 1); c.withLocalAddress(ina); assertEquals(c.getLocalAddress(), ina); InetAddress localHost = InetAddress.getLocalHost(); c.setLocalAddress(localHost); assertEquals(c.getLocalAddress(), localHost); c.withMaxConnections(1); assertEquals(c.getMaxConnections(), 1); c.setMaxConnections(2); assertEquals(c.getMaxConnections(), 2); c.withMaxErrorRetry(1); assertEquals(c.getMaxErrorRetry(), 1); c.setMaxErrorRetry(2); assertEquals(c.getMaxErrorRetry(), 2); c.withPreemptiveBasicProxyAuth(true); assertTrue(c.isPreemptiveBasicProxyAuth()); c.setPreemptiveBasicProxyAuth(false); assertFalse(c.isPreemptiveBasicProxyAuth()); c.withProtocol(Protocol.HTTP);
/** * Factory method for default {@link ClientConfiguration} for all services unless otherwise * specified */ public static ClientConfiguration defaultConfig() { return new ClientConfiguration(); }
protected ClientConfiguration createConfiguration(final ProcessContext context) { final ClientConfiguration config = new ClientConfiguration(); config.setMaxConnections(context.getMaxConcurrentTasks()); config.setMaxErrorRetry(0); config.setUserAgent(DEFAULT_USER_AGENT); config.setProtocol(DEFAULT_PROTOCOL); final int commsTimeout = context.getProperty(TIMEOUT).asTimePeriod(TimeUnit.MILLISECONDS).intValue(); config.setConnectionTimeout(commsTimeout); config.setSocketTimeout(commsTimeout); config.getApacheHttpClientConfig().setSslSocketFactory(sdkTLSSocketFactory); config.setProxyHost(proxyConfig.getProxyServerHost()); config.setProxyPort(proxyConfig.getProxyServerPort()); config.setProxyUsername(proxyConfig.getProxyUserName()); config.setProxyPassword(proxyConfig.getProxyUserPassword());
private AmazonS3 getS3Client() throws Exception{ this.bucketName = properties.getProperty( "usergrid.binary.bucketname" ); if(bucketName == null){ logger.error( "usergrid.binary.bucketname not properly set so amazon bucket is null" ); throw new AwsPropertiesNotFoundException( "usergrid.binary.bucketname" ); } final UsergridAwsCredentialsProvider ugProvider = new UsergridAwsCredentialsProvider(); AWSCredentials credentials = ugProvider.getCredentials(); ClientConfiguration clientConfig = new ClientConfiguration(); clientConfig.setProtocol(Protocol.HTTP); s3Client = new AmazonS3Client(credentials, clientConfig); if(regionName != null) s3Client.setRegion( Region.getRegion(Regions.fromName(regionName)) ); return s3Client; }
ClientConfiguration clientConf = new ClientConfiguration(); .setSocketTimeout((int) alluxioConf.getMs(PropertyKey.UNDERFS_S3A_SOCKET_TIMEOUT_MS)); clientConf.setProtocol(Protocol.HTTPS); } else { clientConf.setProtocol(Protocol.HTTP); clientConf.setProxyHost(conf.get(PropertyKey.UNDERFS_S3_PROXY_HOST)); clientConf.setProxyPort(Integer.parseInt(conf.get(PropertyKey.UNDERFS_S3_PROXY_PORT))); numThreads = numAdminThreads + numTransferThreads; clientConf.setMaxConnections(numThreads); .setRequestTimeout((int) alluxioConf.getMs(PropertyKey.UNDERFS_S3A_REQUEST_TIMEOUT)); clientConf.setSignerOverride(conf.get(PropertyKey.UNDERFS_S3A_SIGNER_ALGORITHM));
AWSCredentialsProvider provider; ClientConfiguration clientConfiguration = new ClientConfiguration(); boolean isHttpProxyEnabled = mConfig.getAwsProxyEnabled(); String httpProxyHost = mConfig.getAwsProxyHttpHost(); int httpProxyPort = mConfig.getAwsProxyHttpPort(); clientConfiguration.setProxyHost(httpProxyHost); clientConfiguration.setProxyPort(httpProxyPort); provider = new DefaultAWSCredentialsProviderChain(); } else { provider = new AWSCredentialsProvider() {
private ClientConfiguration getClientConfiguration(){ if (clientConfiguration == null) { clientConfiguration = new ClientConfiguration(); if(proxyHost != null && proxyHost.length() > 0) { clientConfiguration.setProxyHost(proxyHost); clientConfiguration.setProxyPort(Integer.parseInt(proxyPort)); } } return clientConfiguration; }
final ClientConfiguration configuration = new ClientConfiguration(); configuration.setProtocol(clientOptions.isHttps() ? HTTPS : HTTP); configuration.setConnectionTimeout(clientOptions.getConnectionTimeout()); configuration.setMaxErrorRetry(clientOptions.getMaxErrorRetry()); configuration.setSocketTimeout(clientOptions.getSocketTimeout()); configuration.setUseTcpKeepAlive(clientOptions.getUseTCPKeepAlive()); configuration.setConnectionTTL(clientOptions.getConnectionTtl()); configuration.setSignerOverride(clientOptions.getSigner()); configuration.getProtocol(), configuration.getSignerOverride(), configuration.getConnectionTimeout(), configuration.getMaxErrorRetry(), configuration.getSocketTimeout(), clientOptions.getUseTCPKeepAlive(), clientOptions.getConnectionTtl()));
/** * @param accessKey * @param secretKey * @return */ public static AmazonEC2Client getEC2Client( String accessKey, String secretKey ) { AWSCredentialsProvider provider; if ( accessKey != null && secretKey != null ) { AWSCredentials credentials = new BasicAWSCredentials( accessKey, secretKey ); provider = new StaticCredentialsProvider( credentials ); } else { provider = new DefaultAWSCredentialsProviderChain(); } AmazonEC2Client client = new AmazonEC2Client( provider ); ClientConfiguration configuration = new ClientConfiguration(); configuration.setProtocol( Protocol.HTTPS ); client.setConfiguration( configuration ); return client; }
System.out.println("Inizializing the S3 connection"); s3Credentials = new BasicAWSCredentials(accessKeyId, secretKey); clientConfig = new ClientConfiguration(); clientConfig.setMaxErrorRetry(Integer.parseInt(maxErrorRetry)); if(protocol.equals("HTTP")) { clientConfig.setProtocol(Protocol.HTTP); } else { clientConfig.setProtocol(Protocol.HTTPS); clientConfig.setMaxConnections(Integer.parseInt(maxConnections));
private ClientConfiguration getClientConfiguration(String proxyHost, String proxyPort) { ClientConfiguration clientConfig = new ClientConfiguration(); if (!proxyHost.isEmpty()) { clientConfig.withProxyHost(proxyHost); } if (!proxyPort.isEmpty()) { clientConfig.setProxyPort(Validation.parseInt(proxyPort)); } return clientConfig; } }
private ClientConfiguration createConfiguration(boolean isSecure) { ClientConfiguration config = new ClientConfiguration(); config.setUserAgent(USER_AGENT); Protocol protocol = isSecure ? Protocol.HTTPS : Protocol.HTTP; config.setProtocol(protocol); return config; }
public void apply(ClientConfiguration clientConfiguration) { clientConfiguration.setProxyHost(proxyHost); clientConfiguration.setProxyPort(Integer.parseInt(proxyPort)); clientConfiguration.setProxyUsername(proxyUsername); clientConfiguration.setProxyPassword(proxyPassword); Protocol awsProtocol = Protocol.HTTP; if ("HTTPS".equalsIgnoreCase(protocol)) { awsProtocol = Protocol.HTTPS; } clientConfiguration.setProtocol(awsProtocol); if (isNTLMProxy()) { clientConfiguration.setProxyDomain(proxyDomain); clientConfiguration.setProxyWorkstation(proxyWorkstation); } }