Context Builder: http://code.google.com/p/jclouds/issues/detail?id=21

git-svn-id: http://jclouds.googlecode.com/svn/trunk@865 3d8758e0-26b5-11de-8745-db77d3ebf521

aws/s3/core/src/main/java/org/jclouds/aws/s3/S3ContextFactory.java

@@ -24,18 +24,20 @@
 package org.jclouds.aws.s3;
 
 import static com.google.common.base.Preconditions.checkNotNull;
-import static org.jclouds.aws.s3.reference.S3Constants.PROPERTY_AWS_ACCESSKEYID;
+import static org.jclouds.aws.reference.AWSConstants.PROPERTY_AWS_ACCESSKEYID;
-import static org.jclouds.aws.s3.reference.S3Constants.PROPERTY_AWS_SECRETACCESSKEY;
+import static org.jclouds.aws.reference.AWSConstants.PROPERTY_AWS_SECRETACCESSKEY;
 import static org.jclouds.command.pool.PoolConstants.PROPERTY_POOL_IO_WORKER_THREADS;
 import static org.jclouds.command.pool.PoolConstants.PROPERTY_POOL_MAX_CONNECTIONS;
 import static org.jclouds.command.pool.PoolConstants.PROPERTY_POOL_MAX_CONNECTION_REUSE;
 import static org.jclouds.command.pool.PoolConstants.PROPERTY_POOL_MAX_SESSION_FAILURES;
 import static org.jclouds.command.pool.PoolConstants.PROPERTY_POOL_REQUEST_INVOKER_THREADS;
 import static org.jclouds.http.HttpConstants.PROPERTY_HTTP_ADDRESS;
+import static org.jclouds.http.HttpConstants.PROPERTY_HTTP_MAX_RETRIES;
 import static org.jclouds.http.HttpConstants.PROPERTY_HTTP_PORT;
 import static org.jclouds.http.HttpConstants.PROPERTY_HTTP_SECURE;
-import static org.jclouds.http.HttpConstants.PROPERTY_HTTP_MAX_RETRIES;
 
+import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.List;
 import java.util.Properties;
 
@@ -51,7 +53,6 @@ import com.google.common.annotations.VisibleForTesting;
 import com.google.common.base.Predicate;
 import com.google.common.base.Predicates;
 import com.google.common.collect.Iterables;
-import com.google.common.collect.Lists;
 import com.google.inject.AbstractModule;
 import com.google.inject.Guice;
 import com.google.inject.Injector;
@@ -68,114 +69,189 @@ import com.google.inject.name.Names;
  * If no <code>Module</code>s are specified, the default {@link JDKLoggingModule logging} and
  * {@link JavaUrlHttpFutureCommandClientModule http transports} will be installed.
  * 
