Introduce multiple datasources

This change enables multiple datasources in Polaris, with possibility of **runtime** activation of the desired datasource.

This is achieved by:

1) Introducing a new enabler property: `polaris.persistence.relational.jdbc.datasource`, which points to a named datasource to activate.

2) Declaring, **at build time**, one named datasource for each JDBC driver shipped with the application.

3) Introducing a new `DataSourceActivator` config interceptor that will, at runtime, change the `active` setting of the target datasource to `true`, and all others to `false` (`active` is a runtime setting, contrary to `db-kind`).

This change also makes the server ship with the H2 driver by default, since that's the pre-condition for an H2 datasource to be selected at runtime.

This change will further enable **as future improvements**:

- Using to JDBC + H2 by default for server images, while still allowing users to switch to PostgreSQL *without having to rebuild Polaris*.

- Enabling the persistence to "plug" into not one, but many datasources, e.g. a specific datasource for main persistence, and a separate datasource for metrics. This was outlined in #3960 – but the machinery to make that happen was missing.

Author: adutra

helm/polaris/templates/configmap.yaml

@@ -51,6 +51,9 @@ data:
 
     {{- /* Persistence */ -}}
     {{- $_ = set $map "polaris.persistence.type" .Values.persistence.type -}}
+    {{- if eq .Values.persistence.type "relational-jdbc" -}}
+    {{- $_ = set $map "polaris.persistence.relational.jdbc.datasource" .Values.persistence.relationalJdbc.datasource -}}
+    {{- end -}}
     {{- if eq .Values.persistence.type "nosql" -}}
     {{- $_ = set $map "polaris.persistence.nosql.backend" .Values.persistence.nosql.backend -}}
     {{- $_ = set $map "quarkus.mongodb.database" .Values.persistence.nosql.database -}}

helm/polaris/templates/deployment.yaml

@@ -95,9 +95,9 @@ spec:
             {{- include "polaris.secretToEnv" (list .Values.storage.secret "awsAccessKeyId" "polaris.storage.aws.access-key") | indent 12 -}}
             {{- include "polaris.secretToEnv" (list .Values.storage.secret "awsSecretAccessKey" "polaris.storage.aws.secret-key") | indent 12 -}}
             {{- include "polaris.secretToEnv" (list .Values.storage.secret "gcpToken" "polaris.storage.gcp.token") | indent 12 -}}
-            {{- include "polaris.secretToEnv" (list .Values.persistence.relationalJdbc.secret "username" "quarkus.datasource.username") | indent 12 -}}
-            {{- include "polaris.secretToEnv" (list .Values.persistence.relationalJdbc.secret "password" "quarkus.datasource.password") | indent 12 -}}
-            {{- include "polaris.secretToEnv" (list .Values.persistence.relationalJdbc.secret "jdbcUrl" "quarkus.datasource.jdbc.url") | indent 12 -}}
+            {{- include "polaris.secretToEnv" (list .Values.persistence.relationalJdbc.secret "username" (printf "quarkus.datasource.%s.username" .Values.persistence.relationalJdbc.datasource)) | indent 12 -}}
+            {{- include "polaris.secretToEnv" (list .Values.persistence.relationalJdbc.secret "password" (printf "quarkus.datasource.%s.password" .Values.persistence.relationalJdbc.datasource)) | indent 12 -}}
+            {{- include "polaris.secretToEnv" (list .Values.persistence.relationalJdbc.secret "jdbcUrl" (printf "quarkus.datasource.%s.jdbc.url" .Values.persistence.relationalJdbc.datasource)) | indent 12 -}}
             {{- include "polaris.secretToEnv" (list .Values.persistence.nosql.secret "connectionString" "quarkus.mongodb.connection-string") | indent 12 -}}
             {{- include "polaris.secretToEnv" (list .Values.oidc.client.secret "key" "quarkus.oidc.credentials.secret") | indent 12 -}}
             {{- if .Values.extraEnv -}}

