Build fix test

.github/workflows/ci.yml

@@ -7,4 +7,4 @@ on:
 
 jobs:
   ci:
-    uses: killbill/gh-actions-shared/.github/workflows/ci.yml@main
+    uses: vnandwana/gh-actions-shared/.github/workflows/ci.yml@test

base/src/main/java/org/killbill/billing/platform/config/PropertiesWithSourceCollector.java

@@ -22,19 +22,28 @@
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 import java.util.stream.Collectors;
 
 public class PropertiesWithSourceCollector {
 
     private volatile List<PropertyWithSource> properties = new ArrayList<>();
     private final Object lock = new Object();
 
-    public void addProperties(String source, Map<String, String> props) {
+    public void addProperties(final String source, final Map<String, String> props) {
         synchronized (lock) {
-            List<PropertyWithSource> newList = new ArrayList<>(properties);
-            props.forEach((key, value) ->
-                                  newList.add(new PropertyWithSource(source, key, value)));
-            this.properties = Collections.unmodifiableList(newList);
+            final List<PropertyWithSource> updatedProperties = new ArrayList<>(properties);
+
+            final Set<String> keysToAdd = props.keySet();
+            updatedProperties.removeIf(property -> property.getSource().equals(source) && keysToAdd.contains(property.getKey()));
+
+            props.forEach((key, value) -> {
+                if (value != null) {
+                    updatedProperties.add(new PropertyWithSource(source, key, value));
+                }
+            });
+
+            this.properties = Collections.unmodifiableList(updatedProperties);
         }
     }
 

base/src/main/java/org/killbill/billing/platform/config/RuntimeConfigRegistry.java

@@ -0,0 +1,101 @@
+/*
+ * Copyright 2020-2025 Equinix, Inc
+ * Copyright 2014-2025 The Billing Project, LLC
+ *
+ * The Billing Project licenses this file to you under the Apache License, version 2.0
+ * (the "License"); you may not use this file except in compliance with the
+ * License.  You may obtain a copy of the License at:
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.killbill.billing.platform.config;
+
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.stream.Collectors;
+
+/**
+ * Registry to capture and expose runtime configuration values.
+ */
+public class RuntimeConfigRegistry {
+
+    private static final Map<String, Map<String, String>> RUNTIME_CONFIGS_BY_SOURCE = new ConcurrentHashMap<>();
+
+    public static void put(final String key, final Object value) {
+        putWithSource("RuntimeConfiguration", key, value);
+    }
+
+    public static void putWithSource(final String configSource, final String key, final Object value) {
+        if (value == null) {
+            return;
+        }
+
+        RUNTIME_CONFIGS_BY_SOURCE
+                .computeIfAbsent(configSource, k -> new ConcurrentHashMap<>())
+                .put(key, value.toString());
+    }
+
+    public static void putAllWithSource(final String configSource, final Map<String, ?> values) {
+        if (values == null || values.isEmpty()) {
+            return;
+        }
+
+/*        RUNTIME_CONFIGS_BY_SOURCE
+                .computeIfAbsent(configSource, k -> new ConcurrentHashMap<>())
+                .putAll(values.entrySet()
+                              .stream()
+                              .collect(Collectors.toMap(Map.Entry::getKey,
+                                                        e -> e.getValue() == null ? "" : e.getValue().toString())));*/
+
+        final Map<String, String> nonNullValues = values.entrySet()
+                                                        .stream()
+                                                        .filter(e -> e.getValue() != null)
+                                                        .collect(Collectors.toMap(Map.Entry::getKey,
+                                                                                  e -> e.getValue().toString()));
+
+        if (!nonNullValues.isEmpty()) {
+            RUNTIME_CONFIGS_BY_SOURCE
+                    .computeIfAbsent(configSource, k -> new ConcurrentHashMap<>())
+                    .putAll(nonNullValues);
+        }
+    }
+
+    public static String get(final String key) {
+        for (final Map<String, String> sourceMap : RUNTIME_CONFIGS_BY_SOURCE.values()) {
+            final String value = sourceMap.get(key);
+            if (value != null) {
+                return value;
+            }
+        }
+
+        return "";
+    }
+
+    public static Map<String, String> getBySource(final String source) {
+        return Collections.unmodifiableMap(RUNTIME_CONFIGS_BY_SOURCE.getOrDefault(source, Map.of()));
+    }
+
+    public static Map<String, String> getAll() {
+        final Map<String, String> allConfigs = new LinkedHashMap<>();
+        RUNTIME_CONFIGS_BY_SOURCE.values().forEach(allConfigs::putAll);
+
+        return Collections.unmodifiableMap(allConfigs);
+    }
+
+    public static Map<String, Map<String, String>> getAllBySource() {
+        return Collections.unmodifiableMap(RUNTIME_CONFIGS_BY_SOURCE);
+    }
+
+    public static void clear() {
+        RUNTIME_CONFIGS_BY_SOURCE.clear();
+    }
+}

base/src/main/java/org/killbill/billing/platform/jndi/JNDIManager.java

@@ -31,6 +31,7 @@
 import javax.naming.NamingException;
 import javax.naming.Reference;
 import javax.naming.Referenceable;
+import javax.naming.spi.NamingManager;
 
 import org.killbill.commons.utils.Preconditions;
 import org.slf4j.Logger;
@@ -92,7 +93,17 @@ public Object lookup(final String name) {
 
         try {
             context = getContext();
-            return context.lookup(name);
+            final Object obj = context.lookup(name);
+
+            if (obj instanceof Reference) {
+                try {
+                    return NamingManager.getObjectInstance(obj, null, null, null);
+                } catch (final Exception e) {
+                    logger.warn("Error dereferencing " + name, e);
+                }
+            }
+
+            return obj;
         } catch (final NamingException e) {
             logger.warn("Error looking up " + name, e);
         } finally {

base/src/test/java/org/killbill/billing/platform/config/TestDefaultKillbillConfigSource.java

@@ -21,8 +21,12 @@
 
 import java.io.IOException;
 import java.net.URISyntaxException;
+import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
+import java.util.Properties;
 
 import org.jasypt.encryption.pbe.StandardPBEStringEncryptor;
 import org.jasypt.exceptions.EncryptionOperationNotPossibleException;
@@ -55,6 +59,101 @@ public void setup() {
         System.clearProperty(ENCRYPTED_PROPERTY_2);
     }
 
+    @Test
+    public void testGetPropertiesBySourceContainsExpectedSources() throws URISyntaxException, IOException {
+        final Map<String, String> runtimeConfig = new HashMap<>();
+        runtimeConfig.put("org.killbill.dao.user", "root");
+
+        final OSGIConfigProperties configSource = new DefaultKillbillConfigSource(null, runtimeConfig) {
+            @Override
+            protected Map<String, String> getEnvironmentVariables() {
+                final Map<String, String> mockEnv = new HashMap<>();
+                mockEnv.put(ENVIRONMENT_VARIABLE_PREFIX + "org_killbill_dao_user", "root");
+                return mockEnv;
+            }
+        };
+
+        final Map<String, Map<String, String>> propsBySource = configSource.getPropertiesBySource();
+
+        Assert.assertTrue(propsBySource.containsKey("ImmutableSystemProperties"));
+        Assert.assertTrue(propsBySource.containsKey("EnvironmentVariables"));
+        Assert.assertTrue(propsBySource.containsKey("RuntimeConfiguration"));
+        Assert.assertTrue(propsBySource.containsKey("KillBillDefaults"));
+    }
+
+    @Test(groups = "fast")
+    public void testGetPropertiesAndGetPropertiesBySourceAreInSync() throws URISyntaxException, IOException {
+        // RuntimeConfiguration
+        System.setProperty("org.killbill.dao.user", "root");
+        System.setProperty("org.killbill.dao.password", "password");
+
+        // KillBillDefaults
+        final Map<String, String> killbillDefaultConfig = new HashMap<>();
+        killbillDefaultConfig.put("org.killbill.server.shutdownDelay", "3s");
+        killbillDefaultConfig.put("org.killbill.billing.osgi.dao.logLevel", "INFO");
+
+        // ImmutableSystemProperties
+        killbillDefaultConfig.put("user.timezone", "GMT");
+
+        // EnvironmentVariables
+        final OSGIConfigProperties configSource = new DefaultKillbillConfigSource(null, killbillDefaultConfig) {
+            @Override
+            protected Map<String, String> getEnvironmentVariables() {
+                final Map<String, String> mockEnv = new HashMap<>();
+                mockEnv.put(ENVIRONMENT_VARIABLE_PREFIX + "org_killbill_dao_healthCheckConnectionTimeout", "11s");
+                return mockEnv;
+            }
+        };
+
+        final Properties mergedProperties = configSource.getProperties();
+        final Map<String, Map<String, String>> propertiesBySource = configSource.getPropertiesBySource();
+
+        final Map<String, String> allProperties = new HashMap<>();
+        propertiesBySource.forEach((source, props) -> allProperties.putAll(props));
+
+        for (final String key : mergedProperties.stringPropertyNames()) {
+            final String valueFromFlat = mergedProperties.getProperty(key);
+            final String valueFromSource = allProperties.get(key);
+
+            Assert.assertNotNull(valueFromSource);
+            Assert.assertEquals(valueFromFlat, valueFromSource);
+        }
+
+        // Verify that no property appears in multiple sources
+        final Map<String, Integer> propertyCount = new HashMap<>();
+        propertiesBySource.forEach((source, props) -> {
+            props.keySet().forEach(key -> propertyCount.put(key, propertyCount.getOrDefault(key, 0) + 1));
+        });
+
+        propertyCount.forEach((key, count) -> {
+            Assert.assertEquals(count.intValue(), 1);
+        });
+
+        Assert.assertEquals(mergedProperties.size(), allProperties.size());
+    }
+
+    @Test
+    public void testConflictResolutionPriority() throws Exception {
+        // RuntimeConfiguration
+        System.setProperty("org.killbill.test", "lowValue");
+
+        final DefaultKillbillConfigSource testSource = new DefaultKillbillConfigSource((String) null) {
+            @Override
+            protected Map<String, String> getEnvironmentVariables() {
+                final Map<String, String> mockEnv = new HashMap<>();
+                mockEnv.put(ENVIRONMENT_VARIABLE_PREFIX + "org_killbill_test", "highValue");
+                return mockEnv;
+            }
+        };
+
+        testSource.setProperty("org.killbill.test", "lowValue");
+
+        final Properties properties = testSource.getProperties();
+
+        final String effectiveValue = properties.getProperty("org.killbill.test");
+        Assert.assertEquals(effectiveValue, "highValue");
+    }
+
     @Test(groups = "fast")
     public void testGetProperties() throws URISyntaxException, IOException {
         final Map<String, String> configuration = new HashMap<>();
@@ -70,21 +169,66 @@ public void testGetProperties() throws URISyntaxException, IOException {
 
     @Test(groups = "fast")
     public void testGetPropertiesBySource() throws URISyntaxException, IOException {
-        final Map<String, String> configuration = new HashMap<>();
-        configuration.put("org.killbill.dao.user", "root");
-        configuration.put("org.killbill.dao.password", "password");
-
-        final OSGIConfigProperties configSource = new DefaultKillbillConfigSource(null, configuration);
+        // RuntimeConfiguration
+        System.setProperty("org.killbill.dao.user", "root");
+        System.setProperty("org.killbill.dao.password", "password");
+
+        // KillBillDefaults
+        final Map<String, String> killbillDefaultConfig = new HashMap<>();
+        killbillDefaultConfig.put("org.killbill.server.shutdownDelay", "3s");
+        killbillDefaultConfig.put("org.killbill.billing.osgi.dao.logLevel", "INFO");
+
+        // ImmutableSystemProperties
+        killbillDefaultConfig.put("user.timezone", "GMT");
+
+        // EnvironmentVariables
+        final OSGIConfigProperties configSource = new DefaultKillbillConfigSource(null, killbillDefaultConfig) {
+            @Override
+            protected Map<String, String> getEnvironmentVariables() {
+                final Map<String, String> mockEnv = new HashMap<>();
+                mockEnv.put(ENVIRONMENT_VARIABLE_PREFIX + "org_killbill_dao_healthCheckConnectionTimeout", "11s");
+                mockEnv.put(ENVIRONMENT_VARIABLE_PREFIX + "org_killbill_billing_osgi_dao_maxActive", "99");
+
+                return mockEnv;
+            }
+        };
 
         final Map<String, Map<String, String>> propsBySource = configSource.getPropertiesBySource();
 
         Assert.assertNotNull(propsBySource);
         Assert.assertFalse(propsBySource.isEmpty());
 
-        final Map<String, String> defaultProps = propsBySource.get("ExtraDefaultProperties");
-        Assert.assertNotNull(defaultProps);
-        Assert.assertEquals(defaultProps.get("org.killbill.dao.user"), "root");
-        Assert.assertEquals(defaultProps.get("org.killbill.dao.password"), "password");
+        Assert.assertTrue(propsBySource.containsKey("ImmutableSystemProperties"));
+
+        final Map<String, String> immutableProps = propsBySource.get("ImmutableSystemProperties");
+        Assert.assertEquals(immutableProps.get("user.timezone"), "GMT");
+
+        Assert.assertTrue(propsBySource.containsKey("EnvironmentVariables"));
+
+        final Map<String, String> environmentVariables = propsBySource.get("EnvironmentVariables");
+        Assert.assertEquals(environmentVariables.get("org.killbill.dao.healthCheckConnectionTimeout"), "11s");
+        Assert.assertEquals(environmentVariables.get("org.killbill.billing.osgi.dao.maxActive"), "99");
+
+        Assert.assertTrue(propsBySource.containsKey("RuntimeConfiguration"));
+
+        final Map<String, String> runtimeConfig = propsBySource.get("RuntimeConfiguration");
+        Assert.assertEquals(runtimeConfig.get("org.killbill.dao.user"), "root");
+        Assert.assertEquals(runtimeConfig.get("org.killbill.dao.password"), "password");
+
+        Assert.assertTrue(propsBySource.containsKey("KillBillDefaults"));
+
+        final Map<String, String> killBillDefaults = propsBySource.get("KillBillDefaults");
+        Assert.assertEquals(killBillDefaults.get("org.killbill.server.shutdownDelay"), "3s");
+        Assert.assertEquals(killBillDefaults.get("org.killbill.billing.osgi.dao.logLevel"), "INFO");
+
+        final List<String> actualSourceOrder = new ArrayList<>(propsBySource.keySet());
+
+        final List<String> expectedPrecedenceOrder = Arrays.asList("ImmutableSystemProperties",
+                                                                   "EnvironmentVariables",
+                                                                   "RuntimeConfiguration",
+                                                                   "KillBillDefaults");
+
+        Assert.assertEquals(actualSourceOrder, expectedPrecedenceOrder);
     }
 
     @Test(groups = "fast")

platform-test/src/main/java/org/killbill/billing/platform/test/config/TestKillbillConfigSource.java

@@ -54,7 +54,7 @@ public TestKillbillConfigSource(@Nullable final String file, @Nullable final Cla
 
         // Set default System Properties before creating the instance of DBTestingHelper. Whereas MySQL loads its
         // driver at startup, h2 loads it statically and we need System Properties set at that point
-        populateDefaultProperties();
+        populateDefaultProperties(extraDefaults);
 
         if (dbTestingHelperKlass != null) {
             final PlatformDBTestingHelper dbTestingHelper = (PlatformDBTestingHelper) dbTestingHelperKlass.getDeclaredMethod("get").invoke(null);
@@ -71,7 +71,8 @@ public TestKillbillConfigSource(@Nullable final String file, @Nullable final Cla
 
         this.extraDefaults = extraDefaults;
         // extraDefaults changed, need to reload defaults
-        populateDefaultProperties();
+        populateDefaultProperties(extraDefaults);
+        rebuildCache();
     }
 
     @Override

pom.xml

@@ -54,6 +54,7 @@
     </issueManagement>
     <properties>
         <check.fail-spotbugs>true</check.fail-spotbugs>
+        <check.skip-dependency>true</check.skip-dependency>
         <!-- Bug with maven-deploy-plugin -->
         <deploy.deploy-at-end>false</deploy.deploy-at-end>
         <maven.javadoc.failOnError>false</maven.javadoc.failOnError>