Release/26.7.1

.github/workflows/internal-release.yml

@@ -1,4 +1,4 @@
-name: Publish package to the JFROG Artifactory
+name: Publish module to the JFROG Artifactory
 on:
   push:
     tags-ignore:
@@ -7,20 +7,37 @@ on:
       - "*.md"
     branches:
       - release/*
+      - flowvault-release/*
 
 jobs:
+  resolve-module:
+    runs-on: ubuntu-latest
+    outputs:
+      module: ${{ steps.set-module.outputs.module }}
+    steps:
+      - name: Resolve module from branch name
+        id: set-module
+        run: |
+          if [[ "${{ github.ref_name }}" == flowvault-release/* ]]; then
+            echo "module=flowvault" >> "$GITHUB_OUTPUT"
+          else
+            echo "module=v2" >> "$GITHUB_OUTPUT"
+          fi
+
   build-and-deploy:
+    needs: resolve-module
     uses: ./.github/workflows/shared-build-and-deploy.yml
     with:
       ref: ${{ github.ref_name }}
       server-id: central
       profile: jfrog
       tag: 'internal'
+      module: ${{ needs.resolve-module.outputs.module }}
     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 }} >> .env
-      test-expired-token: ${{ secrets.TEST_EXPIRED_TOKEN }} >> .env
-      test-reusable-token: ${{ secrets.TEST_REUSABLE_TOKEN }} >> .env
+      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
@@ -61,10 +68,10 @@ jobs:
           server-password: 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
-      
+
       - name: Resolve Branch for the Tagged Commit
         id: resolve-branch
-        if: ${{ inputs.tag == 'beta' || inputs.tag == 'public' }} 
+        if: ${{ inputs.tag == 'beta' || inputs.tag == 'public' }}
         run: |
           TAG_COMMIT=$(git rev-list -n 1 ${{ github.ref_name }})
           BRANCH_NAME=$(git for-each-ref --points-at="$TAG_COMMIT" --format='%(refname:short)' refs/remotes/origin | grep -v '/HEAD$' | sed 's#^origin/##' | head -n 1)
@@ -85,9 +92,9 @@ jobs:
         run: |
           chmod +x ./scripts/bump_version.sh
           if ${{ inputs.tag == 'internal' }}; then
-            ./scripts/bump_version.sh "${{ steps.previoustag.outputs.tag }}" "$(git rev-parse --short "$GITHUB_SHA")"
+            ./scripts/bump_version.sh "${{ steps.previoustag.outputs.tag }}" "$(git rev-parse --short "$GITHUB_SHA")" "${{ inputs.module }}"
           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 ${{ inputs.module }}/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,9 +132,14 @@ 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 }}
+          fi
 
         env:
           SERVER_USERNAME: ${{ secrets.server-username }}
           SERVER_PASSWORD: ${{ secrets.server-password  }}
-          GPG_PASSPHRASE: ${{ secrets.gpg-passphrase }}
+          GPG_PASSPHRASE: ${{ secrets.gpg-passphrase }}

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,211 @@
+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 extends BaseSkyflow<Self, V>, V extends BaseVaultConfig> implements ISkyflow<Self, V, Credentials> {
+    protected final BaseSkyflowClientBuilder<V> builder;
+
+    protected BaseSkyflow(BaseSkyflowClientBuilder<V> builder) {
+        this.builder = builder;
+        LogUtil.printInfoLog(InfoLogs.CLIENT_INITIALIZED.getLog());
+    }
+
+    protected abstract Self self();
+
+    @Override
+    public Self addVaultConfig(V vaultConfig) throws SkyflowException {
+        this.builder.addVaultConfigTemplate(vaultConfig);
+        return self();
+    }
+
+    public V getVaultConfig(String vaultId) {
+        return this.builder.vaultConfigMap.get(vaultId);
+    }
+
+    @Override
+    public Self updateVaultConfig(V vaultConfig) throws SkyflowException {
+        this.builder.updateVaultConfigTemplate(vaultConfig);
+        return self();
+    }
+
+    @Override
+    public Self removeVaultConfig(String vaultId) throws SkyflowException {
+        this.builder.removeVaultConfigTemplate(vaultId);
+        return self();
+    }
+
+    @Override
+    public Self updateSkyflowCredentials(Credentials credentials) throws SkyflowException {
+        this.builder.addSkyflowCredentialsTemplate(credentials);
+        return self();
+    }
+
+    @Override
+    public Self setLogLevel(LogLevel logLevel) {
+        this.builder.setLogLevel(logLevel);
+        return self();
+    }
+
+    @Override
+    public LogLevel getLogLevel() {
+        return this.builder.logLevel;
+    }
+
+    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> {
+        protected final LinkedHashMap<String, V> vaultConfigMap = new LinkedHashMap<>();
+        protected Credentials skyflowCredentials;
+        protected LogLevel logLevel = LogLevel.ERROR;
+
+        protected BaseSkyflowClientBuilder() {
+        }
+
+        public BaseSkyflowClientBuilder<V> addVaultConfig(V vaultConfig) throws SkyflowException {
+            addVaultConfigTemplate(vaultConfig);
+            return this;
+        }
+
+        public BaseSkyflowClientBuilder<V> updateVaultConfig(V vaultConfig) throws SkyflowException {
+            updateVaultConfigTemplate(vaultConfig);
+            return this;
+        }
+
+        public BaseSkyflowClientBuilder<V> removeVaultConfig(String vaultId) throws SkyflowException {
+            removeVaultConfigTemplate(vaultId);
+            return this;
+        }
+
+        public BaseSkyflowClientBuilder<V> addSkyflowCredentials(Credentials credentials) throws SkyflowException {
+            addSkyflowCredentialsTemplate(credentials);
+            return this;
+        }
+
+        protected BaseSkyflowClientBuilder<V> 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 (hasVaultClient(vaultId)) {
+                LogUtil.printErrorLog(BaseUtils.parameterizedString(
+                        ErrorLogs.VAULT_CONFIG_EXISTS.getLog(), vaultId
+                ));
+                throw new SkyflowException(ErrorCode.INVALID_INPUT.getCode(),
+                        ErrorMessage.VaultIdAlreadyInConfigList.getMessage());
+            }
+            onVaultConfigAdded(vaultConfigCopy);
+            this.vaultConfigMap.put(vaultId, vaultConfigCopy);
+        }
+
+        protected final void updateVaultConfigTemplate(V vaultConfig) throws SkyflowException {
+            LogUtil.printInfoLog(InfoLogs.VALIDATING_VAULT_CONFIG.getLog());
+            validateVaultConfig(vaultConfig);
+            String vaultId = extractVaultId(vaultConfig);
+            if (!hasVaultClient(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, cloneVaultConfig(previousConfig));
+            onVaultConfigUpdated(merged);
+            this.vaultConfigMap.put(vaultId, merged);
+        }
+
+        protected final void removeVaultConfigTemplate(String vaultId) throws SkyflowException {
+            if (!hasVaultClient(vaultId)) {
+                LogUtil.printErrorLog(BaseUtils.parameterizedString(ErrorLogs.VAULT_CONFIG_DOES_NOT_EXIST.getLog(), vaultId));
+                throw new SkyflowException(ErrorCode.INVALID_INPUT.getCode(), ErrorMessage.VaultIdNotInConfigList.getMessage());
+            }
+            onVaultConfigRemoved(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 SkyflowException(e.getMessage(), e);
+            }
+            onCredentialsUpdated(credentialsCopy);
+            this.skyflowCredentials = credentialsCopy;
+        }
+
+        protected abstract void validateVaultConfig(V vaultConfig) throws SkyflowException;
+
+        protected abstract boolean hasVaultClient(String vaultId);
+
+        @SuppressWarnings("unchecked")
+        protected final V cloneVaultConfig(V vaultConfig) throws SkyflowException {
+            try {
+                return (V) vaultConfig.clone();
+            } catch (CloneNotSupportedException e) {
+                throw new SkyflowException(e.getMessage(), e);
+            }
+        }
+
+        protected final String extractVaultId(V vaultConfig) {
+            return vaultConfig.getVaultId();
+        }
+
+        protected final V mergeVaultConfig(V incoming, V existing) throws SkyflowException {
+            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 SkyflowException(e.getMessage(), e);
+                }
+            }
+            return existing;
+        }
+
+        protected abstract void onVaultConfigAdded(V vaultConfig) throws SkyflowException;
+
+        protected abstract void onVaultConfigUpdated(V updatedConfig) throws SkyflowException;
+
+        protected abstract void onVaultConfigRemoved(String vaultId) throws SkyflowException;
+
+        protected abstract void onCredentialsUpdated(Credentials credentials) throws SkyflowException;
+    }
+
+}