helm/polaris/tests/configmap_test.yaml

@@ -122,9 +122,10 @@ tests:
 
   - it: should configure relational-jdbc persistence
     set:
-      persistence: { type: "relational-jdbc", relationalJdbc: { secret: { name: "polaris-persistence" } } }
+      persistence: { type: "relational-jdbc", relationalJdbc: { datasource: "postgresql", secret: { name: "polaris-persistence" } } }
     asserts:
       - matchRegex: { path: 'data["application.properties"]', pattern: "polaris.persistence.type=relational-jdbc" }
+      - matchRegex: { path: 'data["application.properties"]', pattern: "polaris.persistence.relational.jdbc.datasource=postgresql" }
 
   - it: should configure nosql persistence with default values
     set:

helm/polaris/tests/deployment_test.yaml

@@ -1470,28 +1470,58 @@ tests:
   - it: should set relational-jdbc persistence environment variables
     template: deployment.yaml
     set:
-      persistence: { type: "relational-jdbc", relationalJdbc: { secret: { name: "polaris-persistence", username: "username", password: "password", jdbcUrl: "jdbcUrl" } } }
+      persistence: { type: "relational-jdbc", relationalJdbc: { datasource: "postgresql", secret: { name: "polaris-persistence", username: "username", password: "password", jdbcUrl: "jdbcUrl" } } }
     asserts:
       - contains:
           path: spec.template.spec.containers[0].env
           content:
-            name: quarkus.datasource.username
+            name: quarkus.datasource.postgresql.username
             valueFrom:
               secretKeyRef:
                 name: polaris-persistence
                 key: username
       - contains:
           path: spec.template.spec.containers[0].env
           content:
-            name: quarkus.datasource.password
+            name: quarkus.datasource.postgresql.password
             valueFrom:
               secretKeyRef:
                 name: polaris-persistence
                 key: password
       - contains:
           path: spec.template.spec.containers[0].env
           content:
-            name: quarkus.datasource.jdbc.url
+            name: quarkus.datasource.postgresql.jdbc.url
+            valueFrom:
+              secretKeyRef:
+                name: polaris-persistence
+                key: jdbcUrl
+
+  - it: should set relational-jdbc persistence environment variables for custom datasource name
+    template: deployment.yaml
+    set:
+      persistence: { type: "relational-jdbc", relationalJdbc: { datasource: "mydb", secret: { name: "polaris-persistence", username: "username", password: "password", jdbcUrl: "jdbcUrl" } } }
+    asserts:
+      - contains:
+          path: spec.template.spec.containers[0].env
+          content:
+            name: quarkus.datasource.mydb.username
+            valueFrom:
+              secretKeyRef:
+                name: polaris-persistence
+                key: username
+      - contains:
+          path: spec.template.spec.containers[0].env
+          content:
+            name: quarkus.datasource.mydb.password
+            valueFrom:
+              secretKeyRef:
+                name: polaris-persistence
+                key: password
+      - contains:
+          path: spec.template.spec.containers[0].env
+          content:
+            name: quarkus.datasource.mydb.jdbc.url
             valueFrom:
               secretKeyRef:
                 name: polaris-persistence

helm/polaris/values.schema.json

