introduce DataStoreService connection with sst

Author: jimirocks

pom.xml

@@ -237,7 +237,7 @@
         <dependency>
             <groupId>com.gooddata</groupId>
             <artifactId>gooddata-http-client</artifactId>
-            <version>0.8.3</version>
+            <version>0.9.0</version>
         </dependency>
         <dependency>
             <groupId>commons-lang</groupId>

src/main/java/com/gooddata/GoodData.java

@@ -171,29 +171,28 @@ protected GoodData(String hostname, String login, String password, int port, Str
         notEmpty(login, "login");
         notEmpty(password, "password");
         notEmpty(protocol, "protocol");
-        final HttpClientBuilder httpClientBuilder = createHttpClientBuilder(settings);
+        final HttpClient httpClient = createHttpClient(login, password, hostname, port, protocol,
+                createHttpClientBuilder(settings));
 
-        restTemplate = createRestTemplate(login, password, hostname, httpClientBuilder, port, protocol);
+        restTemplate = createRestTemplate(hostname, httpClient, port, protocol);
 
         accountService = new AccountService(getRestTemplate());
         projectService = new ProjectService(getRestTemplate(), accountService);
         metadataService = new MetadataService(getRestTemplate());
         modelService = new ModelService(getRestTemplate());
         gdcService = new GdcService(getRestTemplate());
-        dataStoreService = new DataStoreService(httpClientBuilder, gdcService, new HttpHost(hostname, port, protocol).toURI(), login, password);
+        dataStoreService = new DataStoreService(httpClient, gdcService, new HttpHost(hostname, port, protocol).toURI());
         datasetService = new DatasetService(getRestTemplate(), dataStoreService);
         reportService = new ReportService(getRestTemplate());
         processService = new ProcessService(getRestTemplate(), accountService, dataStoreService);
         warehouseService = new WarehouseService(getRestTemplate(), hostname, port);
         connectorService = new ConnectorService(getRestTemplate(), projectService);
     }
 
