Merge pull request #48 from martiner/jmi-ads

Introduce Warehouse and Dataload Processes API support

Author: Martin Caslavsky

README.md

@@ -94,3 +94,26 @@ dataStoreService.upload("/dir/file.txt", new FileInputStream("file.txt"));
 InputStream stream = dataStoreService.download("/dir/file.txt");
 dataStoreService.delete("/dir/file.txt");
 ```
+
+### Warehouse API
+Manage warehouses - create, update, list and delete.
+```java
+WarehouseService warehouseService = gd.getWarehouseService();
+Warehouse warehouse = warehouseService.createWarehouse(new Warehouse("title", "authToken", "description"));
+String jdbc = warehouse.getJdbcConnectionString();
+
+warehouse.setTitle("another Title");
+warehouse = warehouseService.updateWarehouse(warehouse);
+
+Collection<Warehouse> warehouseList = warehouseService.listInstances();
+warehouseService.removeWarehouse(warehouse);
+```
+
+### Dataload processes API
+Manage dataload processes - create, update, list, delete, and process executions - execute, get logs, ...
+```java
+ProcessService processService = gd.getProcessService();
+Process process = processService.createProcess(project, new Process('name', 'GRAPH'), new File('path/to/processdatadir')).get();
+ProcessExecutionDetail executionDetail = processService.executeProcess(new ProcessExecution(process, "myGraph.grf")).get();
+processService.getExecutionLog(executionDetail, new FileOutputStream("file/where/the/log/willbewritten");
+```

src/main/java/com/gooddata/AbstractService.java

@@ -3,6 +3,10 @@
  */
 package com.gooddata;
 
+import static com.gooddata.Validate.notNull;
+import static java.lang.String.format;
+import static org.springframework.http.HttpMethod.GET;
+
 import org.codehaus.jackson.map.ObjectMapper;
 import org.springframework.http.HttpHeaders;
 import org.springframework.http.HttpStatus;
@@ -17,11 +21,9 @@
 import java.io.ByteArrayInputStream;
 import java.io.IOException;
 import java.io.InputStream;
+import java.io.OutputStream;
 import java.util.concurrent.TimeUnit;
 
-import static com.gooddata.Validate.notNull;
-import static java.lang.String.format;
-import static org.springframework.http.HttpMethod.GET;
 
 /**
  * Parent for GoodData services providing helpers for REST API calls and polling.
@@ -58,7 +60,7 @@ public AbstractService(RestTemplate restTemplate) {
         this.restTemplate = notNull(restTemplate, "restTemplate");
     }
 
-    final <T> T poll(final PollHandler<T> handler, long timeout, final TimeUnit unit) {
+    final <R> R poll(final PollHandler<?,R> handler, long timeout, final TimeUnit unit) {
         notNull(handler, "handler");
         final long start = System.currentTimeMillis();
         while (true) {
@@ -77,15 +79,15 @@ final <T> T poll(final PollHandler<T> handler, long timeout, final TimeUnit unit
         }
     }
 
-    final <T> boolean pollOnce(final PollHandler<T> handler) {
+    final <P> boolean pollOnce(final PollHandler<P,?> handler) {
         notNull(handler, "handler");
         final ClientHttpResponse response = restTemplate.execute(handler.getPollingUri(), GET, noopRequestCallback,
                 reusableResponseExtractor);
 
         try {
             if (handler.isFinished(response)) {
-                final T data = extractData(response, handler.getResultClass());
-                handler.setResult(data);
+                final P data = extractData(response, handler.getPollClass());
+                handler.handlePollResult(data);
             } else if (HttpStatus.Series.CLIENT_ERROR.equals(response.getStatusCode().series())) {
                 throw new GoodDataException(
                         format("Polling returned client error HTTP status %s", response.getStatusCode().value())
@@ -108,15 +110,18 @@ protected final <T> T extractData(ClientHttpResponse response, Class<T> cls) thr
 
     private class ReusableClientHttpResponse implements ClientHttpResponse {
 
-        private final byte[] body;
+        private byte[] body;
         private final HttpStatus statusCode;
         private final int rawStatusCode;
         private final String statusText;
         private final HttpHeaders headers;
 
         public ReusableClientHttpResponse(ClientHttpResponse response) {
             try {
-                body = FileCopyUtils.copyToByteArray(response.getBody());
+                final InputStream bodyStream = response.getBody();
+                if (bodyStream != null) {
+                    body = FileCopyUtils.copyToByteArray(bodyStream);
+                }
                 statusCode = response.getStatusCode();
                 rawStatusCode = response.getRawStatusCode();
                 statusText = response.getStatusText();
@@ -152,7 +157,7 @@ public HttpHeaders getHeaders() {
 
         @Override
         public InputStream getBody() throws IOException {
-            return new ByteArrayInputStream(body);
+            return body != null ? new ByteArrayInputStream(body) : null;
         }
 
         @Override
@@ -161,4 +166,17 @@ public void close() {
         }
     }
 
+    protected static class OutputStreamResponseExtractor implements ResponseExtractor<Integer> {
+        private final OutputStream output;
+
+        public OutputStreamResponseExtractor(OutputStream output) {
+            this.output = output;
+        }
+
+        @Override
+        public Integer extractData(ClientHttpResponse response) throws IOException {
+            return FileCopyUtils.copy(response.getBody(), output);
+        }
+    }
+
 }

src/main/java/com/gooddata/FutureResult.java

@@ -14,7 +14,7 @@ public final class FutureResult<T> {
 
     private final AbstractService service;
 
-    private final PollHandler<T> handler;
+    private final PollHandler<?,T> handler;
 
     /**
      * Creates a new instance of the result to be eventually retrieved by polling on the REST API.<p>
@@ -23,7 +23,7 @@ public final class FutureResult<T> {
      * @param service this service
      * @param handler poll handler
      */
-    public FutureResult(final AbstractService service, final PollHandler<T> handler) {
+    public FutureResult(final AbstractService service, final PollHandler<?,T> handler) {
         this.service = notNull(service, "service");
         this.handler = notNull(handler, "handler");
     }

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

@@ -4,6 +4,8 @@
 package com.gooddata;
 
 import com.gooddata.account.AccountService;
+import com.gooddata.dataload.processes.ProcessService;
+import com.gooddata.warehouse.WarehouseService;
 import com.gooddata.dataset.DatasetService;
 import com.gooddata.gdc.DataStoreService;
 import com.gooddata.gdc.GdcService;
@@ -59,6 +61,8 @@ public class GoodData {
     private final DataStoreService dataStoreService;
     private final DatasetService datasetService;
     private final ReportService reportService;
+    private final ProcessService processService;
+    private final WarehouseService warehouseService;
 
     /**
      * Create instance configured to communicate with GoodData Platform under user with given credentials.
@@ -111,6 +115,8 @@ public GoodData(String hostname, String login, String password, int port, String
         dataStoreService = new DataStoreService(httpClientBuilder, gdcService, login, password);
         datasetService = new DatasetService(restTemplate, dataStoreService);
         reportService = new ReportService(restTemplate);
+        processService = new ProcessService(restTemplate, accountService);
+        warehouseService = new WarehouseService(restTemplate, hostname, port);
     }
 
     private RestTemplate createRestTemplate(String login, String password, String hostname, HttpClientBuilder builder,
@@ -227,4 +233,15 @@ public ReportService getReportService() {
         return reportService;
     }
 
+    public ProcessService getProcessService() {
+        return processService;
+    }
+    /**
+     * Get initialized service for ADS management (create, access and delete ads instances).
+     *
+     * @return initialized service for ADS management
+     */
+    public WarehouseService getWarehouseService() {
+        return warehouseService;
+    }
 }

src/main/java/com/gooddata/PollHandler.java

@@ -13,28 +13,43 @@
 /**
  * For internal usage by services employing polling.<p>
  * Implementing classes should override {@link #isFinished(ClientHttpResponse)} method and
- * may override {@link #onFinish()} method.
+ * may override {@link #onFinish()} and {@link #handlePollResult(Object)} methods.
  *
- * @see FutureResult
+ * @param <P> polling type
+ * @param <R> result type
+ *
+ * @see com.gooddata.FutureResult
  */
-public class PollHandler<T> {
+public class PollHandler<P,R> {
 
     private final String pollingUri;
 
-    private final Class<T> resultClass;
+    private final Class<P> pollClass;
+    private final Class<R> resultClass;
 
     private boolean done = false;
 
-    private T result;
+    private R result;
 
     /**
      * Creates a new instance of polling handler
-     *
-     * @param pollingUri  URI for polling
-     * @param resultClass class of the result (or {@link Void})
+     *  @param pollingUri  URI for polling
+     *  @param pollAndResultClass class of the polling object and result  (or {@link Void})
      */
-    public PollHandler(final String pollingUri, final Class<T> resultClass) {
+    @SuppressWarnings("unchecked")
+    public PollHandler(final String pollingUri, final Class pollAndResultClass) {
+        this(pollingUri, pollAndResultClass, pollAndResultClass);
+    }
+
+    /**
+     * Creates a new instance of polling handler
+     *  @param pollingUri  URI for polling
+     *  @param pollClass class of the polling object (or {@link Void})
+     *  @param resultClass class of the result (or {@link Void})
+     */
+    public PollHandler(final String pollingUri, final Class<P> pollClass, Class<R> resultClass) {
         this.pollingUri = notNull(pollingUri, "pollingUri");
+        this.pollClass = notNull(pollClass, "pollClass");
         this.resultClass = notNull(resultClass, "resultClass");
     }
 
@@ -47,11 +62,15 @@ final String getPollingUri() {
         return pollingUri;
     }
 
-    final Class<T> getResultClass() {
+    final Class<R> getResultClass() {
         return resultClass;
     }
 
-    final PollHandler<T> setResult(T result) {
+    final Class<P> getPollClass() {
+        return pollClass;
+    }
+
+    protected PollHandler<P,R> setResult(R result) {
         this.result = result;
         this.done = true;
         onFinish();
@@ -67,7 +86,7 @@ final boolean isDone() {
      *
      * @return result
      */
-    protected final T getResult() {
+    protected final R getResult() {
         return result;
     }
 
@@ -87,4 +106,12 @@ protected boolean isFinished(final ClientHttpResponse response) throws IOExcepti
      */
     protected void onFinish() {
     }
+
+    protected void handlePollResult(P pollResult) {
+        if (resultClass.equals(pollClass)) {
+            setResult(resultClass.cast(pollResult));
+        } else {
+            throw new IllegalStateException("Please override handlePollResult method when you want different type of polling and result class");
+        }
+    }
 }

src/main/java/com/gooddata/ZipUtils.java

@@ -0,0 +1,71 @@
+package com.gooddata;
+
+import static com.gooddata.Validate.notNull;
+
+import org.springframework.util.StreamUtils;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.nio.file.Path;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipOutputStream;
+
+/**
+ * Utility class for manipulating zip archives.
+ */
+public abstract class ZipUtils {
+
+    /**
+     * This method compresses the input file to zip format. If the given file is a directory, it recursively
+     * packs the directory into the output. Not including give directory itself
+     *
+     * @param file file to be zipped
+     * @param output stream where the output will be written
+     */
+    public static void zip(File file, OutputStream output) throws IOException {
+        zip(file, output, false);
+    }
+
+    /**
+     * This method compresses the input file to zip format. If the given file is a directory, it recursively
+     * packs the directory into the output.
+     *
+     * @param file file to be zipped
+     * @param output stream where the output will be written
+     * @param includeRoot if root dir should be included
+     */
+    public static void zip(File file, OutputStream output, boolean includeRoot) throws IOException {
+        notNull(file, "file");
+        notNull(output, "output");
+
+        try (ZipOutputStream zos = new ZipOutputStream(output)) {
+            if (file.isDirectory()) {
+                zipDir(includeRoot ? file.getParentFile().toPath() : file.toPath(), file, zos);
+            } else {
+                zipFile(file.getParentFile().toPath(), file, zos);
+            }
+
+        }
+    }
+
+    private static void zipDir(Path rootPath, File dir, ZipOutputStream zos) throws IOException {
+        for (File file : notNull(dir.listFiles(), "listed files")) {
+            if (file.isDirectory()) {
+                zipDir(rootPath, file, zos);
+            } else {
+                zipFile(rootPath, file, zos);
+            }
+        }
+    }
+
+    private static void zipFile(Path rootPath, File file, ZipOutputStream zos) throws IOException {
+        ZipEntry ze = new ZipEntry(rootPath.relativize(file.toPath()).toString());
+        zos.putNextEntry(ze);
+        try (FileInputStream fis = new FileInputStream(file)) {
+            StreamUtils.copy(fis, zos);
+        }
+        zos.closeEntry();
+    }
+}