async method for the requests (#22)

* async method for the requests

* Added threadpool that maps async requests to the threadpool of okhttp
* Extended API with async version of methods
* Moved all json parsing to separate class
* Changed method names to more modern convention
* Changed access to fields in pojos to public

* remove duplicate code, uniform variable naming

* join threads in sdk methods, remove unused code

* add more comments

Author: nilsbehlen

src/main/java/org/privacyidea/AsyncRequestCallable.java

@@ -0,0 +1,90 @@
+package org.privacyidea;
+
+import java.io.IOException;
+import java.util.Collections;
+import java.util.Map;
+import java.util.concurrent.Callable;
+import java.util.concurrent.CountDownLatch;
+import okhttp3.Call;
+import okhttp3.Callback;
+import okhttp3.Response;
+import org.jetbrains.annotations.NotNull;
+
+import static org.privacyidea.PIConstants.ENDPOINT_AUTH;
+
+/**
+ * Instances of this class are submitted to the thread pool so that requests can be executed in parallel.
+ */
+public class AsyncRequestCallable implements Callable<String>, Callback {
+
+    private String path;
+    private final String method;
+    private Map<String, String> headers, params;
+    private final boolean authTokenRequired;
+    private final Endpoint endpoint;
+    private final PrivacyIDEA privacyIDEA;
+    final String[] callbackResult = {null};
+    private CountDownLatch latch;
+
+    public AsyncRequestCallable(PrivacyIDEA privacyIDEA, Endpoint endpoint, String path, Map<String, String> params,
+                                Map<String, String> headers, boolean authTokenRequired, String method) {
+        this.privacyIDEA = privacyIDEA;
+        this.endpoint = endpoint;
+        this.path = path;
+        this.params = params;
+        this.headers = headers;
+        this.authTokenRequired = authTokenRequired;
+        this.method = method;
+    }
+
+    @Override
+    public String call() throws Exception {
+        // If an auth token is required for the request get that first then do the actual request
+        if (this.authTokenRequired) {
+            if (!privacyIDEA.serviceAccountAvailable()) {
+                privacyIDEA.error("Service account is required to retrieve auth token!");
+                return null;
+            }
+            latch = new CountDownLatch(1);
+            String tmpPath = path;
+            path = ENDPOINT_AUTH;
+            endpoint.sendRequestAsync(ENDPOINT_AUTH, privacyIDEA.serviceAccountParam(), Collections.emptyMap(), PIConstants.POST, this);
+            latch.await();
+            // Extract the auth token from the response
+            String response = callbackResult[0];
+            String authToken = privacyIDEA.parser.extractAuthToken(response);
+            if (authToken == null) {
+                // the parser already logs the error.
+                return null;
+            }
+            // Add the auth token to the header
+            headers.put(PIConstants.HEADER_AUTHORIZATION, authToken);
+            path = tmpPath;
+            callbackResult[0] = null;
+        }
+
+        // Do the actual request
+        latch = new CountDownLatch(1);
+        endpoint.sendRequestAsync(path, params, headers, method, this);
+        latch.await();
+        return callbackResult[0];
+    }
+
+    @Override
+    public void onFailure(@NotNull Call call, @NotNull IOException e) {
+        privacyIDEA.error(e);
+        latch.countDown();
+    }
+
+    @Override
+    public void onResponse(@NotNull Call call, @NotNull Response response) throws IOException {
+        if (response.body() != null) {
+            String s = response.body().string();
+            if (!privacyIDEA.logExcludedEndpoints().contains(path) && !ENDPOINT_AUTH.equals(path)) {
+                privacyIDEA.log(path + ":\n" + privacyIDEA.parser.formatJson(s));
+            }
+            callbackResult[0] = s;
+        }
+        latch.countDown();
+    }
+}

src/main/java/org/privacyidea/Endpoint.java

@@ -15,53 +15,34 @@
  */
 package org.privacyidea;
 
-import com.google.gson.Gson;
-import com.google.gson.GsonBuilder;
-import com.google.gson.JsonElement;
-import com.google.gson.JsonObject;
-import com.google.gson.JsonParser;
-import com.google.gson.JsonSyntaxException;
 import java.io.IOException;
 import java.io.UnsupportedEncodingException;
 import java.net.URLEncoder;
 import java.nio.charset.StandardCharsets;
 import java.security.KeyManagementException;
 import java.security.NoSuchAlgorithmException;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.LinkedHashMap;
-import java.util.List;
 import java.util.Map;
 import javax.net.ssl.SSLContext;
 import javax.net.ssl.SSLSocketFactory;
 import javax.net.ssl.TrustManager;
 import javax.net.ssl.X509TrustManager;
+import okhttp3.Callback;
 import okhttp3.FormBody;
 import okhttp3.HttpUrl;
 import okhttp3.OkHttpClient;
 import okhttp3.Request;
-import okhttp3.Response;
 
-import static org.privacyidea.PIConstants.ENDPOINT_AUTH;
 import static org.privacyidea.PIConstants.GET;
-import static org.privacyidea.PIConstants.HEADER_AUTHORIZATION;
 import static org.privacyidea.PIConstants.HEADER_USER_AGENT;
-import static org.privacyidea.PIConstants.PASSWORD;
 import static org.privacyidea.PIConstants.POST;
-import static org.privacyidea.PIConstants.REALM;
-import static org.privacyidea.PIConstants.RESULT;
-import static org.privacyidea.PIConstants.TOKEN;
-import static org.privacyidea.PIConstants.USERNAME;
-import static org.privacyidea.PIConstants.VALUE;
 import static org.privacyidea.PIConstants.WEBAUTHN_PARAMETERS;
 
 /**
- * This class handles sending sending requests to the server.
+ * This class handles sending requests to the server.
  */
 class Endpoint {
 
     private final PrivacyIDEA privacyIDEA;
-    private List<String> logExcludedEndpointPrints = Arrays.asList(PIConstants.ENDPOINT_AUTH, PIConstants.ENDPOINT_POLLTRANSACTION); //Collections.emptyList(); //
     private final PIConfig piconfig;
     private final OkHttpClient client;
 
@@ -84,7 +65,7 @@ public java.security.cert.X509Certificate[] getAcceptedIssuers() {
 
     Endpoint(PrivacyIDEA privacyIDEA) {
         this.privacyIDEA = privacyIDEA;
-        this.piconfig = privacyIDEA.getConfiguration();
+        this.piconfig = privacyIDEA.configuration();
 
         OkHttpClient.Builder builder = new OkHttpClient.Builder();
         if (!this.piconfig.doSSLVerify) {
@@ -102,21 +83,28 @@ public java.security.cert.X509Certificate[] getAcceptedIssuers() {
         this.client = builder.build();
     }
 
-    String sendRequest(String endpoint, Map<String, String> params, boolean authTokenRequired, String method) {
-        return sendRequest(endpoint, params, Collections.emptyMap(), authTokenRequired, method);
-    }
-
-    String sendRequest(String endpoint, Map<String, String> params, Map<String, String> headers, boolean authTokenRequired, String method) {
+    /**
+     * Add a request to the okhttp queue. The callback will be invoked upon success or failure.
+     *
+     * @param endpoint server endpoint
+     * @param params request parameters
+     * @param headers request headers
+     * @param method http request method
+     * @param callback okhttp3 callback
+     */
+    void sendRequestAsync(String endpoint, Map<String, String> params, Map<String, String> headers, String method, Callback callback) {
         HttpUrl httpUrl = HttpUrl.parse(piconfig.serverURL + endpoint);
         if (httpUrl == null) {
             privacyIDEA.error("Server url could not be parsed: " + (piconfig.serverURL + endpoint));
-            return null;
+            // Invoke the callback to terminate the thread that called this method.
+            callback.onFailure(null, new IOException("Request could not be created!"));
+            return;
         }
         HttpUrl.Builder urlBuilder = httpUrl.newBuilder();
 
         if (GET.equals(method)) {
             params.forEach((key, value) -> {
-                //privacyIDEA.log("" + key + "=" + value);
+                //privacyIDEA.log(key + "=" + value);
                 try {
                     String encValue = value;
                     encValue = URLEncoder.encode(value, StandardCharsets.UTF_8.toString());
@@ -128,19 +116,10 @@ String sendRequest(String endpoint, Map<String, String> params, Map<String, Stri
         }
 
         String url = urlBuilder.build().toString();
-        //privacyIDEA.log("using URL: " + url);
+        //privacyIDEA.log("URL: " + url);
         Request.Builder requestBuilder = new Request.Builder()
                 .url(url);
 
-        if (authTokenRequired) {
-            String authToken = getAuthTokenFromServer();
-            if (authToken.isEmpty()) {
-                privacyIDEA.error("Failed to fetch authorization token from server!");
-                return "";
-            }
-            requestBuilder.addHeader(HEADER_AUTHORIZATION, authToken);
-        }
-
         // Add the headers
         requestBuilder.addHeader(HEADER_USER_AGENT, piconfig.userAgent);
         if (headers != null && !headers.isEmpty()) {
@@ -160,7 +139,7 @@ String sendRequest(String endpoint, Map<String, String> params, Map<String, Stri
                             privacyIDEA.error(e);
                         }
                     }
-                    //privacyIDEA.log("" + key + "=" + encValue);
+                    //privacyIDEA.log(key + "=" + encValue);
                     formBodyBuilder.add(key, encValue);
                 }
             });
@@ -170,79 +149,6 @@ String sendRequest(String endpoint, Map<String, String> params, Map<String, Stri
 
         Request request = requestBuilder.build();
         //privacyIDEA.log("HEADERS:\n" + request.headers().toString());
-
-        try {
-            Response response = client.newCall(request).execute();
-            if (response.body() != null) {
-                String ret = response.body().string();
-                if (!logExcludedEndpointPrints.contains(endpoint)) {
-                    privacyIDEA.log(prettyFormatJson(ret));
-                }
-                return ret;
-            } else {
-                privacyIDEA.log("Response body is null.");
-            }
-        } catch (IOException e) {
-            privacyIDEA.error(e);
-        }
-
-        return "";
-    }
-
-    String getAuthTokenFromServer() {
-        if (!privacyIDEA.checkServiceAccountAvailable()) {
-            privacyIDEA.error("Cannot retrieve auth token from server without service account!");
-            return "";
-        }
-
-        Map<String, String> params = new LinkedHashMap<>();
-        params.put(USERNAME, piconfig.serviceAccountName);
-        params.put(PASSWORD, piconfig.serviceAccountPass);
-
-        if (piconfig.serviceAccountRealm != null && !piconfig.serviceAccountRealm.isEmpty()) {
-            params.put(REALM, piconfig.serviceAccountRealm);
-        } else if (piconfig.realm != null && !piconfig.realm.isEmpty()) {
-            params.put(REALM, piconfig.realm);
-        }
-
-        String response = sendRequest(ENDPOINT_AUTH, params, false, POST);
-        if (response != null && !response.isEmpty()) {
-            JsonElement root = JsonParser.parseString(response);
-            if (root != null) {
-                try {
-                    JsonObject obj = root.getAsJsonObject();
-                    return obj.getAsJsonObject(RESULT).getAsJsonObject(VALUE).getAsJsonPrimitive(TOKEN).getAsString();
-                } catch (Exception e) {
-                    privacyIDEA.error("Response did not contain an authorization token: " + prettyFormatJson(response));
-                }
-            }
-        } else {
-            privacyIDEA.error("/auth response was empty or null!");
-        }
-
-        return "";
-    }
-
-    public static String prettyFormatJson(String json) {
-        if (json == null || json.isEmpty()) return "";
-
-        JsonObject obj;
-        Gson gson = new GsonBuilder().setPrettyPrinting().create();
-        try {
-            obj = JsonParser.parseString(json).getAsJsonObject();
-        } catch (JsonSyntaxException e) {
-            e.printStackTrace();
-            return json;
-        }
-
-        return gson.toJson(obj);
-    }
-
-    public List<String> getLogExcludedEndpoints() {
-        return logExcludedEndpointPrints;
-    }
-
-    public void setLogExcludedEndpoints(List<String> list) {
-        logExcludedEndpointPrints = list;
+        client.newCall(request).enqueue(callback);
     }
 }