Rename properties and binder name for eventhubs binder (#25430)

* rename event hubs binder name and properties prefix from eventhub to eventhubs, and refactor some classes names accordingly. Also, this pr remove the duplicate EventHubProvisioner
Azure · Nov 16, 2021 · c7d49d7 · c7d49d7
1 parent a73bd73
commit c7d49d7
Show file tree

Hide file tree

Showing 102 changed files with 752 additions and 770 deletions.
diff --git a/eng/code-quality-reports/src/main/resources/checkstyle/checkstyle-suppressions.xml b/eng/code-quality-reports/src/main/resources/checkstyle/checkstyle-suppressions.xml
@@ -492,7 +492,7 @@ the main ServiceBusClientBuilder. -->
   <suppress checks="com.azure.tools.checkstyle.checks.EnforceFinalFieldsCheck" files="com.azure.spring.messaging.container.AbstractListenerContainer.java"/>
   <suppress checks="com.azure.tools.checkstyle.checks.EnforceFinalFieldsCheck" files="ServiceBusTopicBinderConfiguration.java"/>
   <suppress checks="com.azure.tools.checkstyle.checks.EnforceFinalFieldsCheck" files="ServiceBusQueueBinderConfiguration.java"/>
-  <suppress checks="com.azure.tools.checkstyle.checks.EnforceFinalFieldsCheck" files="com.azure.spring.cloud.stream.binder.eventhubs.config.EventHubBinderConfiguration.java"/>
+  <suppress checks="com.azure.tools.checkstyle.checks.EnforceFinalFieldsCheck" files="com.azure.spring.cloud.stream.binder.eventhubs.config.EventHubsBinderConfiguration.java"/>
 
   <suppress checks="com.azure.tools.checkstyle.checks.EnforceFinalFieldsCheck" files="com.azure.spring.cloud.autoconfigure.keyvault.env.KeyVaultOperation.java"/>
   <suppress checks="com.azure.tools.checkstyle.checks.EnforceFinalFieldsCheck" files="com.azure.spring.cloud.autoconfigure.data.cosmos.CosmosDataAutoConfiguration.java"/>

diff --git a/...venthubs/EventHubHealthConfiguration.java → ...enthubs/EventHubsHealthConfiguration.java b/...venthubs/EventHubHealthConfiguration.java → ...enthubs/EventHubsHealthConfiguration.java
@@ -6,8 +6,8 @@
 import com.azure.messaging.eventhubs.EventHubClientBuilder;
 import com.azure.messaging.eventhubs.EventHubConsumerAsyncClient;
 import com.azure.messaging.eventhubs.EventHubProducerAsyncClient;
-import com.azure.spring.cloud.actuate.eventhubs.EventHubHealthIndicator;
-import com.azure.spring.cloud.autoconfigure.eventhubs.AzureEventHubAutoConfiguration;
+import com.azure.spring.cloud.actuate.eventhubs.EventHubsHealthIndicator;
+import com.azure.spring.cloud.autoconfigure.eventhubs.AzureEventHubsAutoConfiguration;
 import org.springframework.beans.factory.ObjectProvider;
 import org.springframework.boot.actuate.autoconfigure.health.ConditionalOnEnabledHealthIndicator;
 import org.springframework.boot.actuate.health.HealthIndicator;
@@ -22,17 +22,17 @@
  */
 @Configuration
 @ConditionalOnClass({ EventHubClientBuilder.class, HealthIndicator.class })
-@AutoConfigureAfter(AzureEventHubAutoConfiguration.class)
-public class EventHubHealthConfiguration {
+@AutoConfigureAfter(AzureEventHubsAutoConfiguration.class)
+public class EventHubsHealthConfiguration {
 
     @Bean
     @ConditionalOnBean(EventHubClientBuilder.class)
     @ConditionalOnEnabledHealthIndicator("azure-eventhub")
-    public EventHubHealthIndicator eventHubHealthIndicator(
+    public EventHubsHealthIndicator eventHubsHealthIndicator(
         ObjectProvider<EventHubProducerAsyncClient> producerAsyncClients,
         ObjectProvider<EventHubConsumerAsyncClient> consumerAsyncClients) {
 
-        return new EventHubHealthIndicator(producerAsyncClients.getIfAvailable(),
+        return new EventHubsHealthIndicator(producerAsyncClients.getIfAvailable(),
                                            consumerAsyncClients.getIfAvailable());
     }
 

diff --git a/...ng/spring-cloud-azure-actuator-autoconfigure/src/main/resources/META-INF/spring.factories b/...ng/spring-cloud-azure-actuator-autoconfigure/src/main/resources/META-INF/spring.factories
@@ -1,6 +1,6 @@
 org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
 com.azure.spring.cloud.actuate.autoconfigure.cosmos.CosmosHealthConfiguration,\
-com.azure.spring.cloud.actuate.autoconfigure.eventhubs.EventHubHealthConfiguration,\
+com.azure.spring.cloud.actuate.autoconfigure.eventhubs.EventHubsHealthConfiguration,\
 com.azure.spring.cloud.actuate.autoconfigure.keyvault.KeyVaultHealthConfiguration,\
 com.azure.spring.cloud.actuate.autoconfigure.storage.StorageBlobHealthConfiguration,\
 com.azure.spring.cloud.actuate.autoconfigure.storage.StorageFileHealthConfiguration,\

diff --git a/...te/eventhubs/EventHubHealthIndicator.java → ...e/eventhubs/EventHubsHealthIndicator.java b/...te/eventhubs/EventHubHealthIndicator.java → ...e/eventhubs/EventHubsHealthIndicator.java
@@ -11,9 +11,9 @@
 import java.time.Duration;
 
 /**
- * Health indicator for Event Hubs.
+ * Health indicator for Azure Event Hubs.
  */
-public class EventHubHealthIndicator implements HealthIndicator {
+public class EventHubsHealthIndicator implements HealthIndicator {
 
     private static final int DEFAULT_TIMEOUT = 30;
 
@@ -22,8 +22,8 @@ public class EventHubHealthIndicator implements HealthIndicator {
 
     private int timeout = DEFAULT_TIMEOUT;
 
-    public EventHubHealthIndicator(EventHubProducerAsyncClient producerAsyncClient,
-                                   EventHubConsumerAsyncClient consumerAsyncClient) {
+    public EventHubsHealthIndicator(EventHubProducerAsyncClient producerAsyncClient,
+                                    EventHubConsumerAsyncClient consumerAsyncClient) {
         this.producerAsyncClient = producerAsyncClient;
         this.consumerAsyncClient = consumerAsyncClient;
     }

diff --git a/...com/azure/spring/cloud/autoconfigure/eventhubs/AzureBlobCheckpointStoreConfiguration.java b/...com/azure/spring/cloud/autoconfigure/eventhubs/AzureBlobCheckpointStoreConfiguration.java
@@ -5,7 +5,7 @@
 
 import com.azure.messaging.eventhubs.EventHubClientBuilder;
 import com.azure.messaging.eventhubs.checkpointstore.blob.BlobCheckpointStore;
-import com.azure.spring.cloud.autoconfigure.eventhubs.properties.AzureEventHubProperties;
+import com.azure.spring.cloud.autoconfigure.eventhubs.properties.AzureEventHubsProperties;
 import com.azure.spring.service.storage.blob.BlobServiceClientBuilderFactory;
 import com.azure.storage.blob.BlobContainerAsyncClient;
 import org.slf4j.Logger;
@@ -39,12 +39,12 @@ public class AzureBlobCheckpointStoreConfiguration {
     public BlobCheckpointStore blobCheckpointStore(
         @Qualifier(EVENT_HUB_PROCESSOR_CHECKPOINT_STORE_STORAGE_CLIENT_BUILDER_FACTORY_BEAN_NAME)
             BlobServiceClientBuilderFactory factory,
-        AzureEventHubProperties eventHubProperties,
+        AzureEventHubsProperties eventHubsProperties,
         ObjectProvider<BlobCheckpointStoreContainerInitializer> initializers) {
         final BlobContainerAsyncClient blobContainerAsyncClient = factory
             .build()
             .buildAsyncClient()
-            .getBlobContainerAsyncClient(eventHubProperties.getProcessor().getCheckpointStore().getContainerName());
+            .getBlobContainerAsyncClient(eventHubsProperties.getProcessor().getCheckpointStore().getContainerName());
 
         initializers.ifAvailable(initializer -> initializer.init(blobContainerAsyncClient));
 
@@ -65,17 +65,18 @@ public BlobCheckpointStoreContainerInitializer blobCheckpointStoreContainerIniti
 
     @Bean(EVENT_HUB_PROCESSOR_CHECKPOINT_STORE_STORAGE_CLIENT_BUILDER_FACTORY_BEAN_NAME)
     @ConditionalOnMissingBean(name = EVENT_HUB_PROCESSOR_CHECKPOINT_STORE_STORAGE_CLIENT_BUILDER_FACTORY_BEAN_NAME)
-    public BlobServiceClientBuilderFactory eventHubProcessorBlobServiceClientBuilderFactory(AzureEventHubProperties eventHubProperties) {
-        return new BlobServiceClientBuilderFactory(getCheckpointStoreProperties(eventHubProperties));
+    public BlobServiceClientBuilderFactory eventHubProcessorBlobServiceClientBuilderFactory(
+        AzureEventHubsProperties eventHubsProperties) {
+        return new BlobServiceClientBuilderFactory(getCheckpointStoreProperties(eventHubsProperties));
     }
 
-    private AzureEventHubProperties.Processor.BlobCheckpointStore getCheckpointStoreProperties(
-        AzureEventHubProperties ehProperties) {
+    private AzureEventHubsProperties.Processor.BlobCheckpointStore getCheckpointStoreProperties(
+        AzureEventHubsProperties ehProperties) {
 
-        AzureEventHubProperties.Processor.BlobCheckpointStore result = new AzureEventHubProperties.Processor
+        AzureEventHubsProperties.Processor.BlobCheckpointStore result = new AzureEventHubsProperties.Processor
             .BlobCheckpointStore();
-        AzureEventHubProperties.Processor.BlobCheckpointStore csProperties = ehProperties.getProcessor()
-                                                                                       .getCheckpointStore();
+        AzureEventHubsProperties.Processor.BlobCheckpointStore csProperties = ehProperties.getProcessor()
+                                                                                          .getCheckpointStore();
 
         mergeAzureCommonProperties(ehProperties, csProperties, result);
         BeanUtils.copyProperties(csProperties, result);

diff --git a/...thubs/AzureEventHubAutoConfiguration.java → ...hubs/AzureEventHubsAutoConfiguration.java b/...thubs/AzureEventHubAutoConfiguration.java → ...hubs/AzureEventHubsAutoConfiguration.java
@@ -6,7 +6,7 @@
 import com.azure.messaging.eventhubs.EventHubClientBuilder;
 import com.azure.spring.cloud.autoconfigure.AzureServiceConfigurationBase;
 import com.azure.spring.cloud.autoconfigure.condition.ConditionalOnAnyProperty;
-import com.azure.spring.cloud.autoconfigure.eventhubs.properties.AzureEventHubProperties;
+import com.azure.spring.cloud.autoconfigure.eventhubs.properties.AzureEventHubsProperties;
 import com.azure.spring.cloud.autoconfigure.properties.AzureGlobalProperties;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
@@ -22,22 +22,22 @@
 @ConditionalOnProperty(value = "spring.cloud.azure.eventhubs.enabled", havingValue = "true", matchIfMissing = true)
 @ConditionalOnAnyProperty(prefix = "spring.cloud.azure.eventhubs", name = { "connection-string", "namespace" })
 @Import({
-    AzureEventHubClientBuilderConfiguration.class,
-    AzureEventHubConsumerClientConfiguration.class,
-    AzureEventHubProducerClientConfiguration.class,
+    AzureEventHubsClientBuilderConfiguration.class,
+    AzureEventHubsConsumerClientConfiguration.class,
+    AzureEventHubsProducerClientConfiguration.class,
     AzureBlobCheckpointStoreConfiguration.class,
-    AzureEventProcessorClientConfiguration.class
+    AzureEventHubsProcessorClientConfiguration.class
 })
-public class AzureEventHubAutoConfiguration extends AzureServiceConfigurationBase {
+public class AzureEventHubsAutoConfiguration extends AzureServiceConfigurationBase {
 
-    public AzureEventHubAutoConfiguration(AzureGlobalProperties azureGlobalProperties) {
+    public AzureEventHubsAutoConfiguration(AzureGlobalProperties azureGlobalProperties) {
         super(azureGlobalProperties);
     }
 
     @Bean
-    @ConfigurationProperties(AzureEventHubProperties.PREFIX)
-    public AzureEventHubProperties azureEventHubProperties() {
-        return loadProperties(this.azureGlobalProperties, new AzureEventHubProperties());
+    @ConfigurationProperties(AzureEventHubsProperties.PREFIX)
+    public AzureEventHubsProperties azureEventHubsProperties() {
+        return loadProperties(this.azureGlobalProperties, new AzureEventHubsProperties());
     }
 
 }
diff --git a/...reEventHubClientBuilderConfiguration.java → ...eEventHubsClientBuilderConfiguration.java b/...reEventHubClientBuilderConfiguration.java → ...eEventHubsClientBuilderConfiguration.java
@@ -5,7 +5,7 @@
 
 import com.azure.messaging.eventhubs.EventHubClientBuilder;
 import com.azure.spring.cloud.autoconfigure.condition.ConditionalOnAnyProperty;
-import com.azure.spring.cloud.autoconfigure.eventhubs.properties.AzureEventHubProperties;
+import com.azure.spring.cloud.autoconfigure.eventhubs.properties.AzureEventHubsProperties;
 import com.azure.spring.core.AzureSpringIdentifier;
 import com.azure.spring.core.connectionstring.ConnectionStringProvider;
 import com.azure.spring.core.connectionstring.StaticConnectionStringProvider;
@@ -24,7 +24,7 @@
 @Configuration(proxyBeanMethods = false)
 @ConditionalOnAnyProperty(prefix = "spring.cloud.azure.eventhubs", name = { "connection-string", "namespace" })
 @ConditionalOnProperty(prefix = "spring.cloud.azure.eventhubs", name = "event-hub-name")
-class AzureEventHubClientBuilderConfiguration {
+class AzureEventHubsClientBuilderConfiguration {
 
     @Bean
     @ConditionalOnMissingBean
@@ -34,8 +34,8 @@ public EventHubClientBuilder eventHubClientBuilder(EventHubClientBuilderFactory
 
     @Bean
     @ConditionalOnMissingBean
-    public EventHubClientBuilderFactory eventHubClientBuilderFactory(AzureEventHubProperties properties,
-                                                                     ObjectProvider<ConnectionStringProvider<AzureServiceType.EventHub>> connectionStringProviders) {
+    public EventHubClientBuilderFactory eventHubClientBuilderFactory(AzureEventHubsProperties properties,
+                                                                     ObjectProvider<ConnectionStringProvider<AzureServiceType.EventHubs>> connectionStringProviders) {
         final EventHubClientBuilderFactory builderFactory = new EventHubClientBuilderFactory(properties);
 
         builderFactory.setConnectionStringProvider(connectionStringProviders.getIfAvailable());
@@ -45,10 +45,10 @@ public EventHubClientBuilderFactory eventHubClientBuilderFactory(AzureEventHubPr
 
     @Bean
     @ConditionalOnProperty("spring.cloud.azure.eventhubs.connection-string")
-    public StaticConnectionStringProvider<AzureServiceType.EventHub> eventHubStaticConnectionStringProvider(
-        AzureEventHubProperties eventHubProperties) {
-        return new StaticConnectionStringProvider<>(AzureServiceType.EVENT_HUB,
-                                                    eventHubProperties.getConnectionString());
+    public StaticConnectionStringProvider<AzureServiceType.EventHubs> eventHubsStaticConnectionStringProvider(
+        AzureEventHubsProperties eventHubsProperties) {
+        return new StaticConnectionStringProvider<>(AzureServiceType.EVENT_HUBS,
+                                                    eventHubsProperties.getConnectionString());
     }
 
 }
diff --git a/...eEventHubConsumerClientConfiguration.java → ...EventHubsConsumerClientConfiguration.java b/...eEventHubConsumerClientConfiguration.java → ...EventHubsConsumerClientConfiguration.java
@@ -8,7 +8,7 @@
 import com.azure.messaging.eventhubs.EventHubConsumerClient;
 import com.azure.spring.cloud.autoconfigure.condition.ConditionalOnAnyProperty;
 import com.azure.spring.cloud.autoconfigure.condition.ConditionalOnMissingProperty;
-import com.azure.spring.cloud.autoconfigure.eventhubs.properties.AzureEventHubProperties;
+import com.azure.spring.cloud.autoconfigure.eventhubs.properties.AzureEventHubsProperties;
 import com.azure.spring.core.AzureSpringIdentifier;
 import com.azure.spring.core.connectionstring.StaticConnectionStringProvider;
 import com.azure.spring.core.service.AzureServiceType;
@@ -32,12 +32,12 @@
  */
 @Configuration(proxyBeanMethods = false)
 @Import({
-    AzureEventHubConsumerClientConfiguration.DedicatedConsumerConnectionConfiguration.class,
-    AzureEventHubConsumerClientConfiguration.SharedConsumerConnectionConfiguration.class
+    AzureEventHubsConsumerClientConfiguration.DedicatedConsumerConnectionConfiguration.class,
+    AzureEventHubsConsumerClientConfiguration.SharedConsumerConnectionConfiguration.class
 })
 @ConditionalOnAnyProperty(prefix = "spring.cloud.azure.eventhubs", name = { "event-hub-name", "consumer.event-hub-name" })
 @ConditionalOnProperty(prefix = "spring.cloud.azure.eventhubs.consumer", name = "consumer-group")
-class AzureEventHubConsumerClientConfiguration {
+class AzureEventHubsConsumerClientConfiguration {
 
     @ConditionalOnMissingProperty(prefix = "spring.cloud.azure.eventhubs.consumer", name = { "connection-string", "namespace" })
     @ConditionalOnAnyProperty(prefix = "spring.cloud.azure.eventhubs", name = { "connection-string", "namespace" })
@@ -46,7 +46,7 @@ class AzureEventHubConsumerClientConfiguration {
     static class SharedConsumerConnectionConfiguration {
 
         private final EventHubClientBuilder builder;
-        SharedConsumerConnectionConfiguration(AzureEventHubProperties properties, EventHubClientBuilder builder) {
+        SharedConsumerConnectionConfiguration(AzureEventHubsProperties properties, EventHubClientBuilder builder) {
             this.builder = builder;
 
             PropertyMapper mapper = new PropertyMapper();
@@ -71,10 +71,10 @@ public EventHubConsumerClient eventHubConsumerClient(EventHubClientBuilder build
     @Configuration(proxyBeanMethods = false)
     static class DedicatedConsumerConnectionConfiguration {
 
-        private final AzureEventHubProperties.Consumer consumerProperties;
+        private final AzureEventHubsProperties.Consumer consumerProperties;
 
-        DedicatedConsumerConnectionConfiguration(AzureEventHubProperties eventHubProperties) {
-            this.consumerProperties = eventHubProperties.buildConsumerProperties();
+        DedicatedConsumerConnectionConfiguration(AzureEventHubsProperties eventHubsProperties) {
+            this.consumerProperties = eventHubsProperties.buildConsumerProperties();
         }
 
         @Bean(EVENT_HUB_CONSUMER_CLIENT_BUILDER_FACTORY_BEAN_NAME)
@@ -83,7 +83,7 @@ public EventHubClientBuilderFactory eventHubClientBuilderFactoryForConsumer() {
 
             final EventHubClientBuilderFactory builderFactory = new EventHubClientBuilderFactory(this.consumerProperties);
 
-            builderFactory.setConnectionStringProvider(new StaticConnectionStringProvider<>(AzureServiceType.EVENT_HUB,
+            builderFactory.setConnectionStringProvider(new StaticConnectionStringProvider<>(AzureServiceType.EVENT_HUBS,
                                                                                             this.consumerProperties.getConnectionString()));
             builderFactory.setSpringIdentifier(AzureSpringIdentifier.AZURE_SPRING_EVENT_HUB);
             return builderFactory;