- * @author Adrian Cole
+ * @author Adrian Cole, Andrew Newdigate
  * @see S3Context
  */
 public class S3ContextFactory {
-
+   
-   public static final Properties DEFAULT_PROPERTIES;
+   private static final String DEFAULT_SECURE_HTTP_PORT = "443";
-
+   private static final String DEFAULT_NON_SECURE_HTTP_PORT = "80";
-   static {
+   
-      DEFAULT_PROPERTIES = new Properties();
+   private final Properties properties;   
-      DEFAULT_PROPERTIES.setProperty(PROPERTY_HTTP_ADDRESS, "s3.amazonaws.com");
+   private final List<Module> modules = new ArrayList<Module>(3);
-      DEFAULT_PROPERTIES.setProperty(PROPERTY_HTTP_PORT, "443");
+   
-      DEFAULT_PROPERTIES.setProperty(PROPERTY_HTTP_SECURE, "true");
+   private S3ContextFactory(Properties properties) {
-      DEFAULT_PROPERTIES.setProperty(PROPERTY_HTTP_MAX_RETRIES, "5");
+      this.properties = properties;
-      DEFAULT_PROPERTIES.setProperty(PROPERTY_POOL_MAX_CONNECTION_REUSE, "75");
-      DEFAULT_PROPERTIES.setProperty(PROPERTY_POOL_MAX_SESSION_FAILURES, "2");
-      DEFAULT_PROPERTIES.setProperty(PROPERTY_POOL_REQUEST_INVOKER_THREADS, "1");
-      DEFAULT_PROPERTIES.setProperty(PROPERTY_POOL_IO_WORKER_THREADS, "2");
-      DEFAULT_PROPERTIES.setProperty(PROPERTY_POOL_MAX_CONNECTIONS, "12");
    }
 
+   public static S3ContextFactory createContext(String awsAccessKeyId, String awsSecretAccessKey) {
+      Properties properties = new Properties();
+
+      properties.setProperty(PROPERTY_AWS_ACCESSKEYID, checkNotNull(awsAccessKeyId, "awsAccessKeyId"));
+      properties.setProperty(PROPERTY_AWS_SECRETACCESSKEY, checkNotNull(awsSecretAccessKey,"awsSecretAccessKey"));
+      
+      properties.setProperty(PROPERTY_HTTP_ADDRESS, "s3.amazonaws.com");
+      properties.setProperty(PROPERTY_HTTP_SECURE, "true");
+      properties.setProperty(PROPERTY_HTTP_MAX_RETRIES, "5");
+      properties.setProperty(PROPERTY_POOL_MAX_CONNECTION_REUSE, "75");
+      properties.setProperty(PROPERTY_POOL_MAX_SESSION_FAILURES, "2");
+      properties.setProperty(PROPERTY_POOL_REQUEST_INVOKER_THREADS, "1");
+      properties.setProperty(PROPERTY_POOL_IO_WORKER_THREADS, "2");
+      properties.setProperty(PROPERTY_POOL_MAX_CONNECTIONS, "12");
+      
+      return new S3ContextFactory(properties);
+   }
+
+   public S3Context build() {
+      return createInjector().getInstance(S3Context.class);
+   }
+   
    public static Injector createInjector(String awsAccessKeyId, String awsSecretAccessKey,
             Module... modules) {
-      Properties properties = new Properties(DEFAULT_PROPERTIES);
+      return createContext(awsAccessKeyId, awsSecretAccessKey)
-      properties.setProperty(PROPERTY_AWS_ACCESSKEYID, awsAccessKeyId);
+               .withModules(modules)
-      properties.setProperty(PROPERTY_AWS_SECRETACCESSKEY, awsSecretAccessKey);
+               .createInjector();
-      return createInjector(properties, modules);
    }
 
    public static S3Context createS3Context(String awsAccessKeyId, String awsSecretAccessKey,
             Module... modules) {
-      return createInjector(awsAccessKeyId, awsSecretAccessKey, modules).getInstance(
+      return createContext(awsAccessKeyId, awsSecretAccessKey)
-               S3Context.class);
+               .withModules(modules)
+               .build();
+
    }
 
    public static Injector createInjector(String awsAccessKeyId, String awsSecretAccessKey,
             boolean isSecure, Module... modules) {
-      Properties properties = new Properties(DEFAULT_PROPERTIES);
+      return createContext(awsAccessKeyId, awsSecretAccessKey)
-      properties.setProperty(PROPERTY_AWS_ACCESSKEYID, awsAccessKeyId);
+               .withModules(modules)
-      properties.setProperty(PROPERTY_AWS_SECRETACCESSKEY, awsSecretAccessKey);
+               .withHttpSecure(isSecure)
-      properties.setProperty(PROPERTY_HTTP_SECURE, Boolean.toString(isSecure));
+               .createInjector();
-      if (!isSecure)
-         properties.setProperty(PROPERTY_HTTP_PORT, "80");
-      return createInjector(properties, modules);
    }
 
    public static S3Context createS3Context(String awsAccessKeyId, String awsSecretAccessKey,
             boolean isSecure, Module... modules) {
-      return createInjector(awsAccessKeyId, awsSecretAccessKey, isSecure, modules).getInstance(
+      
-               S3Context.class);
+      return createContext(awsAccessKeyId, awsSecretAccessKey)
+               .withModules(modules)
+               .withHttpSecure(isSecure)
+               .build();
    }
 
    public static Injector createInjector(String awsAccessKeyId, String awsSecretAccessKey,
             boolean isSecure, String server, Module... modules) {
-      Properties properties = new Properties(DEFAULT_PROPERTIES);
+      return createContext(awsAccessKeyId, awsSecretAccessKey)
-      properties.setProperty(PROPERTY_AWS_ACCESSKEYID, awsAccessKeyId);
+               .withModules(modules)
-      properties.setProperty(PROPERTY_AWS_SECRETACCESSKEY, awsSecretAccessKey);
+               .withHttpSecure(isSecure)
-      properties.setProperty(PROPERTY_HTTP_SECURE, Boolean.toString(isSecure));
+               .withHttpAddress(server)
-      properties.setProperty(PROPERTY_HTTP_ADDRESS, server);
+               .createInjector();
-      if (!isSecure)
-         properties.setProperty(PROPERTY_HTTP_PORT, "80");
-      return createInjector(properties, modules);
    }
 
    public static S3Context createS3Context(String awsAccessKeyId, String awsSecretAccessKey,
             boolean isSecure, String server, Module... modules) {
-      return createInjector(awsAccessKeyId, awsSecretAccessKey, isSecure, server, modules)
+      return createContext(awsAccessKeyId, awsSecretAccessKey)
-               .getInstance(S3Context.class);
+               .withModules(modules)
+               .withHttpSecure(isSecure)
+               .withHttpAddress(server)
+               .build();
    }
 
    public static S3Context createS3Context(String awsAccessKeyId, String awsSecretAccessKey,
             boolean isSecure, String server, int port, Module... modules) {
-      return createInjector(awsAccessKeyId, awsSecretAccessKey, isSecure, server, port, modules)
+      return createContext(awsAccessKeyId, awsSecretAccessKey)
-               .getInstance(S3Context.class);
+               .withModules(modules)
+               .withHttpSecure(isSecure)
+               .withHttpAddress(server)
+               .withHttpPort(port)
+               .build();
    }
 
    public static Injector createInjector(String awsAccessKeyId, String awsSecretAccessKey,
             boolean isSecure, String server, int port, Module... modules) {
-      Properties properties = new Properties(DEFAULT_PROPERTIES);
+      return createContext(awsAccessKeyId, awsSecretAccessKey)
-      properties.setProperty(PROPERTY_AWS_ACCESSKEYID, awsAccessKeyId);
+               .withModules(modules)
-      properties.setProperty(PROPERTY_AWS_SECRETACCESSKEY, awsSecretAccessKey);
+               .withHttpSecure(isSecure)
-      properties.setProperty(PROPERTY_HTTP_SECURE, Boolean.toString(isSecure));
+               .withHttpAddress(server)
-      properties.setProperty(PROPERTY_HTTP_ADDRESS, server);
+               .withHttpPort(port)
-      properties.setProperty(PROPERTY_HTTP_PORT, port + "");
+               .createInjector();
-      return createInjector(properties, modules);
    }
 
-   public static S3Context createS3Context(Properties properties, Module... modules) {
+   public S3ContextFactory withHttpAddress(String httpAddress) {
-      return createInjector(properties, modules).getInstance(S3Context.class);
+      properties.setProperty(PROPERTY_HTTP_ADDRESS, httpAddress);
+      return this;
+   }
+   
+   public S3ContextFactory withHttpMaxRetries(int httpMaxRetries) {
+      properties.setProperty(PROPERTY_HTTP_MAX_RETRIES, Integer.toString(httpMaxRetries));
+      return this;
    }
 
-   /**
+   public S3ContextFactory withHttpPort(int httpPort) {
-    * Bind the given properties and install the list of modules. If no modules are specified,
+      properties.setProperty(PROPERTY_HTTP_PORT, Integer.toString(httpPort));
-    * install the default {@link JDKLoggingModule} {@link JavaUrlHttpFutureCommandClientModule}
+      return this;
-    * 
+   }
-    * @param properties
-    *           - contains constants used by jclouds {@link #DEFAULT_PROPERTIES}
-    * @param configModules
-    *           - alternative configuration modules
-    */
-   public static Injector createInjector(final Properties properties, Module... configModules) {
-      final List<Module> modules = Lists.newArrayList(configModules);
 
+   public S3ContextFactory withHttpSecure(boolean httpSecure) {
+      properties.setProperty(PROPERTY_HTTP_SECURE, Boolean.toString(httpSecure));
+      return this;
+   }
+
+   public S3ContextFactory withPoolMaxConnectionReuse(int poolMaxConnectionReuse) {
+      properties.setProperty(PROPERTY_POOL_MAX_CONNECTION_REUSE, Integer.toString(poolMaxConnectionReuse));
+      return this;
+
+   }
+
+   public S3ContextFactory withPoolMaxSessionFailures(int poolMaxSessionFailures) {
+      properties.setProperty(PROPERTY_POOL_MAX_SESSION_FAILURES, Integer.toString(poolMaxSessionFailures));
+      return this;
+
+   }
+
+   public S3ContextFactory withPoolRequestInvokerThreads(int poolRequestInvokerThreads) {
+      properties.setProperty(PROPERTY_POOL_REQUEST_INVOKER_THREADS, Integer.toString(poolRequestInvokerThreads));
+      return this;
+
+   }
+
+   public S3ContextFactory withPoolIoWorkerThreads(int poolIoWorkerThreads) {
+      properties.setProperty(PROPERTY_POOL_IO_WORKER_THREADS, Integer.toString(poolIoWorkerThreads));
+      return this;
+
+   }
+
+   public S3ContextFactory withPoolMaxConnections(int poolMaxConnections) {
+      properties.setProperty(PROPERTY_POOL_MAX_CONNECTIONS, Integer.toString(poolMaxConnections));
+      return this;
+   }
+   
+   public S3ContextFactory withModule(Module module) {
+      modules.add(module);
+      return this;
+   }
+   
+   public S3ContextFactory withModules(Module... modules) {
+      this.modules.addAll(Arrays.asList(modules));
+      return this;
+   }
+   
+   private Injector createInjector() {
+      /* Use 80 or 443 as the default port if one hasn't been set? */
+      if(!properties.containsKey(PROPERTY_HTTP_PORT)) {
+         if(Boolean.parseBoolean(properties.getProperty(PROPERTY_HTTP_SECURE))) {
+            properties.setProperty(PROPERTY_HTTP_PORT, DEFAULT_SECURE_HTTP_PORT);
+         } else {
+            properties.setProperty(PROPERTY_HTTP_PORT, DEFAULT_NON_SECURE_HTTP_PORT);
+         }
+
+      }
+      
       addLoggingModuleIfNotPresent(modules);
 
-      addHttpModuleIfNeededAndNotPresent(modules);
-
       addS3ConnectionModuleIfNotPresent(modules);
 
+      addHttpModuleIfNeededAndNotPresent(modules);
+
       return Guice.createInjector(new AbstractModule() {
          @Override
          protected void configure() {
@@ -186,6 +262,7 @@ public class S3ContextFactory {
       }, new S3ContextModule());
    }
 
+
    @VisibleForTesting
    static void addHttpModuleIfNeededAndNotPresent(final List<Module> modules) {
       if (Iterables.any(modules, new Predicate<Module>() {
@@ -219,4 +296,9 @@ public class S3ContextFactory {
       if (!Iterables.any(modules, Predicates.instanceOf(LoggingModule.class)))
          modules.add(new JDKLoggingModule());
    }
+
+   @VisibleForTesting
+   Properties getProperties() {
+      return properties;
+   }
 }

aws/s3/core/src/test/java/org/jclouds/aws/s3/S3ContextFactoryTest.java

@@ -36,76 +36,119 @@ import org.testng.annotations.Test;
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Properties;
 
 /**
  * Tests behavior of modules configured in S3ContextFactory
- *
+ * 
  * @author Adrian Cole
  */
 @Test(groups = "unit", testName = "s3.S3ContextFactoryTest")
 public class S3ContextFactoryTest {
 
-    @HttpFutureCommandClientModule
+   @HttpFutureCommandClientModule
-    static class HttpModule extends AbstractModule {
+   static class HttpModule extends AbstractModule {
 
-        @Override
+      @Override
-        protected void configure() {
+      protected void configure() {
 
-        }
+      }
-    }
+   }
 
-    @Test
+   @Test
-    public void testAddHttpModuleIfNotPresent() {
+   public void testAddHttpModuleIfNotPresent() {
-        List<Module> modules = new ArrayList<Module>();
+      List<Module> modules = new ArrayList<Module>();
-        HttpModule module = new HttpModule();
+      HttpModule module = new HttpModule();
-        modules.add(module);
+      modules.add(module);
-        S3ContextFactory.addHttpModuleIfNeededAndNotPresent(modules);
+      S3ContextFactory.addHttpModuleIfNeededAndNotPresent(modules);
-        assertEquals(modules.size(), 1);
+      assertEquals(modules.size(), 1);
-        assertEquals(modules.remove(0), module);
+      assertEquals(modules.remove(0), module);
-    }
+   }
 
-    @Test
+   @Test
-    public void testAddLoggingModuleIfNotPresent() {
+   public void testAddLoggingModuleIfNotPresent() {
-        List<Module> modules = new ArrayList<Module>();
+      List<Module> modules = new ArrayList<Module>();
-        LoggingModule module = new NullLoggingModule();
+      LoggingModule module = new NullLoggingModule();
-        modules.add(module);
+      modules.add(module);
-        S3ContextFactory.addLoggingModuleIfNotPresent(modules);
+      S3ContextFactory.addLoggingModuleIfNotPresent(modules);
-        assertEquals(modules.size(), 1);
+      assertEquals(modules.size(), 1);
-        assertEquals(modules.remove(0), module);
+      assertEquals(modules.remove(0), module);
-    }
+   }
 
-    @Test
+   @Test
-    public void testAddNone() {
+   public void testAddNone() {
-        List<Module> modules = new ArrayList<Module>();
+      List<Module> modules = new ArrayList<Module>();
-        LoggingModule loggingModule = new NullLoggingModule();
+      LoggingModule loggingModule = new NullLoggingModule();
-        modules.add(loggingModule);
+      modules.add(loggingModule);
-        HttpModule httpModule = new HttpModule();
+      HttpModule httpModule = new HttpModule();
-        modules.add(httpModule);
+      modules.add(httpModule);
-        S3ContextFactory.addHttpModuleIfNeededAndNotPresent(modules);
+      S3ContextFactory.addHttpModuleIfNeededAndNotPresent(modules);
-        S3ContextFactory.addLoggingModuleIfNotPresent(modules);
+      S3ContextFactory.addLoggingModuleIfNotPresent(modules);
-        assertEquals(modules.size(), 2);
+      assertEquals(modules.size(), 2);
-        assertEquals(modules.remove(0), loggingModule);
+      assertEquals(modules.remove(0), loggingModule);
-        assertEquals(modules.remove(0), httpModule);
+      assertEquals(modules.remove(0), httpModule);
-    }
+   }
 
-    @Test
+   @Test
-    public void testAddBothWhenNotLive() {
+   public void testAddBothWhenNotLive() {
-        List<Module> modules = new ArrayList<Module>();
+      List<Module> modules = new ArrayList<Module>();
-        S3ContextFactory.addHttpModuleIfNeededAndNotPresent(modules);
+      S3ContextFactory.addHttpModuleIfNeededAndNotPresent(modules);
-        S3ContextFactory.addLoggingModuleIfNotPresent(modules);
+      S3ContextFactory.addLoggingModuleIfNotPresent(modules);
-        assertEquals(modules.size(), 1);
+      assertEquals(modules.size(), 1);
-        assert modules.remove(0) instanceof JDKLoggingModule;
+      assert modules.remove(0) instanceof JDKLoggingModule;
-    }
+   }
 
-    @Test
+   @Test
-    public void testAddBothWhenLive() {
+   public void testAddBothWhenLive() {
-        List<Module> modules = new ArrayList<Module>();
+      List<Module> modules = new ArrayList<Module>();
-        modules.add(new LiveS3ConnectionModule());
+      modules.add(new LiveS3ConnectionModule());
-        S3ContextFactory.addHttpModuleIfNeededAndNotPresent(modules);
+      S3ContextFactory.addHttpModuleIfNeededAndNotPresent(modules);
-        S3ContextFactory.addLoggingModuleIfNotPresent(modules);
+      S3ContextFactory.addLoggingModuleIfNotPresent(modules);
-        assertEquals(modules.size(), 3);
+      assertEquals(modules.size(), 3);
-        assert modules.remove(0) instanceof LiveS3ConnectionModule;
+      assert modules.remove(0) instanceof LiveS3ConnectionModule;
-        assert modules.remove(0) instanceof JavaUrlHttpFutureCommandClientModule;
+      assert modules.remove(0) instanceof JavaUrlHttpFutureCommandClientModule;
-        assert modules.remove(0) instanceof JDKLoggingModule;
+      assert modules.remove(0) instanceof JDKLoggingModule;
-    }
+   }
+
+   public void testBuilder() {
+      String awsAccessKeyId = "awsAccessKeyId";
+      String awsSecretAccessKey = "awsSecretAccessKey";
+      String httpAddress = "httpAddress";
+      int httpMaxRetries = 9875;
+      int httpPort = 3827;
+      boolean httpSecure = false;
+      int poolIoWorkerThreads= 2727;
+      int poolMaxConnectionReuse = 3932;
+      int poolMaxConnections = 3382;
+      int poolMaxSessionFailures = 857;
+      int poolRequestInvokerThreads = 8362;
+      
+      AbstractModule module1 = new AbstractModule() {
+
+         @Override
+         protected void configure() {
+         }
+      };
+      AbstractModule module2 = new AbstractModule() {
+         
+         @Override
+         protected void configure() {
+         }
+      };
+      
+      S3ContextFactory factory = S3ContextFactory.createContext(awsAccessKeyId, awsSecretAccessKey);
+      factory.withHttpAddress(httpAddress);
+      factory.withHttpMaxRetries(httpMaxRetries);
+      factory.withHttpPort(httpPort);
+      factory.withHttpSecure(httpSecure);
+      factory.withModule(module1);
+      factory.withModules(module2);
+      factory.withPoolIoWorkerThreads(poolIoWorkerThreads);
+      factory.withPoolMaxConnectionReuse(poolMaxConnectionReuse);
+      factory.withPoolMaxConnections(poolMaxConnections);
+      factory.withPoolMaxSessionFailures(poolMaxSessionFailures);
+      factory.withPoolRequestInvokerThreads(poolRequestInvokerThreads);
+      Properties properties = factory.getProperties();
+      
+   }
 }

aws/s3/core/src/test/java/org/jclouds/aws/s3/S3IntegrationTest.java

@@ -166,15 +166,16 @@ public class S3IntegrationTest {
    }
 
    protected void createStubS3Context() {
-      Properties props = new Properties();
+      context = S3ContextFactory.createContext("stub", "stub")
-      props.setProperty(S3Constants.PROPERTY_HTTP_ADDRESS, "stub");
+                  .withHttpAddress("stub")
-      context = S3ContextFactory.createS3Context(props, new StubS3ConnectionModule());
+                  .withModule(new StubS3ConnectionModule())
+                  .build();
    }
 
    protected void createLiveS3Context(String AWSAccessKeyId, String AWSSecretAccessKey) {
-      context = S3ContextFactory.createS3Context(buildS3Properties(checkNotNull(AWSAccessKeyId,
+      context = buildS3ContextFactory(AWSAccessKeyId, AWSSecretAccessKey)
-               "AWSAccessKeyId"), checkNotNull(AWSSecretAccessKey, "AWSSecretAccessKey")),
+                .withModule(createHttpModule())
-               createHttpModule());
+               .build();
    }
 
    @BeforeMethod(dependsOnMethods = "deleteBucket", groups = { "integration", "live" })
@@ -195,15 +196,10 @@ public class S3IntegrationTest {
       return false;
    }
 
-   protected Properties buildS3Properties(String AWSAccessKeyId, String AWSSecretAccessKey) {
+   protected S3ContextFactory buildS3ContextFactory(String AWSAccessKeyId, String AWSSecretAccessKey) {
-      Properties properties = new Properties(S3ContextFactory.DEFAULT_PROPERTIES);
+      return S3ContextFactory.createContext(AWSAccessKeyId, AWSSecretAccessKey)
-      properties.setProperty(S3Constants.PROPERTY_AWS_ACCESSKEYID, checkNotNull(AWSAccessKeyId,
+               .withHttpSecure(false)
-               "AWSAccessKeyId"));
+               .withHttpPort(80);
-      properties.setProperty(S3Constants.PROPERTY_AWS_SECRETACCESSKEY, checkNotNull(
-               AWSSecretAccessKey, "AWSSecretAccessKey"));
-      properties.setProperty(HttpConstants.PROPERTY_HTTP_SECURE, "false");
-      properties.setProperty(HttpConstants.PROPERTY_HTTP_PORT, "80");
-      return properties;
    }
 
    protected Module createHttpModule() {

aws/s3/core/src/test/java/org/jclouds/aws/s3/SecureS3ConnectionIntegrationTest.java

@@ -25,8 +25,6 @@ package org.jclouds.aws.s3;
 
 import org.testng.annotations.Test;
 
-import java.util.Properties;
-
 /**
  * This performs the same test as {@link S3ConnectionIntegrationTest}, except using SSL.
  *
@@ -35,13 +33,11 @@ import java.util.Properties;
 @Test(groups = {"live"}, testName = "s3.SecureS3ConnectionIntegrationTest")
 public class SecureS3ConnectionIntegrationTest extends S3ConnectionIntegrationTest {
     @Override
-    protected Properties buildS3Properties(String AWSAccessKeyId,
+    protected S3ContextFactory buildS3ContextFactory(String AWSAccessKeyId,
                                            String AWSSecretAccessKey) {
-        Properties properties = super.buildS3Properties(AWSAccessKeyId,
+        return S3ContextFactory.createContext(AWSAccessKeyId, AWSSecretAccessKey)
-                AWSSecretAccessKey);
+                 .withHttpSecure(true)
-        properties.setProperty("jclouds.http.secure", Boolean.toString(true));
+                 .withHttpPort(443);
-        properties.setProperty("jclouds.http.port", "443");
-        return properties;
     }
 
 }

aws/s3/extensions/jets3t/src/test/java/org/jclouds/aws/s3/jets3t/JCloudsS3ServiceIntegrationTest.java

@@ -103,6 +103,8 @@ public class JCloudsS3ServiceIntegrationTest extends S3IntegrationTest {
     	throws S3ServiceException, InterruptedException, ExecutionException 
 	{
         String bucketName = bucketPrefix + ".testCreateBucketImplStringStringAccessControlList";
+        bucketName = bucketName.toLowerCase();
+        
         S3Bucket bucket = service.createBucket(new S3Bucket(bucketName));
         assertEquals(bucket.getName(), bucketName);
         assertTrue(client.bucketExists(bucketName).get());
@@ -114,6 +116,9 @@ public class JCloudsS3ServiceIntegrationTest extends S3IntegrationTest {
     public void testDeleteBucketImplString() throws S3ServiceException,
             InterruptedException, ExecutionException, TimeoutException {
         String bucketName = bucketPrefix + ".testDeleteBucketImplString";
+        bucketName = bucketName.toLowerCase();
+        
+        
         service.deleteBucket(bucketName);
         assert !client.bucketExists(bucketName).get(10, TimeUnit.SECONDS);
     }
@@ -130,6 +135,8 @@ public class JCloudsS3ServiceIntegrationTest extends S3IntegrationTest {
         String objectKey = "key";
         String objectValue = "test";
 
+        bucketName = bucketName.toLowerCase();
+        
         addNewObject(bucketName, objectKey, objectValue);
 
         service.deleteObject(bucketName, objectKey);
@@ -186,7 +193,9 @@ public class JCloudsS3ServiceIntegrationTest extends S3IntegrationTest {
         String bucketName = bucketPrefix + ".testGetObjectDetailsImplStringStringCalendarCalendarStringArrayStringArray";
         String objectKey = "key";
         String objectValue = "test";
-
+        
+        bucketName = bucketName.toLowerCase();
+        
         addNewObject(bucketName, objectKey, objectValue);
 
         S3Object objectDetails = service.getObjectDetails(new S3Bucket(bucketName), objectKey);
@@ -208,6 +217,8 @@ public class JCloudsS3ServiceIntegrationTest extends S3IntegrationTest {
         String objectKey = "key";
         String objectValue = "test";
 
+        bucketName = bucketName.toLowerCase();
+        
         addNewObject(bucketName, objectKey, objectValue);
 
         S3Object object = service.getObject(new S3Bucket(bucketName), objectKey);
@@ -239,6 +250,8 @@ public class JCloudsS3ServiceIntegrationTest extends S3IntegrationTest {
             ExecutionException, TimeoutException, S3ServiceException {
         // Ensure there is at least 1 bucket in S3 account to list and compare.
         String bucketName = bucketPrefix + ".testListAllBucketsImplString";
+        bucketName = bucketName.toLowerCase();
+        
         createBucket(bucketName);
 
         S3Bucket[] jsBuckets = service.listAllBuckets();

aws/s3/perftest/src/test/java/org/jclouds/aws/s3/BasePerformance.java

@@ -138,7 +138,7 @@ public abstract class BasePerformance extends S3IntegrationTest {
 
       public PutBytesCallable(String bucketName) {
          this.bucketName = bucketName;
-      }
+      }     
 
       public Callable<Boolean> get() {
          return new Callable<Boolean>() {

aws/s3/perftest/src/test/java/org/jclouds/aws/s3/JCloudsNioPerformanceLiveTest.java

@@ -23,8 +23,6 @@
  */
 package org.jclouds.aws.s3;
 
-import java.util.Properties;
-
 import org.jclouds.http.httpnio.config.HttpNioConnectionPoolClientModule;
 import org.testng.annotations.Test;
 
@@ -34,15 +32,14 @@ import com.google.inject.Module;
 public class JCloudsNioPerformanceLiveTest extends BaseJCloudsPerformance {
 
     @Override
-    protected Properties buildS3Properties(String AWSAccessKeyId,
+    protected S3ContextFactory buildS3ContextFactory(String AWSAccessKeyId,
                                            String AWSSecretAccessKey) {
-        Properties properties = super.buildS3Properties(AWSAccessKeyId, AWSSecretAccessKey);
+        return super.buildS3ContextFactory(AWSAccessKeyId, AWSSecretAccessKey)
-        properties.setProperty("jclouds.http.pool.max_connection_reuse", "75");
+                  .withPoolMaxConnectionReuse(75)
-        properties.setProperty("jclouds.http.pool.max_session_failures", "2");
+                  .withPoolMaxSessionFailures(2)
-        properties.setProperty("jclouds.http.pool.request_invoker_threads", "1");
+                  .withPoolRequestInvokerThreads(1)
-        properties.setProperty("jclouds.http.pool.io_worker_threads", "2");
+                  .withPoolIoWorkerThreads(2)
-        properties.setProperty("jclouds.pool.max_connections", "12");
+                  .withPoolMaxConnections(12);
-        return properties;
     }
 
     @Override