@@ -1001,6 +1001,10 @@
                 "relationalJdbc": {
                     "type": "object",
                     "properties": {
+                        "datasource": {
+                            "description": "The name of the Quarkus named datasource to use for relational persistence. Must match one of the built-in named datasources (h2, postgresql), or a custom datasource configured via extraEnv / extraConfig (in this case, you must use a custom Polaris server image including the custom datasource). Polaris will activate this datasource automatically.",
+                            "type": "string"
+                        },
                         "secret": {
                             "type": "object",
                             "properties": {

helm/polaris/values.yaml

@@ -922,6 +922,12 @@ persistence:
   type: in-memory  # relational-jdbc, nosql
   # The configuration for the relational-jdbc persistence manager.
   relationalJdbc:
+    # -- The name of the Quarkus named datasource to use for relational persistence.
+    # Must match one of the built-in named datasources (h2, postgresql), or a custom datasource
+    # configured via extraEnv / extraConfig (in this case, you must use a custom Polaris server
+    # image including the custom datasource). Polaris will activate this datasource automatically.
+    # @section -- Persistence
+    datasource: postgresql
     # The secret name to pull the database connection properties from.
     secret:
       # -- The secret name to pull database connection properties from

persistence/relational-jdbc/src/main/java/org/apache/polaris/persistence/relational/jdbc/JdbcMetaStoreManagerFactory.java

@@ -22,8 +22,6 @@
 
 import io.smallrye.common.annotation.Identifier;
 import jakarta.enterprise.context.ApplicationScoped;
-import jakarta.enterprise.inject.Instance;
-import jakarta.enterprise.inject.Produces;
 import jakarta.inject.Inject;
 import java.sql.SQLException;
 import java.time.Clock;
@@ -32,7 +30,6 @@
 import java.util.Optional;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
-import javax.sql.DataSource;
 import org.apache.polaris.core.PolarisCallContext;
 import org.apache.polaris.core.PolarisDiagnostics;
 import org.apache.polaris.core.config.BehaviorChangeConfiguration;
@@ -93,13 +90,6 @@ public class JdbcMetaStoreManagerFactory implements MetaStoreManagerFactory {
 
   protected JdbcMetaStoreManagerFactory() {}
 
-  @Produces
-  @ApplicationScoped
-  static DatasourceOperations produceDatasourceOperations(
-      Instance<DataSource> dataSource, RelationalJdbcConfiguration relationalJdbcConfiguration) {
-    return new DatasourceOperations(dataSource.get(), relationalJdbcConfiguration);
-  }
-
   protected PrincipalSecretsGenerator secretsGenerator(
       String realmId, @Nullable RootCredentialsSet rootCredentialsSet) {
     if (rootCredentialsSet != null) {

persistence/relational-jdbc/src/main/java/org/apache/polaris/persistence/relational/jdbc/RelationalJdbcConfiguration.java

@@ -21,18 +21,21 @@
 import java.util.Optional;
 
 public interface RelationalJdbcConfiguration {
-  // max retries before giving up
+  /** The maximum number of retries before giving up the operation. */
   Optional<Integer> maxRetries();
 
-  // max retry duration
+  /** The maximum retry duration in milliseconds. */
   Optional<Long> maxDurationInMs();
 
-  // initial delay
+  /** The initial retry delay. */
   Optional<Long> initialDelayInMs();
 
   /**
    * Explicitly configured database type. If not specified, the database type will be inferred from
    * the JDBC connection metadata. Supported values: "postgresql", "cockroachdb", "h2"
    */
   Optional<String> databaseType();
+
+  /** The datasource name to use. Required. */
+  String dataSource();
 }

persistence/relational-jdbc/src/main/java/org/apache/polaris/persistence/relational/jdbc/RelationalJdbcProductionReadinessChecks.java

@@ -40,7 +40,7 @@ public ProductionReadinessCheck checkRelationalJdbc(
       return ProductionReadinessCheck.of(
           ProductionReadinessCheck.Error.of(
               "The current persistence (jdbc:h2) is intended for tests only.",
-              "quarkus.datasource.jdbc.url"));
+              "polaris.persistence.relational.jdbc.datasource"));
     }
     return ProductionReadinessCheck.OK;
   }

persistence/relational-jdbc/src/test/java/org/apache/polaris/persistence/relational/jdbc/JdbcGrantRecordsIdempotencyTest.java

@@ -154,5 +154,10 @@ public Optional<Long> initialDelayInMs() {
     public Optional<String> databaseType() {
       return Optional.of("h2");
     }
+
+    @Override
+    public String dataSource() {
+      return "h2";
+    }
   }
 }