ContextBootstrapInitializer - config server

ContextBootstrapInitializer.java

package org.springframework.cloud.config.server.config;

import com.fasterxml.jackson.databind.ObjectMapper;
import java.lang.reflect.Field;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import org.springframework.aot.beans.factory.BeanDefinitionRegistrar;
import org.springframework.beans.factory.ObjectProvider;
import org.springframework.cloud.bootstrap.encrypt.KeyProperties;
import org.springframework.cloud.config.server.encryption.EnvironmentEncryptor;
import org.springframework.cloud.config.server.encryption.TextEncryptorLocator;
import org.springframework.cloud.config.server.environment.ConfigTokenProvider;
import org.springframework.cloud.config.server.environment.ConfigurableHttpConnectionFactory;
import org.springframework.cloud.config.server.environment.EnvironmentController;
import org.springframework.cloud.config.server.environment.EnvironmentRepository;
import org.springframework.cloud.config.server.environment.EnvironmentWatch;
import org.springframework.cloud.config.server.environment.MultipleJGitEnvironmentProperties;
import org.springframework.cloud.config.server.environment.MultipleJGitEnvironmentRepository;
import org.springframework.cloud.config.server.environment.MultipleJGitEnvironmentRepositoryFactory;
import org.springframework.cloud.config.server.environment.NativeEnvironmentRepositoryFactory;
import org.springframework.cloud.config.server.environment.VaultEnvironmentRepositoryFactory;
import org.springframework.cloud.config.server.resource.ResourceController;
import org.springframework.cloud.config.server.resource.ResourceRepository;
import org.springframework.cloud.config.server.support.GitCredentialsProviderFactory;
import org.springframework.context.support.GenericApplicationContext;
import org.springframework.core.env.ConfigurableEnvironment;
import org.springframework.security.crypto.encrypt.TextEncryptor;
import org.springframework.util.ReflectionUtils;

public final class ContextBootstrapInitializer {
  public static void registerConfigServerConfiguration_enableConfigServerMarker(
      GenericApplicationContext context) {
    BeanDefinitionRegistrar.of("enableConfigServerMarker", ConfigServerConfiguration.Marker.class).withFactoryMethod(ConfigServerConfiguration.class, "enableConfigServerMarker")
        .instanceSupplier(() -> context.getBean(ConfigServerConfiguration.class).enableConfigServerMarker()).register(context);
  }

  public static void registerEnvironmentRepositoryConfiguration_NativeFactoryConfig(
      GenericApplicationContext context) {
    BeanDefinitionRegistrar.of("org.springframework.cloud.config.server.config.EnvironmentRepositoryConfiguration$NativeFactoryConfig", EnvironmentRepositoryConfiguration.NativeFactoryConfig.class)
        .instanceSupplier(() -> new EnvironmentRepositoryConfiguration.NativeFactoryConfig()).register(context);
  }

  public static void registerNativeFactoryConfig_nativeEnvironmentRepositoryFactory(
      GenericApplicationContext context) {
    BeanDefinitionRegistrar.of("nativeEnvironmentRepositoryFactory", NativeEnvironmentRepositoryFactory.class).withFactoryMethod(EnvironmentRepositoryConfiguration.NativeFactoryConfig.class, "nativeEnvironmentRepositoryFactory", ConfigurableEnvironment.class, ConfigServerProperties.class)
        .instanceSupplier((instanceContext) -> instanceContext.create(context, (attributes) -> context.getBean(EnvironmentRepositoryConfiguration.NativeFactoryConfig.class).nativeEnvironmentRepositoryFactory(attributes.get(0), attributes.get(1)))).register(context);
  }

  public static void registerEnvironmentRepositoryConfiguration_VaultHttpClientConfig(
      GenericApplicationContext context) {
    BeanDefinitionRegistrar.of("org.springframework.cloud.config.server.config.EnvironmentRepositoryConfiguration$VaultHttpClientConfig", EnvironmentRepositoryConfiguration.VaultHttpClientConfig.class)
        .instanceSupplier(() -> new EnvironmentRepositoryConfiguration.VaultHttpClientConfig()).register(context);
  }

