Feat(spring): Adding FromConfigMap annotation that dynamically maps data config-map to map

spring/pom.xml

@@ -64,6 +64,11 @@
       <artifactId>wiremock</artifactId>
       <scope>test</scope>
     </dependency>
+    <dependency>
+      <groupId>org.awaitility</groupId>
+      <artifactId>awaitility</artifactId>
+      <scope>test</scope>
+    </dependency>
 
   </dependencies>
 

spring/src/main/java/io/kubernetes/client/spring/extended/manifests/KubernetesFromConfigMapProcessor.java

@@ -0,0 +1,164 @@
+/*
+Copyright 2021 The Kubernetes Authors.
+Licensed 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 io.kubernetes.client.spring.extended.manifests;
+
+import com.github.benmanes.caffeine.cache.CacheLoader;
+import com.github.benmanes.caffeine.cache.Caffeine;
+import com.github.benmanes.caffeine.cache.LoadingCache;
+import io.kubernetes.client.openapi.models.V1ConfigMap;
+import io.kubernetes.client.spring.extended.manifests.annotation.FromConfigMap;
+import io.kubernetes.client.spring.extended.manifests.config.KubernetesManifestsProperties;
+import io.kubernetes.client.spring.extended.manifests.configmaps.ConfigMapGetter;
+import java.lang.reflect.Field;
+import java.util.Map;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+import java.util.function.Supplier;
+import org.checkerframework.checker.nullness.qual.NonNull;
+import org.checkerframework.checker.nullness.qual.Nullable;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.BeansException;
+import org.springframework.beans.factory.BeanCreationException;
+import org.springframework.beans.factory.NoSuchBeanDefinitionException;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.config.BeanPostProcessor;
+import org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessor;
+import org.springframework.context.ApplicationContext;
+import org.springframework.context.ApplicationContextAware;
+import org.springframework.util.ReflectionUtils;
+
+public class KubernetesFromConfigMapProcessor
+    implements InstantiationAwareBeanPostProcessor, BeanPostProcessor, ApplicationContextAware {
+
+  private static final Logger log = LoggerFactory.getLogger(KubernetesFromConfigMapProcessor.class);
+
+  private ApplicationContext applicationContext;
+
+  private final ScheduledExecutorService configMapKeyRefresher =
+      Executors.newSingleThreadScheduledExecutor();
+
+  @Autowired private KubernetesManifestsProperties manifestsProperties;
+
+  public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
+
+    for (Field field : bean.getClass().getDeclaredFields()) {
+      ReflectionUtils.makeAccessible(field);
+      try {
+        if (field.get(bean) != null) {
+          continue; // field already set, skip processing
+        }
+      } catch (IllegalAccessException e) {
+        log.warn("Failed inject resource for @FromConfigMap annotated field {}", field, e);
+        continue;
+      }
+
+      FromConfigMap fromConfigMapAnnotation = field.getAnnotation(FromConfigMap.class);
+      if (fromConfigMapAnnotation == null) {
+        continue; // skip if the field doesn't have the annotation
+      }
+
+      if (!Map.class.isAssignableFrom(field.getType())) {
+        log.warn(
+            "Failed inject resource for @FromConfigMap annotated field {}, the declaring type should be Map<String, String>",
+            field);
+        continue;
+      }
+
+      ConfigMapGetter configMapGetter =
+          getOrCreateConfigMapGetter(fromConfigMapAnnotation, applicationContext);
+
+      LoadingCache<String, String> configMapDataCache =
+          Caffeine.newBuilder()
+              .expireAfterWrite(manifestsProperties.getRefreshInterval())
+              .build(
+                  new ConfigMapGetterCacheLoader(
+                      () -> {
+                        return configMapGetter.get(
+                            fromConfigMapAnnotation.namespace(), fromConfigMapAnnotation.name());
+                      }));
+      fullyRefreshCache(configMapGetter, fromConfigMapAnnotation, configMapDataCache);
+      configMapKeyRefresher.scheduleAtFixedRate(
+          () -> {
+            fullyRefreshCache(configMapGetter, fromConfigMapAnnotation, configMapDataCache);
+          },
+          manifestsProperties.getRefreshInterval().getSeconds(),
+          manifestsProperties.getRefreshInterval().getSeconds(),
+          TimeUnit.SECONDS);
+      ReflectionUtils.setField(field, bean, configMapDataCache.asMap());
+    }
+
+    return bean;
+  }
+
+  private static void fullyRefreshCache(
+      ConfigMapGetter configMapGetter,
+      FromConfigMap fromConfigMapAnnotation,
+      LoadingCache<String, String> configMapDataCache) {
+    V1ConfigMap configMap =
+        configMapGetter.get(fromConfigMapAnnotation.namespace(), fromConfigMapAnnotation.name());
+    if (configMap == null || configMap.getData() == null) {
+      return;
+    }
+    // TODO: make the cache data refreshment atomic
+    configMap.getData().keySet().stream().forEach(key -> configMapDataCache.refresh(key));
+  }
+
+  private ConfigMapGetter getOrCreateConfigMapGetter(
+      FromConfigMap fromConfigMapAnnotation, ApplicationContext applicationContext) {
+    ConfigMapGetter configMapGetter;
+    try {
+      configMapGetter =
+          applicationContext
+              .getAutowireCapableBeanFactory()
+              .getBean(fromConfigMapAnnotation.configMapGetter());
+    } catch (NoSuchBeanDefinitionException ne) {
+      try {
+        configMapGetter = fromConfigMapAnnotation.configMapGetter().newInstance();
+      } catch (IllegalAccessException | InstantiationException e) {
+        throw new BeanCreationException("failed creating configmap getter instance", e);
+      }
+      applicationContext.getAutowireCapableBeanFactory().autowireBean(configMapGetter);
+      applicationContext
+          .getAutowireCapableBeanFactory()
+          .initializeBean(
+              configMapGetter,
+              "configmap-getter-" + fromConfigMapAnnotation.configMapGetter().getSimpleName());
+    }
+    return configMapGetter;
+  }
+
+  @Override
+  public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
+    this.applicationContext = applicationContext;
+  }
+
+  static class ConfigMapGetterCacheLoader implements CacheLoader<String, String> {
+
+    ConfigMapGetterCacheLoader(Supplier<V1ConfigMap> configMapSupplier) {
+      this.configMapSupplier = configMapSupplier;
+    }
+
+    private final Supplier<V1ConfigMap> configMapSupplier;
+
+    @Override
+    public @Nullable String load(@NonNull String key) throws Exception {
+      V1ConfigMap configMap = this.configMapSupplier.get();
+      if (configMap == null || configMap.getData() == null) {
+        return null;
+      }
+      return configMap.getData().get(key);
+    }
+  }
+}

spring/src/main/java/io/kubernetes/client/spring/extended/manifests/annotation/FromConfigMap.java

@@ -0,0 +1,56 @@
+/*
+Copyright 2021 The Kubernetes Authors.
+Licensed 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 io.kubernetes.client.spring.extended.manifests.annotation;
+
+import io.kubernetes.client.spring.extended.manifests.configmaps.ConfigMapGetter;
+import io.kubernetes.client.spring.extended.manifests.configmaps.PollingConfigMapGetter;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Injecting resources by reading from ConfigMap.
+ *
+ * <p>The annotations has to be be applied to member field of type Map<String, String>.
+ *
+ * <p>The content of the map will be automatically updated at the interval specified by the property
+ * "kubernetes.manifests.refreshInterval".
+ *
+ * <p>If the given configmap, is not present in the cluster, the content of the map will stay empty.
+ */
+@Target({ElementType.FIELD})
+@Retention(RetentionPolicy.RUNTIME)
+public @interface FromConfigMap {
+
+  /**
+   * Namespace of the configmap.
+   *
+   * @return the string
+   */
+  String namespace();
+
+  /**
+   * Name of the configmap
+   *
+   * @return the string
+   */
+  String name();
+
+  /**
+   * Config map getter class.
+   *
+   * @return the class
+   */
+  Class<? extends ConfigMapGetter> configMapGetter() default PollingConfigMapGetter.class;
+}

