Utils.java

package com.skyflow.utils;

import com.google.gson.JsonObject;
import com.skyflow.config.ConnectionConfig;
import com.skyflow.config.Credentials;
import com.skyflow.enums.Env;
import com.skyflow.errors.ErrorCode;
import com.skyflow.errors.ErrorMessage;
import com.skyflow.errors.SkyflowException;
import com.skyflow.logs.ErrorLogs;
import com.skyflow.logs.InfoLogs;
import com.skyflow.serviceaccount.util.BearerToken;
import com.skyflow.utils.logger.LogUtil;
import com.skyflow.vault.connection.InvokeConnectionRequest;
import org.apache.commons.codec.binary.Base64;

import java.io.File;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLEncoder;
import java.nio.charset.StandardCharsets;
import java.security.KeyFactory;
import java.security.NoSuchAlgorithmException;
import java.security.PrivateKey;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.PKCS8EncodedKeySpec;
import java.util.HashMap;
import java.util.Map;

public final class Utils {
    public static String getVaultURL(String clusterId, Env env) {
        StringBuilder sb = new StringBuilder(Constants.SECURE_PROTOCOL);
        sb.append(clusterId);
        switch (env) {
            case DEV:
                sb.append(Constants.DEV_DOMAIN);
                break;
            case STAGE:
                sb.append(Constants.STAGE_DOMAIN);
                break;
            case SANDBOX:
                sb.append(Constants.SANDBOX_DOMAIN);
                break;
            case PROD:
            default:
                sb.append(Constants.PROD_DOMAIN);
                break;
        }
        return sb.toString();
    }

    public static String generateBearerToken(Credentials credentials) throws SkyflowException {
        if (credentials.getPath() != null) {
            return BearerToken.builder()
                    .setCredentials(new File(credentials.getPath()))
                    .setRoles(credentials.getRoles())
                    .setCtx(credentials.getContext())
                    .build()
                    .getBearerToken();
        } else if (credentials.getCredentialsString() != null) {
            return BearerToken.builder()
                    .setCredentials(credentials.getCredentialsString())
                    .setRoles(credentials.getRoles())
                    .setCtx(credentials.getContext())
                    .build()
                    .getBearerToken();
        } else {
            return credentials.getToken();
        }
    }

    public static PrivateKey getPrivateKeyFromPem(String pemKey) throws SkyflowException {
        @SuppressWarnings("checkstyle:LocalVariableName")
        String PKCS8PrivateHeader = Constants.PKCS8_PRIVATE_HEADER;
        @SuppressWarnings("checkstyle:LocalVariableName")
        String PKCS8PrivateFooter = Constants.PKCS8_PRIVATE_FOOTER;

        String privateKeyContent = pemKey;
        PrivateKey privateKey = null;

        if (pemKey.contains(PKCS8PrivateHeader)) {
            privateKeyContent = privateKeyContent.replace(PKCS8PrivateHeader, Constants.EMPTY_STRING);
            privateKeyContent = privateKeyContent.replace(PKCS8PrivateFooter, Constants.EMPTY_STRING);
            privateKeyContent = privateKeyContent.replace("\n", Constants.EMPTY_STRING);
            privateKeyContent = privateKeyContent.replace("\r\n", Constants.EMPTY_STRING);
            privateKey = parsePkcs8PrivateKey(Base64.decodeBase64(privateKeyContent));
        } else {
            LogUtil.printErrorLog(ErrorLogs.JWT_INVALID_FORMAT.getLog());
            throw new SkyflowException(ErrorCode.INVALID_INPUT.getCode(), ErrorMessage.JwtInvalidFormat.getMessage());
        }
        return privateKey;
    }

    public static String getBaseURL(String url) throws MalformedURLException {
        URL parsedUrl = new URL(url);
        String protocol = parsedUrl.getProtocol();
        String host = parsedUrl.getHost();
        return String.format(Constants.UrlFormat.PROTOCOL_HOST_FORMAT, protocol, host);
    }

    public static String parameterizedString(String base, String... args) {
        for (int index = 0; index < args.length; index++) {
            base = base.replace("%s" + (index + 1), args[index]);
        }
        return base;
    }