  public static void registerVaultHttpClientConfig_vaultRestTemplateFactory(
      GenericApplicationContext context) {
    BeanDefinitionRegistrar.of("vaultRestTemplateFactory", VaultEnvironmentRepositoryFactory.VaultRestTemplateFactory.class).withFactoryMethod(EnvironmentRepositoryConfiguration.VaultHttpClientConfig.class, "vaultRestTemplateFactory")
        .instanceSupplier(() -> context.getBean(EnvironmentRepositoryConfiguration.VaultHttpClientConfig.class).vaultRestTemplateFactory()).register(context);
  }

  public static void registerEnvironmentRepositoryConfiguration_VaultFactoryConfig(
      GenericApplicationContext context) {
    BeanDefinitionRegistrar.of("org.springframework.cloud.config.server.config.EnvironmentRepositoryConfiguration$VaultFactoryConfig", EnvironmentRepositoryConfiguration.VaultFactoryConfig.class)
        .instanceSupplier(() -> new EnvironmentRepositoryConfiguration.VaultFactoryConfig()).register(context);
  }

  public static void registerVaultFactoryConfig_vaultEnvironmentRepositoryFactory(
      GenericApplicationContext context) {
    BeanDefinitionRegistrar.of("vaultEnvironmentRepositoryFactory", VaultEnvironmentRepositoryFactory.class).withFactoryMethod(EnvironmentRepositoryConfiguration.VaultFactoryConfig.class, "vaultEnvironmentRepositoryFactory", ObjectProvider.class, EnvironmentWatch.class, Optional.class, ConfigTokenProvider.class)
        .instanceSupplier((instanceContext) -> instanceContext.create(context, (attributes) -> context.getBean(EnvironmentRepositoryConfiguration.VaultFactoryConfig.class).vaultEnvironmentRepositoryFactory(attributes.get(0), attributes.get(1), attributes.get(2), attributes.get(3)))).register(context);
  }

  public static void registerEnvironmentRepositoryConfiguration_JGitHttpClientConfig(
      GenericApplicationContext context) {
    BeanDefinitionRegistrar.of("org.springframework.cloud.config.server.config.EnvironmentRepositoryConfiguration$JGitHttpClientConfig", EnvironmentRepositoryConfiguration.JGitHttpClientConfig.class)
        .instanceSupplier(() -> new EnvironmentRepositoryConfiguration.JGitHttpClientConfig()).register(context);
  }

  public static void registerJGitHttpClientConfig_httpClientConnectionFactory(
      GenericApplicationContext context) {
    BeanDefinitionRegistrar.of("httpClientConnectionFactory", ConfigurableHttpConnectionFactory.class).withFactoryMethod(EnvironmentRepositoryConfiguration.JGitHttpClientConfig.class, "httpClientConnectionFactory")
        .instanceSupplier(() -> context.getBean(EnvironmentRepositoryConfiguration.JGitHttpClientConfig.class).httpClientConnectionFactory()).register(context);
  }

  public static void registerEnvironmentRepositoryConfiguration_JGitFactoryConfig(
      GenericApplicationContext context) {
    BeanDefinitionRegistrar.of("org.springframework.cloud.config.server.config.EnvironmentRepositoryConfiguration$JGitFactoryConfig", EnvironmentRepositoryConfiguration.JGitFactoryConfig.class)
        .instanceSupplier(() -> new EnvironmentRepositoryConfiguration.JGitFactoryConfig()).register(context);
  }