-    private RestTemplate createRestTemplate(String login, String password, String hostname, HttpClientBuilder builder,
-                                            int port, String protocol) {
-        final HttpClient client = createHttpClient(login, password, hostname, port, protocol, builder);
+    private RestTemplate createRestTemplate(String hostname, HttpClient httpClient, int port, String protocol) {
 
         final UriPrefixingClientHttpRequestFactory factory = new UriPrefixingClientHttpRequestFactory(
-                new HttpComponentsClientHttpRequestFactory(client), hostname, port, protocol);
+                new HttpComponentsClientHttpRequestFactory(httpClient), hostname, port, protocol);
         final RestTemplate restTemplate = new RestTemplate(factory);
         restTemplate.setInterceptors(Arrays.<ClientHttpRequestInterceptor>asList(
                 new HeaderSettingRequestInterceptor(singletonMap("Accept", getAcceptHeaderValue()))));

src/main/java/com/gooddata/gdc/DataStoreService.java

@@ -6,11 +6,30 @@
 import com.github.sardine.Sardine;
 import com.github.sardine.impl.SardineImpl;
 import com.gooddata.UriPrefixer;
+import org.apache.commons.lang.Validate;
+import org.apache.http.Header;
+import org.apache.http.HeaderIterator;
+import org.apache.http.HttpEntity;
+import org.apache.http.HttpHost;
+import org.apache.http.HttpRequest;
+import org.apache.http.HttpResponse;
+import org.apache.http.ProtocolVersion;
+import org.apache.http.StatusLine;
+import org.apache.http.client.ClientProtocolException;
+import org.apache.http.client.HttpClient;
+import org.apache.http.client.ResponseHandler;
+import org.apache.http.client.methods.CloseableHttpResponse;
+import org.apache.http.client.methods.HttpUriRequest;
+import org.apache.http.conn.ClientConnectionManager;
+import org.apache.http.impl.client.CloseableHttpClient;
 import org.apache.http.impl.client.HttpClientBuilder;
+import org.apache.http.params.HttpParams;
+import org.apache.http.protocol.HttpContext;
 
 import java.io.IOException;
 import java.io.InputStream;
 import java.net.URI;
+import java.util.Locale;
 
 import static com.gooddata.util.Validate.notEmpty;
 import static com.gooddata.util.Validate.notNull;
@@ -28,16 +47,14 @@ public class DataStoreService {
 
     /**
      * Creates new DataStoreService
-     * @param httClientBuilder httpClientBuilder to build datastore connection
+     * @param httpClient httpClient to make datastore connection
      * @param gdcService used to obtain datastore URI
      * @param gdcUri complete GDC URI used to prefix possibly relative datastore path
-     * @param user datastore user
-     * @param pass datastore password
      */
-    public DataStoreService(HttpClientBuilder httClientBuilder, GdcService gdcService, String gdcUri, String user, String pass) {
+    public DataStoreService(HttpClient httpClient, GdcService gdcService, String gdcUri) {
         this.gdcService = notNull(gdcService, "gdcService");
         this.gdcUri = URI.create(notEmpty(gdcUri, "gdcUri"));
-        sardine = new SardineImpl(httClientBuilder, user, pass);
+        sardine = new SardineImpl(new CustomHttpClientBuilder(httpClient));
     }
 
     private UriPrefixer getPrefixer() {
@@ -109,4 +126,240 @@ public void delete(String path) {
             throw new DataStoreException("Unable to delete " + uri, e);
         }
     }
+
+    private static class CustomHttpClientBuilder extends HttpClientBuilder {
+
+        private final HttpClient client;
+
+        private CustomHttpClientBuilder(HttpClient client) {
+            this.client = client;
+        }
+
+        @Override
+        public CloseableHttpClient build() {
+            return new FakeCloseableHttpClient(client);
+        }
+    }
+
+    private static class FakeCloseableHttpClient extends CloseableHttpClient {
+        private final HttpClient client;
+
+        private FakeCloseableHttpClient(HttpClient client) {
+            notNull(client, "client can't be null");
+            this.client = client;
+        }
+
+        @Override
+        protected CloseableHttpResponse doExecute(HttpHost target, HttpRequest request, HttpContext context) throws IOException, ClientProtocolException {
+            // nothing to do - this method is never called, because we override all methods from CloseableHttpClient
+            return null;
+        }
+
+        @Override
+        public void close() throws IOException {
+            // nothing to close - wrappedClient doesn't have to implement CloseableHttpClient
+        }
+
+        @Override
+        @Deprecated
+        public HttpParams getParams() {
+            return client.getParams();
+        }
+
+        @Override
+        @Deprecated
+        public ClientConnectionManager getConnectionManager() {
+            return client.getConnectionManager();
+        }
+
+        @Override
+        public CloseableHttpResponse execute(HttpUriRequest request) throws IOException, ClientProtocolException {
+            return new FakeCloseableHttpResponse(client.execute(request));
+        }
+
+        @Override
+        public CloseableHttpResponse execute(HttpUriRequest request, HttpContext context) throws IOException, ClientProtocolException {
+            return new FakeCloseableHttpResponse(client.execute(request, context));
+        }
+
+        @Override
+        public CloseableHttpResponse execute(HttpHost target, HttpRequest request) throws IOException, ClientProtocolException {
+            return new FakeCloseableHttpResponse(client.execute(target, request));
+        }
+
+        @Override
+        public CloseableHttpResponse execute(HttpHost target, HttpRequest request, HttpContext context) throws IOException, ClientProtocolException {
+            return new FakeCloseableHttpResponse(client.execute(target, request, context));
+        }
+
+        @Override
+        public <T> T execute(HttpUriRequest request, ResponseHandler<? extends T> responseHandler) throws IOException, ClientProtocolException {
+            return client.execute(request, responseHandler);
+        }
+
+        @Override
+        public <T> T execute(HttpUriRequest request, ResponseHandler<? extends T> responseHandler, HttpContext context) throws IOException, ClientProtocolException {
+            return client.execute(request, responseHandler, context);
+        }
+
+        @Override
+        public <T> T execute(HttpHost target, HttpRequest request, ResponseHandler<? extends T> responseHandler) throws IOException, ClientProtocolException {
+            return client.execute(target, request, responseHandler);
+        }
+
+        @Override
+        public <T> T execute(HttpHost target, HttpRequest request, ResponseHandler<? extends T> responseHandler, HttpContext context) throws IOException, ClientProtocolException {
+            return client.execute(target, request, responseHandler, context);
+        }
+    }
+
+    private static class FakeCloseableHttpResponse implements CloseableHttpResponse {
+
+        private final HttpResponse wrappedResponse;
+
+        public FakeCloseableHttpResponse(HttpResponse wrappedResponse) {
+            Validate.notNull(wrappedResponse, "wrappedResponse cannot be null!");
+            this.wrappedResponse = wrappedResponse;
+        }
+
+        @Override
+        public void close() throws IOException {
+            // nothing to close - wrappedClient doesn't have to implement CloseableHttpResponse
+        }
+
+        @Override
+        public StatusLine getStatusLine() {
+            return wrappedResponse.getStatusLine();
+        }
+
+        @Override
+        public void setStatusLine(StatusLine statusline) {
+            wrappedResponse.setStatusLine(statusline);
+        }
+
+        @Override
+        public void setStatusLine(ProtocolVersion ver, int code) {
+            wrappedResponse.setStatusLine(ver, code);
+        }
+
+        @Override
+        public void setStatusLine(ProtocolVersion ver, int code, String reason) {
+            wrappedResponse.setStatusLine(ver, code, reason);
+        }
+
+        @Override
+        public void setStatusCode(int code) throws IllegalStateException {
+            wrappedResponse.setStatusCode(code);
+        }
+
+        @Override
+        public void setReasonPhrase(String reason) throws IllegalStateException {
+            wrappedResponse.setReasonPhrase(reason);
+        }
+
+        @Override
+        public HttpEntity getEntity() {
+            return wrappedResponse.getEntity();
+        }
+
+        @Override
+        public void setEntity(HttpEntity entity) {
+            wrappedResponse.setEntity(entity);
+        }
+
+        @Override
+        public Locale getLocale() {
+            return wrappedResponse.getLocale();
+        }
+
+        @Override
+        public void setLocale(Locale loc) {
+            wrappedResponse.setLocale(loc);
+        }
+
+        @Override
+        public ProtocolVersion getProtocolVersion() {
+            return wrappedResponse.getProtocolVersion();
+        }
+
+        @Override
+        public boolean containsHeader(String name) {
+            return wrappedResponse.containsHeader(name);
+        }
+
+        @Override
+        public Header[] getHeaders(String name) {
+            return wrappedResponse.getHeaders(name);
+        }
+
+        @Override
+        public Header getFirstHeader(String name) {
+            return wrappedResponse.getFirstHeader(name);
+        }
+
+        @Override
+        public Header getLastHeader(String name) {
+            return wrappedResponse.getLastHeader(name);
+        }
+
+        @Override
+        public Header[] getAllHeaders() {
+            return wrappedResponse.getAllHeaders();
+        }
+
+        @Override
+        public void addHeader(Header header) {
+            wrappedResponse.addHeader(header);
+        }
+
+        @Override
+        public void addHeader(String name, String value) {
+            wrappedResponse.addHeader(name, value);
+        }
+
+        @Override
+        public void setHeader(Header header) {
+            wrappedResponse.setHeader(header);
+        }
+
+        @Override
+        public void setHeader(String name, String value) {
+            wrappedResponse.setHeader(name, value);
+        }
+
+        @Override
+        public void setHeaders(Header[] headers) {
+            wrappedResponse.setHeaders(headers);
+        }
+
+        @Override
+        public void removeHeader(Header header) {
+            wrappedResponse.removeHeader(header);
+        }
+
+        @Override
+        public void removeHeaders(String name) {
+            wrappedResponse.removeHeaders(name);
+        }
+
+        @Override
+        public HeaderIterator headerIterator() {
+            return wrappedResponse.headerIterator();
+        }
+
+        @Override
+        public HeaderIterator headerIterator(String name) {
+            return wrappedResponse.headerIterator(name);
+        }
+
+        @Override
+        public HttpParams getParams() {
+            return wrappedResponse.getParams();
+        }
+
+        @Override
+        public void setParams(HttpParams params) {
+            wrappedResponse.setParams(params);
+        }
+    }
 }