spring/src/main/java/io/kubernetes/client/spring/extended/manifests/config/KubernetesManifestsAutoConfiguration.java

@@ -12,27 +12,38 @@
 */
 package io.kubernetes.client.spring.extended.manifests.config;
 
+import io.kubernetes.client.spring.extended.manifests.KubernetesFromConfigMapProcessor;
 import io.kubernetes.client.spring.extended.manifests.KubernetesFromYamlProcessor;
 import io.kubernetes.client.spring.extended.manifests.KubernetesKubectlApplyProcessor;
 import io.kubernetes.client.spring.extended.manifests.KubernetesKubectlCreateProcessor;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
+import org.springframework.boot.context.properties.EnableConfigurationProperties;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 
 @Configuration(proxyBeanMethods = false)
 @ConditionalOnKubernetesManifestsEnabled
+@EnableConfigurationProperties({
+  KubernetesManifestsProperties.class,
+})
 public class KubernetesManifestsAutoConfiguration {
 
   @Bean
   @ConditionalOnMissingBean
-  public KubernetesKubectlCreateProcessor kubernetesKubectlCreateProcessor() {
-    return new KubernetesKubectlCreateProcessor();
+  public KubernetesFromYamlProcessor kubernetesFromYamlProcessor() {
+    return new KubernetesFromYamlProcessor();
   }
 
   @Bean
   @ConditionalOnMissingBean
-  public KubernetesFromYamlProcessor kubernetesFromYamlProcessor() {
-    return new KubernetesFromYamlProcessor();
+  public KubernetesFromConfigMapProcessor kubernetesFromConfigMapProcessor() {
+    return new KubernetesFromConfigMapProcessor();
+  }
+
+  @Bean
+  @ConditionalOnMissingBean
+  public KubernetesKubectlCreateProcessor kubernetesKubectlCreateProcessor() {
+    return new KubernetesKubectlCreateProcessor();
   }
 
   @Bean

spring/src/main/java/io/kubernetes/client/spring/extended/manifests/config/KubernetesManifestsProperties.java

@@ -0,0 +1,30 @@
+/*
+Copyright 2021 The Kubernetes Authors.
+Licensed 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 io.kubernetes.client.spring.extended.manifests.config;
+
+import java.time.Duration;
+import org.springframework.boot.context.properties.ConfigurationProperties;
+
+@ConfigurationProperties("kubernetes.manifests")
+public class KubernetesManifestsProperties {
+  private Duration refreshInterval = Duration.ofSeconds(5);
+
+  public Duration getRefreshInterval() {
+    return refreshInterval;
+  }
+
+  public KubernetesManifestsProperties setRefreshInterval(Duration refreshInterval) {
+    this.refreshInterval = refreshInterval;
+    return this;
+  }
+}

spring/src/main/java/io/kubernetes/client/spring/extended/manifests/configmaps/ConfigMapGetter.java

@@ -0,0 +1,19 @@
+/*
+Copyright 2021 The Kubernetes Authors.
+Licensed 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 io.kubernetes.client.spring.extended.manifests.configmaps;
+
+import io.kubernetes.client.openapi.models.V1ConfigMap;
+
+public interface ConfigMapGetter {
+  V1ConfigMap get(String namespace, String name);
+}

spring/src/main/java/io/kubernetes/client/spring/extended/manifests/configmaps/InformerConfigMapGetter.java

@@ -0,0 +1,27 @@
+/*
+Copyright 2021 The Kubernetes Authors.
+Licensed 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 io.kubernetes.client.spring.extended.manifests.configmaps;
+
+import io.kubernetes.client.informer.cache.Lister;
+import io.kubernetes.client.openapi.models.V1ConfigMap;
+import org.springframework.beans.factory.annotation.Autowired;
+
+public class InformerConfigMapGetter implements ConfigMapGetter {
+
+  @Autowired private Lister<V1ConfigMap> configMapLister;
+
+  @Override
+  public V1ConfigMap get(String namespace, String name) {
+    return this.configMapLister.namespace(namespace).get(name);
+  }
+}