  public static void registerJGitFactoryConfig_gitEnvironmentRepositoryFactory(
      GenericApplicationContext context) {
    BeanDefinitionRegistrar.of("gitEnvironmentRepositoryFactory", MultipleJGitEnvironmentRepositoryFactory.class).withFactoryMethod(EnvironmentRepositoryConfiguration.JGitFactoryConfig.class, "gitEnvironmentRepositoryFactory", ConfigurableEnvironment.class, ConfigServerProperties.class, Optional.class, Optional.class, Optional.class, GitCredentialsProviderFactory.class)
        .instanceSupplier((instanceContext) -> instanceContext.create(context, (attributes) -> context.getBean(EnvironmentRepositoryConfiguration.JGitFactoryConfig.class).gitEnvironmentRepositoryFactory(attributes.get(0), attributes.get(1), attributes.get(2), attributes.get(3), attributes.get(4), attributes.get(5)))).register(context);
  }

  public static void registerJGitFactoryConfig_gitCredentialsProviderFactory(
      GenericApplicationContext context) {
    BeanDefinitionRegistrar.of("gitCredentialsProviderFactory", GitCredentialsProviderFactory.class).withFactoryMethod(EnvironmentRepositoryConfiguration.JGitFactoryConfig.class, "gitCredentialsProviderFactory")
        .instanceSupplier(() -> context.getBean(EnvironmentRepositoryConfiguration.JGitFactoryConfig.class).gitCredentialsProviderFactory()).register(context);
  }

  public static void registerEnvironmentRepositoryConfiguration_DefaultEnvironmentWatch(
      GenericApplicationContext context) {
    BeanDefinitionRegistrar.of("org.springframework.cloud.config.server.config.EnvironmentRepositoryConfiguration$DefaultEnvironmentWatch", EnvironmentRepositoryConfiguration.DefaultEnvironmentWatch.class)
        .instanceSupplier(() -> new EnvironmentRepositoryConfiguration.DefaultEnvironmentWatch()).register(context);
  }

  public static void registerDefaultEnvironmentWatch_environmentWatch(
      GenericApplicationContext context) {
    BeanDefinitionRegistrar.of("environmentWatch", EnvironmentWatch.class).withFactoryMethod(EnvironmentRepositoryConfiguration.DefaultEnvironmentWatch.class, "environmentWatch")
        .instanceSupplier(() -> context.getBean(EnvironmentRepositoryConfiguration.DefaultEnvironmentWatch.class).environmentWatch()).register(context);
  }

  public static void registerDefaultRepositoryConfiguration(GenericApplicationContext context) {
    BeanDefinitionRegistrar.of("org.springframework.cloud.config.server.config.DefaultRepositoryConfiguration", DefaultRepositoryConfiguration.class)
        .instanceSupplier(() -> new DefaultRepositoryConfiguration()).register(context);
  }

  public static void registerDefaultRepositoryConfiguration_defaultEnvironmentRepository(
      GenericApplicationContext context) {
    BeanDefinitionRegistrar.of("defaultEnvironmentRepository", MultipleJGitEnvironmentRepository.class).withFactoryMethod(DefaultRepositoryConfiguration.class, "defaultEnvironmentRepository", MultipleJGitEnvironmentRepositoryFactory.class, MultipleJGitEnvironmentProperties.class)
        .instanceSupplier((instanceContext) -> instanceContext.create(context, (attributes) -> context.getBean(DefaultRepositoryConfiguration.class).defaultEnvironmentRepository(attributes.get(0), attributes.get(1)))).register(context);
  }

  public static void registerConfigServerEncryptionConfiguration(
      GenericApplicationContext context) {
    BeanDefinitionRegistrar.of("org.springframework.cloud.config.server.config.ConfigServerEncryptionConfiguration", ConfigServerEncryptionConfiguration.class)
        .instanceSupplier((instanceContext) -> {
          ConfigServerEncryptionConfiguration bean = new ConfigServerEncryptionConfiguration();
          instanceContext.field("encryptor", TextEncryptorLocator.class)
              .resolve(context, false).ifResolved((attributes) -> {
                Field encryptorField = ReflectionUtils.findField(ConfigServerEncryptionConfiguration.class, "encryptor", TextEncryptorLocator.class);
                ReflectionUtils.makeAccessible(encryptorField);
                ReflectionUtils.setField(encryptorField, bean, attributes.get(0));
              });
              instanceContext.field("properties", ConfigServerProperties.class)
                  .invoke(context, (attributes) -> {
                    Field propertiesField = ReflectionUtils.findField(ConfigServerEncryptionConfiguration.class, "properties", ConfigServerProperties.class);
                    ReflectionUtils.makeAccessible(propertiesField);
                    ReflectionUtils.setField(propertiesField, bean, attributes.get(0));
                  });
                  return bean;
                }).register(context);
          }