    public static String constructConnectionURL(ConnectionConfig config, InvokeConnectionRequest invokeConnectionRequest) {
        StringBuilder filledURL = new StringBuilder(config.getConnectionUrl());

        if (invokeConnectionRequest.getPathParams() != null && !invokeConnectionRequest.getPathParams().isEmpty()) {
            for (Map.Entry<String, String> entry : invokeConnectionRequest.getPathParams().entrySet()) {
                String key = entry.getKey();
                String value = entry.getValue();
                try {
                    String encodedValue = URLEncoder.encode(value, StandardCharsets.UTF_8.name());
                    filledURL = new StringBuilder(filledURL.toString().replace(String.format(Constants.CURLY_PLACEHOLDER, key), encodedValue));
                } catch (Exception e) {
                    filledURL = new StringBuilder(filledURL.toString().replace(String.format(Constants.CURLY_PLACEHOLDER, key), value));
                }
            }
        }

        if (invokeConnectionRequest.getQueryParams() != null && !invokeConnectionRequest.getQueryParams().isEmpty()) {
            filledURL.append("?");
            for (Map.Entry<String, String> entry : invokeConnectionRequest.getQueryParams().entrySet()) {
                String key = entry.getKey();
                String value = entry.getValue();
                try {
                    String encodedKey = URLEncoder.encode(key, StandardCharsets.UTF_8.name());
                    String encodedValue = URLEncoder.encode(value, StandardCharsets.UTF_8.name());
                    filledURL.append(encodedKey).append(Constants.HttpUtility.FORM_ENCODE_SEPARATOR).append(encodedValue).append(Constants.HttpUtility.FORM_ENCODE_DELIMITER);
                } catch (Exception e) {
                    filledURL.append(key).append(Constants.HttpUtility.FORM_ENCODE_SEPARATOR).append(value).append(Constants.HttpUtility.FORM_ENCODE_DELIMITER);
                }
            }
            filledURL = new StringBuilder(filledURL.substring(0, filledURL.length() - 1));
        }

        return filledURL.toString();
    }

    public static Map<String, String> constructConnectionHeadersMap(Map<String, String> requestHeaders) {
        Map<String, String> headersMap = new HashMap<>();
        for (Map.Entry<String, String> entry : requestHeaders.entrySet()) {
            String key = entry.getKey();
            String value = entry.getValue();
            headersMap.put(key.toLowerCase(), value);
        }
        return headersMap;
    }

    public static JsonObject getMetrics() {
        JsonObject details = new JsonObject();
        String sdkVersion = Constants.SDK_VERSION;
        String deviceModel;
        String osDetails;
        String javaVersion;
        // Retrieve device model
        try {
            deviceModel = System.getProperty(Constants.SystemProperty.OS_NAME);
            if (deviceModel == null) throw new Exception();
        } catch (Exception e) {
            LogUtil.printInfoLog(parameterizedString(
                    InfoLogs.UNABLE_TO_GENERATE_SDK_METRIC.getLog(),
                    Constants.SDK_METRIC_CLIENT_DEVICE_MODEL
            ));
            deviceModel = Constants.EMPTY_STRING;
        }

        // Retrieve OS details
        try {
            osDetails = System.getProperty(Constants.SystemProperty.OS_VERSION);
            if (osDetails == null) throw new Exception();
        } catch (Exception e) {
            LogUtil.printInfoLog(parameterizedString(
                    InfoLogs.UNABLE_TO_GENERATE_SDK_METRIC.getLog(),
                    Constants.SDK_METRIC_CLIENT_OS_DETAILS
            ));
            osDetails = Constants.EMPTY_STRING;
        }

        // Retrieve Java version details
        try {
            javaVersion = System.getProperty(Constants.SystemProperty.JAVA_VERSION);
            if (javaVersion == null) throw new Exception();
        } catch (Exception e) {
            LogUtil.printInfoLog(parameterizedString(
                    InfoLogs.UNABLE_TO_GENERATE_SDK_METRIC.getLog(),
                    Constants.SDK_METRIC_RUNTIME_DETAILS
            ));
            javaVersion = Constants.EMPTY_STRING;
        }
        details.addProperty(Constants.SDK_METRIC_NAME_VERSION, Constants.SDK_METRIC_NAME_VERSION_PREFIX + sdkVersion);
        details.addProperty(Constants.SDK_METRIC_CLIENT_DEVICE_MODEL, deviceModel);
        details.addProperty(Constants.SDK_METRIC_RUNTIME_DETAILS, Constants.SDK_METRIC_RUNTIME_DETAILS_PREFIX + javaVersion);
        details.addProperty(Constants.SDK_METRIC_CLIENT_OS_DETAILS, osDetails);
        return details;
    }

    private static PrivateKey parsePkcs8PrivateKey(byte[] pkcs8Bytes) throws SkyflowException {
        KeyFactory keyFactory;
        PrivateKey privateKey = null;
        try {
            PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(pkcs8Bytes);
            keyFactory = KeyFactory.getInstance(Constants.CryptoAlgorithm.RSA);
            privateKey = keyFactory.generatePrivate(keySpec);
        } catch (NoSuchAlgorithmException e) {
            LogUtil.printErrorLog(ErrorLogs.INVALID_ALGORITHM.getLog());
            throw new SkyflowException(ErrorCode.INVALID_INPUT.getCode(), ErrorMessage.InvalidAlgorithm.getMessage());
        } catch (InvalidKeySpecException e) {
            LogUtil.printErrorLog(ErrorLogs.INVALID_KEY_SPEC.getLog());
            throw new SkyflowException(ErrorCode.INVALID_INPUT.getCode(), ErrorMessage.InvalidKeySpec.getMessage());
        }
        return privateKey;
    }
}