SK-2967 java sdk add flow db vault api support using modular build approach

.github/workflows/flowvault-internal-release.yml

@@ -0,0 +1,27 @@
+name: Publish v3 module to the JFROG Artifactory
+on:
+  push:
+    tags-ignore:
+      - '*.*'
+    paths-ignore:
+      - "*.md"
+    branches:
+      - v3-release/*
+
+jobs:
+  build-and-deploy-v3:
+    uses: ./.github/workflows/shared-build-and-deploy.yml
+    with:
+      ref: ${{ github.ref_name }}
+      server-id: central
+      profile: jfrog
+      tag: 'internal'
+      module: 'flowvault'
+    secrets:
+      server-username: ${{ secrets.ARTIFACTORY_USERNAME }}
+      server-password: ${{ secrets.ARTIFACTORY_PASSWORD }}
+      gpg-key: ${{ secrets.JFROG_GPG_KEY }}
+      gpg-passphrase: ${{ secrets.JFROG_GPG_PASSPHRASE }}
+      skyflow-credentials: ${{ secrets.SKYFLOW_CREDENTIALS }}
+      test-expired-token: ${{ secrets.TEST_EXPIRED_TOKEN }}
+      test-reusable-token: ${{ secrets.TEST_REUSABLE_TOKEN }}

.github/workflows/shared-build-and-deploy.yml

@@ -21,6 +21,13 @@ on:
         description: 'Release Tag'
         required: true
         type: string
+
+      module:
+        description: 'Module to build and publish'
+        required: false
+        type: string
+        default: ''
+
     secrets:
       server-username:
         required: true
@@ -57,10 +64,10 @@ jobs:
           java-version: "11"
           distribution: "adopt"
           server-id: ${{ inputs.server-id }}
-          server-username: SERVER_USERNAME
-          server-password: SERVER_PASSWORD
+          server-username: ${{ secrets.server-username }}
+          server-password: ${{ secrets.server-password }}
           gpg-private-key: ${{ secrets.gpg-key }} # Value of the GPG private key to import
-          gpg-passphrase: GPG_PASSPHRASE # env variable for GPG private key passphrase
+          gpg-passphrase: ${{ secrets.gpg-passphrase }} # env variable for GPG private key passphrase
 
       - name: Resolve Branch for the Tagged Commit
         id: resolve-branch
@@ -87,7 +94,7 @@ jobs:
           if ${{ inputs.tag == 'internal' }}; then
             ./scripts/bump_version.sh "${{ steps.previoustag.outputs.tag }}" "$(git rev-parse --short "$GITHUB_SHA")"
           else
-            ./scripts/bump_version.sh "${{ steps.previoustag.outputs.tag }}"
+            ./scripts/bump_version.sh "${{ steps.previoustag.outputs.tag }}" "" "${{ inputs.module }}"
           fi
 
       - name: Commit changes
@@ -99,7 +106,7 @@ jobs:
             git checkout ${{ env.branch_name }}
           fi
 
-          git add pom.xml
+          git add flowvault/pom.xml
           if [[ "${{ inputs.tag }}" == "internal" ]]; then
             git commit -m "[AUTOMATED] Private Release ${{ steps.previoustag.outputs.tag }}-dev-$(git rev-parse --short $GITHUB_SHA)"
             git push origin ${{ github.ref_name }} -f
@@ -125,7 +132,12 @@ jobs:
           json: ${{ secrets.TEST_CREDENTIALS_FILE_STRING }}
 
       - name: Publish package
-        run: mvn --batch-mode deploy -P ${{ inputs.profile }}
+        run: |
+          if [[ "${{ inputs.tag }}" == "internal" ]]; then
+            mvn --batch-mode -pl ${{ inputs.module }} -am deploy -P jfrog  -DskipTests
+          elif [[ "${{ inputs.tag }}" == "beta" || "${{ inputs.tag }}" == "public" ]]; then
+            mvn --batch-mode -pl ${{ inputs.module }} -am deploy -P ${{ inputs.profile }} -DskipTests
+          fi
 
         env:
           SERVER_USERNAME: ${{ secrets.server-username }}

common/pom.xml

@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <parent>
+        <groupId>com.skyflow</groupId>
+        <artifactId>skyflow</artifactId>
+        <version>1.0.0</version>
+        <relativePath>../pom.xml</relativePath>
+    </parent>
+
+    <artifactId>common</artifactId>
+    <version>1.0.0</version>
+    <name>${project.groupId}:${project.artifactId}</name>
+
+
+    <properties>
+        <maven.deploy.skip>true</maven.deploy.skip>
+        <maven.compiler.source>8</maven.compiler.source>
+        <maven.compiler.target>8</maven.compiler.target>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+    </properties>
+</project>

common/src/main/java/com/skyflow/BaseSkyflow.java

@@ -0,0 +1,205 @@
+package com.skyflow;
+
+import com.skyflow.config.BaseVaultConfig;
+import com.skyflow.config.Credentials;
+import com.skyflow.enums.LogLevel;
+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.utils.BaseUtils;
+import com.skyflow.utils.logger.LogUtil;
+import com.skyflow.utils.validations.BaseValidations;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+
+abstract class BaseSkyflow<Self, V extends BaseVaultConfig, VC> implements ISkyflow<Self, V, Credentials, VC> {
+    protected final BaseSkyflowClientBuilder<V, VC> builder;
+
+    protected BaseSkyflow(BaseSkyflowClientBuilder<V, VC> builder) {
+        this.builder = builder;
+        LogUtil.printInfoLog(InfoLogs.CLIENT_INITIALIZED.getLog());
+    }
+
+    protected abstract Self self();
+
+    public Self addVaultConfig(V vaultConfig) throws SkyflowException {
+        this.builder.addVaultConfigTemplate(vaultConfig);
+        return self();
+    }
+
+    public V getVaultConfig(String vaultId) {
+        return this.builder.vaultConfigMap.get(vaultId);
+    }
+
+    public Self updateVaultConfig(V vaultConfig) throws SkyflowException {
+        this.builder.updateVaultConfigTemplate(vaultConfig);
+        return self();
+    }
+
+    public Self removeVaultConfig(String vaultId) throws SkyflowException {
+        this.builder.removeVaultConfigTemplate(vaultId);
+        return self();
+    }
+
+    public Self updateSkyflowCredentials(Credentials credentials) throws SkyflowException {
+        this.builder.addSkyflowCredentialsTemplate(credentials);
+        return self();
+    }
+
+    public Self setLogLevel(LogLevel logLevel) {
+        this.builder.setLogLevel(logLevel);
+        return self();
+    }
+
+    public LogLevel getLogLevel() {
+        return this.builder.logLevel;
+    }
+
+    public VC vault() throws SkyflowException {
+        return resolveOrThrow(this.builder.vaultClientsMap, null, ErrorLogs.VAULT_CONFIG_DOES_NOT_EXIST, ErrorMessage.VaultIdNotInConfigList);
+    }
+
+    protected static <T> T resolveOrThrow(Map<String, T> map, String key,
+                                           ErrorLogs errorLog, ErrorMessage errorMessage) throws SkyflowException {
+        T value = key != null ? map.get(key) : map.values().stream().findFirst().orElse(null);
+        if (value == null) {
+            LogUtil.printErrorLog(errorLog.getLog());
+            throw new SkyflowException(ErrorCode.INVALID_INPUT.getCode(), errorMessage.getMessage());
+        }
+        return value;
+    }
+
+    abstract static class BaseSkyflowClientBuilder<V extends BaseVaultConfig, VC> {
+        protected final LinkedHashMap<String, V> vaultConfigMap = new LinkedHashMap<>();
+        protected final LinkedHashMap<String, VC> vaultClientsMap = new LinkedHashMap<>();
+        protected Credentials skyflowCredentials;
+        protected LogLevel logLevel = LogLevel.ERROR;
+
+        protected BaseSkyflowClientBuilder() {
+        }
+
+        public BaseSkyflowClientBuilder<V, VC> addVaultConfig(V vaultConfig) throws SkyflowException {
+            addVaultConfigTemplate(vaultConfig);
+            return this;
+        }
+
+        public BaseSkyflowClientBuilder<V, VC> updateVaultConfig(V vaultConfig) throws SkyflowException {
+            updateVaultConfigTemplate(vaultConfig);
+            return this;
+        }
+
+        public BaseSkyflowClientBuilder<V, VC> removeVaultConfig(String vaultId) throws SkyflowException {
+            removeVaultConfigTemplate(vaultId);
+            return this;
+        }
+
+        public BaseSkyflowClientBuilder<V, VC> addSkyflowCredentials(Credentials credentials) throws SkyflowException {
+            addSkyflowCredentialsTemplate(credentials);
+            return this;
+        }
+
+        protected BaseSkyflowClientBuilder<V, VC> setLogLevel(LogLevel logLevel) {
+            this.logLevel = logLevel == null ? LogLevel.ERROR : logLevel;
+            LogUtil.setupLogger(this.logLevel);
+            LogUtil.printInfoLog(BaseUtils.parameterizedString(
+                    InfoLogs.CURRENT_LOG_LEVEL.getLog(), String.valueOf(this.logLevel)
+            ));
+            return this;
+        }
+
+        protected final void addVaultConfigTemplate(V vaultConfig) throws SkyflowException {
+            LogUtil.printInfoLog(InfoLogs.VALIDATING_VAULT_CONFIG.getLog());
+            validateVaultConfig(vaultConfig);
+            V vaultConfigCopy = cloneVaultConfig(vaultConfig);
+            String vaultId = extractVaultId(vaultConfigCopy);
+            if (this.vaultClientsMap.containsKey(vaultId)) {
+                LogUtil.printErrorLog(BaseUtils.parameterizedString(
+                        ErrorLogs.VAULT_CONFIG_EXISTS.getLog(), vaultId
+                ));
+                throw new SkyflowException(ErrorCode.INVALID_INPUT.getCode(),
+                        ErrorMessage.VaultIdAlreadyInConfigList.getMessage());
+            }
+            this.vaultConfigMap.put(vaultId, vaultConfigCopy);
+            onVaultConfigAdded(vaultConfigCopy);
+        }
+
+        protected final void updateVaultConfigTemplate(V vaultConfig) throws SkyflowException {
+            LogUtil.printInfoLog(InfoLogs.VALIDATING_VAULT_CONFIG.getLog());
+            validateVaultConfig(vaultConfig);
+            String vaultId = extractVaultId(vaultConfig);
+            if (!this.vaultClientsMap.containsKey(vaultId)) {
+                LogUtil.printErrorLog(BaseUtils.parameterizedString(
+                        ErrorLogs.VAULT_CONFIG_DOES_NOT_EXIST.getLog(), vaultId
+                ));
+                throw new SkyflowException(ErrorCode.INVALID_INPUT.getCode(), ErrorMessage.VaultIdNotInConfigList.getMessage());
+            }
+            V previousConfig = this.vaultConfigMap.get(vaultId);
+            V merged = mergeVaultConfig(vaultConfig, previousConfig);
+            onVaultConfigUpdated(merged);
+        }
+
+        protected final void removeVaultConfigTemplate(String vaultId) throws SkyflowException {
+            if (!this.vaultClientsMap.containsKey(vaultId)) {
+                LogUtil.printErrorLog(BaseUtils.parameterizedString(ErrorLogs.VAULT_CONFIG_DOES_NOT_EXIST.getLog(), vaultId));
+                throw new SkyflowException(ErrorCode.INVALID_INPUT.getCode(), ErrorMessage.VaultIdNotInConfigList.getMessage());
+            }
+            this.vaultClientsMap.remove(vaultId);
+            this.vaultConfigMap.remove(vaultId);
+        }
+
+        protected final void addSkyflowCredentialsTemplate(Credentials credentials) throws SkyflowException {
+            BaseValidations.validateCredentials(credentials);
+            Credentials credentialsCopy;
+            try {
+                credentialsCopy = (Credentials) credentials.clone();
+            } catch (CloneNotSupportedException e) {
+                throw new RuntimeException(e);
+            }
+            this.skyflowCredentials = credentialsCopy;
+            onCredentialsUpdated(credentialsCopy);
+        }
+
+        protected abstract void validateVaultConfig(V vaultConfig) throws SkyflowException;
+
+        @SuppressWarnings("unchecked")
+        protected final V cloneVaultConfig(V vaultConfig) {
+            try {
+                return (V) vaultConfig.clone();
+            } catch (CloneNotSupportedException e) {
+                throw new RuntimeException(e);
+            }
+        }
+
+        protected final String extractVaultId(V vaultConfig) {
+            return vaultConfig.getVaultId();
+        }
+
+        protected final V mergeVaultConfig(V incoming, V existing) {
+            if (incoming.getEnv() != null) {
+                existing.setEnv(incoming.getEnv());
+            }
+            if (incoming.getClusterId() != null) {
+                existing.setClusterId(incoming.getClusterId());
+            }
+            if (incoming.getCredentials() != null) {
+                try {
+                    existing.setCredentials((Credentials) incoming.getCredentials().clone());
+                } catch (CloneNotSupportedException e) {
+                    throw new RuntimeException(e);
+                }
+            }
+            return existing;
+        }
+
+        protected abstract void onVaultConfigAdded(V vaultConfig) throws SkyflowException;
+
+        protected abstract void onVaultConfigUpdated(V updatedConfig) throws SkyflowException;
+
+        protected abstract void onCredentialsUpdated(Credentials credentials) throws SkyflowException;
+    }
+
+}