          public static void registerConfigServerMvcConfiguration_EnvironmentControllerConfiguration(
              GenericApplicationContext context) {
            BeanDefinitionRegistrar.of("org.springframework.cloud.config.server.config.ConfigServerMvcConfiguration$EnvironmentControllerConfiguration", ConfigServerMvcConfiguration.EnvironmentControllerConfiguration.class)
                .instanceSupplier((instanceContext) -> {
                  ConfigServerMvcConfiguration.EnvironmentControllerConfiguration bean = new ConfigServerMvcConfiguration.EnvironmentControllerConfiguration();
                  instanceContext.field("environmentEncryptors", List.class)
                      .resolve(context, false).ifResolved((attributes) -> {
                        Field environmentEncryptorsField = ReflectionUtils.findField(ConfigServerMvcConfiguration.EnvironmentControllerConfiguration.class, "environmentEncryptors", List.class);
                        ReflectionUtils.makeAccessible(environmentEncryptorsField);
                        ReflectionUtils.setField(environmentEncryptorsField, bean, attributes.get(0));
                      });
                      instanceContext.field("resourceEncryptorMap", Map.class)
                          .resolve(context, false).ifResolved((attributes) -> {
                            Field resourceEncryptorMapField = ReflectionUtils.findField(ConfigServerMvcConfiguration.EnvironmentControllerConfiguration.class, "resourceEncryptorMap", Map.class);
                            ReflectionUtils.makeAccessible(resourceEncryptorMapField);
                            ReflectionUtils.setField(resourceEncryptorMapField, bean, attributes.get(0));
                          });
                          instanceContext.field("objectMapper", ObjectMapper.class)
                              .resolve(context, false).ifResolved((attributes) -> {
                                Field objectMapperField = ReflectionUtils.findField(ConfigServerMvcConfiguration.EnvironmentControllerConfiguration.class, "objectMapper", ObjectMapper.class);
                                ReflectionUtils.makeAccessible(objectMapperField);
                                ReflectionUtils.setField(objectMapperField, bean, attributes.get(0));
                              });
                              return bean;
                            }).register(context);
                      }

                      public static void registerEnvironmentControllerConfiguration_environmentController(
                          GenericApplicationContext context) {
                        BeanDefinitionRegistrar.of("environmentController", EnvironmentController.class).withFactoryMethod(ConfigServerMvcConfiguration.EnvironmentControllerConfiguration.class, "environmentController", EnvironmentRepository.class, ConfigServerProperties.class)
                            .instanceSupplier((instanceContext) -> instanceContext.create(context, (attributes) -> context.getBean(ConfigServerMvcConfiguration.EnvironmentControllerConfiguration.class).environmentController(attributes.get(0), attributes.get(1)))).register(context);
                      }

                      public static void registerEnvironmentControllerConfiguration_resourceController(
                          GenericApplicationContext context) {
                        BeanDefinitionRegistrar.of("resourceController", ResourceController.class).withFactoryMethod(ConfigServerMvcConfiguration.EnvironmentControllerConfiguration.class, "resourceController", ResourceRepository.class, EnvironmentRepository.class, ConfigServerProperties.class)
                            .instanceSupplier((instanceContext) -> instanceContext.create(context, (attributes) -> context.getBean(ConfigServerMvcConfiguration.EnvironmentControllerConfiguration.class).resourceController(attributes.get(0), attributes.get(1), attributes.get(2)))).register(context);
                      }

