listObjects leak fix and test

Author: tjcelaya

java-manta-client/src/main/java/com/joyent/manta/client/MantaClient.java

@@ -714,7 +714,8 @@ public Stream<MantaObject> listObjects(final String path) throws IOException {
                 StreamSupport.stream(Spliterators.spliteratorUnknownSize(
                         itr, Spliterator.ORDERED | Spliterator.NONNULL), false);
 
-        Stream<MantaObject> stream = backingStream.map(item -> {
+        Stream<MantaObject> stream = backingStream.onClose(itr::close)
+                .map(item -> {
             String name = Objects.toString(item.get("name"));
             String mtime = Objects.toString(item.get("mtime"));
             String type = Objects.toString(item.get("type"));

java-manta-client/src/test/java/com/joyent/manta/client/MantaClientTest.java

@@ -0,0 +1,43 @@
+package com.joyent.manta.client;
+
+import com.joyent.manta.config.ConfigContext;
+import com.joyent.manta.config.TestConfigContext;
+import org.mockito.Mockito;
+import org.testng.annotations.AfterTest;
+import org.testng.annotations.Test;
+
+import java.io.IOException;
+import java.util.stream.Stream;
+
+import static org.mockito.Matchers.anyString;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+public class MantaClientTest {
+
+    @AfterTest
+    public void teardown() {
+        Mockito.validateMockitoUsage();
+    }
+
+    @Test
+    public void listObjectsDoesNotLeakConnections() throws IOException {
+        // BasicHttpClientConnectionManager maintains a single connection
+
+        final MantaDirectoryListingIterator iteratorMock = mock(MantaDirectoryListingIterator.class);
+        when(iteratorMock.hasNext()).thenReturn(true);
+
+        final ConfigContext config = TestConfigContext.generateKeyPairBackedConfig().right.setMantaUser("user");
+        final MantaClient client = new MantaClient(config);
+        final MantaClient clientSpy = spy(client);
+        doReturn(iteratorMock).when(clientSpy).streamingIterator(anyString());
+
+        final Stream<MantaObject> listing = clientSpy.listObjects("/");
+        listing.close();
+
+        verify(iteratorMock).close();
+    }
+}

java-manta-client/src/test/java/com/joyent/manta/config/TestConfigContext.java

@@ -7,7 +7,18 @@
  */
 package com.joyent.manta.config;
 
+import com.joyent.http.signature.KeyFingerprinter;
+import org.apache.commons.lang3.tuple.ImmutablePair;
+import org.bouncycastle.openssl.jcajce.JcaMiscPEMGenerator;
+import org.bouncycastle.openssl.jcajce.JcaPEMWriter;
+import org.bouncycastle.openssl.jcajce.JcePEMEncryptorBuilder;
+
+import java.io.IOException;
+import java.io.StringWriter;
 import java.net.URL;
+import java.security.KeyPair;
+import java.security.KeyPairGenerator;
+import java.security.NoSuchAlgorithmException;
 import java.util.Properties;
 
 /**
@@ -97,4 +108,60 @@ static ConfigContext buildTestContext(String mantaUrl,
 
         return testConfig;
     }
+
+     public static ImmutablePair<KeyPair, BaseChainedConfigContext> generateKeyPairBackedConfig() {
+        return generateKeyPairBackedConfig(null);
+    }
+
+    /**
+     * Some test cases need a direct reference to a KeyPair along with it's associated config. Manually calling
+     * KeyPairFactory with a half-baked config can get cumbersome, so let's build a ConfigContext which has
+     * everything ready and supplies the relevant KeyPair.
+     *
+     * @return the generated keypair and a config which uses a serialized version of that keypair
+     */
+    public static ImmutablePair<KeyPair, BaseChainedConfigContext> generateKeyPairBackedConfig(final String passphrase) {
+        final KeyPair keyPair;
+        try {
+            keyPair = KeyPairGenerator.getInstance("RSA").generateKeyPair();
+        } catch (final NoSuchAlgorithmException impossible) {
+            throw new Error(impossible); // "RSA" is always provided
+        }
+
+        final Object keySerializer;
+        if (passphrase != null) {
+            try {
+                keySerializer = new JcaMiscPEMGenerator(
+                        keyPair.getPrivate(),
+                        new JcePEMEncryptorBuilder("AES-128-CBC").build(passphrase.toCharArray()));
+            } catch (IOException e) {
+                throw new RuntimeException(e);
+            }
+        } else {
+            keySerializer = keyPair.getPrivate();
+        }
+
+        final String keyContent;
+        try (final StringWriter content = new StringWriter();
+             final JcaPEMWriter writer = new JcaPEMWriter(content)) {
+            writer.writeObject(keySerializer);
+            writer.flush();
+            keyContent = content.toString();
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+
+        final BaseChainedConfigContext config = new ChainedConfigContext(DEFAULT_CONFIG)
+                // we need to unset the key path in case one exists at ~/.ssh/id_rsa
+                // see the static initializer in DefaultsConfigContext
+                .setMantaKeyPath(null)
+                .setPrivateKeyContent(keyContent)
+                .setMantaKeyId(KeyFingerprinter.md5Fingerprint(keyPair));
+
+        if (passphrase != null) {
+            config.setPassword(passphrase);
+        }
+
+        return new ImmutablePair<>(keyPair, config);
+    }
 }