                      public static void registerEncryptionAutoConfiguration_EncryptorConfiguration(
                          GenericApplicationContext context) {
                        BeanDefinitionRegistrar.of("org.springframework.cloud.config.server.config.EncryptionAutoConfiguration$EncryptorConfiguration", EncryptionAutoConfiguration.EncryptorConfiguration.class)
                            .instanceSupplier((instanceContext) -> {
                              EncryptionAutoConfiguration.EncryptorConfiguration bean = new EncryptionAutoConfiguration.EncryptorConfiguration();
                              instanceContext.field("locator", TextEncryptorLocator.class)
                                  .resolve(context, false).ifResolved((attributes) -> {
                                    Field locatorField = ReflectionUtils.findField(EncryptionAutoConfiguration.EncryptorConfiguration.class, "locator", TextEncryptorLocator.class);
                                    ReflectionUtils.makeAccessible(locatorField);
                                    ReflectionUtils.setField(locatorField, bean, attributes.get(0));
                                  });
                                  instanceContext.field("encryptor", TextEncryptor.class)
                                      .invoke(context, (attributes) -> {
                                        Field encryptorField = ReflectionUtils.findField(EncryptionAutoConfiguration.EncryptorConfiguration.class, "encryptor", TextEncryptor.class);
                                        ReflectionUtils.makeAccessible(encryptorField);
                                        ReflectionUtils.setField(encryptorField, bean, attributes.get(0));
                                      });
                                      return bean;
                                    }).register(context);
                              }

                              public static void registerEncryptorConfiguration_environmentEncryptor(
                                  GenericApplicationContext context) {
                                BeanDefinitionRegistrar.of("environmentEncryptor", EnvironmentEncryptor.class).withFactoryMethod(EncryptionAutoConfiguration.EncryptorConfiguration.class, "environmentEncryptor")
                                    .instanceSupplier(() -> context.getBean(EncryptionAutoConfiguration.EncryptorConfiguration.class).environmentEncryptor()).register(context);
                              }

                              public static void registerDefaultTextEncryptorConfiguration(
                                  GenericApplicationContext context) {
                                BeanDefinitionRegistrar.of("org.springframework.cloud.config.server.config.DefaultTextEncryptorConfiguration", DefaultTextEncryptorConfiguration.class)
                                    .instanceSupplier((instanceContext) -> {
                                      DefaultTextEncryptorConfiguration bean = new DefaultTextEncryptorConfiguration();
                                      instanceContext.field("key", KeyProperties.class)
                                          .invoke(context, (attributes) -> {
                                            Field keyField = ReflectionUtils.findField(DefaultTextEncryptorConfiguration.class, "key", KeyProperties.class);
                                            ReflectionUtils.makeAccessible(keyField);
                                            ReflectionUtils.setField(keyField, bean, attributes.get(0));
                                          });
                                          instanceContext.field("locator", TextEncryptorLocator.class)
                                              .resolve(context, false).ifResolved((attributes) -> {
                                                Field locatorField = ReflectionUtils.findField(DefaultTextEncryptorConfiguration.class, "locator", TextEncryptorLocator.class);
                                                ReflectionUtils.makeAccessible(locatorField);
                                                ReflectionUtils.setField(locatorField, bean, attributes.get(0));
                                              });
                                              return bean;
                                            }).register(context);
                                      }

                                      public static void registerDefaultTextEncryptorConfiguration_defaultTextEncryptor(
                                          GenericApplicationContext context) {
                                        BeanDefinitionRegistrar.of("defaultTextEncryptor", TextEncryptor.class).withFactoryMethod(DefaultTextEncryptorConfiguration.class, "defaultTextEncryptor")
                                            .instanceSupplier(() -> context.getBean(DefaultTextEncryptorConfiguration.class).defaultTextEncryptor()).register(context);
                                      }
                                    }